code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* Menu functions for ProUI
* Author: Miguel A. Risco-Castillo
* Version: 1.10.1
* Date: 2022/05/01
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DWIN_LCD_PROUI)
#include "../common/encoder.h"
#include "dwin.h"
#include "menus.h"
int8_t MenuItemTotal = 0;
int8_t MenuItemCount = 0;
CustomMenuItem** menuItems = nullptr;
Menu *currentMenu = nullptr;
Menu *previousMenu = nullptr;
MenuData_t menuData;
// Menuitem Drawing functions =================================================
void drawTitle(Title* aTitle) {
dwinDrawRectangle(1, hmiData.colorTitleBg, 0, 0, DWIN_WIDTH - 1, TITLE_HEIGHT - 1);
if (aTitle->frameid)
dwinFrameAreaCopy(aTitle->frameid, aTitle->frame.left, aTitle->frame.top, aTitle->frame.right, aTitle->frame.bottom, 14, (TITLE_HEIGHT - (aTitle->frame.bottom - aTitle->frame.top)) / 2 - 1);
else
#if ENABLED(TITLE_CENTERED)
DWINUI::drawCenteredString(false, DWIN_FONT_HEAD, hmiData.colorTitleTxt, hmiData.colorTitleBg, (TITLE_HEIGHT - DWINUI::fontHeight(DWIN_FONT_HEAD)) / 2 - 1, aTitle->caption);
#else
dwinDrawString(false, DWIN_FONT_HEAD, hmiData.colorTitleTxt, hmiData.colorTitleBg, 14, (TITLE_HEIGHT - DWINUI::fontHeight(DWIN_FONT_HEAD)) / 2 - 1, aTitle->caption);
#endif
}
void drawMenuCursor(const int8_t line) {
const uint16_t ypos = MYPOS(line);
DWINUI::drawBox(1, hmiData.colorCursor, {0, ypos, 15, MLINE - 1});
}
void eraseMenuCursor(const int8_t line) {
const uint16_t ypos = MYPOS(line);
DWINUI::drawBox(1, hmiData.colorBackground, {0, ypos, 15, MLINE - 1});
}
void eraseMenuText(const int8_t line) {
if (line < 0 || line >= TROWS) return;
const uint16_t ypos = MYPOS(line) + 1;
DWINUI::drawBox(1, hmiData.colorBackground, {LBLX, ypos, DWIN_WIDTH - LBLX, MLINE - 2});
}
void drawMenuLine(const uint8_t line, const uint8_t icon/*=0*/, const char * const label/*=nullptr*/, bool more/*=false*/, bool selected/*=false*/) {
if (icon) DWINUI::drawIcon(icon, ICOX, MBASE(line) - 3);
if (label) DWINUI::drawString(LBLX, MBASE(line) - 1, (char*)label);
if (more) DWINUI::drawIcon(ICON_More, VALX + 16, MBASE(line) - 3);
if (selected) drawMenuCursor(line);
dwinDrawHLine(hmiData.colorSplitLine, 16, MYPOS(line + 1), 240);
}
void drawMenuLine(const uint8_t line, const uint8_t icon/*=0*/, FSTR_P label/*=nullptr*/, bool more/*=false*/, bool selected/*=false*/) {
drawMenuLine(line, icon, FTOP(label), more, selected);
}
void drawCheckboxLine(const uint8_t line, const bool checked) {
DWINUI::drawCheckbox(hmiData.colorText, hmiData.colorBackground, VALX + 3 * DWINUI::fontWidth(), MBASE(line) - 1, checked);
}
void showCheckboxLine(const bool checked) {
const uint8_t line = currentMenu->line();
DWINUI::drawCheckbox(hmiData.colorText, hmiData.colorBackground, VALX + 3 * DWINUI::fontWidth(), MBASE(line) - 1, checked);
dwinUpdateLCD();
}
void toggleCheckboxLine(bool &checked) {
checked = !checked;
showCheckboxLine(checked);
}
void drawMenuIntValue(uint16_t bcolor, const uint8_t line, uint8_t iNum, const int32_t value/*=0*/) {
DWINUI::drawSignedInt(hmiData.colorText, bcolor, iNum , VALX, MBASE(line) - 1, value);
}
void onDrawMenuItem(MenuItem* menuitem, int8_t line) {
if (menuitem->icon) DWINUI::drawIcon(menuitem->icon, ICOX, MBASE(line) - 3);
if (menuitem->frameid)
dwinFrameAreaCopy(menuitem->frameid, menuitem->frame.left, menuitem->frame.top, menuitem->frame.right, menuitem->frame.bottom, LBLX, MBASE(line));
else
DWINUI::drawString(LBLX, MBASE(line) - 1, menuitem->caption);
dwinDrawHLine(hmiData.colorSplitLine, 16, MYPOS(line + 1), 240);
}
void onDrawSubMenu(MenuItem* menuitem, int8_t line) {
onDrawMenuItem(menuitem, line);
DWINUI::drawIcon(ICON_More, VALX + 16, MBASE(line) - 3);
}
void onDrawIntMenu(MenuItem* menuitem, int8_t line, int32_t value) {
onDrawMenuItem(menuitem, line);
drawMenuIntValue(hmiData.colorBackground, line, 4, value);
}
void onDrawPIntMenu(MenuItem* menuitem, int8_t line) {
const int16_t value = *(int16_t*)static_cast<MenuItemPtr*>(menuitem)->value;
onDrawIntMenu(menuitem, line, value);
}
void onDrawPInt8Menu(MenuItem* menuitem, int8_t line) {
const uint8_t value = *(uint8_t*)static_cast<MenuItemPtr*>(menuitem)->value;
onDrawIntMenu(menuitem, line, value);
}
void onDrawPInt32Menu(MenuItem* menuitem, int8_t line) {
const uint32_t value = *(uint32_t*)static_cast<MenuItemPtr*>(menuitem)->value;
onDrawIntMenu(menuitem, line, value);
}
void onDrawFloatMenu(MenuItem* menuitem, int8_t line, uint8_t dp, const float value) {
onDrawMenuItem(menuitem, line);
DWINUI::drawSignedFloat(hmiData.colorText, hmiData.colorBackground, 3, dp, VALX - dp * DWINUI::fontWidth(DWIN_FONT_MENU), MBASE(line), value);
}
void onDrawPFloatMenu(MenuItem* menuitem, int8_t line, uint8_t dp) {
const float value = *(float*)static_cast<MenuItemPtr*>(menuitem)->value;
onDrawFloatMenu(menuitem, line, dp, value);
}
void onDrawChkbMenu(MenuItem* menuitem, int8_t line, bool checked) {
onDrawMenuItem(menuitem, line);
drawCheckboxLine(line, checked);
}
void onDrawChkbMenu(MenuItem* menuitem, int8_t line) {
const bool val = *(bool*)static_cast<MenuItemPtr*>(menuitem)->value;
onDrawChkbMenu(menuitem, line, val);
}
void DrawItemEdit(const bool selected) {
const uint16_t bcolor = selected ? hmiData.colorSelected : hmiData.colorBackground;
const uint8_t iNum = 4 - ((menuData.dp > 0) ? (menuData.dp - 1) : 0);
switch (checkkey) {
case ID_SetIntNoDraw: if (menuData.liveUpdate) menuData.liveUpdate(); break;
case ID_SetInt:
case ID_SetPInt: DWINUI::drawSignedInt(hmiData.colorText, bcolor, iNum , VALX, MBASE(currentMenu->line()) - 1, menuData.value); break;
case ID_SetFloat:
case ID_SetPFloat: DWINUI::drawSignedFloat(hmiData.colorText, bcolor, iNum, menuData.dp, VALX - 2 * DWINUI::fontWidth(), MBASE(currentMenu->line()), menuData.value / POW(10, menuData.dp)); break;
default: break;
}
}
//-----------------------------------------------------------------------------
// On click functions
//-----------------------------------------------------------------------------
// Generic onclick event without draw
// process: process id HMI destiny
// lo: low limit
// hi: high limit
// dp: decimal places, 0 for integers
// val: value / scaled value
// liveUpdate: live update function when the encoder changes
// apply: update function when the encoder is pressed
void setOnClick(uint8_t process, const int32_t lo, const int32_t hi, uint8_t dp, const int32_t val, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
checkkey = process;
menuData.minValue = lo;
menuData.maxValue = hi;
menuData.dp = dp;
menuData.apply = apply;
menuData.liveUpdate = liveUpdate;
menuData.value = constrain(val, lo, hi);
encoderRate.enabled = true;
}
// Generic onclick event for integer values
// process: process id HMI destiny
// lo: scaled low limit
// hi: scaled high limit
// val: value
// liveUpdate: live update function when the encoder changes
// apply: update function when the encoder is pressed
void setValueOnClick(uint8_t process, const int32_t lo, const int32_t hi, const int32_t val, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
setOnClick(process, lo, hi, 0, val, apply, liveUpdate);
DrawItemEdit(true);
}
// Generic onclick event for float values
// process: process id HMI destiny
// lo: scaled low limit
// hi: scaled high limit
// val: value
// liveUpdate: live update function when the encoder changes
// apply: update function when the encoder is pressed
void setValueOnClick(uint8_t process, const float lo, const float hi, uint8_t dp, const float val, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
const int32_t value = round(val * POW(10, dp));
setOnClick(process, lo * POW(10, dp), hi * POW(10, dp), dp, value, apply, liveUpdate);
DrawItemEdit(true);
}
// Generic onclick event for integer values
// lo: scaled low limit
// hi: scaled high limit
// val: value
// liveUpdate: live update function when the encoder changes
// apply: update function when the encoder is pressed
void setIntOnClick(const int32_t lo, const int32_t hi, const int32_t val, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
setValueOnClick(ID_SetInt, lo, hi, val, apply, liveUpdate);
}
// Generic onclick event for set pointer to 16 bit uinteger values
// lo: low limit
// hi: high limit
// liveUpdate: live update function when the encoder changes
// apply: update function when the encoder is pressed
void setPIntOnClick(const int32_t lo, const int32_t hi, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
menuData.intPtr = (int16_t*)static_cast<MenuItemPtr*>(currentMenu->selectedItem())->value;
const int32_t value = *menuData.intPtr;
setValueOnClick(ID_SetPInt, lo, hi, value, apply, liveUpdate);
}
// Generic onclick event for float values
// process: process id HMI destiny
// lo: low limit
// hi: high limit
// dp: decimal places
// val: value
void setFloatOnClick(const float lo, const float hi, uint8_t dp, const float val, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
setValueOnClick(ID_SetFloat, lo, hi, dp, val, apply, liveUpdate);
}
// Generic onclick event for set pointer to float values
// lo: low limit
// hi: high limit
// liveUpdate: live update function when the encoder changes
// apply: update function when the encoder is pressed
void setPFloatOnClick(const float lo, const float hi, uint8_t dp, void (*apply)()/*=nullptr*/, void (*liveUpdate)()/*=nullptr*/) {
menuData.floatPtr = (float*)static_cast<MenuItemPtr*>(currentMenu->selectedItem())->value;
setValueOnClick(ID_SetPFloat, lo, hi, dp, *menuData.floatPtr, apply, liveUpdate);
}
// HMI Control functions ======================================================
// Generic menu control using the encoder
void hmiMenu() {
const EncoderState encoder_diffState = get_encoder_state();
if (currentMenu) {
if (encoder_diffState == ENCODER_DIFF_NO) return;
if (encoder_diffState == ENCODER_DIFF_ENTER)
currentMenu->onClick();
else
currentMenu->onScroll(encoder_diffState == ENCODER_DIFF_CW);
}
}
// Get a value using the encoder
// draw : draw the value
// Return value:
// 0 : no change
// 1 : live change
// 2 : apply change
int8_t hmiGet(bool draw) {
const int32_t lo = menuData.minValue, hi = menuData.maxValue, cval = menuData.value;
const EncoderState encoder_diffState = TERN(SMOOTH_ENCODER_MENUITEMS, get_encoder_state(), encoderReceiveAnalyze());
if (encoder_diffState != ENCODER_DIFF_NO) {
if (applyEncoder(encoder_diffState, menuData.value)) {
encoderRate.enabled = false;
if (draw) DrawItemEdit(false);
checkkey = ID_Menu;
return 2;
}
LIMIT(menuData.value, lo, hi);
}
const bool change = cval != menuData.value;
if (change) DrawItemEdit(true);
return int8_t(change);
}
// Set and draw a value using the encoder
void hmiSetDraw() {
const int8_t val = hmiGet(true);
switch (val) {
case 0: return;
case 1: if (menuData.liveUpdate) menuData.liveUpdate(); break;
case 2: if (menuData.apply) menuData.apply(); break;
}
}
// Set an value without drawing
void hmiSetNoDraw() {
const int8_t val = hmiGet(false);
switch (val) {
case 0: return;
case 1: if (menuData.liveUpdate) menuData.liveUpdate(); break;
case 2: if (menuData.apply) menuData.apply(); break;
}
}
// Set an integer pointer variable using the encoder
void hmiSetPInt() {
const int8_t val = hmiGet(true);
switch (val) {
case 0: return;
case 1: if (menuData.liveUpdate) menuData.liveUpdate(); break;
case 2: *menuData.intPtr = menuData.value; if (menuData.apply) menuData.apply(); break;
}
}
// Set a scaled float pointer variable using the encoder
void hmiSetPFloat() {
const int8_t val = hmiGet(true);
switch (val) {
case 0: return;
case 1: if (menuData.liveUpdate) menuData.liveUpdate(); break;
case 2: *menuData.floatPtr = menuData.value / POW(10, menuData.dp); if (menuData.apply) menuData.apply(); break;
}
}
// Menu Class ===============================================================
Menu::Menu() {
selected = 0;
topline = 0;
}
void Menu::draw() {
menuTitle.draw();
DWINUI::setColors(hmiData.colorText, hmiData.colorBackground, hmiData.colorStatusBg);
dwinDrawRectangle(1, DWINUI::backColor, 0, TITLE_HEIGHT, DWIN_WIDTH - 1, STATUS_Y - 1);
for (int8_t i = 0; i < MenuItemCount; i++)
menuItems[i]->draw(i - topline);
drawMenuCursor(line());
dwinUpdateLCD();
}
void Menu::onScroll(bool dir) {
int8_t sel = selected;
if (dir) sel++; else sel--;
LIMIT(sel, 0, MenuItemCount - 1);
if (sel != selected) {
eraseMenuCursor(line());
dwinUpdateLCD();
if ((sel - topline) == TROWS) {
dwinFrameAreaMove(1, DWIN_SCROLL_UP, MLINE, DWINUI::backColor, 0, TITLE_HEIGHT + 1, DWIN_WIDTH, STATUS_Y - 1);
topline++;
menuItems[sel]->draw(TROWS - 1);
}
if ((sel < topline)) {
dwinFrameAreaMove(1, DWIN_SCROLL_DOWN, MLINE, DWINUI::backColor, 0, TITLE_HEIGHT + 1, DWIN_WIDTH, STATUS_Y - 1);
topline--;
menuItems[sel]->draw(0);
}
selected = sel;
drawMenuCursor(line());
dwinUpdateLCD();
}
}
void Menu::onClick() {
if (menuItems[selected]->onClick != nullptr) (*menuItems[selected]->onClick)();
}
CustomMenuItem *Menu::selectedItem() {
return menuItems[selected];
}
CustomMenuItem** Menu::items() {
return menuItems;
}
int8_t Menu::count() {
return MenuItemCount;
};
/* MenuItem Class ===========================================================*/
void CustomMenuItem::draw(int8_t line) {
if (line < 0 || line >= TROWS) return;
if (onDraw != nullptr) (*onDraw)(static_cast<MenuItem*>(this), line);
};
void CustomMenuItem::redraw(bool erase/*=false*/) {
const int8_t line = currentMenu->line(this->pos);
if (erase) eraseMenuText(line);
draw(line);
}
CustomMenuItem::CustomMenuItem(OnDrawItem ondraw, OnClickItem onclick) {
onClick = onclick;
onDraw = ondraw;
}
MenuItem::MenuItem(uint8_t cicon, const char * const text, OnDrawItem ondraw, OnClickItem onclick) : CustomMenuItem(ondraw, onclick) {
icon = cicon;
setCaption(text);
}
MenuItem::MenuItem(uint8_t cicon, uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, OnDrawItem ondraw, OnClickItem onclick) : CustomMenuItem(ondraw, onclick) {
icon = cicon;
caption[0] = '\0';
frameid = id;
frame = { x1, y1, x2, y2 };
}
void MenuItem::setCaption(const char * const text) {
const uint8_t len = _MIN(sizeof(caption) - 1, strlen(text));
memcpy(&caption[0], text, len);
caption[len] = '\0';
}
void MenuItem::setFrame(uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2) {
caption[0] = '\0';
frameid = id;
frame = { x1, y1, x2, y2 };
}
MenuItemPtr::MenuItemPtr(uint8_t cicon, const char * const text, OnDrawItem ondraw, OnClickItem onclick, void* val) : MenuItem(cicon, text, ondraw, onclick) {
value = val;
};
// Menu auxiliary functions ===================================================
void menuItemsClear() {
if (menuItems == nullptr) return;
for (int8_t i = 0; i < MenuItemCount; i++) delete menuItems[i];
delete[] menuItems;
menuItems = nullptr;
MenuItemCount = 0;
MenuItemTotal = 0;
}
void menuItemsPrepare(int8_t totalitems) {
menuItemsClear();
MenuItemTotal = _MIN(totalitems, MENU_MAX_ITEMS);
menuItems = new CustomMenuItem*[totalitems];
}
bool isMenu(Menu* _menu) {
return ((checkkey == ID_Menu) && !!currentMenu && (currentMenu == _menu));
}
template<typename T>
T* menuItemAdd(T* menuitem) {
menuItems[MenuItemCount] = menuitem;
menuitem->pos = MenuItemCount++;
return menuitem;
}
CustomMenuItem* menuItemAdd(OnDrawItem ondraw/*=nullptr*/, OnClickItem onclick/*=nullptr*/) {
if (MenuItemCount < MenuItemTotal) {
CustomMenuItem* menuitem = new CustomMenuItem(ondraw, onclick);
return menuItemAdd(menuitem);
}
else return nullptr;
}
MenuItem* menuItemAdd(uint8_t cicon, const char * const text/*=nullptr*/, OnDrawItem ondraw/*=nullptr*/, OnClickItem onclick/*=nullptr*/) {
if (MenuItemCount < MenuItemTotal) {
MenuItem* menuitem = new MenuItem(cicon, text, ondraw, onclick);
return menuItemAdd(menuitem);
}
else return nullptr;
}
MenuItem* menuItemAdd(uint8_t cicon, uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, OnDrawItem ondraw/*=nullptr*/, OnClickItem onclick/*=nullptr*/) {
if (MenuItemCount < MenuItemTotal) {
MenuItem* menuitem = new MenuItem(cicon, id, x1, y1, x2, y2, ondraw, onclick);
return menuItemAdd(menuitem);
}
else return nullptr;
}
MenuItem* editItemAdd(uint8_t cicon, const char * const text, OnDrawItem ondraw, OnClickItem onclick, void* val) {
if (MenuItemCount < MenuItemTotal) {
MenuItem* menuitem = new MenuItemPtr(cicon, text, ondraw, onclick, val);
return menuItemAdd(menuitem);
}
else return nullptr;
}
void initMenu() {
currentMenu = nullptr;
previousMenu = nullptr;
}
bool setMenu(Menu* &menu, FSTR_P fTitle, int8_t totalitems) {
if (!menu) menu = new Menu();
const bool notCurrent = (currentMenu != menu);
if (notCurrent) {
menu->menuTitle.setCaption(fTitle);
menuItemsPrepare(totalitems);
}
return notCurrent;
}
bool setMenu(Menu* &menu, frame_rect_t cn, FSTR_P fTitle, int8_t totalitems) {
if (!menu) menu = new Menu();
const bool notCurrent = (currentMenu != menu);
if (notCurrent) {
if (cn.w != 0)
menu->menuTitle.setFrame(cn.x, cn.y, cn.w, cn.h);
else
menu->menuTitle.setCaption(fTitle);
menuItemsPrepare(totalitems);
}
return notCurrent;
}
void resetMenu(Menu* &menu) {
if (menu) {
menu->topline = 0;
menu->selected = 0;
}
}
void invalidateMenu() {
resetMenu(currentMenu);
currentMenu = nullptr;
}
void updateMenu(Menu* &menu) {
if (!menu) return;
if (currentMenu != menu) {
previousMenu = currentMenu;
currentMenu = menu;
}
menu->draw();
}
void ReDrawMenu(bool force/*=false*/) {
if (currentMenu && (force || checkkey == ID_Menu)) currentMenu->draw();
if (force) DrawItemEdit(true);
}
void ReDrawItem() {
static_cast<MenuItem*>(currentMenu->selectedItem())->redraw(false);
}
#endif // DWIN_LCD_PROUI
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/menus.cpp
|
C++
|
agpl-3.0
| 19,160
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Menu functions for ProUI
* Author: Miguel A. Risco-Castillo
* Version: 1.10.1
* Date: 2022/05/01
*/
#include "dwinui.h"
#define MENU_CHAR_LIMIT 24
#ifndef MENU_MAX_ITEMS
#define MENU_MAX_ITEMS 100
#endif
typedef struct {
int32_t maxValue = 0; // Auxiliar max integer/scaled float value
int32_t minValue = 0; // Auxiliar min integer/scaled float value
int8_t dp = 0; // Auxiliar decimal places
int32_t value = 0; // Auxiliar integer / scaled float value
int16_t *intPtr = nullptr; // Auxiliar pointer to 16 bit integer variable
float *floatPtr = nullptr; // Auxiliar pointer to float variable
void (*apply)() = nullptr; // Auxiliar apply function
void (*liveUpdate)() = nullptr; // Auxiliar live update function
} MenuData_t;
extern MenuData_t menuData;
// Auxiliary Macros ===========================================================
// Create and add a MenuItem object to the menu array
#define SET_MENU(I,L,V) setMenu(I, GET_TEXT_F(L), V)
#define SET_MENU_F(I,L,V) setMenu(I, F(L), V)
#define SET_MENU_R(I,R,L,V) setMenu(I, R, GET_TEXT_F(L), V)
#define BACK_ITEM(H) menuItemAdd(ICON_Back, GET_TEXT_F(MSG_BUTTON_BACK), onDrawMenuItem, H)
#define MENU_ITEM(I,L,V...) menuItemAdd(I, GET_TEXT_F(L), V)
#define EDIT_ITEM(I,L,V...) editItemAdd(I, GET_TEXT_F(L), V)
#define MENU_ITEM_F(I,L,V...) menuItemAdd(I, F(L), V)
#define EDIT_ITEM_F(I,L,V...) editItemAdd(I, F(L), V)
// Menu Classes ===============================================================
class CustomMenuItem;
class MenuItem;
typedef void (*OnDrawCustomItem)(CustomMenuItem* menuitem, int8_t line);
typedef void (*OnDrawItem)(MenuItem* menuitem, int8_t line);
typedef void (*OnClickItem)();
class CustomMenuItem {
public:
int8_t pos = 0;
OnDrawItem onDraw = nullptr;
void (*onClick)() = nullptr;
CustomMenuItem() {};
CustomMenuItem(OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr);
virtual ~CustomMenuItem(){};
virtual void draw(int8_t line);
void redraw(bool erase=false);
};
class MenuItem: public CustomMenuItem {
public:
uint8_t icon = 0;
char caption[MENU_CHAR_LIMIT] = "";
uint8_t frameid = 0;
rect_t frame = {0};
using CustomMenuItem::CustomMenuItem;
MenuItem(uint8_t cicon, const char * const text=nullptr, OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr);
MenuItem(uint8_t cicon, uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr);
void setFrame(uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2);
void setCaption(const char * const text=nullptr);
};
class MenuItemPtr: public MenuItem {
public:
void *value = nullptr;
using MenuItem::MenuItem;
MenuItemPtr(uint8_t cicon, const char * const text, OnDrawItem ondraw, OnClickItem onclick, void* val);
MenuItemPtr(uint8_t cicon, FSTR_P text, OnDrawItem ondraw, OnClickItem onclick, void* val) : MenuItemPtr(cicon, FTOP(text), ondraw, onclick, val){}
};
class Menu {
public:
int8_t topline = 0;
int8_t selected = 0;
Title menuTitle;
Menu();
virtual ~Menu(){};
inline int8_t line() { return selected - topline; };
inline int8_t line(uint8_t pos) {return pos - topline; };
int8_t count();
virtual void draw();
virtual void onScroll(bool dir);
void onClick();
CustomMenuItem* selectedItem();
static CustomMenuItem** items();
};
extern Menu *currentMenu;
extern Menu *previousMenu;
// Menuitem Drawing functions =================================================
void drawTitle(Title* aTitle);
void drawMenuCursor(const int8_t line);
void eraseMenuCursor(const int8_t line);
void eraseMenuText(const int8_t line);
void drawMenuLine(const uint8_t line, const uint8_t icon=0, const char * const label=nullptr, bool more=false, bool selected=false);
void drawMenuLine(const uint8_t line, const uint8_t icon=0, FSTR_P label=nullptr, bool more=false, bool selected=false);
void drawCheckboxLine(const uint8_t line, const bool checked);
void showCheckboxLine(const bool checked);
void toggleCheckboxLine(bool &checked);
void drawMenuIntValue(uint16_t bcolor, const uint8_t line, uint8_t iNum, const int32_t value=0);
void onDrawMenuItem(MenuItem* menuitem, int8_t line);
void onDrawSubMenu(MenuItem* menuitem, int8_t line);
void onDrawIntMenu(MenuItem* menuitem, int8_t line, int32_t value);
void onDrawPIntMenu(MenuItem* menuitem, int8_t line);
void onDrawPInt8Menu(MenuItem* menuitem, int8_t line);
void onDrawPInt32Menu(MenuItem* menuitem, int8_t line);
void onDrawFloatMenu(MenuItem* menuitem, int8_t line, uint8_t dp, const float value);
void onDrawPFloatMenu(MenuItem* menuitem, int8_t line, uint8_t dp);
inline void onDrawPFloatMenu(MenuItem* menuitem, int8_t line) { onDrawPFloatMenu(menuitem, line, UNITFDIGITS); };
inline void onDrawPFloat2Menu(MenuItem* menuitem, int8_t line) { onDrawPFloatMenu(menuitem, line, 2); };
inline void onDrawPFloat3Menu(MenuItem* menuitem, int8_t line) { onDrawPFloatMenu(menuitem, line, 3); };
inline void onDrawPFloat4Menu(MenuItem* menuitem, int8_t line) { onDrawPFloatMenu(menuitem, line, 4); };
void onDrawChkbMenu(MenuItem* menuitem, int8_t line, bool checked);
void onDrawChkbMenu(MenuItem* menuitem, int8_t line);
// On click functions =========================================================
void setOnClick(uint8_t process, const int32_t lo, const int32_t hi, uint8_t dp, const int32_t val, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
void setValueOnClick(uint8_t process, const int32_t lo, const int32_t hi, const int32_t val, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
void setValueOnClick(uint8_t process, const float lo, const float hi, uint8_t dp, const float val, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
void setIntOnClick(const int32_t lo, const int32_t hi, const int32_t val, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
void setPIntOnClick(const int32_t lo, const int32_t hi, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
void setFloatOnClick(const float lo, const float hi, uint8_t dp, const float val, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
void setPFloatOnClick(const float lo, const float hi, uint8_t dp, void (*apply)()=nullptr, void (*liveUpdate)()=nullptr);
// HMI user control functions =================================================
void hmiMenu();
void hmiSetDraw();
void hmiSetNoDraw();
void hmiSetPInt();
void hmiSetPFloat();
// Menu auxiliary functions ===================================================
// Initialize menu
void initMenu();
// Create a new menu
bool setMenu(Menu* &menu, FSTR_P fTitle, int8_t totalitems);
bool setMenu(Menu* &menu, frame_rect_t cn, FSTR_P fTitle, int8_t totalitems);
// Reset top line and selected item
void resetMenu(Menu* &menu);
// Invalidate currentMenu to prepare for full menu drawing
void invalidateMenu();
// Update the Menu and Draw if it is valid
void updateMenu(Menu* &menu);
// Redraw the current Menu if it is valid
void ReDrawMenu(bool force=false);
// Redraw selected menu item
void ReDrawItem();
// Clear menuItems array and free menuItems elements
void menuItemsClear();
// Prepare menuItems array
void menuItemsPrepare(int8_t totalitems);
// Is the current menu = menu?
bool isMenu(Menu* menu);
// Add elements to the menuItems array
CustomMenuItem* menuItemAdd(OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr);
MenuItem* menuItemAdd(uint8_t cicon, const char * const text=nullptr, OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr);
inline MenuItem* menuItemAdd(uint8_t cicon, FSTR_P text=nullptr, OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr) {
return menuItemAdd(cicon, FTOP(text), ondraw, onclick);
}
MenuItem* menuItemAdd(uint8_t cicon, uint8_t id, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, OnDrawItem ondraw=nullptr, OnClickItem onclick=nullptr);
MenuItem* editItemAdd(uint8_t cicon, const char * const text, OnDrawItem ondraw, OnClickItem onclick, void* val);
inline MenuItem* editItemAdd(uint8_t cicon, FSTR_P text, OnDrawItem ondraw, OnClickItem onclick, void* val) {
return editItemAdd(cicon, FTOP(text), ondraw, onclick, val);
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/menus.h
|
C++
|
agpl-3.0
| 9,063
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* Mesh Viewer for PRO UI
* Author: Miguel A. Risco-Castillo (MRISCOC)
* version: 4.2.1
* Date: 2023/05/05
*/
#include "../../../inc/MarlinConfigPre.h"
#if ALL(DWIN_LCD_PROUI, HAS_MESH)
#include "../../../core/types.h"
#include "../../marlinui.h"
#include "dwin.h"
#include "dwin_popup.h"
#include "../../../feature/bedlevel/bedlevel.h"
#include "meshviewer.h"
#if ENABLED(USE_GRID_MESHVIEWER)
#include "bedlevel_tools.h"
#endif
bool meshredraw; // Redraw mesh points
uint8_t sizex, sizey; // Mesh XY size
uint8_t rmax; // Maximum radius
#define margin 25 // XY Margins
#define rmin 5 // Minimum radius
#define zmin -20 // rmin at z=-0.20
#define zmax 20 // rmax at z= 0.20
#define width DWIN_WIDTH - 2 * margin
#define r(z) ((z - zmin) * (rmax - rmin) / (zmax - zmin) + rmin)
#define px(xp) (margin + (xp) * (width) / (sizex - 1))
#define py(yp) (30 + DWIN_WIDTH - margin - (yp) * (width) / (sizey - 1))
constexpr uint8_t meshfont = TERN(TJC_DISPLAY, font8x16, font6x12);
MeshViewer meshViewer;
float MeshViewer::max, MeshViewer::min;
void MeshViewer::drawMeshGrid(const uint8_t csizex, const uint8_t csizey) {
sizex = csizex;
sizey = csizey;
rmax = _MIN(margin - 2, 0.5 * (width) / (sizex - 1));
min = 100;
max = -100;
DWINUI::clearMainArea();
dwinDrawRectangle(0, hmiData.colorSplitLine, px(0), py(0), px(sizex - 1), py(sizey - 1));
for (uint8_t x = 1; x < sizex - 1; ++x) dwinDrawVLine(hmiData.colorSplitLine, px(x), py(sizey - 1), width);
for (uint8_t y = 1; y < sizey - 1; ++y) dwinDrawHLine(hmiData.colorSplitLine, px(0), py(y), width);
}
void MeshViewer::drawMeshPoint(const uint8_t x, const uint8_t y, const float z) {
const uint8_t fs = DWINUI::fontWidth(meshfont);
const int16_t v = isnan(z) ? 0 : round(z * 100);
NOLESS(max, z); NOMORE(min, z);
const uint16_t color = DWINUI::rainbowInt(v, zmin, zmax);
DWINUI::drawFillCircle(color, px(x), py(y), r(_MAX(_MIN(v, zmax), zmin)));
TERN_(TJC_DISPLAY, delay(100));
const uint16_t fy = py(y) - fs;
if (sizex < TERN(TJC_DISPLAY, 8, 9)) {
if (v == 0) DWINUI::drawFloat(meshfont, 1, 2, px(x) - 2 * fs, fy, 0);
else DWINUI::drawSignedFloat(meshfont, 1, 2, px(x) - 3 * fs, fy, z);
}
else {
char msg[9]; msg[0] = '\0';
switch (v) {
case -999 ... -100:
case 100 ... 999: DWINUI::drawSignedFloat(meshfont, 1, 1, px(x) - 3 * fs, fy, z); break;
case -99 ... -1: sprintf_P(msg, PSTR("-.%2i"), -v); break;
case 1 ... 99: sprintf_P(msg, PSTR( ".%2i"), v); break;
default:
dwinDrawString(false, meshfont, DWINUI::textColor, DWINUI::backColor, px(x) - 4, fy, "0");
return;
}
dwinDrawString(false, meshfont, DWINUI::textColor, DWINUI::backColor, px(x) - 2 * fs, fy, msg);
}
}
void MeshViewer::drawMesh(const bed_mesh_t zval, const uint8_t csizex, const uint8_t csizey) {
drawMeshGrid(csizex, csizey);
for (uint8_t y = 0; y < csizey; ++y) {
hal.watchdog_refresh();
for (uint8_t x = 0; x < csizex; ++x) drawMeshPoint(x, y, zval[x][y]);
}
}
void MeshViewer::draw(const bool withsave/*=false*/, const bool redraw/*=true*/) {
title.showCaption(GET_TEXT_F(MSG_MESH_VIEWER));
#if ENABLED(USE_GRID_MESHVIEWER)
DWINUI::clearMainArea();
bedLevelTools.viewer_print_value = true;
bedLevelTools.drawBedMesh(-1, 1, 8, 10 + TITLE_HEIGHT);
#else
if (redraw) drawMesh(bedlevel.z_values, GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y);
else DWINUI::drawBox(1, hmiData.colorBackground, { 89, 305, 99, 38 });
#endif
if (withsave) {
DWINUI::drawButton(BTN_Save, 26, 305);
DWINUI::drawButton(BTN_Continue, 146, 305);
drawSelectHighlight(hmiFlag.select_flag, 305);
}
else
DWINUI::drawButton(BTN_Continue, 86, 305);
#if ENABLED(USE_GRID_MESHVIEWER)
bedLevelTools.setMeshViewerStatus();
#else
char str_1[6], str_2[6] = "";
ui.status_printf(0, F("Mesh minZ: %s, maxZ: %s"), dtostrf(min, 1, 2, str_1), dtostrf(max, 1, 2, str_2));
#endif
}
void drawMeshViewer() { meshViewer.draw(true, meshredraw); }
void onClick_MeshViewer() { if (hmiFlag.select_flag) saveMesh(); hmiReturnScreen(); }
void gotoMeshViewer(const bool redraw) {
meshredraw = redraw;
if (leveling_is_valid()) gotoPopup(drawMeshViewer, onClick_MeshViewer);
else hmiReturnScreen();
}
#endif // DWIN_LCD_PROUI && HAS_MESH
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/meshviewer.cpp
|
C++
|
agpl-3.0
| 5,377
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Mesh Viewer for PRO UI
* Author: Miguel A. Risco-Castillo (MRISCOC)
* version: 4.2.1
* Date: 2023/05/05
*/
class MeshViewer {
public:
static float max, min;
static void drawMeshGrid(const uint8_t csizex, const uint8_t csizey);
static void drawMeshPoint(const uint8_t x, const uint8_t y, const float z);
static void draw(const bool withsave=false, const bool redraw=true);
static void drawMesh(const bed_mesh_t zval, const uint8_t csizex, const uint8_t csizey);
};
extern MeshViewer meshViewer;
void gotoMeshViewer(const bool redraw);
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/meshviewer.h
|
C++
|
agpl-3.0
| 1,434
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* DWIN Single var plot
* Author: Miguel A. Risco-Castillo
* Version: 2.2.3
* Date: 2023/01/29
*/
#include "../../../inc/MarlinConfig.h"
#if ENABLED(DWIN_LCD_PROUI)
#include "dwin_defines.h"
#if PROUI_TUNING_GRAPH
#include "dwin.h"
#include "../../marlinui.h"
#include "plot.h"
#define plotBgColor RGB(1, 12, 8)
Plot plot;
Plot::PlotData Plot::data;
void Plot::draw(const frame_rect_t &frame, const_celsius_float_t max, const_celsius_float_t ref/*=0*/) {
data.graphframe = frame;
data.graphpoints = 0;
data.scale = frame.h / max;
data.x2 = frame.x + frame.w - 1;
data.y2 = frame.y + frame.h - 1;
data.r = LROUND((data.y2) - ref * data.scale);
DWINUI::drawBox(1, plotBgColor, frame);
for (uint8_t i = 1; i < 4; i++) if (i * 60 < frame.w) dwinDrawVLine(COLOR_LINE, i * 60 + frame.x, frame.y, frame.h);
DWINUI::drawBox(0, COLOR_WHITE, DWINUI::extendFrame(frame, 1));
dwinDrawHLine(COLOR_RED, frame.x, data.r, frame.w);
}
void Plot::update(const_celsius_float_t value) {
if (!data.scale) return;
const uint16_t y = LROUND((data.y2) - value * data.scale);
if (data.graphpoints < data.graphframe.w) {
if (data.graphpoints < 1)
dwinDrawPoint(COLOR_YELLOW, 1, 1, data.graphframe.x, y);
else
dwinDrawLine(COLOR_YELLOW, data.graphpoints + data.graphframe.x - 1, data.yP, data.graphpoints + data.graphframe.x, y);
}
else {
dwinFrameAreaMove(1, 0, 1, plotBgColor, data.graphframe.x, data.graphframe.y, data.x2, data.y2);
if ((data.graphpoints % 60) == 0) dwinDrawVLine(COLOR_LINE, data.x2 - 1, data.graphframe.y + 1, data.graphframe.h - 2);
dwinDrawPoint(COLOR_RED, 1, 1, data.x2 - 1, data.r);
dwinDrawLine(COLOR_YELLOW, data.x2 - 2, data.yP, data.x2 - 1, y);
}
data.yP = y;
data.graphpoints++;
TERN_(HAS_BACKLIGHT_TIMEOUT, ui.refresh_backlight_timeout());
}
#endif // PROUI_TUNING_GRAPH
#endif // DWIN_LCD_PROUI
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/plot.cpp
|
C++
|
agpl-3.0
| 2,757
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* DWIN Single var plot
* Author: Miguel A. Risco-Castillo
* Version: 2.2.3
* Date: 2023/01/29
*/
#include "dwinui.h"
class Plot {
public:
static void draw(const frame_rect_t &frame, const_celsius_float_t max, const_celsius_float_t ref=0);
static void update(const_celsius_float_t value);
private:
static struct PlotData {
uint16_t graphpoints, r, x2, y2, yP = 0;
frame_rect_t graphframe = {0};
float scale = 0;
} data;
};
extern Plot plot;
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/plot.h
|
C++
|
agpl-3.0
| 1,349
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* Print Stats page for PRO UI
* Author: Miguel A. Risco-Castillo (MRISCOC)
* Version: 1.4.0
* Date: 2022/12/03
*/
#include "../../../inc/MarlinConfigPre.h"
#if ALL(DWIN_LCD_PROUI, PRINTCOUNTER)
#include "printstats.h"
#include "../../../core/types.h"
#include "../../../MarlinCore.h"
#include "../../marlinui.h"
#include "../../../module/printcounter.h"
#include "dwin.h"
#include "dwin_popup.h"
PrintStats printStats;
void PrintStats::draw() {
char str[30] = "";
constexpr int8_t MRG = 30;
title.showCaption(GET_TEXT_F(MSG_INFO_STATS_MENU));
DWINUI::clearMainArea();
drawPopupBkgd();
DWINUI::drawButton(BTN_Continue, 86, 250);
printStatistics ps = print_job_timer.getStats();
DWINUI::drawString(MRG, 80, TS(GET_TEXT_F(MSG_INFO_PRINT_COUNT), F(": "), ps.totalPrints));
DWINUI::drawString(MRG, 100, TS(GET_TEXT_F(MSG_INFO_COMPLETED_PRINTS), F(": "), ps.finishedPrints));
duration_t(print_job_timer.getStats().printTime).toDigital(str, true);
DWINUI::drawString(MRG, 120, TS(GET_TEXT_F(MSG_INFO_PRINT_TIME), F(": "), str));
duration_t(print_job_timer.getStats().longestPrint).toDigital(str, true);
DWINUI::drawString(MRG, 140, TS(GET_TEXT_F(MSG_INFO_PRINT_LONGEST), F(": "), str));
DWINUI::drawString(MRG, 160, TS(GET_TEXT_F(MSG_INFO_PRINT_FILAMENT), F(": "), p_float_t(ps.filamentUsed / 1000, 2), F(" m")));
}
void PrintStats::reset() {
print_job_timer.initStats();
DONE_BUZZ(true);
}
void gotoPrintStats() {
printStats.draw();
hmiSaveProcessID(ID_WaitResponse);
}
// Print Stats Reset popup
void popupResetStats() { dwinPopupConfirmCancel(ICON_Info_0, GET_TEXT_F(MSG_RESET_STATS)); }
void onClickResetStats() {
if (hmiFlag.select_flag) printStats.reset();
hmiReturnScreen();
}
void printStatsReset() { gotoPopup(popupResetStats, onClickResetStats); }
#endif // DWIN_LCD_PROUI && PRINTCOUNTER
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/printstats.cpp
|
C++
|
agpl-3.0
| 2,717
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* Print Stats page for PRO UI
* Author: Miguel A. Risco-Castillo (MRISCOC)
* Version: 1.4.0
* Date: 2022/12/03
*/
class PrintStats {
public:
static void draw();
static void reset();
};
extern PrintStats printStats;
void gotoPrintStats();
void printStatsReset();
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/printstats.h
|
C++
|
agpl-3.0
| 1,154
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2024 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 <https://www.gnu.org/licenses/>.
*
*/
/*********************
* proui_extui.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: <https://www.gnu.org/licenses/>. *
****************************************************************************/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DWIN_LCD_PROUI)
#include "dwin_popup.h"
#include "../../extui/ui_api.h"
#include "../../../module/stepper.h"
#if ENABLED(PREVENT_COLD_EXTRUSION)
#include "../../../module/temperature.h"
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../feature/powerloss.h"
#endif
namespace ExtUI {
void onStartup() { dwinInitScreen(); }
void onIdle() {}
void onPrinterKilled(FSTR_P const error, FSTR_P const component) {}
void onMediaInserted() {}
void onMediaError() {}
void onMediaRemoved() {}
void onHeatingError(const heater_id_t heater_id) {
dwinPopupTemperature(heater_id, 2); // "Heating failed"
}
void onMinTempError(const heater_id_t heater_id) {
dwinPopupTemperature(heater_id, 0); // "Too low"
}
void onMaxTempError(const heater_id_t heater_id) {
dwinPopupTemperature(heater_id, 1); // "Too high"
}
void onPlayTone(const uint16_t frequency, const uint16_t duration/*=0*/) {}
void onPrintTimerStarted() {}
void onPrintTimerPaused() {}
void onPrintTimerStopped() {}
#if HAS_FILAMENT_SENSOR
void onFilamentRunout(const extruder_t extruder) {
dwinFilamentRunout(extruder);
}
#endif
void onUserConfirmRequired(const char * const cstr) {
// TODO: A version of this method that takes an icon and button title,
// or implement some kind of ExtUI enum.
onUserConfirmRequired(ICON_Continue_1, cstr, GET_TEXT_F(MSG_USERWAIT));
}
// For fancy LCDs include an icon ID, message, and translated button title
void onUserConfirmRequired(const int icon, const char * const cstr, FSTR_P const fBtn) {
dwinPopupConfirm(icon, cstr, fBtn);
}
void onUserConfirmRequired(const int icon, FSTR_P const fstr, FSTR_P const fBtn) {
dwinPopupConfirm(icon, fstr, fBtn);
}
void onStatusChanged(const char * const) { dwinCheckStatusMessage(); }
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void onPauseMode(const PauseMessage message, const PauseMode mode/*=PAUSE_MODE_SAME*/, const uint8_t extruder/*=active_extruder*/) {
if (mode != PAUSE_MODE_SAME) pause_mode = mode;
switch (message) {
case PAUSE_MESSAGE_PARKING: dwinPopupPause(GET_TEXT_F(MSG_PAUSE_PRINT_PARKING)); break; // M125
case PAUSE_MESSAGE_CHANGING: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_INIT)); break; // pause_print (M125, M600)
case PAUSE_MESSAGE_WAITING: dwinPopupPause(GET_TEXT_F(MSG_ADVANCED_PAUSE_WAITING), BTN_Continue); break;
case PAUSE_MESSAGE_INSERT: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_INSERT), BTN_Continue); break;
case PAUSE_MESSAGE_LOAD: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_LOAD)); break;
case PAUSE_MESSAGE_UNLOAD: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_UNLOAD)); break; // Unload of pause and Unload of M702
case PAUSE_MESSAGE_PURGE: dwinPopupPause(GET_TEXT_F(TERN(ADVANCED_PAUSE_CONTINUOUS_PURGE, MSG_FILAMENT_CHANGE_CONT_PURGE, MSG_FILAMENT_CHANGE_PURGE))); break;
case PAUSE_MESSAGE_OPTION: gotoFilamentPurge(); break;
case PAUSE_MESSAGE_RESUME: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_RESUME)); break;
case PAUSE_MESSAGE_HEAT: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_HEAT), BTN_Continue); break;
case PAUSE_MESSAGE_HEATING: dwinPopupPause(GET_TEXT_F(MSG_FILAMENT_CHANGE_HEATING)); break;
case PAUSE_MESSAGE_STATUS: hmiReturnScreen(); break; // Exit from Pause, Load and Unload
default: break;
}
}
#endif
void onHomingStart() { dwinHomingStart(); }
void onHomingDone() { dwinHomingDone(); }
void onPrintDone() {}
void onFactoryReset() { dwinSetDataDefaults(); }
// Copy settings to EEPROM buffer for write
void onStoreSettings(char *buff) { dwinCopySettingsTo(buff); }
// Get settings from loaded EEPROM data
void onLoadSettings(const char *buff) { dwinCopySettingsFrom(buff); }
void onPostprocessSettings() {
// Called after loading or resetting stored settings
}
void onSettingsStored(const bool success) {
// Called after the entire EEPROM has been written,
// whether successful or not.
}
void onSettingsLoaded(const bool success) {
// Called after the entire EEPROM has been read,
// whether successful or not.
}
#if HAS_LEVELING
void onLevelingStart() { dwinLevelingStart(); }
void onLevelingDone() { dwinLevelingDone(); }
#if ENABLED(PREHEAT_BEFORE_LEVELING)
celsius_t getLevelingBedTemp() { return hmiData.bedLevT; }
#endif
#endif
#if HAS_MESH
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) {
const int16_t idx = ypos * (GRID_MAX_POINTS_X) + xpos;
dwinMeshUpdate(_MIN(idx, GRID_MAX_POINTS), int(GRID_MAX_POINTS), zval);
dwinRedrawScreen();
}
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) {
// Called to indicate a special condition
}
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
void onSetMinExtrusionTemp(const celsius_t t) { hmiData.extMinT = t; }
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
void onSetPowerLoss(const bool onoff) {
// Called when power-loss is enabled/disabled
}
void onPowerLoss() {
// Called when power-loss state is detected
}
void onPowerLossResume() {
// Called on resume from power-loss
recovery.ui_flag_resume = true;
}
#endif
#if HAS_PID_HEATING
void onPIDTuning(const pidresult_t rst) {
// Called for temperature PID tuning result
switch (rst) {
#if ENABLED(PIDTEMP)
case PID_STARTED: dwinPIDTuning(PIDTEMP_START); break;
#endif
#if ENABLED(PIDTEMPBED)
case PID_BED_STARTED: dwinPIDTuning(PIDTEMPBED_START); break;
#endif
#if ENABLED(PIDTEMPCHAMBER)
case PID_CHAMBER_STARTED: dwinPIDTuning(PIDTEMPCHAMBER_START); break;
#endif
case PID_BAD_HEATER_ID: dwinPIDTuning(tempcontrol_t(PID_BAD_HEATER_ID)); break;
case PID_TEMP_TOO_HIGH: dwinPIDTuning(tempcontrol_t(PID_TEMP_TOO_HIGH)); break;
case PID_TUNING_TIMEOUT: dwinPIDTuning(tempcontrol_t(PID_TUNING_TIMEOUT)); break;
case PID_DONE: dwinPIDTuning(AUTOTUNE_DONE); break;
}
}
void onStartM303(const int count, const heater_id_t hid, const celsius_t temp) {
dwinStartM303(count, hid, temp);
}
#endif
#if ENABLED(MPC_AUTOTUNE)
void onMPCTuning(const mpcresult_t rst) {
// Called for temperature MPC tuning result
switch (rst) {
case MPC_STARTED: dwinMPCTuning(MPC_STARTED); break;
case MPC_TEMP_ERROR: dwinMPCTuning(MPC_TEMP_ERROR); break;
case MPC_INTERRUPTED: dwinMPCTuning(MPC_INTERRUPTED); break;
case MPC_DONE: dwinMPCTuning(AUTOTUNE_DONE); break;
}
}
#endif
#if ENABLED(PLATFORM_M997_SUPPORT)
void onFirmwareFlash() { dwinRebootScreen(); }
#endif
void onSteppersDisabled() {}
void onSteppersEnabled() {}
void onAxisDisabled(const axis_t axis) {
set_axis_untrusted(AxisEnum(axis)); // MRISCOC workaround: https://github.com/MarlinFirmware/Marlin/issues/23095
}
void onAxisEnabled(const axis_t) {}
} // ExtUI
#endif // DWIN_LCD_PROUI
|
2301_81045437/Marlin
|
Marlin/src/lcd/e3v2/proui/proui_extui.cpp
|
C++
|
agpl-3.0
| 9,542
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic/Tunes.cpp
*/
/***********************************************************************
* A Utility to play tunes using the buzzer in the printer controller. *
* See Tunes.h for note and tune definitions. *
***********************************************************************/
#include "../../../inc/MarlinConfigPre.h"
#if ANY(ANYCUBIC_LCD_CHIRON, ANYCUBIC_LCD_VYPER)
#include "Tunes.h"
#include "../../../libs/buzzer.h"
#include "../ui_api.h"
namespace Anycubic {
void playTune(const uint16_t *tune, const uint8_t speed/*=1*/) {
const uint16_t wholenotelen = tune[0] / speed;
for (uint8_t pos = 1; pos < MAX_TUNE_LENGTH; pos += 2) {
const uint16_t freq = tune[pos];
if (freq == n_END) break;
BUZZ(wholenotelen / tune[pos + 1], freq);
}
}
}
#endif // ANYCUBIC_LCD_CHIRON || ANYCUBIC_LCD_VYPER
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic/Tunes.cpp
|
C++
|
agpl-3.0
| 1,754
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic/Tunes.h
*/
/**************************************************************************
* Notes definition from https://pages.mtu.edu/~suits/NoteFreqCalcs.html *
* *
* The format of a tune is: *
* {<whole note time>,<note1>,<length1>, <note2>,<length2>, ... <END>} *
* *
* 1) The first value is the length of a whole note in milliseconds *
* 2) Then a sequence of pitch and duration pairs *
* 3) Finally the END marker so your tunes can be any length up to *
* MAX_TUNE_LEN *
*************************************************************************/
#include <stdint.h>
#define MAX_TUNE_LENGTH 128
// Note duration divisors
enum { l_T1=1, l_T2 =2, l_T3=3, l_T4 =4, l_T8=8, l_T16=16 };
// Note Frequency
enum {
n_P = 0, // silence or pause
n_C0= 16, n_CS0= 17, n_D0= 18, n_DS0= 19, n_E0= 21, n_F0= 22, n_FS0= 23, n_G0= 25, n_GS0= 26, n_A0= 28, n_AS0= 29, n_B0= 31,
n_C1= 33, n_CS1= 35, n_D1= 37, n_DS1= 39, n_E1= 41, n_F1= 44, n_FS1= 46, n_G1= 49, n_GS1= 52, n_A1= 55, n_AS1= 58, n_B1= 62,
n_C2= 65, n_CS2= 69, n_D2= 73, n_DS2= 78, n_E2= 82, n_F2= 87, n_FS2= 93, n_G2= 98, n_GS2= 104, n_A2= 110, n_AS2= 117, n_B2= 123,
n_C3= 131, n_CS3= 139, n_D3= 147, n_DS3= 156, n_E3= 165, n_F3= 175, n_FS3= 185, n_G3= 196, n_GS3= 208, n_A3= 220, n_AS3= 233, n_B3= 247,
n_C4= 262, n_CS4= 277, n_D4= 294, n_DS4= 311, n_E4= 330, n_F4= 349, n_FS4= 370, n_G4= 392, n_GS4= 415, n_A4= 440, n_AS4= 466, n_B4= 494,
n_C5= 523, n_CS5= 554, n_D5= 587, n_DS5= 622, n_E5= 659, n_F5= 698, n_FS5= 740, n_G5= 784, n_GS5= 831, n_A5= 880, n_AS5= 932, n_B5= 988,
n_C6=1047, n_CS6=1109, n_D6=1175, n_DS6=1245, n_E6=1319, n_F6=1397, n_FS6=1480, n_G6=1568, n_GS6=1661, n_A6=1760, n_AS6=1865, n_B6=1976,
n_C7=2093, n_CS7=2217, n_D7=2349, n_DS7=2489, n_E7=2637, n_F7=2794, n_FS7=2960, n_G7=3136, n_GS7=3322, n_A7=3520, n_AS7=3729, n_B7=3951,
n_C8=4186, n_CS8=4435, n_D8=4699, n_DS8=4978, n_E8=5274, n_F8=5587, n_FS8=5920, n_G8=6272, n_GS8=6645, n_A8=7040, n_AS8=7459, n_B8=7902,
n_END=10000 // end of tune marker
};
namespace Anycubic {
void playTune(const uint16_t *tune, const uint8_t speed=1);
// Only uncomment the tunes you are using to save memory
// This will help you write tunes!
// https://www.apronus.com/music/flashpiano.htm
const uint16_t SOS[] = {
250,
n_G6,l_T3, n_P,l_T3, n_G6,l_T3, n_P,l_T3, n_G6,l_T3, n_P,l_T1,
n_G6,l_T1, n_P,l_T3, n_G6,l_T1, n_P,l_T3, n_G6,l_T1, n_P,l_T1,
n_G6,l_T3, n_P,l_T3, n_G6,l_T3, n_P,l_T3, n_G6,l_T3, n_P,l_T1,
n_END
};
const uint16_t BeepBeep[] = {
500,
n_C7,l_T8, n_P,l_T16, n_C7,l_T8, n_P,l_T8,
n_END
};
const uint16_t BeepBeepBeeep[] = {
1000,
n_G7,l_T4, n_P,l_T16, n_G7,l_T4, n_P,l_T8, n_G7,l_T2,
n_END
};
const uint16_t Anycubic_PowerOn[] = {
1000,
n_F7,l_T8, n_P,l_T8, n_C7,l_T8, n_P,l_T8, n_D7,l_T8, n_P,l_T8,
n_E7,l_T8, n_P,l_T8, n_D7,l_T4, n_P,l_T4,
n_END
};
const uint16_t GB_PowerOn[] = {
500,
n_C6,l_T4, n_P,l_T16, n_C7,l_T2, n_P,l_T8,
n_END
};
const uint16_t HeaterTimeout[] = {
1000,
n_C6,l_T1,
n_END
};
const uint16_t FilamentOut[] = {
1000,
n_AS7,l_T4, n_P,l_T16, n_FS7,l_T2,
n_END
};
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic/Tunes.h
|
C++
|
agpl-3.0
| 4,393
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic/common_defs.h
*/
#include "../../../inc/MarlinConfigPre.h"
#define ACDEBUGLEVEL 0 // 0: off, 255: all levels enabled
#if ACDEBUGLEVEL
// Bit-masks for selective debug:
enum ACDebugMask : uint8_t {
AC_INFO = 1,
AC_ACTION = 2,
AC_FILE = 4,
AC_PANEL = 8,
AC_MARLIN = 16,
AC_SOME = 32,
AC_ALL = 64
};
#define ACDEBUG(mask) ( ((mask) & ACDEBUGLEVEL) == mask ) // Debug flag macro
#else
#define ACDEBUG(mask) false
#endif
#define TFTSer LCD_SERIAL // Serial interface for TFT panel now uses marlinserial
#define MAX_FOLDER_DEPTH 4 // Limit folder depth TFT has a limit for the file path
#define MAX_CMND_LEN 16 * MAX_FOLDER_DEPTH // Maximum Length for a Panel command
#define MAX_PATH_LEN 16 * MAX_FOLDER_DEPTH // Maximum number of characters in a SD file path
#define AC_HEATER_FAULT_VALIDATION_TIME 5 // number of 1/2 second loops before signalling a heater fault
#define AC_LOWEST_MESHPOINT_VAL Z_PROBE_LOW_POINT // The lowest value you can set for a single mesh point offset
// TFT panel commands
#define AC_msg_sd_card_inserted F("J00")
#define AC_msg_sd_card_removed F("J01")
#define AC_msg_no_sd_card F("J02")
#define AC_msg_usb_connected F("J03")
#define AC_msg_print_from_sd_card F("J04")
#define AC_msg_pause F("J05")
#define AC_msg_nozzle_heating F("J06")
#define AC_msg_nozzle_heating_done F("J07")
#define AC_msg_bed_heating F("J08")
#define AC_msg_bed_heating_done F("J09")
#define AC_msg_nozzle_temp_abnormal F("J10")
#define AC_msg_kill_lcd F("J11")
#define AC_msg_ready F("J12")
#define AC_msg_low_nozzle_temp F("J13")
#define AC_msg_print_complete F("J14")
#define AC_msg_filament_out_alert F("J15")
#define AC_msg_stop F("J16")
#define AC_msg_main_board_has_reset F("J17")
#define AC_msg_paused F("J18")
#define AC_msg_j19_unknown F("J19")
#define AC_msg_sd_file_open_success F("J20")
#define AC_msg_sd_file_open_failed F("J21")
#define AC_msg_level_monitor_finished F("J22")
#define AC_msg_filament_out_block F("J23")
#define AC_msg_probing_not_allowed F("J24")
#define AC_msg_probing_complete F("J25")
#define AC_msg_start_probing F("J26")
#define AC_msg_version F("J27")
// TFT panel messages
#define MARLIN_msg_start_probing PSTR("Probing Point 1/25")
#define MARLIN_msg_probing_failed PSTR("Probing Failed")
#define MARLIN_msg_ready PSTR(" Ready.")
#define MARLIN_msg_print_paused PSTR("Print Paused")
#define MARLIN_msg_print_aborted PSTR("Print Aborted")
#define MARLIN_msg_extruder_heating PSTR("E Heating...")
#define MARLIN_msg_bed_heating PSTR("Bed Heating...")
#define MARLIN_msg_nozzle_parked PSTR("Nozzle Parked")
#define MARLIN_msg_heater_timeout PSTR("Heater Timeout")
#define MARLIN_msg_reheating PSTR("Reheating...")
#define MARLIN_msg_reheat_done PSTR("Reheat finished.")
#define MARLIN_msg_filament_purging PSTR("Filament Purging...")
#define MARLIN_msg_special_pause PSTR("PB") // AnyCubic
#define AC_cmnd_auto_unload_filament F("M701") // Marlin unload routine
#define AC_cmnd_auto_load_filament F("M702 M0 PB") // AnyCubic: Marlin load routine, pause for user to clean nozzle
#define AC_cmnd_manual_load_filament F("M83\nG1 E50 F700\nM82") // replace the manual panel commands with something a little faster
#define AC_cmnd_manual_unload_filament F("M83\nG1 E-50 F1200\nM82")
#define AC_cmnd_enable_leveling F("M420SV")
#define AC_cmnd_power_loss_recovery F("G28XYR5\nG28Z") // Lift, home X and Y then home Z when in 'safe' position
namespace Anycubic {
enum heater_state_t : uint8_t {
AC_heater_off,
AC_heater_temp_set,
AC_heater_temp_reached
};
enum timer_event_t : uint8_t {
AC_timer_started,
AC_timer_paused,
AC_timer_stopped
};
enum media_event_t : uint8_t {
AC_media_inserted,
AC_media_removed,
AC_media_error
};
enum file_menu_t : uint8_t {
AC_menu_file,
AC_menu_command,
AC_menu_change_to_file,
AC_menu_change_to_command
};
} // Anycubic
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic/common_defs.h
|
C++
|
agpl-3.0
| 5,374
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_chiron/FileNavigator.cpp
*
* Extensible_UI implementation for Anycubic Chiron
* Written By Nick Wells, 2020 [https://github.com/SwiftNick]
* (not affiliated with Anycubic, Ltd.)
*
* The AC panel wants files in block of 4 and can only display a flat list
* This library allows full folder traversal or flat file display and supports both standerd and new style panels.
*
* ## Old Style TFT panel
* Supported chars {}[]-+=_"$%^&*()~<>|
* Max display length 22 chars
* Max path len 29 chars
* (DOS 8.3 filepath max 29chars)
* (long filepath Max 22)
*
* ## New TFT Panel Format file display format
* Supported chars {}[]-+=_!"$%^&*()~<>\|
* Max display length 26 chars
* Max path len 29 chars
* (DOS 8.3 filepath must end '.GCO')
* (long filepath must end '.gcode')
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_CHIRON)
#include "FileNavigator.h"
#include "chiron_tft.h"
using namespace ExtUI;
#define DEBUG_OUT ACDEBUG(AC_FILE)
#include "../../../core/debug_out.h"
namespace Anycubic {
FileNavigator filenavigator;
FileList FileNavigator::filelist; // ExtUI file API
uint16_t FileNavigator::lastpanelindex;
uint16_t FileNavigator::currentindex; // override the panel request
uint8_t FileNavigator::folderdepth;
uint16_t FileNavigator::currentDirIndex[MAX_FOLDER_DEPTH]; // track folder pos for iteration
char FileNavigator::currentDirPath[MAX_PATH_LEN + 1]; // Current folder path
FileNavigator::FileNavigator() { reset(); }
void FileNavigator::reset() {
currentDirPath[0] = '\0';
folderdepth = 0;
currentindex = 0;
lastpanelindex = 0;
ZERO(currentDirIndex);
// Start at root folder
while (!filelist.isAtRootDir()) filelist.upDir();
refresh();
}
void FileNavigator::refresh() { filelist.refresh(); }
void FileNavigator::changeDIR(const char *folder) {
if (folderdepth >= MAX_FOLDER_DEPTH) return; // limit the folder depth
currentDirIndex[folderdepth] = currentindex;
strcat(currentDirPath, folder);
strcat(currentDirPath, "/");
filelist.changeDir(folder);
folderdepth++;
currentindex = 0;
}
void FileNavigator::upDIR() {
if (!filelist.isAtRootDir()) {
filelist.upDir();
folderdepth--;
currentindex = currentDirIndex[folderdepth]; // restore last position in the folder
filelist.seek(currentindex); // restore file information
}
// Remove the child folder from the stored path
if (folderdepth == 0)
currentDirPath[0] = '\0';
else {
char * const pos = strchr(currentDirPath, '/');
*(pos + 1) = '\0';
}
}
void FileNavigator::skiptofileindex(uint16_t skip) {
if (skip == 0) return;
while (skip > 0) {
if (filelist.seek(currentindex)) {
if (!filelist.isDir()) {
skip--;
currentindex++;
}
else
changeDIR(filelist.shortFilename());
} // valid file
if (currentindex == filelist.count()) {
if (folderdepth > 0) {
upDIR();
currentindex++;
}
else break; // end of root folder
} // end of folder
} // files needed
// No more files available.
}
#if ENABLED(AC_SD_FOLDER_VIEW) // SD Folder navigation
void FileNavigator::getFiles(uint16_t index, panel_type_t paneltype, uint8_t filesneeded) {
if (index == 0) currentindex = 0;
// Each time we change folder we reset the file index to 0 and keep track
// of the current position, since the TFT panel isn't aware of folder trees.
if (index > 0) {
--currentindex; // go back a file to take account of the .. we added to the root.
if (index > lastpanelindex)
currentindex += filesneeded;
else
currentindex = currentindex < 4 ? 0 : currentindex - filesneeded;
}
lastpanelindex = index;
if (currentindex == 0 && folderdepth > 0) { // Add a link to go up a folder
// The new panel ignores entries that don't end in .GCO or .gcode so add and pad them.
if (paneltype <= AC_panel_new) {
TFTSer.println("<<.GCO");
chiron.tftSendLn(F(".. .gcode"));
}
else {
TFTSer.println("<<");
TFTSer.println("..");
}
filesneeded--;
}
for (uint16_t seek = currentindex; seek < currentindex + filesneeded; seek++)
if (filelist.seek(seek)) sendFile(paneltype);
}
void FileNavigator::sendFile(panel_type_t paneltype) {
if (filelist.isDir()) {
// Add mandatory tags for new panel otherwise lines are ignored.
if (paneltype <= AC_panel_new) {
TFTSer.print(filelist.shortFilename());
TFTSer.println(".GCO");
TFTSer.print(filelist.shortFilename());
TFTSer.write('/');
// Make sure we fill all 29 chars of the display line to clear the text buffer otherwise the last line is still visible
for (int8_t i = strlen(filelist.shortFilename()); i < 19; i++)
TFTSer.write(' ');
TFTSer.println(".gcode");
}
else {
TFTSer.println(filelist.shortFilename());
TFTSer.print(filelist.shortFilename());
TFTSer.write('/');
TFTSer.println();
}
}
else { // Not DIR
TFTSer.write('/');
if (folderdepth > 0) TFTSer.print(currentDirPath);
TFTSer.println(filelist.shortFilename());
TFTSer.print(filelist.longFilename());
// Make sure we fill all 29 chars of the display line to clear the text buffer otherwise the last line is still visible
if (paneltype == AC_panel_new)
for (int8_t i = strlen(filelist.longFilename()); i < 26; i++)
TFTSer.write(' ');
TFTSer.println();
}
} // AC_SD_FOLDER_VIEW
#else // Flat file list
void FileNavigator::getFiles(uint16_t index, panel_type_t paneltype, uint8_t filesneeded) {
// if we're searching backwards, jump back to start and search forward
if (index < lastpanelindex) {
reset();
skiptofileindex(index);
}
lastpanelindex = index;
while (filesneeded > 0) {
if (filelist.seek(currentindex)) {
if (!filelist.isDir()) {
sendFile(paneltype);
filesneeded--;
currentindex++;
}
else
changeDIR(filelist.shortFilename());
} // valid file
if (currentindex == filelist.count()) {
if (folderdepth > 0) {
upDIR();
currentindex++;
}
else break; // end of root folder
} // end of folder
} // files needed
// No more files available.
}
void FileNavigator::sendFile(panel_type_t paneltype) {
TFTSer.write('/');
if (folderdepth > 0) TFTSer.print(currentDirPath);
TFTSer.println(filelist.shortFilename());
if (folderdepth > 0) TFTSer.print(currentDirPath);
TFTSer.println(filelist.longFilename());
}
#endif // Flat file list
} // Anycubic namespace
#endif // ANYCUBIC_LCD_CHIRON
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_chiron/FileNavigator.cpp
|
C++
|
agpl-3.0
| 7,772
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic_chiron/FileNavigator.h
*
* Extensible_UI implementation for Anycubic Chiron
* Written By Nick Wells, 2020 [https://github.com/SwiftNick]
* (not affiliated with Anycubic, Ltd.)
*/
#include "chiron_tft_defs.h"
#include "../ui_api.h"
using namespace ExtUI;
namespace Anycubic {
class FileNavigator {
public:
static FileList filelist;
FileNavigator();
static void reset();
static void getFiles(uint16_t, panel_type_t, uint8_t filesneeded=4);
static void upDIR();
static void changeDIR(const char *);
static void sendFile(panel_type_t);
static void refresh();
static void skiptofileindex(uint16_t);
private:
static uint16_t lastpanelindex;
static uint16_t currentindex;
static uint8_t folderdepth;
static uint16_t currentDirIndex[MAX_FOLDER_DEPTH];
static char currentDirPath[MAX_PATH_LEN + 1];
};
extern FileNavigator filenavigator;
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_chiron/FileNavigator.h
|
C++
|
agpl-3.0
| 1,849
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_chiron/chiron_extui.cpp
*
* Anycubic Chiron TFT support for Marlin
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_CHIRON)
#include "../ui_api.h"
#include "chiron_tft.h"
using namespace Anycubic;
namespace ExtUI {
void onStartup() { chiron.startup(); }
void onIdle() { chiron.idleLoop(); }
void onPrinterKilled(FSTR_P const error, FSTR_P const component) {
chiron.printerKilled(error, component);
}
void onMediaInserted() { chiron.mediaEvent(AC_media_inserted); }
void onMediaError() { chiron.mediaEvent(AC_media_error); }
void onMediaRemoved() { chiron.mediaEvent(AC_media_removed); }
void onHeatingError(const heater_id_t header_id) {}
void onMinTempError(const heater_id_t header_id) {}
void onMaxTempError(const heater_id_t header_id) {}
void onPlayTone(const uint16_t frequency, const uint16_t duration/*=0*/) {
#if ENABLED(SPEAKER)
::tone(BEEPER_PIN, frequency, duration);
#endif
}
void onPrintTimerStarted() { chiron.timerEvent(AC_timer_started); }
void onPrintTimerPaused() { chiron.timerEvent(AC_timer_paused); }
void onPrintTimerStopped() { chiron.timerEvent(AC_timer_stopped); }
void onPrintDone() {}
void onFilamentRunout(const extruder_t) { chiron.filamentRunout(); }
void onUserConfirmRequired(const char * const msg) { chiron.confirmationRequest(msg); }
// For fancy LCDs include an icon ID, message, and translated button title
void onUserConfirmRequired(const int icon, const char * const cstr, FSTR_P const fBtn) {
onUserConfirmRequired(cstr);
UNUSED(icon); UNUSED(fBtn);
}
void onUserConfirmRequired(const int icon, FSTR_P const fstr, FSTR_P const fBtn) {
onUserConfirmRequired(fstr);
UNUSED(icon); UNUSED(fBtn);
}
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void onPauseMode(
const PauseMessage message,
const PauseMode mode/*=PAUSE_MODE_SAME*/,
const uint8_t extruder/*=active_extruder*/
) {
stdOnPauseMode(message, mode, extruder);
}
#endif
void onStatusChanged(const char * const msg) { chiron.statusChange(msg); }
void onHomingStart() {}
void onHomingDone() {}
void onFactoryReset() {}
void onStoreSettings(char *buff) {
// Called when saving to EEPROM (i.e. M500). If the ExtUI needs
// permanent data to be stored, it can write up to eeprom_data_size bytes
// into buff.
// Example:
// static_assert(sizeof(myDataStruct) <= eeprom_data_size);
// memcpy(buff, &myDataStruct, sizeof(myDataStruct));
}
void onLoadSettings(const char *buff) {
// Called while loading settings from EEPROM. If the ExtUI
// needs to retrieve data, it should copy up to eeprom_data_size bytes
// from buff
// Example:
// static_assert(sizeof(myDataStruct) <= eeprom_data_size);
// memcpy(&myDataStruct, buff, sizeof(myDataStruct));
}
void onPostprocessSettings() {
// Called after loading or resetting stored settings
}
void onSettingsStored(const bool success) {
// Called after the entire EEPROM has been written,
// whether successful or not.
}
void onSettingsLoaded(const bool success) {
// Called after the entire EEPROM has been read,
// whether successful or not.
}
#if HAS_LEVELING
void onLevelingStart() {}
void onLevelingDone() {}
#if ENABLED(PREHEAT_BEFORE_LEVELING)
celsius_t getLevelingBedTemp() { return LEVELING_BED_TEMP; }
#endif
#endif
#if HAS_MESH
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) {
// Called when any mesh points are updated
//SERIAL_ECHOLNPGM("onMeshUpdate() x:", xpos, " y:", ypos, " z:", zval);
}
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) {
// Called to indicate a special condition
//SERIAL_ECHOLNPGM("onMeshUpdate() x:", xpos, " y:", ypos, " state:", state);
}
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
void onSetMinExtrusionTemp(const celsius_t) {}
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
void onSetPowerLoss(const bool onoff) {
// Called when power-loss is enabled/disabled
}
void onPowerLoss() {
// Called when power-loss state is detected
}
// Called on resume from power-loss
void onPowerLossResume() { chiron.powerLossRecovery(); }
#endif
#if HAS_PID_HEATING
void onPIDTuning(const pidresult_t rst) {
// Called for temperature PID tuning result
}
void onStartM303(const int count, const heater_id_t hid, const celsius_t temp) {
// Called by M303 to update the UI
}
#endif
#if ENABLED(MPC_AUTOTUNE)
void onMPCTuning(const mpcresult_t rst) {
// Called for temperature MPC tuning result
}
#endif
#if ENABLED(PLATFORM_M997_SUPPORT)
void onFirmwareFlash() {}
#endif
void onSteppersDisabled() {}
void onSteppersEnabled() {}
void onAxisDisabled(const axis_t) {}
void onAxisEnabled(const axis_t) {}
}
#endif // ANYCUBIC_LCD_CHIRON
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_chiron/chiron_extui.cpp
|
C++
|
agpl-3.0
| 5,914
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_chiron/chiron_tft.cpp
*
* Extensible_UI implementation for Anycubic Chiron
* Written By Nick Wells, 2020 [https://github.com/SwiftNick]
* (not affiliated with Anycubic, Ltd.)
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_CHIRON)
#include "chiron_tft.h"
#include "../anycubic/Tunes.h"
#include "FileNavigator.h"
#include "../../../gcode/queue.h"
#include "../../../module/stepper.h"
#include "../../../sd/cardreader.h"
#include "../../../libs/numtostr.h"
#include "../../../MarlinCore.h"
#define DEBUG_OUT ACDEBUGLEVEL
#include "../../../core/debug_out.h"
namespace Anycubic {
ChironTFT chiron;
#if AUTO_DETECT_CHIRON_TFT
panel_type_t ChironTFT::panel_type = AC_panel_unknown;
#endif
last_error_t ChironTFT::last_error;
printer_state_t ChironTFT::printer_state;
paused_state_t ChironTFT::pause_state;
heater_state_t ChironTFT::hotend_state;
heater_state_t ChironTFT::hotbed_state;
xy_uint8_t ChironTFT::selectedmeshpoint;
char ChironTFT::selectedfile[MAX_PATH_LEN + 1];
char ChironTFT::panel_command[MAX_CMND_LEN + 1];
uint8_t ChironTFT::command_len;
float ChironTFT::live_Zoffset;
file_menu_t ChironTFT::file_menu;
void ChironTFT::startup() {
selectedfile[0] = '\0';
panel_command[0] = '\0';
command_len = 0;
last_error = AC_error_none;
printer_state = AC_printer_idle;
pause_state = AC_paused_idle;
hotend_state = AC_heater_off;
hotbed_state = AC_heater_off;
live_Zoffset = 0.0;
file_menu = AC_menu_file;
// Filament runout is handled by Marlin settings in Configuration.h
// opt_set FIL_RUNOUT_STATE HIGH // Pin state indicating that filament is NOT present.
// opt_enable FIL_RUNOUT_PULLUP
TFTSer.begin(115200);
// Wait for the TFT panel to initialize and finish the animation
safe_delay(1000);
// There are different panels for the Chiron with slightly different commands
// So we need to know what we are working with.
// Panel type can be defined otherwise detect it automatically
switch (panel_type) {
case AC_panel_new: SERIAL_ECHOLN(AC_msg_new_panel_set); break;
case AC_panel_standard: SERIAL_ECHOLN(AC_msg_old_panel_set); break;
default: SERIAL_ECHOLN(AC_msg_auto_panel_detection);
detectPanelType();
break;
}
// Signal Board has reset
tftSendLn(AC_msg_main_board_has_reset);
// Enable leveling and Disable end stops during print
// as Z home places nozzle above the bed so we need to allow it past the end stops
injectCommands(AC_cmnd_enable_leveling);
// startup tunes are defined in Tunes.h
playTune(TERN(AC_DEFAULT_STARTUP_TUNE, Anycubic_PowerOn, GB_PowerOn));
#if ACDEBUGLEVEL
DEBUG_ECHOLNPGM("AC Debug Level ", ACDEBUGLEVEL);
#endif
tftSendLn(AC_msg_ready);
}
void ChironTFT::detectPanelType() {
#if AUTO_DETECT_CHIRON_TFT
// Send a query to the TFT
tftSendLn(AC_Test_for_OldPanel); // The panel will respond with 'SXY 480 320'
tftSendLn(AC_Test_for_NewPanel); // the panel will respond with '[0]=0 ' to '[19]=0 '
#endif
}
void ChironTFT::idleLoop() {
if (readTFTCommand()) {
processPanelRequest();
command_len = 0;
}
checkHeaters();
}
void ChironTFT::printerKilled(FSTR_P const error, FSTR_P const component) {
tftSendLn(AC_msg_kill_lcd);
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("printerKilled()\nerror: ", error , "\ncomponent: ", component);
#endif
}
void ChironTFT::mediaEvent(media_event_t event) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("ProcessMediaStatus() ", event);
#endif
switch (event) {
case AC_media_inserted:
tftSendLn(AC_msg_sd_card_inserted);
break;
case AC_media_removed:
tftSendLn(AC_msg_sd_card_removed);
break;
case AC_media_error:
last_error = AC_error_noSD;
tftSendLn(AC_msg_no_sd_card);
break;
}
}
void ChironTFT::timerEvent(timer_event_t event) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("timerEvent() ", event);
DEBUG_ECHOLNPGM("Printer State: ", printer_state);
#endif
switch (event) {
case AC_timer_started: {
live_Zoffset = 0.0; // reset print offset
setSoftEndstopState(false); // disable endstops to print
printer_state = AC_printer_printing;
tftSendLn(AC_msg_print_from_sd_card);
} break;
case AC_timer_paused: {
printer_state = AC_printer_paused;
pause_state = AC_paused_idle;
tftSendLn(AC_msg_paused);
} break;
case AC_timer_stopped: {
if (printer_state != AC_printer_idle) {
printer_state = AC_printer_stopping;
tftSendLn(AC_msg_print_complete);
}
setSoftEndstopState(true); // enable endstops
} break;
}
}
void ChironTFT::filamentRunout() {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("filamentRunout() printer_state ", printer_state);
#endif
// 1 Signal filament out
last_error = AC_error_filament_runout;
tftSendLn(isPrintingFromMedia() ? AC_msg_filament_out_alert : AC_msg_filament_out_block);
playTune(FilamentOut);
}
void ChironTFT::confirmationRequest(const char * const msg) {
// M108 continue
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("confirmationRequest() ", msg, " printer_state:", printer_state);
#endif
switch (printer_state) {
case AC_printer_pausing: {
if (strcmp_P(msg, MARLIN_msg_print_paused) == 0 || strcmp_P(msg, MARLIN_msg_nozzle_parked) == 0) {
tftSendLn(AC_msg_paused); // enable continue button
printer_state = AC_printer_paused;
}
} break;
case AC_printer_resuming_from_power_outage:
case AC_printer_printing:
case AC_printer_paused: {
// Heater timeout, send acknowledgement
if (strcmp_P(msg, MARLIN_msg_heater_timeout) == 0) {
pause_state = AC_paused_heater_timed_out;
tftSendLn(AC_msg_paused); // enable continue button
playTune(HeaterTimeout);
}
// Reheat finished, send acknowledgement
else if (strcmp_P(msg, MARLIN_msg_reheat_done) == 0) {
pause_state = AC_paused_idle;
tftSendLn(AC_msg_paused); // enable continue button
}
// Filament Purging, send acknowledgement enter run mode
else if (strcmp_P(msg, MARLIN_msg_filament_purging) == 0) {
pause_state = AC_paused_purging_filament;
tftSendLn(AC_msg_paused); // enable continue button
}
} break;
default:
break;
}
}
void ChironTFT::statusChange(const char * const msg) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("statusChange() ", msg);
DEBUG_ECHOLNPGM("printer_state:", printer_state);
#endif
bool msg_matched = false;
// The only way to get printer status is to parse messages
// Use the state to minimise the work we do here.
switch (printer_state) {
case AC_printer_probing: {
// If probing completes ok save the mesh and park
// Ignore the custom machine name
if (strcmp_P(msg + strlen(MACHINE_NAME), MARLIN_msg_ready) == 0) {
injectCommands(F("M500\nG27"));
tftSendLn(AC_msg_probing_complete);
printer_state = AC_printer_idle;
msg_matched = true;
}
// If probing fails don't save the mesh raise the probe above the bad point
if (strcmp_P(msg, MARLIN_msg_probing_failed) == 0) {
playTune(BeepBeepBeeep);
injectCommands(F("G1 Z50 F500"));
tftSendLn(AC_msg_probing_complete);
printer_state = AC_printer_idle;
msg_matched = true;
}
} break;
case AC_printer_printing: {
if (strcmp_P(msg, MARLIN_msg_reheating) == 0) {
tftSendLn(AC_msg_paused); // enable continue button
msg_matched = true;
}
} break;
case AC_printer_pausing: {
if (strcmp_P(msg, MARLIN_msg_print_paused) == 0) {
tftSendLn(AC_msg_paused);
printer_state = AC_printer_paused;
pause_state = AC_paused_idle;
msg_matched = true;
}
} break;
case AC_printer_stopping: {
if (strcmp_P(msg, MARLIN_msg_print_aborted) == 0) {
tftSendLn(AC_msg_stop);
printer_state = AC_printer_idle;
msg_matched = true;
}
} break;
default:
break;
}
// If not matched earlier see if this was a heater message
if (!msg_matched) {
if (strcmp_P(msg, MARLIN_msg_extruder_heating) == 0) {
tftSendLn(AC_msg_nozzle_heating);
hotend_state = AC_heater_temp_set;
}
else if (strcmp_P(msg, MARLIN_msg_bed_heating) == 0) {
tftSendLn(AC_msg_bed_heating);
hotbed_state = AC_heater_temp_set;
}
else if (strcmp_P(msg, MARLIN_msg_EEPROM_version) == 0) {
last_error = AC_error_EEPROM;
}
}
}
void ChironTFT::powerLossRecovery() {
printer_state = AC_printer_resuming_from_power_outage; // Play tune to notify user we can recover.
last_error = AC_error_powerloss;
playTune(SOS);
SERIAL_ECHOLN(AC_msg_powerloss_recovery);
}
void ChironTFT::printComplete() {
tftSend(AC_msg_print_complete);
printer_state = AC_printer_idle;
setSoftEndstopState(true); // enable endstops
}
void ChironTFT::tftSend(FSTR_P const fstr/*=nullptr*/) { // A helper to print PROGMEM string to the panel
#if ACDEBUG(AC_SOME)
DEBUG_ECHO(fstr);
#endif
PGM_P str = FTOP(fstr);
while (const char c = pgm_read_byte(str++)) TFTSer.write(c);
}
void ChironTFT::tftSendLn(FSTR_P const fstr/*=nullptr*/) {
if (fstr) {
#if ACDEBUG(AC_SOME)
DEBUG_ECHOPGM("> ");
#endif
tftSend(fstr);
#if ACDEBUG(AC_SOME)
SERIAL_EOL();
#endif
}
TFTSer.println();
}
bool ChironTFT::readTFTCommand() {
bool command_ready = false;
while (TFTSer.available() > 0 && command_len < MAX_CMND_LEN) {
panel_command[command_len] = TFTSer.read();
if (panel_command[command_len] == '\n') {
command_ready = true;
break;
}
command_len++;
}
if (command_ready || command_len == MAX_CMND_LEN) {
panel_command[command_len] = '\0';
#if ACDEBUG(AC_ALL)
DEBUG_ECHOLNPGM("len(",command_len,") < ", panel_command);
#endif
command_ready = true;
}
return command_ready;
}
int8_t ChironTFT::findToken(char c) {
for (int8_t pos = 0; pos < command_len; pos++) {
if (panel_command[pos] == c) {
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Tpos:", pos, " ", c);
#endif
return pos;
}
}
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Not found: ", c);
#endif
return -1;
}
void ChironTFT::checkHeaters() {
uint8_t faultDuration = 0;
// if the hotend temp is abnormal, confirm state before signalling panel
celsius_float_t temp = getActualTemp_celsius(E0);
while (!WITHIN(temp, HEATER_0_MINTEMP, HEATER_0_MAXTEMP)) {
faultDuration++;
if (faultDuration >= AC_HEATER_FAULT_VALIDATION_TIME) {
tftSendLn(AC_msg_nozzle_temp_abnormal);
last_error = AC_error_abnormal_temp_t0;
SERIAL_ECHOLNPGM("Extruder temp abnormal! : ", temp);
break;
}
delay_ms(500);
temp = getActualTemp_celsius(E0);
}
// If the hotbed temp is abnormal, confirm state before signaling panel
faultDuration = 0;
temp = getActualTemp_celsius(BED);
while (!WITHIN(temp, BED_MINTEMP, BED_MAXTEMP)) {
faultDuration++;
if (faultDuration >= AC_HEATER_FAULT_VALIDATION_TIME) {
tftSendLn(AC_msg_nozzle_temp_abnormal);
last_error = AC_error_abnormal_temp_bed;
SERIAL_ECHOLNPGM("Bed temp abnormal! : ", temp);
break;
}
delay_ms(500);
temp = getActualTemp_celsius(E0);
}
// Update panel with hotend heater status
if (hotend_state != AC_heater_temp_reached) {
if (WITHIN(getActualTemp_celsius(E0) - getTargetTemp_celsius(E0), -(TEMP_WINDOW), TEMP_WINDOW)) {
tftSendLn(AC_msg_nozzle_heating_done);
hotend_state = AC_heater_temp_reached;
}
}
// Update panel with bed heater status
if (hotbed_state != AC_heater_temp_reached) {
if (WITHIN(getActualTemp_celsius(BED) - getTargetTemp_celsius(BED), -(TEMP_BED_WINDOW), TEMP_BED_WINDOW)) {
tftSendLn(AC_msg_bed_heating_done);
hotbed_state = AC_heater_temp_reached;
}
}
}
void ChironTFT::sendFileList(int8_t startindex) {
// Respond to panel request for 4 files starting at index
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("## sendFileList ## ", startindex);
#endif
tftSendLn(F("FN "));
filenavigator.getFiles(startindex, panel_type, 4);
tftSendLn(F("END"));
}
void ChironTFT::selectFile() {
const size_t fnlen = command_len - 4 + (panel_type <= AC_panel_new);
strlcpy(selectedfile, panel_command + 4, fnlen + 1);
#if ACDEBUG(AC_FILE)
DEBUG_ECHOLNPGM(" Selected File: ", selectedfile);
#endif
switch (selectedfile[0]) {
case '/': // Valid file selected
tftSendLn(AC_msg_sd_file_open_success);
break;
case '<': // .. (go up folder level)
filenavigator.upDIR();
tftSendLn(AC_msg_sd_file_open_failed);
sendFileList( 0 );
break;
default: // enter subfolder
// For new panel remove the '.GCO' tag that was added to the end of the path
if (panel_type <= AC_panel_new) selectedfile[fnlen - 4] = '\0';
filenavigator.changeDIR(selectedfile);
tftSendLn(AC_msg_sd_file_open_failed);
sendFileList( 0 );
break;
}
}
void ChironTFT::processPanelRequest() {
// Break these up into logical blocks // as its easier to navigate than one huge switch case!
int8_t tpos = findToken('A');
// Panel request are 'A0' - 'A36'
if (tpos >= 0) {
const int8_t req = atoi(&panel_command[tpos + 1]);
// Information requests A0 - A8 and A33
if (req <= 8 || req == 33) panelInfo(req);
// Simple Actions A9 - A28
else if (req <= 28) panelAction(req);
// Process Initiation
else if (req <= 36) panelProcess(req);
}
else {
#if AUTO_DETECT_CHIRON_TFT
// This may be a response to a panel type detection query
if (panel_type == AC_panel_unknown) {
tpos = findToken('S'); // old panel will respond to 'SIZE' with 'SXY 480 320'
if (tpos >= 0) {
if (panel_command[tpos + 1] == 'X' && panel_command[tpos + 2] =='Y') {
panel_type = AC_panel_standard;
SERIAL_ECHOLN(AC_msg_old_panel_detected);
}
}
else {
// new panel will respond to 'J200' with '[0]=0'
// it seems only after a power cycle so detection assumes a new panel
tpos = findToken('[');
if (tpos >= 0) {
if (panel_command[tpos + 1] == '0' && panel_command[tpos + 2] ==']') {
panel_type = AC_panel_new;
SERIAL_ECHOLN(AC_msg_new_panel_detected);
}
}
}
return;
}
#endif
tftSendLn(); // Ignore unknown requests
}
}
void ChironTFT::panelInfo(uint8_t req) {
// information requests A0-A8 and A33
switch (req) {
case 0: // A0 Get HOTEND Temp
tftSend(F("A0V "));
TFTSer.println(getActualTemp_celsius(E0));
break;
case 1: // A1 Get HOTEND Target Temp
tftSend(F("A1V "));
TFTSer.println(getTargetTemp_celsius(E0));
break;
case 2: // A2 Get BED Temp
tftSend(F("A2V "));
TFTSer.println(getActualTemp_celsius(BED));
break;
case 3: // A3 Get BED Target Temp
tftSend(F("A3V "));
TFTSer.println(getTargetTemp_celsius(BED));
break;
case 4: // A4 Get FAN Speed
tftSend(F("A4V "));
TFTSer.println(getActualFan_percent(FAN0));
break;
case 5: // A5 Get Current Coordinates
tftSend(F("A5V X: "));
TFTSer.print(getAxisPosition_mm(X));
tftSend(F(" Y: "));
TFTSer.print(getAxisPosition_mm(Y));
tftSend(F(" Z: "));
TFTSer.println(getAxisPosition_mm(Z));
break;
case 6: // A6 Get printing progress
if (isPrintingFromMedia()) {
tftSend(F("A6V "));
TFTSer.println(ui8tostr2(getProgress_percent()));
}
else
tftSendLn(F("A6V ---"));
break;
case 7: { // A7 Get Printing Time
uint32_t time = getProgress_seconds_elapsed() / 60;
tftSend(F("A7V "));
TFTSer.print(ui8tostr2(time / 60));
tftSend(F(" H "));
TFTSer.print(ui8tostr2(time % 60));
tftSend(F(" M"));
#if ACDEBUG(AC_ALL)
DEBUG_ECHOLNPGM("Print time ", ui8tostr2(time / 60), ":", ui8tostr2(time % 60));
#endif
} break;
case 8: // A8 Get SD Card list A8 S0
if (!isMediaInserted()) safe_delay(500);
if (!isMediaInserted()) // Make sure the card is removed
tftSendLn(AC_msg_no_sd_card);
else if (panel_command[3] == 'S')
sendFileList( atoi( &panel_command[4] ) );
break;
case 33: // A33 Get firmware info
tftSend(F("J33 "));
// If there is an error recorded, show that instead of the FW version
if (!getLastError()) tftSendLn(F(SHORT_BUILD_VERSION));
break;
}
}
void ChironTFT::panelAction(uint8_t req) {
switch (req) {
case 9: // A9 Pause SD print
if (isPrintingFromMedia()) {
tftSendLn(AC_msg_pause);
pausePrint();
printer_state = AC_printer_pausing;
}
else
tftSendLn(AC_msg_stop);
break;
case 10: // A10 Resume SD Print
if (pause_state == AC_paused_idle || printer_state == AC_printer_resuming_from_power_outage)
resumePrint();
else
setUserConfirmed();
break;
case 11: // A11 Stop SD print
if (isPrintingFromMedia()) {
printer_state = AC_printer_stopping;
stopPrint();
}
else {
if (printer_state == AC_printer_resuming_from_power_outage)
injectCommands(F("M1000 C")); // Cancel recovery
tftSendLn(AC_msg_stop);
printer_state = AC_printer_idle;
}
break;
case 12: // A12 Kill printer
kill(); // from marlincore.h
break;
case 13: // A13 Select file
selectFile();
break;
case 14: // A14 Start Printing
// Allows printer to restart the job if we don't want to recover
if (printer_state == AC_printer_resuming_from_power_outage) {
injectCommands(F("M1000 C")); // Cancel recovery
printer_state = AC_printer_idle;
}
DEBUG_ECHOLNPGM("Print: ", selectedfile);
printFile(selectedfile);
tftSendLn(AC_msg_print_from_sd_card);
break;
case 15: // A15 Resuming from outage
if (printer_state == AC_printer_resuming_from_power_outage) {
// Need to home here to restore the Z position
injectCommands(AC_cmnd_power_loss_recovery);
injectCommands(F("M1000")); // home and start recovery
}
break;
case 16: { // A16 Set HotEnd temp A17 S170
const float set_Htemp = atof(&panel_command[5]);
hotend_state = set_Htemp ? AC_heater_temp_set : AC_heater_off;
switch ((char)panel_command[4]) {
// Set Temp
case 'S': case 'C': setTargetTemp_celsius(set_Htemp, E0);
}
} break;
case 17: { // A17 Set bed temp
const float set_Btemp = atof(&panel_command[5]);
hotbed_state = set_Btemp ? AC_heater_temp_set : AC_heater_off;
if (panel_command[4] == 'S')
setTargetTemp_celsius(set_Btemp, BED);
} break;
case 18: // A18 Set Fan Speed
if (panel_command[4] == 'S')
setTargetFan_percent(atof(&panel_command[5]), FAN0);
break;
case 19: // A19 Motors off
if (!isPrinting()) {
stepper.disable_all_steppers();
tftSendLn(AC_msg_ready);
}
break;
case 20: // A20 Read/write print speed
if (panel_command[4] == 'S')
setFeedrate_percent(atoi(&panel_command[5]));
else {
tftSend(F("A20V "));
TFTSer.println(getFeedrate_percent());
}
break;
case 21: // A21 Home Axis A21 X
if (!isPrinting()) {
switch ((char)panel_command[4]) {
case 'X': injectCommands(F("G28X")); break;
case 'Y': injectCommands(F("G28Y")); break;
case 'Z': injectCommands(F("G28Z")); break;
case 'C': injectCommands_P(G28_STR); break;
}
}
break;
case 22: { // A22 Move Axis
// The commands have changed on the new panel
// Old TFT A22 X -1F1500 A22 X +1F1500
// New TFT A22 X-1.0 F1500 A22 X1.0 F1500
// Send a G-code-relative non-print move and let the controller deal with it
// G91 G0 <panel command> G90
if (!isPrinting()) { // Ignore request if printing
char MoveCmnd[30];
sprintf_P(MoveCmnd, PSTR("G91\nG0%s\nG90"), panel_command + 3);
#if ACDEBUG(AC_ACTION)
DEBUG_ECHOLNPGM("Move: ", MoveCmnd);
#endif
setSoftEndstopState(true); // enable endstops
injectCommands(MoveCmnd);
}
} break;
case 23: // A23 Preheat PLA
// Ignore request if printing
if (!isPrinting()) {
// Temps defined in configuration.h
setTargetTemp_celsius(PREHEAT_1_TEMP_BED, BED);
setTargetTemp_celsius(PREHEAT_1_TEMP_HOTEND, E0);
tftSendLn();
hotbed_state = AC_heater_temp_set;
hotend_state = AC_heater_temp_set;
}
break;
case 24: // A24 Preheat ABS
// Ignore request if printing
if (!isPrinting()) {
setTargetTemp_celsius(PREHEAT_2_TEMP_BED, BED);
setTargetTemp_celsius(PREHEAT_2_TEMP_HOTEND, E0);
tftSendLn();
hotbed_state = AC_heater_temp_set;
hotend_state = AC_heater_temp_set;
}
break;
case 25: // A25 Cool Down
// Ignore request if printing
if (!isPrinting()) {
setTargetTemp_celsius(0, E0);
setTargetTemp_celsius(0, BED);
tftSendLn(AC_msg_ready);
hotbed_state = AC_heater_off;
hotend_state = AC_heater_off;
}
break;
case 26: // A26 Refresh SD
if (card.isMounted())card.release();
card.mount();
safe_delay(500);
filenavigator.reset();
break;
case 27: // A27 Servo Angles adjust
break;
case 28: // A28 Filament set A28 O/C
// Ignore request if printing
if (isPrinting()) break;
tftSendLn();
break;
}
}
void ChironTFT::panelProcess(uint8_t req) {
switch (req) {
case 29: { // A29 Read Mesh Point A29 X1 Y1
xy_uint8_t pos;
float pos_z;
pos.x = atoi(&panel_command[findToken('X')+1]);
pos.y = atoi(&panel_command[findToken('Y')+1]);
pos_z = getMeshPoint(pos);
tftSend(F("A29V "));
TFTSer.println(pos_z * 100);
if (!isPrinting()) {
setSoftEndstopState(true); // disable endstops
// If the same meshpoint is selected twice in a row, move the head to that ready for adjustment
if ((selectedmeshpoint.x == pos.x) && (selectedmeshpoint.y == pos.y)) {
if (!isPositionKnown())
injectCommands_P(G28_STR); // home
if (isPositionKnown()) {
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Moving to mesh point at x: ", pos.x, " y: ", pos.y, " z: ", pos_z);
#endif
// Go up before moving
setAxisPosition_mm(3.0,Z);
setAxisPosition_mm(17 + (93 * pos.x), X);
setAxisPosition_mm(20 + (93 * pos.y), Y);
setAxisPosition_mm(0.0, Z);
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Current Z: ", getAxisPosition_mm(Z));
#endif
}
}
selectedmeshpoint.x = pos.x;
selectedmeshpoint.y = pos.y;
}
} break;
case 30: // A30 Auto leveling
if (findToken('S') >= 0) { // Start probing New panel adds spaces..
// Ignore request if printing
if (isPrinting())
tftSendLn(AC_msg_probing_not_allowed); // forbid auto leveling
else {
tftSendLn(AC_msg_start_probing);
injectCommands(F("G28\nG29"));
printer_state = AC_printer_probing;
}
}
else
tftSendLn(AC_msg_start_probing); // Just enter levelling menu
break;
case 31: // A31 Adjust all Probe Points
// The tokens can occur in different places on the new panel so we need to find it.
if (findToken('C') >= 0) { // Restore and apply original offsets
if (!isPrinting()) {
injectCommands(F("M501\nM420 S1"));
selectedmeshpoint.x = selectedmeshpoint.y = 99;
SERIAL_ECHOLN(AC_msg_mesh_changes_abandoned);
}
}
else if (findToken('D') >= 0) { // Save Z Offset tables and restore leveling state
if (!isPrinting()) {
setAxisPosition_mm(1.0,Z); // Lift nozzle before any further movements are made
injectCommands(F("M500"));
SERIAL_ECHOLN(AC_msg_mesh_changes_saved);
selectedmeshpoint.x = selectedmeshpoint.y = 99;
}
}
else if (findToken('G') >= 0) { // Get current offset
tftSend(F("A31V "));
// When printing use the live z Offset position
// we will use babystepping to move the print head
if (isPrinting())
TFTSer.println(live_Zoffset);
else {
TFTSer.println(getZOffset_mm());
selectedmeshpoint.x = selectedmeshpoint.y = 99;
}
}
else {
int8_t tokenpos = findToken('S');
if (tokenpos >= 0) { // Set offset (adjusts all points by value)
float Zshift = atof(&panel_command[tokenpos+1]);
setSoftEndstopState(false); // disable endstops
// Allow temporary Z position nudging during print
// From the leveling panel use the all points UI to adjust the print pos.
if (isPrinting()) {
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Change Zoffset from:", live_Zoffset, " to ", live_Zoffset + Zshift);
#endif
if (isAxisPositionKnown(Z)) {
#if ACDEBUG(AC_INFO)
const float currZpos = getAxisPosition_mm(Z);
DEBUG_ECHOLNPGM("Nudge Z pos from ", currZpos, " to ", currZpos + constrain(Zshift, -0.05, 0.05));
#endif
// Use babystepping to adjust the head position
int16_t steps = mmToWholeSteps(constrain(Zshift,-0.05,0.05), Z);
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Steps to move Z: ", steps);
#endif
babystepAxis_steps(steps, Z);
live_Zoffset += Zshift;
}
tftSend(F("A31V "));
TFTSer.println(live_Zoffset);
}
else {
GRID_LOOP(x, y) {
const xy_uint8_t pos { x, y };
const float currval = getMeshPoint(pos);
setMeshPoint(pos, constrain(currval + Zshift, AC_LOWEST_MESHPOINT_VAL, 2));
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Change mesh point X", x," Y",y ," from ", currval, " to ", getMeshPoint(pos) );
#endif
}
const float currZOffset = getZOffset_mm();
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Change probe offset from ", currZOffset, " to ", currZOffset + Zshift);
#endif
setZOffset_mm(currZOffset + Zshift);
tftSend(F("A31V "));
TFTSer.println(getZOffset_mm());
if (isAxisPositionKnown(Z)) {
// Move Z axis
const float currZpos = getAxisPosition_mm(Z);
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Move Z pos from ", currZpos, " to ", currZpos + constrain(Zshift, -0.05, 0.05));
#endif
setAxisPosition_mm(currZpos+constrain(Zshift,-0.05,0.05),Z);
}
}
}
}
break;
case 32: // A32 clean leveling beep flag
// Ignore request if printing
//if (isPrinting()) break;
//injectCommands(F("M500\nM420 S1\nG1 Z10 F240\nG1 X0 Y0 F6000"));
//TFTSer.println();
break;
// A33 firmware info request see panelInfo()
case 34: // A34 Adjust single mesh point A34 C/S X1 Y1 V123
if (panel_command[3] == 'C') { // Restore original offsets
injectCommands(F("M501\nM420 S1"));
selectedmeshpoint.x = selectedmeshpoint.y = 99;
//printer_state = AC_printer_idle;
}
else {
xy_uint8_t pos;
pos.x = atoi(&panel_command[5]);
pos.y = atoi(&panel_command[8]);
float currmesh = getMeshPoint(pos);
float newval = atof(&panel_command[11])/100;
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Change mesh point x:", pos.x, " y:", pos.y);
DEBUG_ECHOLNPGM("from ", currmesh, " to ", newval);
#endif
// Update Meshpoint
setMeshPoint(pos,newval);
if (printer_state == AC_printer_idle || printer_state == AC_printer_probing /*!isPrinting()*/) {
// if we are at the current mesh point indicated on the panel Move Z pos +/- 0.05mm
// (The panel changes the mesh value by +/- 0.05mm on each button press)
if (selectedmeshpoint.x == pos.x && selectedmeshpoint.y == pos.y) {
setSoftEndstopState(false);
float currZpos = getAxisPosition_mm(Z);
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("Move Z pos from ", currZpos, " to ", currZpos + constrain(newval - currmesh, -0.05, 0.05));
#endif
setAxisPosition_mm(currZpos + constrain(newval - currmesh, -0.05, 0.05), Z);
}
}
}
break;
case 36: // A36 Auto leveling for new TFT bet that was a typo in the panel code!
tftSendLn(AC_msg_start_probing);
break;
}
}
bool ChironTFT::getLastError() {
switch (last_error) {
case AC_error_abnormal_temp_bed: tftSendLn(AC_msg_error_bed_temp); break;
case AC_error_abnormal_temp_t0: tftSendLn(AC_msg_error_hotend_temp); break;
case AC_error_noSD: tftSendLn(AC_msg_error_sd_card); break;
case AC_error_powerloss: tftSendLn(AC_msg_power_loss); break;
case AC_error_EEPROM: tftSendLn(AC_msg_eeprom_version); break;
case AC_error_filament_runout: tftSendLn(AC_msg_filament_out); break;
default: return false;
}
last_error = AC_error_none;
return true;
}
} // Anycubic namespace
#endif // ANYCUBIC_LCD_CHIRON
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_chiron/chiron_tft.cpp
|
C++
|
agpl-3.0
| 31,230
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic_chiron/chiron_tft.h
*
* Extensible_UI implementation for Anycubic Chiron
* Written By Nick Wells, 2020 [https://github.com/SwiftNick]
* (not affiliated with Anycubic, Ltd.)
*/
#include "chiron_tft_defs.h"
#include "../../../inc/MarlinConfigPre.h"
#include "../ui_api.h"
#if NONE(CHIRON_TFT_STANDARD, CHIRON_TFT_NEW)
#define AUTO_DETECT_CHIRON_TFT 1
#endif
namespace Anycubic {
class ChironTFT {
#if AUTO_DETECT_CHIRON_TFT
static panel_type_t panel_type;
#else
static constexpr panel_type_t panel_type = TERN(CHIRON_TFT_NEW, AC_panel_new, AC_panel_standard);
#endif
static last_error_t last_error;
static printer_state_t printer_state;
static paused_state_t pause_state;
static heater_state_t hotend_state;
static heater_state_t hotbed_state;
static xy_uint8_t selectedmeshpoint;
static char panel_command[MAX_CMND_LEN + 1];
static uint8_t command_len;
static char selectedfile[MAX_PATH_LEN + 1];
static float live_Zoffset;
static file_menu_t file_menu;
public:
static void startup();
static void idleLoop();
static void printerKilled(FSTR_P, FSTR_P);
static void mediaEvent(media_event_t);
static void timerEvent(timer_event_t);
static void filamentRunout();
static void confirmationRequest(const char * const);
static void statusChange(const char * const);
static void powerLossRecovery();
static void printComplete();
static void tftSend(FSTR_P const=nullptr);
static void tftSendLn(FSTR_P const=nullptr);
private:
static void detectPanelType();
static bool readTFTCommand();
static int8_t findToken(char);
static void checkHeaters();
static void sendFileList(int8_t);
static void selectFile();
static void processPanelRequest();
static void panelInfo(uint8_t);
static void panelAction(uint8_t);
static void panelProcess(uint8_t);
static bool getLastError();
};
extern ChironTFT chiron;
} // Anycubic namespace
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_chiron/chiron_tft.h
|
C++
|
agpl-3.0
| 2,923
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic_chiron/chiron_defs.h
*
* Extensible_UI implementation for Anycubic Chiron
* Written By Nick Wells, 2020 [https://github.com/SwiftNick]
* (not affiliated with Anycubic, Ltd.)
*/
#include "../anycubic/common_defs.h"
// TFT panel messages
#define AC_msg_mesh_changes_abandoned F("Mesh changes abandoned, previous mesh restored.")
#define AC_msg_mesh_changes_saved F("Mesh changes saved.")
#define AC_msg_old_panel_detected F("Standard TFT panel detected!")
#define AC_msg_new_panel_detected F("New TFT panel detected!")
#define AC_msg_auto_panel_detection F("Auto detect panel type (assuming new panel)")
#define AC_msg_old_panel_set F("Set for standard TFT panel.")
#define AC_msg_new_panel_set F("Set for new TFT panel.")
#define AC_msg_powerloss_recovery F("Resuming from power outage! select the same SD file then press resume")
// Error messages must not contain spaces
#define AC_msg_error_bed_temp F("Abnormal_bed_temp")
#define AC_msg_error_hotend_temp F("Abnormal_hotend_temp")
#define AC_msg_error_sd_card F("SD_card_error")
#define AC_msg_filament_out F("Filament_runout")
#define AC_msg_power_loss F("Power_failure")
#define AC_msg_eeprom_version F("EEPROM_ver_wrong")
#define MARLIN_msg_EEPROM_version PSTR("EEPROM Version Error")
#define AC_Test_for_OldPanel F("SIZE") // An old panel will respond with 'SXY 480 320' a new panel wont respond.
#define AC_Test_for_NewPanel F("J200") // A new panel will respond with '[0]=0 [1]=0' to '[19]=0 ' an old panel wont respond
namespace Anycubic {
enum paused_state_t : uint8_t {
AC_paused_heater_timed_out,
AC_paused_purging_filament,
AC_paused_idle
};
enum printer_state_t : uint8_t {
AC_printer_booting,
AC_printer_idle,
AC_printer_probing,
AC_printer_printing,
AC_printer_pausing,
AC_printer_paused,
AC_printer_stopping,
AC_printer_resuming_from_power_outage
};
enum panel_type_t : uint8_t { // order is important here as we assume new panel if type is unknown
AC_panel_unknown,
AC_panel_new,
AC_panel_standard
};
enum last_error_t : uint8_t {
AC_error_none,
AC_error_abnormal_temp_t0,
AC_error_abnormal_temp_bed,
AC_error_noSD,
AC_error_powerloss,
AC_error_filament_runout,
AC_error_EEPROM
};
} // Anycubic
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_chiron/chiron_tft_defs.h
|
C++
|
agpl-3.0
| 3,336
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_i3mega/anycubic_extui.cpp
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_I3MEGA)
#include "anycubic_i3mega_lcd.h"
#include "../ui_api.h"
#include <Arduino.h> // for the ::tone() call
namespace ExtUI {
void onStartup() { anycubicTFT.onSetup(); }
void onIdle() { anycubicTFT.onCommandScan(); }
void onPrinterKilled(FSTR_P const error, FSTR_P const component) { anycubicTFT.onKillTFT(); }
void onMediaInserted() { anycubicTFT.onSDCardStateChange(true); }
void onMediaError() { anycubicTFT.onSDCardError(); }
void onMediaRemoved() { anycubicTFT.onSDCardStateChange(false); }
void onHeatingError(const heater_id_t header_id) {}
void onMinTempError(const heater_id_t header_id) {}
void onMaxTempError(const heater_id_t header_id) {}
void onPlayTone(const uint16_t frequency, const uint16_t duration/*=0*/) {
TERN_(SPEAKER, ::tone(BEEPER_PIN, frequency, duration));
}
void onPrintTimerStarted() { anycubicTFT.onPrintTimerStarted(); }
void onPrintTimerPaused() { anycubicTFT.onPrintTimerPaused(); }
void onPrintTimerStopped() { anycubicTFT.onPrintTimerStopped(); }
void onFilamentRunout(const extruder_t extruder) { anycubicTFT.onFilamentRunout(); }
void onUserConfirmRequired(const char * const msg) { anycubicTFT.onUserConfirmRequired(msg); }
// For fancy LCDs include an icon ID, message, and translated button title
void onUserConfirmRequired(const int icon, const char * const cstr, FSTR_P const fBtn) {
onUserConfirmRequired(cstr);
UNUSED(icon); UNUSED(fBtn);
}
void onUserConfirmRequired(const int icon, FSTR_P const fstr, FSTR_P const fBtn) {
onUserConfirmRequired(fstr);
UNUSED(icon); UNUSED(fBtn);
}
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void onPauseMode(
const PauseMessage message,
const PauseMode mode/*=PAUSE_MODE_SAME*/,
const uint8_t extruder/*=active_extruder*/
) {
stdOnPauseMode(message, mode, extruder);
}
#endif
void onStatusChanged(const char * const msg) {}
void onHomingStart() {}
void onHomingDone() {}
void onPrintDone() {}
void onFactoryReset() {}
void onStoreSettings(char *buff) {
// Called when saving to EEPROM (i.e. M500). If the ExtUI needs
// permanent data to be stored, it can write up to eeprom_data_size bytes
// into buff.
// Example:
// static_assert(sizeof(myDataStruct) <= eeprom_data_size);
// memcpy(buff, &myDataStruct, sizeof(myDataStruct));
}
void onLoadSettings(const char *buff) {
// Called while loading settings from EEPROM. If the ExtUI
// needs to retrieve data, it should copy up to eeprom_data_size bytes
// from buff
// Example:
// static_assert(sizeof(myDataStruct) <= eeprom_data_size);
// memcpy(&myDataStruct, buff, sizeof(myDataStruct));
}
void onPostprocessSettings() {
// Called after loading or resetting stored settings
}
void onSettingsStored(const bool success) {
// Called after the entire EEPROM has been written,
// whether successful or not.
}
void onSettingsLoaded(const bool success) {
// Called after the entire EEPROM has been read,
// whether successful or not.
}
#if HAS_LEVELING
void onLevelingStart() {}
void onLevelingDone() {}
#if ENABLED(PREHEAT_BEFORE_LEVELING)
celsius_t getLevelingBedTemp() { return LEVELING_BED_TEMP; }
#endif
#endif
#if HAS_MESH
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) {
// Called when any mesh points are updated
}
void onMeshUpdate(const int8_t xpos, const int8_t ypos, probe_state_t state) {
// Called when any mesh points are updated
}
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
void onSetMinExtrusionTemp(const celsius_t) {}
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
void onSetPowerLoss(const bool onoff) {
// Called when power-loss is enabled/disabled
}
void onPowerLoss() {
// Called when power-loss state is detected
}
void onPowerLossResume() {
// Called on resume from power-loss
}
#endif
#if HAS_PID_HEATING
void onPIDTuning(const pidresult_t rst) {
// Called for temperature PID tuning result
}
void onStartM303(const int count, const heater_id_t hid, const celsius_t temp) {
// Called by M303 to update the UI
}
#endif
#if ENABLED(MPC_AUTOTUNE)
void onMPCTuning(const mpcresult_t rst) {
// Called for temperature MPC tuning result
}
#endif
#if ENABLED(PLATFORM_M997_SUPPORT)
void onFirmwareFlash() {}
#endif
void onSteppersDisabled() {}
void onSteppersEnabled() {}
void onAxisDisabled(const axis_t) {}
void onAxisEnabled(const axis_t) {}
}
#endif // ANYCUBIC_LCD_I3MEGA
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_i3mega/anycubic_extui.cpp
|
C++
|
agpl-3.0
| 5,672
|
/**
* anycubic_i3mega_lcd.cpp --- Support for Anycubic i3 Mega TFT
* Created by Christian Hopp on 09.12.17.
* Improved by David Ramiro
* Converted to ExtUI by John BouAntoun 21 June 2020
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_I3MEGA)
//#define ANYCUBIC_LCD_DEBUG
#define DEBUG_OUT ENABLED(ANYCUBIC_LCD_DEBUG)
#include "../../../core/debug_out.h"
#include "anycubic_i3mega_lcd.h"
#include "../ui_api.h"
#include "../../../libs/numtostr.h"
#include "../../../module/stepper.h" // for disable_all_steppers
#include "../../../module/motion.h" // for quickstop_stepper, A20 read printing speed, feedrate_percentage
#include "../../../MarlinCore.h" // for disable_steppers
#include "../../../inc/MarlinConfig.h"
// command sending macro's with debugging capability
#define SEND_PGM(x) send_P(PSTR(x))
#define SENDLINE_PGM(x) sendLine_P(PSTR(x))
#define SEND_PGM_VAL(x,y) (send_P(PSTR(x)), sendLine(i16tostr3rj(y)))
#define SEND(x) send(x)
#define SENDLINE(x) sendLine(x)
#define SENDLINE_DBG_PGM(x,y) do{ sendLine_P(PSTR(x)); DEBUG_ECHOLNPGM(y); }while(0)
#define SENDLINE_DBG_PGM_VAL(x,y,z) do{ sendLine_P(PSTR(x)); DEBUG_ECHOLNPGM(y, z); }while(0)
// Append ".gcode" to filename, if requested. Used for some DGUS-clone displays with built-in filter.
// Filenames are limited to 26 characters, so the actual name for the FILENAME can be 20 characters at most.
// If a longer string is desired without "extension, use the ALTNAME macro to provide a (longer) alternative.
#define SPECIAL_MENU_FILENAME(A) A TERN_(ANYCUBIC_LCD_GCODE_EXT, ".gcode")
#define SPECIAL_MENU_ALTNAME(A, B) TERN(ANYCUBIC_LCD_GCODE_EXT, A ".gcode", B)
AnycubicTFT anycubicTFT;
char AnycubicTFT::tftCommands[TFTBUFSIZE][TFT_MAX_CMD_SIZE];
int AnycubicTFT::tftBufLen = 0,
AnycubicTFT::tftBufIndR = 0,
AnycubicTFT::tftBufIndW = 0;
char* AnycubicTFT::tftStrchrPtr;
uint8_t AnycubicTFT::specialMenu = false;
AnycubicMediaPrintState AnycubicTFT::mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
AnycubicMediaPauseState AnycubicTFT::mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
char AnycubicTFT::selectedDirectory[30];
char AnycubicTFT::selectedFile[FILENAME_LENGTH];
// Serial helpers
static void sendNewLine() { LCD_SERIAL.write('\r'); LCD_SERIAL.write('\n'); }
static void send(const char *str) { LCD_SERIAL.print(str); }
static void send_P(PGM_P str) {
while (const char c = pgm_read_byte(str++))
LCD_SERIAL.write(c);
}
static void sendLine(const char *str) { send(str); sendNewLine(); }
static void sendLine_P(PGM_P str) { send_P(str); sendNewLine(); }
using namespace ExtUI;
AnycubicTFT::AnycubicTFT() {}
void AnycubicTFT::onSetup() {
#ifndef LCD_BAUDRATE
#define LCD_BAUDRATE 115200
#endif
LCD_SERIAL.begin(LCD_BAUDRATE);
SENDLINE_DBG_PGM("J17", "TFT Serial Debug: Main board reset... J17"); // J17 Main board reset
delay_ms(10);
// Init the state of the key pins running on the TFT
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
SET_INPUT_PULLUP(FIL_RUNOUT1_PIN);
#endif
mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
// doSDCardStateCheck();
SENDLINE_DBG_PGM("J12", "TFT Serial Debug: Ready... J12"); // J12 Ready
delay_ms(10);
doFilamentRunoutCheck();
selectedFile[0] = 0;
#if ENABLED(STARTUP_CHIME)
injectCommands(F("M300 P250 S554\nM300 P250 S554\nM300 P250 S740\nM300 P250 S554\nM300 P250 S740\nM300 P250 S554\nM300 P500 S831"));
#endif
DEBUG_ECHOLNPGM("TFT Serial Debug: Finished startup");
}
void AnycubicTFT::onCommandScan() {
static millis_t nextStopCheck = 0; // used to slow the stopped print check down to reasonable times
const millis_t ms = millis();
if (ELAPSED(ms, nextStopCheck)) {
nextStopCheck = ms + 1000UL;
if (mediaPrintingState == AMPRINTSTATE_STOP_REQUESTED && isNozzleHomed()) {
DEBUG_ECHOLNPGM("TFT Serial Debug: Finished stopping print, releasing motors ...");
mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
injectCommands(F("M84\nM27")); // disable stepper motors and force report of SD status
delay_ms(200);
// tell printer to release resources of print to indicate it is done
SENDLINE_DBG_PGM("J14", "TFT Serial Debug: SD Print Stopped... J14");
}
}
if (tftBufLen < (TFTBUFSIZE) - 1)
getCommandFromTFT();
if (tftBufLen) {
--tftBufLen;
tftBufIndR = (tftBufIndR + 1) % (TFTBUFSIZE);
}
}
void AnycubicTFT::onKillTFT() {
SENDLINE_DBG_PGM("J11", "TFT Serial Debug: Kill command... J11");
}
void AnycubicTFT::onSDCardStateChange(bool isInserted) {
DEBUG_ECHOLNPGM("TFT Serial Debug: onSDCardStateChange event triggered...", isInserted);
doSDCardStateCheck();
}
void AnycubicTFT::onSDCardError() {
DEBUG_ECHOLNPGM("TFT Serial Debug: onSDCardError event triggered...");
SENDLINE_DBG_PGM("J21", "TFT Serial Debug: On SD Card Error ... J21");
}
void AnycubicTFT::onFilamentRunout() {
DEBUG_ECHOLNPGM("TFT Serial Debug: onFilamentRunout triggered...");
doFilamentRunoutCheck();
}
void AnycubicTFT::onUserConfirmRequired(const char * const msg) {
DEBUG_ECHOLNPGM("TFT Serial Debug: onUserConfirmRequired triggered... ", msg);
#if HAS_MEDIA
/**
* Need to handle the process of following states
* "Nozzle Parked"
* "Load Filament"
* "Filament Purging..."
* "HeaterTimeout"
* "Reheat finished."
*
* NOTE: The only way to handle these states is strcmp_P with the msg unfortunately (very expensive)
*/
if (strcmp_P(msg, PSTR("Nozzle Parked")) == 0) {
mediaPrintingState = AMPRINTSTATE_PAUSED;
mediaPauseState = AMPAUSESTATE_PARKED;
// enable continue button
SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD print paused done... J18");
}
else if (strcmp_P(msg, PSTR("Load Filament")) == 0) {
mediaPrintingState = AMPRINTSTATE_PAUSED;
mediaPauseState = AMPAUSESTATE_FILAMENT_OUT;
// enable continue button
SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm Filament is out... J18");
SENDLINE_DBG_PGM("J23", "TFT Serial Debug: UserConfirm Blocking filament prompt... J23");
}
else if (strcmp_P(msg, PSTR("Filament Purging...")) == 0) {
mediaPrintingState = AMPRINTSTATE_PAUSED;
mediaPauseState = AMPAUSESTATE_PARKING;
// TODO: JBA I don't think J05 just disables the continue button, i think it injects a rogue M25. So taking this out
// disable continue button
// SENDLINE_DBG_PGM("J05", "TFT Serial Debug: UserConfirm SD Filament Purging... J05"); // J05 printing pause
// enable continue button
SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm Filament is purging... J18");
}
else if (strcmp_P(msg, PSTR("HeaterTimeout")) == 0) {
mediaPrintingState = AMPRINTSTATE_PAUSED;
mediaPauseState = AMPAUSESTATE_HEATER_TIMEOUT;
// enable continue button
SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD Heater timeout... J18");
}
else if (strcmp_P(msg, PSTR("Reheat finished.")) == 0) {
mediaPrintingState = AMPRINTSTATE_PAUSED;
mediaPauseState = AMPAUSESTATE_REHEAT_FINISHED;
// enable continue button
SENDLINE_DBG_PGM("J18", "TFT Serial Debug: UserConfirm SD Reheat done... J18");
}
#endif
}
float AnycubicTFT::codeValue() {
return (strtod(&tftCommands[tftBufIndR][tftStrchrPtr - tftCommands[tftBufIndR] + 1], nullptr));
}
bool AnycubicTFT::codeSeen(char code) {
tftStrchrPtr = strchr(tftCommands[tftBufIndR], code);
return !!tftStrchrPtr; // Return True if a character was found
}
bool AnycubicTFT::isNozzleHomed() {
const float xPosition = getAxisPosition_mm((axis_t) X);
const float yPosition = getAxisPosition_mm((axis_t) Y);
return WITHIN(xPosition, X_MIN_POS - 0.1, X_MIN_POS + 0.1) &&
WITHIN(yPosition, Y_MIN_POS - 0.1, Y_MIN_POS + 0.1);
}
void AnycubicTFT::handleSpecialMenu() {
/**
* NOTE: that the file selection command actual lowercases the entire selected file/foldername, so charracter comparisons need to be lowercase.
*/
if (selectedDirectory[0] != '<') {
DEBUG_ECHOLNPGM("TFT Serial Debug: Attempted to handleSpecialMenu on non-special menu... ", selectedDirectory);
return;
}
switch (selectedDirectory[1]) {
default: break;
case 'e': specialMenu = false; return; // "<exit>"
#if ENABLED(PROBE_MANUALLY)
case '0':
switch (selectedDirectory[2]) {
default: break;
case '1': // "<01ZUp0.1>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Z Up 0.1"));
injectCommands(F("G91\nG1 Z+0.1\nG90"));
break;
case '2': // "<02ZUp0.02>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Z Up 0.02"));
injectCommands(F("G91\nG1 Z+0.02\nG90"));
break;
case '3': // "<03ZDn0.02>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Z Down 0.02"));
injectCommands(F("G91\nG1 Z-0.02\nG90"));
break;
case '4': // "<04ZDn0.1>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Z Down 0.1"));
injectCommands(F("G91\nG1 Z-0.1\nG90"));
break;
case '5': // "<05PrehtBed>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Preheat Bed"));
injectCommands(F("M140 S65"));
break;
case '6': // "<06SMeshLvl>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Start Mesh Leveling"));
injectCommands(F("G29S1"));
break;
case '7': // "<07MeshNPnt>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Next Mesh Point"));
injectCommands(F("G29S2"));
break;
case '8': // "<08HtEndPID>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Auto Tune Hotend PID"));
// need to dwell for half a second to give the fan a chance to start before the pid tuning starts
injectCommands(F("M106 S204\nG4 P500\nM303 E0 S215 C15 U1"));
break;
case '9': // "<09HtBedPID>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Auto Tune Hotbed PID"));
injectCommands(F("M303 E-1 S65 C6 U1"));
break;
}
break;
case '1':
switch (selectedDirectory[2]) {
default: break;
case '0': // "<10FWDeflts>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Load FW Defaults"));
injectCommands(F("M502\nM300 P105 S1661\nM300 P210 S1108"));
break;
case '1': // "<11SvEEPROM>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Save EEPROM"));
injectCommands(F("M500\nM300 P105 S1108\nM300 P210 S1661"));
break;
}
break;
#else // !PROBE_MANUALLY
case '0':
switch (selectedDirectory[2]) {
default: break;
case '1': // "<01PrehtBed>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Preheat Bed"));
injectCommands(F("M140 S65"));
break;
case '2': // "<02ABL>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Auto Bed Leveling"));
injectCommands(F("G29N"));
break;
case '3': // "<03HtendPID>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Auto Tune Hotend PID"));
// need to dwell for half a second to give the fan a chance to start before the pid tuning starts
injectCommands(F("M106 S204\nG4 P500\nM303 E0 S215 C15 U1"));
break;
case '4': // "<04HtbedPID>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Auto Tune Hotbed PID"));
injectCommands(F("M303 E-1 S65 C6 U1"));
break;
case '5': // "<05FWDeflts>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Load FW Defaults"));
injectCommands(F("M502\nM300 P105 S1661\nM300 P210 S1108"));
break;
case '6': // "<06SvEEPROM>"
SERIAL_ECHOLNPGM("Special Menu: ", F("Save EEPROM"));
injectCommands(F("M500\nM300 P105 S1108\nM300 P210 S1661"));
break;
case '7': // <07SendM108>
SERIAL_ECHOLNPGM("Special Menu: ", F("Send User Confirmation"));
injectCommands(F("M108"));
break;
}
break;
#endif // !PROBE_MANUALLY
}
}
void AnycubicTFT::renderCurrentFileList() {
#if HAS_MEDIA
uint16_t selectedNumber = 0;
selectedDirectory[0] = 0;
selectedFile[0] = 0;
FileList currentFileList;
SENDLINE_PGM("FN "); // Filelist start
if (!isMediaInserted() && !specialMenu) {
SENDLINE_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to render Current File List... J02");
SENDLINE_PGM("<SPECI~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Special Menu>"));
}
else {
if (codeSeen('S'))
selectedNumber = codeValue();
if (specialMenu)
renderSpecialMenu(selectedNumber);
else if (selectedNumber <= currentFileList.count())
renderCurrentFolder(selectedNumber);
}
SENDLINE_PGM("END"); // Filelist stop
#endif // HAS_MEDIA
}
void AnycubicTFT::renderSpecialMenu(uint16_t selectedNumber) {
switch (selectedNumber) {
default: break;
#if ENABLED(PROBE_MANUALLY)
case 0: // First Page
SENDLINE_PGM("<01ZUP~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Z Up 0.1>"));
SENDLINE_PGM("<02ZUP~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Z Up 0.02>"));
SENDLINE_PGM("<03ZDO~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Z Down 0.02>"));
SENDLINE_PGM("<04ZDO~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Z Down 0.1>"));
break;
case 4: // Second Page
SENDLINE_PGM("<05PRE~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Preheat Bed>"));
SENDLINE_PGM("<06MES~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_ALTNAME("<Mesh Leveling>", "<Start Mesh Leveling>"));
SENDLINE_PGM("<07NEX~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Next Mesh Point>"));
SENDLINE_PGM("<08PID~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<PID Tune Hotend>"));
break;
case 8: // Third Page
SENDLINE_PGM("<09PID~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<PID Tune Hotbed>"));
SENDLINE_PGM("<10FWD~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Load FW Defaults>"));
SENDLINE_PGM("<11SAV~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Save EEPROM>"));
SENDLINE_PGM("<EXIT_~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Exit>"));
break;
#else // !PROBE_MANUALLY
case 0: // First Page
SENDLINE_PGM("<01PRE~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Preheat Bed>"));
SENDLINE_PGM("<02ABL~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Auto Bed Leveling>"));
SENDLINE_PGM("<03PID~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_ALTNAME("<PID Tune Hotend>", "<Auto Tune Hotend PID>"));
SENDLINE_PGM("<04PID~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_ALTNAME("<PID Tune Hotbed>", "<Auto Tune Hotbed PID>"));
break;
case 4: // Second Page
SENDLINE_PGM("<05FWD~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Load FW Defaults>"));
SENDLINE_PGM("<06SAV~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Save EEPROM>"));
SENDLINE_PGM("<06SEN~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_ALTNAME("<User Confirmation>", "<Send User Confirmation>"));
SENDLINE_PGM("<EXIT_~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Exit>"));
break;
#endif // !PROBE_MANUALLY
}
}
void AnycubicTFT::renderCurrentFolder(uint16_t selectedNumber) {
FileList currentFileList;
const uint16_t dir_files = currentFileList.count(),
max_files = (dir_files - selectedNumber) < 4 ? dir_files : selectedNumber + 3;
for (uint16_t cnt = selectedNumber; cnt <= max_files; cnt++) {
if (cnt == 0) { // Special Entry
if (currentFileList.isAtRootDir()) {
SENDLINE_PGM("<SPECI~1.GCO");
SENDLINE_PGM(SPECIAL_MENU_FILENAME("<Special Menu>"));
}
else {
SENDLINE_PGM("/..");
SENDLINE_PGM("/..");
}
}
else {
currentFileList.seek(cnt - 1, false);
DEBUG_ECHOLN(currentFileList.filename());
if (currentFileList.isDir()) {
SEND_PGM("/");
SENDLINE(currentFileList.shortFilename());
SEND_PGM("/");
SENDLINE(currentFileList.filename());
}
else {
SENDLINE(currentFileList.shortFilename());
SENDLINE(currentFileList.filename());
}
}
}
}
void AnycubicTFT::onPrintTimerStarted() {
#if HAS_MEDIA
if (mediaPrintingState == AMPRINTSTATE_PRINTING)
SENDLINE_DBG_PGM("J04", "TFT Serial Debug: Starting SD Print... J04"); // J04 Starting Print
#endif
}
void AnycubicTFT::onPrintTimerPaused() {
#if HAS_MEDIA
if (isPrintingFromMedia()) {
mediaPrintingState = AMPRINTSTATE_PAUSED;
mediaPauseState = AMPAUSESTATE_PARKING;
}
#endif
}
void AnycubicTFT::onPrintTimerStopped() {
#if HAS_MEDIA
if (mediaPrintingState == AMPRINTSTATE_PRINTING) {
mediaPrintingState = AMPRINTSTATE_NOT_PRINTING;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
SENDLINE_DBG_PGM("J14", "TFT Serial Debug: SD Print Completed... J14");
}
// otherwise it was stopped by the printer so don't send print completed signal to TFT
#endif
}
#define ROUND(val) int((val)+0.5f)
void AnycubicTFT::getCommandFromTFT() {
static int serial_count = 0;
char *starpos = nullptr;
while (LCD_SERIAL.available() > 0 && tftBufLen < (TFTBUFSIZE)) {
char c = LCD_SERIAL.read();
if (c != '\n' && c != '\r' && c != ':' && serial_count < (TFT_MAX_CMD_SIZE - 1)) {
tftCommands[tftBufIndW][serial_count++] = c;
continue;
}
if (!serial_count) return; // if empty line
tftCommands[tftBufIndW][serial_count] = 0; // terminate string
if ((strchr(tftCommands[tftBufIndW], 'A') != nullptr)) {
int16_t a_command;
tftStrchrPtr = strchr(tftCommands[tftBufIndW], 'A');
a_command = ((int)((strtod(&tftCommands[tftBufIndW][tftStrchrPtr - tftCommands[tftBufIndW] + 1], nullptr))));
if (a_command > 7 && a_command != 20) { // No debugging of status polls, please!
DEBUG_ECHOLNPGM("TFT Serial Command: ", tftCommands[tftBufIndW]);
}
switch (a_command) {
case 0: { // A0 GET HOTEND TEMP
const celsius_float_t hotendActualTemp = getActualTemp_celsius(E0);
SEND_PGM_VAL("A0V ", ROUND(hotendActualTemp));
}
break;
case 1: { // A1 GET HOTEND TARGET TEMP
const celsius_float_t hotendTargetTemp = getTargetTemp_celsius(E0);
SEND_PGM_VAL("A1V ", ROUND(hotendTargetTemp));
}
break;
case 2: { // A2 GET HOTBED TEMP
const celsius_float_t heatedBedActualTemp = getActualTemp_celsius(BED);
SEND_PGM_VAL("A2V ", ROUND(heatedBedActualTemp));
}
break;
case 3: { // A3 GET HOTBED TARGET TEMP
const celsius_float_t heatedBedTargetTemp = getTargetTemp_celsius(BED);
SEND_PGM_VAL("A3V ", ROUND(heatedBedTargetTemp));
} break;
case 4: { // A4 GET FAN SPEED
SEND_PGM_VAL("A4V ", int(getActualFan_percent(FAN0)));
} break;
case 5: { // A5 GET CURRENT COORDINATE
const float xPosition = getAxisPosition_mm(X),
yPosition = getAxisPosition_mm(Y),
zPosition = getAxisPosition_mm(Z);
SEND_PGM("A5V X: "); LCD_SERIAL.print(xPosition);
SEND_PGM( " Y: "); LCD_SERIAL.print(yPosition);
SEND_PGM( " Z: "); LCD_SERIAL.print(zPosition);
SENDLINE_PGM("");
} break;
case 6: // A6 GET SD CARD PRINTING STATUS
#if HAS_MEDIA
if (isPrintingFromMedia()) {
SEND_PGM("A6V ");
if (isMediaInserted())
SENDLINE(ui8tostr3rj(getProgress_percent()));
else
SENDLINE_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to return printing status... J02");
}
else
SENDLINE_PGM("A6V ---");
#endif
break;
case 7: { // A7 GET PRINTING TIME
const uint32_t elapsedSeconds = getProgress_seconds_elapsed();
SEND_PGM("A7V ");
if (elapsedSeconds != 0) { // print time
const uint32_t elapsedMinutes = elapsedSeconds / 60;
SEND(ui8tostr2(elapsedMinutes / 60));
SEND_PGM(" H ");
SEND(ui8tostr2(elapsedMinutes % 60));
SENDLINE_PGM(" M");
}
else
SENDLINE_PGM(" 999:999");
}
break;
case 8: // A8 GET SD LIST
#if HAS_MEDIA
selectedFile[0] = 0;
renderCurrentFileList();
#endif
break;
case 9: // A9 pause sd print
TERN_(HAS_MEDIA, if (isPrintingFromMedia()) pausePrint());
break;
case 10: // A10 resume sd print
#if HAS_MEDIA
if (isPrintingFromMediaPaused())
resumePrint();
#endif
break;
case 11: // A11 STOP SD PRINT
TERN_(HAS_MEDIA, stopPrint());
break;
case 12: // A12 kill
kill(F(STR_ERR_KILLED));
break;
case 13: // A13 SELECTION FILE
#if HAS_MEDIA
if (isMediaInserted()) {
starpos = (strchr(tftStrchrPtr + 4, '*'));
if (tftStrchrPtr[4] == '/') {
strcpy(selectedDirectory, tftStrchrPtr + 5);
selectedFile[0] = 0;
SENDLINE_DBG_PGM("J21", "TFT Serial Debug: Clear file selection... J21 "); // J21 Not File Selected
SENDLINE_PGM("");
}
else if (tftStrchrPtr[4] == '<') {
strcpy(selectedDirectory, tftStrchrPtr + 4);
specialMenu = true;
selectedFile[0] = 0;
SENDLINE_DBG_PGM("J21", "TFT Serial Debug: Clear file selection... J21 "); // J21 Not File Selected
SENDLINE_PGM("");
}
else {
selectedDirectory[0] = 0;
if (starpos) *(starpos - 1) = '\0';
strcpy(selectedFile, tftStrchrPtr + 4);
SENDLINE_DBG_PGM_VAL("J20", "TFT Serial Debug: File Selected... J20 ", selectedFile); // J20 File Selected
}
}
#endif
break;
case 14: // A14 START PRINTING
#if HAS_MEDIA
if (!isPrinting() && strlen(selectedFile) > 0)
startPrint();
#endif
break;
case 15: // A15 RESUMING FROM OUTAGE
// TODO: JBA implement resume form outage
break;
case 16: { // A16 set hotend temp
uint16_t tempvalue;
if (codeSeen('S')) {
tempvalue = constrain(codeValue(), 0, 275);
setTargetTemp_celsius(tempvalue, (extruder_t)E0);
}
else if (codeSeen('C') && !isPrinting()) {
if (getAxisPosition_mm(Z) < 10)
injectCommands(F("G1 Z10")); // RASE Z AXIS
tempvalue = constrain(codeValue(), 0, 275);
setTargetTemp_celsius(tempvalue, (extruder_t)E0);
}
}
break;
case 17: { // A17 set heated bed temp
uint16_t tempbed;
if (codeSeen('S')) {
tempbed = constrain(codeValue(), 0, 100);
setTargetTemp_celsius(tempbed, (heater_t)BED);
}
}
break;
case 18: { // A18 set fan speed
float fanPercent;
if (codeSeen('S')) {
fanPercent = constrain(codeValue(), 0, 100);
setTargetFan_percent(fanPercent, FAN0);
}
else
fanPercent = 100;
setTargetFan_percent(fanPercent, FAN0);
SENDLINE_PGM("");
}
break;
case 19: // A19 stop stepper drivers - sent on stop extrude command and on turn motors off command
if (!isPrinting()) {
quickstop_stepper();
stepper.disable_all_steppers();
}
SENDLINE_PGM("");
break;
case 20: // A20 read printing speed
if (codeSeen('S'))
feedrate_percentage = constrain(codeValue(), 40, 999);
else
SEND_PGM_VAL("A20V ", feedrate_percentage);
break;
case 21: // A21 all home
if (!isPrinting() && !isPrintingFromMediaPaused()) {
if (codeSeen('X') || codeSeen('Y') || codeSeen('Z')) {
if (codeSeen('X'))
injectCommands(F("G28X"));
if (codeSeen('Y'))
injectCommands(F("G28Y"));
if (codeSeen('Z'))
injectCommands(F("G28Z"));
}
else if (codeSeen('C')) {
injectCommands_P(G28_STR);
}
}
break;
case 22: // A22 move X/Y/Z or extrude
if (!isPrinting()) {
float coorvalue;
uint16_t movespeed = 0;
char commandStr[30];
char fullCommandStr[38];
commandStr[0] = 0; // empty string
if (codeSeen('F')) // Set feedrate
movespeed = codeValue();
if (codeSeen('X')) { // Move in X direction
coorvalue = codeValue();
if ((coorvalue <= 0.2) && coorvalue > 0)
sprintf_P(commandStr, PSTR("G1 X0.1F%i"), movespeed);
else if ((coorvalue <= -0.1) && coorvalue > -1)
sprintf_P(commandStr, PSTR("G1 X-0.1F%i"), movespeed);
else
sprintf_P(commandStr, PSTR("G1 X%iF%i"), int(coorvalue), movespeed);
}
else if (codeSeen('Y')) { // Move in Y direction
coorvalue = codeValue();
if ((coorvalue <= 0.2) && coorvalue > 0)
sprintf_P(commandStr, PSTR("G1 Y0.1F%i"), movespeed);
else if ((coorvalue <= -0.1) && coorvalue > -1)
sprintf_P(commandStr, PSTR("G1 Y-0.1F%i"), movespeed);
else
sprintf_P(commandStr, PSTR("G1 Y%iF%i"), int(coorvalue), movespeed);
}
else if (codeSeen('Z')) { // Move in Z direction
coorvalue = codeValue();
if ((coorvalue <= 0.2) && coorvalue > 0)
sprintf_P(commandStr, PSTR("G1 Z0.1F%i"), movespeed);
else if ((coorvalue <= -0.1) && coorvalue > -1)
sprintf_P(commandStr, PSTR("G1 Z-0.1F%i"), movespeed);
else
sprintf_P(commandStr, PSTR("G1 Z%iF%i"), int(coorvalue), movespeed);
}
else if (codeSeen('E')) { // Extrude
coorvalue = codeValue();
if ((coorvalue <= 0.2) && coorvalue > 0)
sprintf_P(commandStr, PSTR("G1 E0.1F%i"), movespeed);
else if ((coorvalue <= -0.1) && coorvalue > -1)
sprintf_P(commandStr, PSTR("G1 E-0.1F%i"), movespeed);
else
sprintf_P(commandStr, PSTR("G1 E%iF500"), int(coorvalue));
}
if (strlen(commandStr) > 0) {
sprintf_P(fullCommandStr, PSTR("G91\n%s\nG90"), commandStr);
DEBUG_ECHOPGM("TFT Serial Debug: A22 Move final request with gcode... ");
DEBUG_ECHOLN(fullCommandStr);
injectCommands(fullCommandStr);
}
}
SENDLINE_PGM("");
break;
case 23: // A23 preheat pla
if (!isPrinting()) {
if (getAxisPosition_mm(Z) < 10)
injectCommands(F("G1 Z10")); // RASE Z AXIS
setTargetTemp_celsius(PREHEAT_1_TEMP_BED, (heater_t)BED);
setTargetTemp_celsius(PREHEAT_1_TEMP_HOTEND, (extruder_t)E0);
SENDLINE_PGM("OK");
}
break;
case 24:// A24 preheat abs
if (!isPrinting()) {
if (getAxisPosition_mm(Z) < 10)
injectCommands(F("G1 Z10")); // RASE Z AXIS
setTargetTemp_celsius(PREHEAT_2_TEMP_BED, (heater_t)BED);
setTargetTemp_celsius(PREHEAT_2_TEMP_HOTEND, (extruder_t)E0);
SENDLINE_PGM("OK");
}
break;
case 25: // A25 cool down
if (!isPrinting()) {
setTargetTemp_celsius(0, (heater_t)BED);
setTargetTemp_celsius(0, (extruder_t)E0);
SENDLINE_DBG_PGM("J12", "TFT Serial Debug: Cooling down... J12"); // J12 cool down
}
break;
case 26: // A26 refresh SD
#if HAS_MEDIA
if (isMediaInserted()) {
if (strlen(selectedDirectory) > 0) {
FileList currentFileList;
if ((selectedDirectory[0] == '.') && (selectedDirectory[1] == '.')) {
currentFileList.upDir();
}
else {
if (selectedDirectory[0] == '<')
handleSpecialMenu();
else
currentFileList.changeDir(selectedDirectory);
}
}
}
else {
SENDLINE_DBG_PGM("J02", "TFT Serial Debug: No SD Card mounted to refresh SD A26... J02");
}
selectedDirectory[0] = 0;
#endif
break;
#if ENABLED(SERVO_ENDSTOPS)
case 27: break; // A27 servos angles adjust
#endif
case 28: // A28 filament test
if (codeSeen('O'))
NOOP;
else if (codeSeen('C'))
NOOP;
SENDLINE_PGM("");
break;
case 33: // A33 get version info
SEND_PGM("J33 ");
SENDLINE_PGM(DETAILED_BUILD_VERSION);
break;
default:
break;
}
}
tftBufIndW = (tftBufIndW + 1) % (TFTBUFSIZE);
tftBufLen++;
serial_count = 0; // clear buffer
} // while
}
void AnycubicTFT::doSDCardStateCheck() {
#if ALL(HAS_MEDIA, HAS_SD_DETECT)
bool isInserted = isMediaInserted();
if (isInserted)
SENDLINE_DBG_PGM("J00", "TFT Serial Debug: SD card state changed... isInserted");
else
SENDLINE_DBG_PGM("J01", "TFT Serial Debug: SD card state changed... !isInserted");
#endif
}
void AnycubicTFT::doFilamentRunoutCheck() {
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
// NOTE: getFilamentRunoutState() only returns the runout state if the job is printing
// we want to actually check the status of the pin here, regardless of printstate
if (READ(FIL_RUNOUT1_PIN) == FIL_RUNOUT1_STATE) {
if (mediaPrintingState == AMPRINTSTATE_PRINTING || mediaPrintingState == AMPRINTSTATE_PAUSED || mediaPrintingState == AMPRINTSTATE_PAUSE_REQUESTED) {
// play tone to indicate filament is out
injectCommands(F("\nM300 P200 S1567\nM300 P200 S1174\nM300 P200 S1567\nM300 P200 S1174\nM300 P2000 S1567"));
// tell the user that the filament has run out and wait
SENDLINE_DBG_PGM("J23", "TFT Serial Debug: Blocking filament prompt... J23");
}
else {
SENDLINE_DBG_PGM("J15", "TFT Serial Debug: Non blocking filament runout... J15");
}
}
#endif // FILAMENT_RUNOUT_SENSOR
}
void AnycubicTFT::startPrint() {
#if HAS_MEDIA
if (!isPrinting() && strlen(selectedFile) > 0) {
DEBUG_ECHOLNPGM("TFT Serial Debug: About to print file ... ", isPrinting(), " ", selectedFile);
mediaPrintingState = AMPRINTSTATE_PRINTING;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
printFile(selectedFile);
}
#endif // SDUPPORT
}
void AnycubicTFT::pausePrint() {
#if HAS_MEDIA
if (isPrintingFromMedia() && mediaPrintingState != AMPRINTSTATE_STOP_REQUESTED && mediaPauseState == AMPAUSESTATE_NOT_PAUSED) {
mediaPrintingState = AMPRINTSTATE_PAUSE_REQUESTED;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED; // need the userconfirm method to update pause state
SENDLINE_DBG_PGM("J05", "TFT Serial Debug: SD print pause started... J05"); // J05 printing pause
// for some reason pausing the print doesn't retract the extruder so force a manual one here
injectCommands(F("G91\nG1 E-2 F1800\nG90"));
pausePrint();
}
#endif
}
void AnycubicTFT::resumePrint() {
#if HAS_MEDIA
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
if (READ(FIL_RUNOUT1_PIN) == FIL_RUNOUT1_STATE) {
DEBUG_ECHOLNPGM("TFT Serial Debug: Resume Print with filament sensor still tripped... ");
// trigger the user message box
doFilamentRunoutCheck();
// re-enable the continue button
SENDLINE_DBG_PGM("J18", "TFT Serial Debug: Resume Print with filament sensor still tripped... J18");
return;
}
#endif
if (mediaPauseState == AMPAUSESTATE_HEATER_TIMEOUT) {
mediaPauseState = AMPAUSESTATE_REHEATING;
// TODO: JBA I don't think J05 just disables the continue button, i think it injects a rogue M25. So taking this out
// // disable the continue button
// SENDLINE_DBG_PGM("J05", "TFT Serial Debug: Resume called with heater timeout... J05"); // J05 printing pause
// reheat the nozzle
setUserConfirmed();
}
else {
mediaPrintingState = AMPRINTSTATE_PRINTING;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
SENDLINE_DBG_PGM("J04", "TFT Serial Debug: SD print resumed... J04"); // J04 printing form sd card now
resumePrint();
}
#endif
}
void AnycubicTFT::stopPrint() {
#if HAS_MEDIA
mediaPrintingState = AMPRINTSTATE_STOP_REQUESTED;
mediaPauseState = AMPAUSESTATE_NOT_PAUSED;
SENDLINE_DBG_PGM("J16", "TFT Serial Debug: SD print stop called... J16");
// for some reason stopping the print doesn't retract the extruder so force a manual one here
injectCommands(F("G91\nG1 E-2 F1800\nG90"));
stopPrint();
#endif
}
#endif // ANYCUBIC_LCD_I3MEGA
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_i3mega/anycubic_i3mega_lcd.cpp
|
C++
|
agpl-3.0
| 34,969
|
/**
* anycubic_i3mega_lcd.h --- Support for Anycubic i3 Mega TFT
* Created by Christian Hopp on 09.12.17.
* Improved by David Ramiro
* Converted to ExtUI by John BouAntoun 21 June 2020
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include "../../../inc/MarlinConfigPre.h"
#include "../../../sd/SdFatConfig.h" // for the FILENAME_LENGTH macro
#define TFTBUFSIZE 4
#define TFT_MAX_CMD_SIZE 96
enum AnycubicMediaPrintState {
AMPRINTSTATE_NOT_PRINTING,
AMPRINTSTATE_PRINTING,
AMPRINTSTATE_PAUSE_REQUESTED,
AMPRINTSTATE_PAUSED,
AMPRINTSTATE_STOP_REQUESTED
};
enum AnycubicMediaPauseState {
AMPAUSESTATE_NOT_PAUSED,
AMPAUSESTATE_PARKING,
AMPAUSESTATE_PARKED,
AMPAUSESTATE_FILAMENT_OUT,
AMPAUSESTATE_FILAMENT_PURGING,
AMPAUSESTATE_HEATER_TIMEOUT,
AMPAUSESTATE_REHEATING,
AMPAUSESTATE_REHEAT_FINISHED
};
class AnycubicTFT {
public:
AnycubicTFT();
static void onSetup();
static void onCommandScan();
static void onKillTFT();
static void onSDCardStateChange(bool);
static void onSDCardError();
static void onFilamentRunout();
static void onUserConfirmRequired(const char *);
static void onPrintTimerStarted();
static void onPrintTimerPaused();
static void onPrintTimerStopped();
private:
static char tftCommands[TFTBUFSIZE][TFT_MAX_CMD_SIZE];
static int tftBufLen, tftBufIndR, tftBufIndW;
static char *tftStrchrPtr;
static uint8_t specialMenu;
static AnycubicMediaPrintState mediaPrintingState;
static AnycubicMediaPauseState mediaPauseState;
static float codeValue();
static bool codeSeen(char);
static bool isNozzleHomed();
static void renderCurrentFileList();
static void renderSpecialMenu(uint16_t);
static void renderCurrentFolder(uint16_t);
static void getCommandFromTFT();
static void checkSDCardChange();
static void checkPauseState();
static void handleSpecialMenu();
static void doSDCardStateCheck();
static void doFilamentRunoutCheck();
static void startPrint();
static void pausePrint();
static void resumePrint();
static void stopPrint();
static char selectedDirectory[30];
static char selectedFile[FILENAME_LENGTH];
};
extern AnycubicTFT anycubicTFT;
extern const char G28_STR[];
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_i3mega/anycubic_i3mega_lcd.h
|
C++
|
agpl-3.0
| 2,908
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_vyper/FileNavigator.cpp
*/
/***************************************************************************
* The AC panel wants files in block of 4 and can only display a flat list *
* This library allows full folder traversal. *
***************************************************************************/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_VYPER)
#include "FileNavigator.h"
#include "dgus_tft.h"
using namespace ExtUI;
namespace Anycubic {
FileList FileNavigator::filelist; // ExtUI file API
char FileNavigator::currentDirPath[MAX_PATH_LEN + 1]; // Current folder path
uint16_t FileNavigator::lastindex;
uint8_t FileNavigator::folderdepth;
uint16_t FileNavigator::currentindex; // override the panel request
FileNavigator filenavigator;
FileNavigator::FileNavigator() { reset(); }
void FileNavigator::reset() {
currentDirPath[0] = '\0';
folderdepth = 0;
currentindex = 0;
lastindex = 0;
// Start at root folder
while (!filelist.isAtRootDir()) filelist.upDir();
refresh();
}
void FileNavigator::refresh() { filelist.refresh(); }
void FileNavigator::getFiles(uint16_t index) {
uint8_t files = 5;
if (index == 0) currentindex = 0;
// Each time we change folder we reset the file index to 0 and keep track
// of the current position as the TFT panel isnt aware of folders trees.
if (index > 0) {
//--currentindex; // go back a file to take account off the .. we added to the root.
if (index > lastindex)
currentindex += files;
else
currentindex = currentindex < 5 ? 0 : currentindex - files;
}
lastindex = index;
#if ACDEBUG(AC_FILE)
SERIAL_ECHOLNPGM("index=", index, " currentindex=", currentindex, " lastindex=", lastindex);
#endif
uint8_t file_num = 0;
for (uint16_t _seek = currentindex; _seek < currentindex + files; _seek++) {
#if ACDEBUG(AC_FILE)
SERIAL_ECHOLNPGM("_seek: ", _seek, " currentindex: ", currentindex, " files: ", files);
#endif
if (filelist.seek(_seek)) {
//sendFile();
DgusTFT::sendTxtToTFT(filelist.longFilename(), TXT_FILE_0 + file_num*0x30);
#if ACDEBUG(AC_FILE)
SERIAL_ECHOLNPGM("seek: ", _seek, " '", filelist.longFilename(), "' '", currentDirPath, "", filelist.shortFilename(), "'\n");
#endif
}
else {
#if ACDEBUG(AC_FILE)
SERIAL_ECHOLNPGM("over seek: ", _seek);
#endif
DgusTFT::sendTxtToTFT("\0", TXT_FILE_0 + file_num*0x30);
}
file_num++;
}
}
void FileNavigator::sendFile() {
// Send the file and folder info to the panel.
// This info will be returned when the file is selected.
// Permitted special characters in file name: -_*#~
// Panel can display 22 characters per line.
if (!filelist.isDir())
DgusTFT::sendTxtToTFT(filelist.longFilename(), TXT_FILE_0);
}
void FileNavigator::changeDIR(char *folder) {
#if ACDEBUG(AC_FILE)
SERIAL_ECHOLNPGM("currentfolder: ", currentDirPath, " New: ", folder);
#endif
if (folderdepth >= MAX_FOLDER_DEPTH) return; // limit the folder depth
strcat(currentDirPath, folder);
strcat(currentDirPath, "/");
filelist.changeDir(folder);
refresh();
folderdepth++;
currentindex = 0;
}
void FileNavigator::upDIR() {
filelist.upDir();
refresh();
folderdepth--;
currentindex = 0;
// Remove the last child folder from the stored path
if (folderdepth == 0) {
currentDirPath[0] = '\0';
reset();
}
else {
char *pos = nullptr;
for (uint8_t f = 0; f < folderdepth; f++)
pos = strchr(currentDirPath, '/');
*(pos + 1) = '\0';
}
#if ACDEBUG(AC_FILE)
SERIAL_ECHOLNPGM("depth: ", folderdepth, " currentDirPath: ", currentDirPath);
#endif
}
char* FileNavigator::getCurrentDirPath() { return currentDirPath; }
uint16_t FileNavigator::getFileNum() { return filelist.count(); }
}
#endif // ANYCUBIC_LCD_VYPER
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_vyper/FileNavigator.cpp
|
C++
|
agpl-3.0
| 5,026
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic_vyper/FileNavigator.h
*/
#include "dgus_tft_defs.h"
#include "../ui_api.h"
using namespace ExtUI;
namespace Anycubic {
class FileNavigator {
public:
static FileList filelist;
FileNavigator();
static void reset();
static void getFiles(uint16_t);
static void upDIR();
static void changeDIR(char *);
static void sendFile();
static void refresh();
static char* getCurrentDirPath();
static uint16_t getFileNum();
private:
static uint16_t lastindex;
static uint16_t currentindex;
static uint8_t folderdepth;
static char currentDirPath[MAX_PATH_LEN + 1];
};
extern FileNavigator filenavigator;
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_vyper/FileNavigator.h
|
C++
|
agpl-3.0
| 1,601
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_vyper/dgus_tft.cpp
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_VYPER)
#include "dgus_tft.h"
#include "../anycubic/Tunes.h"
#include "FileNavigator.h"
#include "../../../gcode/queue.h"
#include "../../../sd/cardreader.h"
#include "../../../libs/numtostr.h"
#include "../../../MarlinCore.h"
#include "../../../core/serial.h"
#include "../../../module/stepper.h"
#include "../../../module/probe.h"
#include "../../../module/temperature.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../feature/powerloss.h"
#endif
#define DEBUG_OUT ACDEBUGLEVEL
#include "../../../core/debug_out.h"
#include <string>
namespace Anycubic {
const char MESSAGE_charu[] = {0xB4, 0xE6, 0xB4, 0xA2, 0xBF, 0xA8, 0xD2, 0xD1, 0xB2, 0xE5, 0xC8, 0xEB, 0x00}; // '忙'垄驴篓脪脩虏氓脠毛
const char MESSAGE_bachu[] = {0xB4, 0xE6, 0xB4, 0xA2, 0xBF, 0xA8, 0xD2, 0xD1, 0xB0, 0xCE, 0xB3, 0xF6, 0x00};
const char MESSAGE_wuka[] = {0xCE, 0xDE, 0xB4, 0xE6, 0xB4, 0xA2, 0xBF, 0xA8, 0x00};
const char MESSAGE_lianji[] = {0xC1, 0xAA, 0xBB, 0xFA, 0xD6, 0xD0, 0x00};
const char MESSAGE_tuoji[] = {0xCD, 0xD1, 0xBB, 0xFA, 0xB4, 0xF2, 0xD3, 0xA1, 0xD6, 0xD0, 0x00};
const char MESSAGE_zanting[] = {0xB4, 0xF2, 0xD3, 0xA1, 0xD4, 0xDD, 0xCD, 0xA3, 0xD6, 0xD0, 0x00};
const char MESSAGE_tingzhi[] = {0xCD, 0xA3, 0xD6, 0xB9, 0xB4, 0xF2, 0xD3, 0xA1, 0x00};
const char MESSAGE_wancheng[] = {0xCD, 0xEA, 0xB3, 0xC9, 0xB4, 0xF2, 0xD3, 0xA1, 0x00};
const char MESSAGE_hotend_heating[] = {0xB4, 0xF2, 0xD3, 0xA1, 0xCD, 0xB7, 0xD5, 0xFD, 0xD4, 0xDA, 0xBC, 0xD3, 0xC8, 0xC8, 0x00};
const char MESSAGE_hotend_over[] = {0xB4, 0xF2, 0xD3, 0xA1, 0xCD, 0xB7, 0xBC, 0xD3, 0xC8, 0xC8, 0xCD, 0xEA, 0xB3, 0xC9, 0x00};
const char MESSAGE_bed_heating[] = {0xC8, 0xC8, 0xB4, 0xB2, 0xD5, 0xFD, 0xD4, 0xDA, 0xBC, 0xD3, 0xC8, 0xC8, 0x00};
const char MESSAGE_bed_over[] = {0xC8, 0xC8, 0xB4, 0xB2, 0xBC, 0xD3, 0xC8, 0xC8, 0xCD, 0xEA, 0xB3, 0xC9, 0x00};
const char MESSAGE_ready[] = {0xD7, 0xBC, 0xB1, 0xB8, 0xBE, 0xCD, 0xD0, 0xF7, 0x00};
const char MESSAGE_cold[] = {0xB4, 0xF2, 0xD3, 0xA1, 0xCD, 0xB7, 0xCE, 0xC2, 0xB6, 0xC8, 0xB9, 0xFD, 0xB5, 0xCD, 0x00};
const char *p_mesage[] = { MESSAGE_charu, MESSAGE_bachu, MESSAGE_wuka, MESSAGE_lianji, MESSAGE_tuoji, MESSAGE_zanting,
MESSAGE_tingzhi, MESSAGE_wancheng, MESSAGE_hotend_heating, MESSAGE_hotend_over, MESSAGE_bed_heating,
MESSAGE_bed_over, MESSAGE_ready, MESSAGE_cold };
DgusTFT::p_fun fun_array[] = {
DgusTFT::page1, DgusTFT::page2, DgusTFT::page3, DgusTFT::page4, DgusTFT::page5, DgusTFT::page6,
DgusTFT::page7, DgusTFT::page8, DgusTFT::page9, DgusTFT::page10, DgusTFT::page11, DgusTFT::page12,
DgusTFT::page13, DgusTFT::page14, DgusTFT::page15, DgusTFT::page16, DgusTFT::page17, DgusTFT::page18,
DgusTFT::page19, DgusTFT::page20, DgusTFT::page21, DgusTFT::page22, DgusTFT::page23, DgusTFT::page24,
DgusTFT::page25, DgusTFT::page26, DgusTFT::page27, DgusTFT::page28, DgusTFT::page29, DgusTFT::page30,
DgusTFT::page31, DgusTFT::page32
#if HAS_LEVELING
, DgusTFT::page33 , DgusTFT::page34
#endif
};
printer_state_t DgusTFT::printer_state;
paused_state_t DgusTFT::pause_state;
#if HAS_HOTEND
heater_state_t DgusTFT::hotend_state;
#endif
#if HAS_HEATED_BED
heater_state_t DgusTFT::hotbed_state;
#endif
char DgusTFT::selectedfile[MAX_PATH_LEN];
char DgusTFT::panel_command[MAX_CMND_LEN];
uint8_t DgusTFT::command_len;
file_menu_t DgusTFT::file_menu;
bool DgusTFT::data_received;
uint8_t DgusTFT::data_buf[DATA_BUF_SIZE];
uint8_t DgusTFT::data_index;
uint16_t DgusTFT::page_index_now, DgusTFT::page_index_last, DgusTFT::page_index_last_2;
uint8_t DgusTFT::message_index;
uint8_t DgusTFT::pop_up_index;
uint32_t DgusTFT::key_value;
uint8_t DgusTFT::lcd_txtbox_index;
uint8_t DgusTFT::lcd_txtbox_page;
int16_t DgusTFT::feedrate_back;
lcd_info_t DgusTFT::lcd_info, DgusTFT::lcd_info_back;
language_t DgusTFT::ui_language;
uint16_t page_index_saved; // flags to keep from bombing the host display
uint8_t pop_up_index_saved;
uint32_t key_value_saved;
void DEBUG_PRINT_PAUSED_STATE(const paused_state_t state, FSTR_P const msg=nullptr);
void DEBUG_PRINT_PRINTER_STATE(const printer_state_t state, FSTR_P const msg=nullptr);
void DEBUG_PRINT_TIMER_EVENT(const timer_event_t event, FSTR_P const msg=nullptr);
void DEBUG_PRINT_MEDIA_EVENT(const media_event_t event, FSTR_P const msg=nullptr);
DgusTFT dgus;
DgusTFT::DgusTFT() {
data_buf[0] = '\0';
message_index = 100;
pop_up_index = 100;
page_index_now = page_index_last = page_index_last_2 = 1;
lcd_txtbox_index = 0;
feedrate_back = -1;
}
void DgusTFT::startup() {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("DgusTFT::startup()");
#endif
selectedfile[0] = '\0';
panel_command[0] = '\0';
command_len = 0;
printer_state = AC_printer_idle;
pause_state = AC_paused_idle;
TERN_(HAS_HOTEND, hotend_state = AC_heater_off);
TERN_(HAS_HEATED_BED, hotbed_state = AC_heater_off);
file_menu = AC_menu_file;
set_language(ui_language); // use language stored in EEPROM
// Filament runout is handled by Marlin settings in Configuration.h
// opt_set FIL_RUNOUT_STATE HIGH // Pin state indicating that filament is NOT present.
// opt_enable FIL_RUNOUT_PULLUP
TFTSer.begin(115200);
// Signal Board has reset
tftSendLn(AC_msg_main_board_has_reset);
// Enable levelling and Disable end stops during print
// as Z home places nozzle above the bed so we need to allow it past the end stops
injectCommands(AC_cmnd_enable_leveling);
#if ACDEBUGLEVEL
DEBUG_ECHOLNPGM("startup AC Debug Level ", ACDEBUGLEVEL);
#endif
tftSendLn(AC_msg_ready);
}
void DgusTFT::paramInit() {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("DgusTFT::paramInit()");
#endif
if (lcd_info.language == CHS)
page_index_now = 1;
else if (lcd_info.language == ENG)
page_index_now = 121;
lcdAudioSet(lcd_info.audio_on);
#if ACDEBUG(AC_MARLIN)
if (lcd_info.language == CHS)
DEBUG_ECHOLNPGM("paramInit lcd language: CHS");
else if (lcd_info.language == ENG)
DEBUG_ECHOLNPGM("paramInit lcd language: ENG");
if (lcd_info.audio_on)
DEBUG_ECHOLNPGM("paramInit lcd audio: ON");
else
DEBUG_ECHOLNPGM("paramInit lcd audio: OFF");
#endif
requestValueFromTFT(0x14); // get page ID
}
void DgusTFT::idleLoop() {
if (readTFTCommand()) {
processPanelRequest();
command_len = 0;
}
#if ACDEBUG(AC_MARLIN)
if (key_value) {
DEBUG_ECHOLNPGM("idleLoop page: ", page_index_now);
DEBUG_ECHOLNPGM("key: ", key_value);
}
#endif
switch (page_index_now) {
case 115: page115(); break;
case 117: page117(); break;
//case 124: page124(); break;
//case 125: page125(); break;
case 170: page170(); break;
#if ENABLED(POWER_LOSS_RECOVERY)
case 171: page171(); break;
case 173: page173(); break;
#endif
#if HAS_LEVELING
case 175: page175(); break;
case 176: page176(); break;
#endif
case 177 ... 198: {
#if 0 // ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("line: ", __LINE__);
DEBUG_ECHOLNPGM("func: ", page_index_now);
#endif
//page177_to_198();
} break;
case 199 ... 200: {
#if 0 // ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("line: ", __LINE__);
DEBUG_ECHOLNPGM("func: ", page_index_now);
#endif
page199_to_200();
} break;
case 201: case 204: page201(); break;
case 202: case 205: page202(); break;
case 203: case 206: page203(); break;
default:
if (lcd_info.language == CHS) {
if (WITHIN(page_index_now, 1, 1 + COUNT(fun_array))) {
fun_array[page_index_now - 1]();
}
else {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("line: ", __LINE__);
DEBUG_ECHOLNPGM("fun doesn't exist: ", page_index_now);
#endif
}
}
else if (lcd_info.language == ENG) {
if (WITHIN(page_index_now, 121, 121 + COUNT(fun_array))) {
fun_array[page_index_now - 121](); // ENG page_index is 120 more than CHS
}
else {
SERIAL_ECHOLNPGM("lcd function doesn't exist");
SERIAL_ECHOLNPGM("page_index_last: ", page_index_last);
SERIAL_ECHOLNPGM("page_index_last_2: ", page_index_last_2);
}
}
break;
}
pop_up_manager();
key_value = 0;
checkHeaters();
}
uint8_t FSHlength(FSTR_P FSHinput) {
PGM_P FSHinputPointer = reinterpret_cast<PGM_P>(FSHinput);
uint8_t stringLength = 0;
while (pgm_read_byte(FSHinputPointer++)) stringLength++;
return stringLength;
}
#undef GET_TEXT
#define GET_TEXT(MSG) Language_en::MSG
void DgusTFT::printerKilled(FSTR_P error_p, FSTR_P component_p) {
// copy string in FLASH to RAM for strcmp_P
uint8_t textLength = FSHlength(error_p);
char error[FSHlength(error_p) + 1];
memcpy_P(error, error_p, textLength + 1); // +1 for the null terminator
textLength = FSHlength(component_p);
char component[FSHlength(component_p) + 1];
memcpy_P(component, component_p, textLength + 1); // +1 for the null terminator
tftSendLn(AC_msg_kill_lcd);
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("printerKilled()\nerror: ", error, "\ncomponent: ", component);
#endif
if (strcmp_P(error, GET_TEXT(MSG_ERR_HEATING_FAILED)) == 0) {
if (strcmp_P(component, GET_TEXT(MSG_BED)) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_BED_HEATER);
SERIAL_ECHOLNPGM("Check Bed heater");
}
else if (strcmp_P(component, PSTR("E1")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_HOTEND_HEATER);
SERIAL_ECHOLNPGM("Check E1 heater");
}
}
else if (strcmp_P(error, GET_TEXT(MSG_ERR_MINTEMP)) == 0) {
if (strcmp_P(component, GET_TEXT(MSG_BED)) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_BED_NTC);
SERIAL_ECHOLNPGM("Check Bed thermistor");
}
else if (strcmp_P(component, PSTR("E1")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_HOTEND_NTC);
SERIAL_ECHOLNPGM("Check E1 thermistor");
}
}
else if (strcmp_P(error, GET_TEXT(MSG_ERR_MAXTEMP)) == 0) {
if (strcmp_P(component, GET_TEXT(MSG_BED)) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_BED_NTC);
SERIAL_ECHOLNPGM("Check Bed thermistor");
}
else if (strcmp_P(component, PSTR("E1")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_HOTEND_NTC);
SERIAL_ECHOLNPGM("Check E1 thermistor");
}
}
else if (strcmp_P(error, GET_TEXT(MSG_ERR_THERMAL_RUNAWAY)) == 0) {
if (strcmp_P(component, GET_TEXT(MSG_BED)) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_BED_HEATER);
SERIAL_ECHOLNPGM("Check Bed thermal runaway");
}
else if (strcmp_P(component, PSTR("E1")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_HOTEND_HEATER);
SERIAL_ECHOLNPGM("Check E1 thermal runaway");
}
}
else if (strcmp_P(error, GET_TEXT(MSG_KILL_HOMING_FAILED)) == 0) {
if (strcmp_P(component, PSTR("X")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_X_ENDSTOP);
SERIAL_ECHOLNPGM("Check X endstop");
}
else if (strcmp_P(component, PSTR("Y")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_Y_ENDSTOP);
SERIAL_ECHOLNPGM("Check Y endstop");
}
else if (strcmp_P(component, PSTR("Z")) == 0) {
changePageOfTFT(PAGE_CHS_ABNORMAL_Z_ENDSTOP);
SERIAL_ECHOLNPGM("Check Z endstop");
}
}
}
void DgusTFT::set_descript_color(const uint16_t color, const uint8_t index/*=lcd_txtbox_index*/) {
sendColorToTFT(color, TXT_DESCRIPT_0 + 0x30 * (index - 1));
}
void DgusTFT::mediaEvent(media_event_t event) {
#if ACDEBUG(AC_MARLIN)
DEBUG_PRINT_MEDIA_EVENT(event);
#endif
switch (event) {
case AC_media_inserted:
filenavigator.reset();
lcd_txtbox_page = 0;
if (lcd_txtbox_index) {
set_descript_color(COLOR_BLUE);
lcd_txtbox_index = 0;
}
sendFileList(lcd_txtbox_index);
break;
case AC_media_removed:
tftSendLn(AC_msg_sd_card_removed);
filenavigator.reset();
lcd_txtbox_page = 0;
if (lcd_txtbox_index) {
set_descript_color(COLOR_BLUE);
lcd_txtbox_index = 0;
}
sendFileList(lcd_txtbox_index);
break;
case AC_media_error:
tftSendLn(AC_msg_no_sd_card);
break;
}
}
void DgusTFT::timerEvent(timer_event_t event) {
#if ACDEBUG(AC_MARLIN)
DEBUG_PRINT_TIMER_EVENT(event);
DEBUG_PRINT_PRINTER_STATE(printer_state);
#endif
switch (event) {
case AC_timer_started:
setSoftEndstopState(false); // disable endstops to print
printer_state = AC_printer_printing;
tftSendLn(AC_msg_print_from_sd_card);
break;
case AC_timer_paused:
//printer_state = AC_printer_paused;
//pause_state = AC_paused_idle;
tftSendLn(AC_msg_paused);
break;
case AC_timer_stopped:
if (printer_state != AC_printer_idle) {
if (printer_state == AC_printer_stopping_from_media_remove) {
changePageOfTFT(PAGE_NO_SD);
}
else {
printer_state = AC_printer_stopping;
// Get Printing Time
uint32_t time = getProgress_seconds_elapsed() / 60;
char str_buf[20];
sprintf(str_buf, "%s H ", utostr3(time / 60));
sprintf(str_buf + strlen(str_buf), "%s M", utostr3(time % 60));
sendTxtToTFT(str_buf, TXT_FINISH_TIME);
changePageOfTFT(PAGE_PRINT_FINISH);
tftSendLn(AC_msg_print_complete);
pop_up_index = 100;
}
}
setSoftEndstopState(true); // enable endstops
break;
}
}
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
void DgusTFT::filamentRunout() {
#if ACDEBUG(AC_MARLIN)
DEBUG_PRINT_PRINTER_STATE(printer_state, F("filamentRunout() "));
// 1 Signal filament out
tftSendLn(isPrintingFromMedia() ? AC_msg_filament_out_alert : AC_msg_filament_out_block);
//printer_state = AC_printer_filament_out;
DEBUG_ECHOLNPGM("getFilamentRunoutState: ", getFilamentRunoutState());
#endif
pop_up_index = 15; // show filament lack.
if (READ(FIL_RUNOUT_PIN) == FIL_RUNOUT_STATE) {
playTune(FilamentOut);
feedrate_back = getFeedrate_percent();
if (isPrintingFromMedia()) {
pausePrint();
printer_state = AC_printer_pausing;
pause_state = AC_paused_filament_lack;
}
}
}
#endif // FILAMENT_RUNOUT_SENSOR
void DgusTFT::confirmationRequest(const char * const msg) {
// M108 continue
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("HomingComplete, line: ", __LINE__);
DEBUG_ECHOLNPGM("confirmationRequest() ", msg);
DEBUG_PRINT_PRINTER_STATE(printer_state);
DEBUG_PRINT_PAUSED_STATE(pause_state);
#endif
switch (printer_state) {
case AC_printer_pausing: {
if (strcmp_P(msg, MARLIN_msg_print_paused) == 0 || strcmp_P(msg, MARLIN_msg_nozzle_parked) == 0) {
if (pause_state != AC_paused_filament_lack)
changePageOfTFT(PAGE_STATUS1); // enable continue button
printer_state = AC_printer_paused;
}
}
break;
#if ENABLED(POWER_LOSS_RECOVERY)
case AC_printer_resuming_from_power_outage:
#endif
case AC_printer_printing:
case AC_printer_paused:
// Heater timout, send acknowledgement
if (strcmp_P(msg, MARLIN_msg_heater_timeout) == 0) {
pause_state = AC_paused_heater_timed_out;
tftSendLn(AC_msg_paused); // enable continue button
playTune(HeaterTimeout);
}
// Reheat finished, send acknowledgement
else if (strcmp_P(msg, MARLIN_msg_reheat_done) == 0) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("send M108 ", __LINE__);
#endif
injectCommands(F("M108"));
if (pause_state != AC_paused_filament_lack)
pause_state = AC_paused_idle;
tftSendLn(AC_msg_paused); // enable continue button
}
// Filament Purging, send acknowledgement enter run mode
else if (strcmp_P(msg, MARLIN_msg_filament_purging) == 0) {
pause_state = AC_paused_purging_filament;
tftSendLn(AC_msg_paused); // enable continue button
}
else if (strcmp_P(msg, MARLIN_msg_nozzle_parked) == 0) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("send M108 ", __LINE__);
#endif
injectCommands(F("M108"));
if (pause_state != AC_paused_filament_lack)
pause_state = AC_paused_idle;
}
break;
default: break;
}
}
void DgusTFT::statusChange(const char * const msg) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("statusChange() ", msg);
DEBUG_PRINT_PRINTER_STATE(printer_state);
DEBUG_PRINT_PAUSED_STATE(pause_state);
#endif
bool msg_matched = false;
#if HAS_LEVELING
static grid_count_t probe_cnt = 0;
#endif
// The only way to get printer status is to parse messages
// Use the state to minimise the work we do here.
switch (printer_state) {
#if HAS_LEVELING
case AC_printer_probing:
if (strncmp_P(msg, MARLIN_msg_probing_point, strlen_P(MARLIN_msg_probing_point)) == 0)
probe_cnt++;
// If probing completes ok save the mesh and park
// Ignore the custom machine name
if (strcmp_P(msg + strlen(MACHINE_NAME), MARLIN_msg_ready) == 0) {
if (probe_cnt == GRID_MAX_POINTS) {
probe_cnt = 0;
injectCommands(F("M500")); // G27 park nozzle
//changePageOfTFT(PAGE_PreLEVEL);
fakeChangePageOfTFT(PAGE_PreLEVEL); // Prevent UI refreshing too quickly when probing is done
printer_state = AC_printer_idle;
msg_matched = true;
}
}
// If probing fails don't save the mesh raise the probe above the bad point
if (strcmp_P(msg, MARLIN_msg_probing_failed) == 0) {
playTune(BeepBeepBeeep);
injectCommands(F("G1 Z50 F500"));
changePageOfTFT(PAGE_CHS_ABNORMAL_LEVELING_SENSOR);
tftSendLn(AC_msg_probing_complete);
printer_state = AC_printer_idle;
msg_matched = true;
}
if (strcmp_P(msg, MARLIN_msg_probe_preheat_start) == 0)
changePageOfTFT(PAGE_CHS_PROBE_PREHEATING);
if (strcmp_P(msg, MARLIN_msg_probe_preheat_stop) == 0)
changePageOfTFT(PAGE_LEVELING);
break;
#endif
case AC_printer_printing:
if (strcmp_P(msg, MARLIN_msg_reheating) == 0) {
tftSendLn(AC_msg_paused); // enable continue button
changePageOfTFT(PAGE_STATUS2);
msg_matched = true;
}
else if (strcmp_P(msg, MARLIN_msg_media_removed) == 0) {
msg_matched = true;
printer_state = AC_printer_stopping_from_media_remove;
}
else {
#if ENABLED(FILAMENT_RUNOUT_SENSOR)
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("setFilamentRunoutState: ", __LINE__);
#endif
setFilamentRunoutState(false);
#endif
}
break;
case AC_printer_pausing:
if (strcmp_P(msg, MARLIN_msg_print_paused) == 0) {
if (pause_state != AC_paused_filament_lack) {
changePageOfTFT(PAGE_STATUS1); // show resume
pause_state = AC_paused_idle;
}
printer_state = AC_printer_paused;
msg_matched = true;
}
break;
case AC_printer_paused:
if (strcmp_P(msg, MARLIN_msg_print_paused) == 0) {
if (pause_state != AC_paused_filament_lack) {
changePageOfTFT(PAGE_STATUS1); // show resume
pause_state = AC_paused_idle;
}
printer_state = AC_printer_paused;
msg_matched = true;
}
break;
case AC_printer_stopping:
if (strcmp_P(msg, MARLIN_msg_print_aborted) == 0) {
changePageOfTFT(PAGE_MAIN);
printer_state = AC_printer_idle;
msg_matched = true;
}
break;
default: break;
}
// If not matched earlier see if this was a heater message
if (!msg_matched) {
#if HAS_HOTEND
if (strcmp_P(msg, MARLIN_msg_extruder_heating) == 0) {
tftSendLn(AC_msg_nozzle_heating);
hotend_state = AC_heater_temp_set;
return;
}
#endif
#if HAS_HEATED_BED
if (strcmp_P(msg, MARLIN_msg_bed_heating) == 0) {
tftSendLn(AC_msg_bed_heating);
hotbed_state = AC_heater_temp_set;
}
#endif
}
}
#if ENABLED(POWER_LOSS_RECOVERY)
void DgusTFT::powerLoss() {
// On: 5A A5 05 82 00 82 00 00
// Off: 5A A5 05 82 00 82 00 64
uint8_t data[] = { 0x5A, 0xA5, 0x05, 0x82, 0x00, 0x82, 0x00, uint8_t(recovery.enabled ? 0x00 : 0x64) };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
}
void DgusTFT::powerLossRecovery() {
printer_state = AC_printer_resuming_from_power_outage; // Play tune to notify user we can recover.
}
#endif // POWER_LOSS_RECOVERY
void DgusTFT::homingStart() {
if (!isPrintingFromMedia())
changePageOfTFT(PAGE_CHS_HOMING);
}
void DgusTFT::homingComplete() {
if (lcd_info.language == ENG && page_index_last > 120)
page_index_last -= 120;
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("HomingComplete, line: ", __LINE__);
DEBUG_ECHOLNPGM("page_index_last: ", page_index_last);
#endif
if (!isPrintingFromMedia())
changePageOfTFT(page_index_last);
}
void DgusTFT::tftSend(FSTR_P const fstr/*=nullptr*/) { // A helper to print PROGMEM string to the panel
#if ACDEBUG(AC_SOME)
DEBUG_ECHO(fstr);
#endif
PGM_P str = FTOP(fstr);
while (const char c = pgm_read_byte(str++)) TFTSer.write(c);
}
void DgusTFT::tftSendLn(FSTR_P const fstr/*=nullptr*/) {
if (fstr) {
#if ACDEBUG(AC_SOME)
DEBUG_ECHOPGM("> ");
#endif
tftSend(fstr);
#if ACDEBUG(AC_SOME)
SERIAL_EOL();
#endif
}
TFTSer.println();
}
void DgusTFT::sendValueToTFT(const uint16_t value, const uint16_t address) {
uint8_t data[] = { 0x5A, 0xA5, 0x05, 0x82, uint8_t(address >> 8), uint8_t(address & 0xFF), uint8_t(value >> 8), uint8_t(value & 0xFF) };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
}
void DgusTFT::requestValueFromTFT(const uint16_t address) {
uint8_t data[] = { 0x5A, 0xA5, 0x04, 0x83, uint8_t(address >> 8), uint8_t(address & 0xFF), 0x01 };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
}
void DgusTFT::sendTxtToTFT(const char *pdata, const uint16_t address) {
uint8_t data_len = strlen(pdata);
uint8_t data[] = { 0x5A, 0xA5, uint8_t(data_len + 5), 0x82, uint8_t(address >> 8), uint8_t(address & 0xFF) };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
for (uint8_t i = 0; i < data_len; ++i) TFTSer.write(pdata[i]);
TFTSer.write(0xFF); TFTSer.write(0xFF);
}
void DgusTFT::sendColorToTFT(const uint16_t color, const uint16_t address) {
uint8_t data[] = { 0x5A, 0xA5, 0x05, 0x82, uint8_t(address >> 8), uint8_t(address & 0xFF), uint8_t(color >> 8), uint8_t(color & 0xFF) };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
}
void DgusTFT::sendReadNumOfTxtToTFT(const uint8_t number, const uint16_t address) {
uint8_t data[] = { 0x5A, 0xA5, 0x04, 0x83, uint8_t(address >> 8), uint8_t(address & 0xFF), number };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
}
void DgusTFT::changePageOfTFT(const uint16_t page_index, const bool no_send/*=false*/) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("changePageOfTFT: ", page_index);
#endif
uint32_t data_temp = 0;
if (lcd_info.language == CHS) {
data_temp = page_index;
}
else if (lcd_info.language == ENG) {
switch (page_index) {
case PAGE_OUTAGE_RECOVERY:
data_temp = PAGE_ENG_OUTAGE_RECOVERY; break;
case PAGE_CHS_PROBE_PREHEATING:
data_temp = PAGE_ENG_PROBE_PREHEATING; break;
case PAGE_CHS_HOMING ... PAGE_ENG_HOMING:
data_temp = page_index + 12; break;
case PAGE_CHS_PROBE_PRECHECK ... PAGE_CHS_PROBE_PRECHECK_FAILED:
data_temp = page_index + 3; break;
default:
data_temp = page_index + 120; break;
}
}
if (!no_send) {
uint8_t data[] = { 0x5A, 0xA5, 0x07, 0x82, 0x00, 0x84, 0x5A, 0x01, uint8_t(data_temp >> 8), uint8_t(data_temp & 0xFF) };
for (uint8_t i = 0; i < COUNT(data); ++i) TFTSer.write(data[i]);
}
page_index_last_2 = page_index_last;
page_index_last = page_index_now;
page_index_now = data_temp;
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("page_index_last_2: ", page_index_last_2);
DEBUG_ECHOLNPGM("page_index_last: ", page_index_last);
DEBUG_ECHOLNPGM("page_index_now: ", page_index_now);
#endif
}
void DgusTFT::fakeChangePageOfTFT(const uint16_t page_index) {
#if ACDEBUG(AC_MARLIN)
if (page_index_saved != page_index_now)
DEBUG_ECHOLNPGM("fakeChangePageOfTFT: ", page_index);
#endif
changePageOfTFT(page_index, true);
}
void DgusTFT::lcdAudioSet(const bool audio_on) {
// On: 5A A5 07 82 00 80 5A 00 00 1A
// Off: 5A A5 07 82 00 80 5A 00 00 12
uint8_t data[] = { 0x5A, 0xA5, 0x07, 0x82, 0x00, 0x80, 0x5A, 0x00, 0x00, uint8_t(audio_on ? 0x1A : 0x12) };
for (uint8_t i = 0; i < 10; ++i) TFTSer.write(data[i]);
}
bool DgusTFT::readTFTCommand() {
static uint8_t length = 0, cnt = 0, tft_receive_steps = 0;
uint8_t data;
if (0 == TFTSer.available() || data_received) return false;
data = TFTSer.read();
if (tft_receive_steps == 0) {
if (data != 0x5A) {
cnt = 0;
length = 0;
data_index = 0;
data_received = false;
return false;
}
while (!TFTSer.available()) TERN_(USE_WATCHDOG, hal.watchdog_refresh());
data = TFTSer.read();
// MYSERIAL.write(data );
if (data == 0xA5) tft_receive_steps = 2;
}
else if (tft_receive_steps == 2) {
length = data;
tft_receive_steps = 3;
data_index = 0;
cnt = 0;
}
else if (tft_receive_steps == 3) {
if (data_index >= (DATA_BUF_SIZE -1)) {
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("lcd uart buff overflow: ", data_index);
#endif
data_index = 0;
data_received = false;
return false;
}
data_buf[data_index++] = data;
cnt++;
if (cnt >= length) { // Receive complete
tft_receive_steps = 0;
cnt = 0;
data_index = 0;
data_received = true;
return true;
}
}
return false;
}
#if 0
{
//SERIAL_ECHOLNPGM("readTFTCommand: ", millis());
//return -1;
bool command_ready = false;
uint8_t data = 0;
while (TFTSer.available() > 0 && command_len < MAX_CMND_LEN) {
data = TFTSer.read();
if (0 == command_len) {
// if
}
panel_command[command_len] =
if (panel_command[command_len] == '\n') {
command_ready = true;
break;
}
command_len++;
}
if (command_ready) {
panel_command[command_len] = 0x00;
#if ACDEBUG(AC_ALL)
DEBUG_ECHOLNPGM("< panel_command ", panel_command);
#endif
#if ACDEBUG(AC_SOME)
// Ignore status request commands
uint8_t req = atoi(&panel_command[1]);
if (req > 7 && req != 20) {
DEBUG_ECHOLNPGM("> ", panel_command);
DEBUG_PRINT_PRINTER_STATE(printer_state);
}
#endif
}
return command_ready;
}
#endif
int8_t DgusTFT::findCmdPos(const char * buff, const char q) {
for (int8_t pos = 0; pos < MAX_CMND_LEN; ++pos)
if (buff[pos] == q) return pos;
return -1;
}
void DgusTFT::checkHeaters() {
static uint32_t time_last = 0;
if (PENDING(millis(), time_last)) return;
time_last = millis() + 500;
float temp = 0;
#if HAS_HOTEND
// If the hotend temp is abnormal, confirm state before signalling panel
static uint8_t faultE0Duration = 0;
temp = getActualTemp_celsius(E0);
if (!WITHIN(temp, HEATER_0_MINTEMP, HEATER_0_MAXTEMP)) {
faultE0Duration++;
if (faultE0Duration >= AC_HEATER_FAULT_VALIDATION_TIME) {
tftSendLn(AC_msg_nozzle_temp_abnormal);
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("Extruder temp abnormal! : ", temp);
#endif
faultE0Duration = 0;
}
}
#endif
#if HAS_HEATED_BED
static uint8_t faultBedDuration = 0;
temp = getActualTemp_celsius(BED);
if (!WITHIN(temp, BED_MINTEMP, BED_MAXTEMP)) {
faultBedDuration++;
if (faultBedDuration >= AC_HEATER_FAULT_VALIDATION_TIME) {
tftSendLn(AC_msg_bed_temp_abnormal);
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("Bed temp abnormal! : ", temp);
#endif
faultBedDuration = 0;
}
}
#endif
#if 0
// Update panel with hotend heater status
if (hotend_state != AC_heater_temp_reached) {
if (WITHIN(getActualTemp_celsius(E0) - getTargetTemp_celsius(E0), -1, 1)) {
tftSendLn(AC_msg_nozzle_heating_done);
hotend_state = AC_heater_temp_reached;
}
}
// Update panel with bed heater status
if (hotbed_state != AC_heater_temp_reached) {
if (WITHIN(getActualTemp_celsius(BED) - getTargetTemp_celsius(BED), -0.5, 0.5)) {
tftSendLn(AC_msg_bed_heating_done);
hotbed_state = AC_heater_temp_reached;
}
}
#endif
}
void DgusTFT::sendFileList(int8_t startindex) {
// Respond to panel request for 4 files starting at index
#if ACDEBUG(AC_INFO)
DEBUG_ECHOLNPGM("## sendFileList ## ", startindex);
#endif
filenavigator.getFiles(startindex);
}
void DgusTFT::selectFile() {
strlcpy(selectedfile, panel_command + 4, command_len - 3);
#if ACDEBUG(AC_FILE)
DEBUG_ECHOLNPGM(" Selected File: ", selectedfile);
#endif
switch (selectedfile[0]) {
case '/': // Valid file selected
tftSendLn(AC_msg_sd_file_open_success);
break;
case '<': // .. (go up folder level)
filenavigator.upDIR();
tftSendLn(AC_msg_sd_file_open_failed);
sendFileList(0);
break;
default: // enter sub folder
filenavigator.changeDIR(selectedfile);
tftSendLn(AC_msg_sd_file_open_failed);
sendFileList(0);
break;
}
}
void DgusTFT::processPanelRequest() {
uint16_t control_index = 0;
uint32_t control_value;
uint16_t temp;
char str_buf[20];
if (data_received) {
data_received = false;
if (0x83 == data_buf[0]) {
control_index = uint16_t(data_buf[1] << 8) | uint16_t(data_buf[2]);
if ((control_index & 0xF000) == KEY_ADDRESS) { // is KEY
//key_index = control_index;
key_value = (uint16_t(data_buf[4]) << 8) | uint16_t(data_buf[5]);
}
#if HAS_HOTEND
else if (control_index == TXT_HOTEND_TARGET || control_index == TXT_ADJUST_HOTEND) { // hotend target temp
control_value = (uint16_t(data_buf[4]) << 8) | uint16_t(data_buf[5]);
temp = constrain(uint16_t(control_value), 0, thermalManager.hotend_max_target(0));
setTargetTemp_celsius(temp, E0);
//sprintf(str_buf,"%u/%u", (uint16_t)thermalManager.degHotend(0), uint16_t(control_value));
//sendTxtToTFT(str_buf, TXT_PRINT_HOTEND);
}
#endif
#if HAS_HEATED_BED
else if (control_index == TXT_BED_TARGET || control_index == TXT_ADJUST_BED) {// bed target temp
control_value = (uint16_t(data_buf[4]) << 8) | uint16_t(data_buf[5]);
temp = constrain(uint16_t(control_value), 0, BED_MAX_TARGET);
setTargetTemp_celsius(temp, BED);
//sprintf(str_buf,"%u/%u", uint16_t(thermalManager.degBed()), uint16_t(control_value));
//sendTxtToTFT(str_buf, TXT_PRINT_BED);
}
#endif
#if HAS_FAN
else if (control_index == TXT_FAN_SPEED_TARGET) { // fan speed
control_value = (uint16_t(data_buf[4]) << 8) | uint16_t(data_buf[5]);
temp = constrain(uint16_t(control_value), 0, 100);
sendValueToTFT(temp, TXT_FAN_SPEED_NOW);
sendValueToTFT(temp, TXT_FAN_SPEED_TARGET);
setTargetFan_percent(temp, FAN0);
}
#endif
else if (control_index == TXT_PRINT_SPEED_TARGET || control_index == TXT_ADJUST_SPEED) { // print speed
control_value = (uint16_t(data_buf[4]) << 8) | uint16_t(data_buf[5]);
const uint16_t feedrate = constrain(uint16_t(control_value), 40, 999);
//feedrate_percentage=constrain(control_value,40,999);
sprintf(str_buf, "%u", feedrate);
sendTxtToTFT(str_buf, TXT_PRINT_SPEED);
sendValueToTFT(feedrate, TXT_PRINT_SPEED_NOW);
sendValueToTFT(feedrate, TXT_PRINT_SPEED_TARGET);
setFeedrate_percent(feedrate);
}
else if (control_index == REG_LCD_READY) {
control_value = (uint32_t(data_buf[3]) << 16) | (uint32_t(data_buf[4]) << 8) | uint32_t(data_buf[5]);
if (control_value == 0x010072) { // startup last gif
lcdAudioSet(lcd_info.audio_on);
sendValueToTFT(2, ADDRESS_MOVE_DISTANCE);
#if ENABLED(CASE_LIGHT_ENABLE)
sendValueToTFT(getCaseLightState(), ADDRESS_SYSTEM_LED_STATUS);
sendValueToTFT(getCaseLightState(), ADDRESS_PRINT_SETTING_LED_STATUS);
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
const bool is_outage = AC_printer_resuming_from_power_outage == printer_state;
if (is_outage) {
changePageOfTFT(PAGE_OUTAGE_RECOVERY);
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
char filename[64] = { '\0' };
card.getLongPath(filename, recovery.info.sd_filename);
sendTxtToTFT(filename, TXT_OUTAGE_RECOVERY_FILE);
#else
sendTxtToTFT(recovery.info.sd_filename, TXT_OUTAGE_RECOVERY_FILE);
#endif
playTune(SOS);
}
#else
constexpr bool is_outage = false;
#endif
if (!is_outage) changePageOfTFT(PAGE_MAIN);
}
else if (control_value == 0x010000) { // startup first gif
// startup tunes are defined in Tunes.h
playTune(Anycubic_PowerOn); // takes 3500 ms
}
}
/*
else if ((control_index & 0xF000) == 0x2000) { // is TXT ADDRESS
tft_txt_index = control_index;
j = 0;
for (i = 4; ;i++) {
tft_txt_buf[j] = data_buf[i];
if (tft_txt_buf[j] == 0xFF) {
tft_txt_buf[j] = 0;
break;
}
j++;
}
}
*/
}
else if (0x82 == data_buf[0]) {
// send_cmd_to_pc(cmd ,start );
}
}
}
#if 0
{
// Break these up into logical blocks // as its easier to navigate than one huge switch case!
int8_t req = atoi(&panel_command[1]);
// Information requests A0 - A8 and A33
if (req <= 8 || req == 33) panelInfo(req);
// Simple Actions A9 - A28
else if (req <= 28) panelAction(req);
// Process Initiation
else if (req <= 34) panelProcess(req);
else tftSendLn();
}
#endif
void DgusTFT::set_language(language_t language) {
lcd_info.language = ui_language = lcd_info_back.language = language;
}
void DgusTFT::toggle_language() {
lcd_info.language = ui_language = (lcd_info.language == CHS ? ENG : CHS);
}
void DgusTFT::goto_system_page() {
changePageOfTFT(lcd_info.language == CHS
? (lcd_info.audio_on ? PAGE_SYSTEM_CHS_AUDIO_ON : PAGE_SYSTEM_CHS_AUDIO_OFF)
: (lcd_info.audio_on ? 11 : 50) // PAGE_SYSTEM_ENG_AUDIO_ON/OFF - 120
);
}
void DgusTFT::toggle_audio() {
lcd_info.audio_on = !lcd_info.audio_on;
goto_system_page();
lcdAudioSet(lcd_info.audio_on);
}
void DgusTFT::store_changes() {
if (lcd_info_back.language != lcd_info.language || lcd_info_back.audio_on != lcd_info.audio_on) {
lcd_info_back = lcd_info;
injectCommands(F("M500"));
}
}
#if HAS_HOTEND
void DgusTFT::send_temperature_hotend(uint32_t addr) {
char str_buf[16];
sprintf(str_buf, "%u/%u", uint16_t(getActualTemp_celsius(E0)), uint16_t(getTargetTemp_celsius(E0)));
sendTxtToTFT(str_buf, addr);
}
#endif
#if HAS_HEATED_BED
void DgusTFT::send_temperature_bed(uint32_t addr) {
char str_buf[16];
sprintf(str_buf, "%u/%u", uint16_t(getActualTemp_celsius(BED)), uint16_t(getTargetTemp_celsius(BED)));
sendTxtToTFT(str_buf, addr);
}
#endif
void DgusTFT::page1() {
#if ACDEBUG(AC_ALL)
if (page_index_saved != page_index_now || key_value_saved != key_value) {
DEBUG_ECHOLNPGM("page1 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: { // main page, print
lcd_txtbox_page = 0;
if (lcd_txtbox_index) {
set_descript_color(COLOR_BLUE);
lcd_txtbox_index = 0;
}
changePageOfTFT(PAGE_FILE);
sendFileList(0);
} break;
case 2: { // tool
changePageOfTFT(PAGE_TOOL);
#if ENABLED(CASE_LIGHT_ENABLE)
sendValueToTFT(getCaseLightState(), ADDRESS_SYSTEM_LED_STATUS);
#endif
} break;
case 3: // prepare
changePageOfTFT(PAGE_PREPARE);
break;
case 4: // system
goto_system_page();
break;
}
#if 0
if (message_index < 30) {
sendTxtToTFT(p_mesage[message_index], TXT_MAIN_MESSAGE);
message_index = 30;
}
#endif
#if HAS_HOTEND || HAS_HEATED_BED
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_PREHEAT_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_PREHEAT_BED));
#endif
}
void DgusTFT::page2() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page2 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
char file_index = 0;
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_MAIN);
set_descript_color(COLOR_BLUE);
break;
case 2: // page up
if (lcd_txtbox_page > 0) {
lcd_txtbox_page--;
set_descript_color(COLOR_BLUE);
lcd_txtbox_index = 0;
sendFileList(lcd_txtbox_page * 5);
}
break;
case 3: // page down
if ((lcd_txtbox_page + 1) * 5 < filenavigator.getFileNum()) {
lcd_txtbox_page++;
set_descript_color(COLOR_BLUE);
lcd_txtbox_index = 0;
sendFileList(lcd_txtbox_page * 5);
}
break;
case 4: // page refresh
if (!isMediaInserted()) safe_delay(500);
filenavigator.reset();
lcd_txtbox_page = 0;
if (lcd_txtbox_index) {
set_descript_color(COLOR_BLUE);
lcd_txtbox_index = 0;
}
sendFileList(lcd_txtbox_index);
break;
case 5: // resume of outage(last power off)
#if ACDEBUG(AC_MARLIN)
DEBUG_PRINT_PRINTER_STATE(printer_state);
#endif
if (lcd_txtbox_index > 0 && lcd_txtbox_index < 6) { // 1~5
if (filenavigator.filelist.seek(lcd_txtbox_page * 5 + (lcd_txtbox_index - 1))) {
set_descript_color(COLOR_BLUE);
TERN_(CASE_LIGHT_ENABLE, setCaseLightState(true));
char str_buf[20];
strlcpy_P(str_buf, filenavigator.filelist.longFilename(), 18);
sendTxtToTFT(str_buf, TXT_PRINT_NAME);
#if ENABLED(POWER_LOSS_RECOVERY)
if (printer_state == AC_printer_resuming_from_power_outage) {
// Need to home here to restore the Z position
//injectCommands(AC_cmnd_power_loss_recovery);
//SERIAL_ECHOLNPGM("start resuming from power outage: ", AC_cmnd_power_loss_recovery);
changePageOfTFT(PAGE_STATUS2); // show pause
injectCommands(F("M1000")); // home and start recovery
}
#endif
}
}
break;
case 6: // start print
if (lcd_txtbox_index > 0 && lcd_txtbox_index < 6) { // 1~5
if (filenavigator.filelist.seek(lcd_txtbox_page * 5 + lcd_txtbox_index - 1)) {
#if 0
SERIAL_ECHOLNPGM("start print: ", lcd_txtbox_page * 5 + (lcd_txtbox_index - 1));
SERIAL_ECHOLNPGM("start print: ", filenavigator.filelist.shortFilename());
SERIAL_ECHOLNPGM("start print: ", filenavigator.filelist.longFilename());
#endif
set_descript_color(COLOR_BLUE);
// Allows printer to restart the job if we don't want to recover
if (printer_state == AC_printer_resuming_from_power_outage) {
injectCommands(F("M1000 C")); // Cancel recovery
printer_state = AC_printer_idle;
}
TERN_(CASE_LIGHT_ENABLE, setCaseLightState(true));
printFile(filenavigator.filelist.shortFilename());
char str_buf[20];
strlcpy_P(str_buf, filenavigator.filelist.longFilename(), 18);
sendTxtToTFT(str_buf, TXT_PRINT_NAME);
sprintf(str_buf, "%5.2f", getFeedrate_percent());
sendTxtToTFT(str_buf, TXT_PRINT_SPEED);
sprintf(str_buf, "%u", uint16_t(getProgress_percent()));
sendTxtToTFT(str_buf, TXT_PRINT_PROGRESS);
uint32_t time = 0;
sprintf(str_buf, "%s H ", utostr3(time / 60));
sprintf(str_buf + strlen(str_buf), "%s M", utostr3(time % 60));
sendTxtToTFT(str_buf, TXT_PRINT_TIME);
changePageOfTFT(PAGE_STATUS2);
}
}
break;
case 7: // txtbox 1 click
case 8: // txtbox 2 click
case 9: // txtbox 3 click
case 10: // txtbox 4 click
case 11: { // txtbox 5 click
static uint8_t lcd_txtbox_index_last = 0;
lcd_txtbox_index = key_value - 6;
// lcd_txtbox_page 0~...
// lcd_txtbox_index 1~5
file_index = lcd_txtbox_page * 5 + (lcd_txtbox_index - 1);
if (file_index < filenavigator.getFileNum()) {
set_descript_color(COLOR_RED);
if (lcd_txtbox_index_last && lcd_txtbox_index_last != lcd_txtbox_index) // 1~5
set_descript_color(COLOR_BLUE, lcd_txtbox_index_last);
lcd_txtbox_index_last = lcd_txtbox_index;
}
} break;
}
}
void DgusTFT::page3() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page3 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
static millis_t flash_time = 0;
const millis_t ms = millis();
char str_buf[20];
static uint8_t progress_last = 0;
switch (key_value) {
case 0: break;
case 1: // return
if (!isPrintingFromMedia()) // only idle status can return
changePageOfTFT(PAGE_FILE);
break;
case 2: // resume print
#if ACDEBUG(AC_MARLIN)
DEBUG_PRINT_PRINTER_STATE(printer_state);
DEBUG_PRINT_PAUSED_STATE(pause_state);
#endif
if ( pause_state == AC_paused_idle
|| pause_state == AC_paused_filament_lack
|| printer_state == AC_printer_resuming_from_power_outage
) {
printer_state = AC_printer_idle;
pause_state = AC_paused_idle;
resumePrint();
changePageOfTFT(PAGE_STATUS2); // show pause print
flash_time = ms + 1500;
}
else
setUserConfirmed();
break;
case 3: // print stop
if (isPrintingFromMedia())
changePageOfTFT(PAGE_STOP_CONF);
break;
case 4: // print change param
changePageOfTFT(PAGE_ADJUST);
TERN_(CASE_LIGHT_ENABLE, sendValueToTFT(getCaseLightState(), ADDRESS_PRINT_SETTING_LED_STATUS));
TERN_(HAS_HOTEND, sendValueToTFT(uint16_t(getTargetTemp_celsius(E0)), TXT_ADJUST_HOTEND));
TERN_(HAS_HEATED_BED, sendValueToTFT(uint16_t(getTargetTemp_celsius(BED)), TXT_ADJUST_BED));
feedrate_back = getFeedrate_percent();
sendValueToTFT(uint16_t(feedrate_back), TXT_ADJUST_SPEED);
flash_time = ms + 1500;
break;
}
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
if (feedrate_back != getFeedrate_percent()) {
if (getFeedrate_percent() != 0)
sprintf(str_buf, "%5.2f", getFeedrate_percent());
else
sprintf(str_buf, "%d", feedrate_back);
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("print speed: ", str_buf);
DEBUG_ECHOLNPGM("feedrate_back: ", feedrate_back);
#endif
sendTxtToTFT(str_buf, TXT_PRINT_SPEED);
feedrate_back = getFeedrate_percent();
}
if (progress_last != getProgress_percent()) {
sprintf(str_buf, "%u", getProgress_percent());
sendTxtToTFT(str_buf, TXT_PRINT_PROGRESS);
progress_last = getProgress_percent();
}
// Get Printing Time
uint32_t time = getProgress_seconds_elapsed() / 60;
sprintf(str_buf, "%s H ", utostr3(time / 60));
sprintf(str_buf + strlen(str_buf), "%s M", utostr3(time % 60));
sendTxtToTFT(str_buf, TXT_PRINT_TIME);
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_PRINT_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_PRINT_BED));
}
void DgusTFT::page4() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page4 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
char str_buf[20];
static uint8_t progress_last = 0;
switch (key_value) {
case 0: break;
case 1: // return
if (!isPrintingFromMedia()) // only is idle status can return
changePageOfTFT(PAGE_FILE);
break;
case 2: // print pause
if (isPrintingFromMedia()) {
pausePrint();
printer_state = AC_printer_pausing;
pause_state = AC_paused_idle;
changePageOfTFT(PAGE_WAIT_PAUSE);
//injectCommands(F("M108")); // stop waiting temperature M109
}
break;
case 3: // print stop
if (isPrintingFromMedia())
changePageOfTFT(PAGE_STOP_CONF);
break;
case 4: // print settings
changePageOfTFT(PAGE_ADJUST);
TERN_(CASE_LIGHT_ENABLE, sendValueToTFT(getCaseLightState(), ADDRESS_PRINT_SETTING_LED_STATUS));
TERN_(HAS_HOTEND, sendValueToTFT(uint16_t(getTargetTemp_celsius(E0)), TXT_ADJUST_HOTEND));
TERN_(HAS_HEATED_BED, sendValueToTFT(uint16_t(getTargetTemp_celsius(BED)), TXT_ADJUST_BED));
feedrate_back = getFeedrate_percent();
sendValueToTFT((uint16_t)feedrate_back, TXT_ADJUST_SPEED);
TERN_(HAS_FAN, sendValueToTFT(uint16_t(getActualFan_percent(FAN0)), TXT_FAN_SPEED_TARGET));
str_buf[0] = 0;
strcat(str_buf, ftostr52sprj(getZOffset_mm()) + 3);
sendTxtToTFT(str_buf, TXT_LEVEL_OFFSET);
//sendTxtToTFT(ftostr52sprj(getZOffset_mm()), TXT_LEVEL_OFFSET);
requestValueFromTFT(TXT_ADJUST_SPEED); // attempt to make feedrate visible on visit to this page
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
if (feedrate_back != getFeedrate_percent()) {
if (getFeedrate_percent() != 0)
sprintf(str_buf, "%5.2f", getFeedrate_percent());
else
sprintf(str_buf, "%d", feedrate_back);
sendTxtToTFT(str_buf, TXT_PRINT_SPEED);
feedrate_back = getFeedrate_percent();
}
if (progress_last != getProgress_percent()) {
sprintf(str_buf, "%u", getProgress_percent());
sendTxtToTFT(str_buf, TXT_PRINT_PROGRESS);
progress_last = getProgress_percent();
}
uint32_t time = getProgress_seconds_elapsed() / 60;
sprintf(str_buf, "%s H ", utostr3(time / 60));
sprintf(str_buf + strlen(str_buf), "%s M", utostr3(time % 60));
sendTxtToTFT(str_buf, TXT_PRINT_TIME);
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_PRINT_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_PRINT_BED));
}
void DgusTFT::page5() { // print settings
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page5 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
static bool z_change = false;
switch (key_value) {
case 0: break;
case 1: // return
if (AC_printer_printing == printer_state)
changePageOfTFT(PAGE_STATUS2); // show pause
else if (AC_printer_paused == printer_state)
changePageOfTFT(PAGE_STATUS1); // show print
break;
#if ENABLED(MESH_EDIT_MENU)
case 2: { // -
float z_off = getZOffset_mm();
//SERIAL_ECHOLNPGM("z_off: ", z_off);
//setSoftEndstopState(false);
if (z_off <= -5) return;
z_off -= 0.05f;
setZOffset_mm(z_off);
char str_buf[10];
str_buf[0] = 0;
strcat(str_buf, ftostr52sprj(getZOffset_mm()) + 2);
sendTxtToTFT(str_buf, TXT_LEVEL_OFFSET);
//sendTxtToTFT(ftostr52sprj(getZOffset_mm()), TXT_LEVEL_OFFSET);
//if (isAxisPositionKnown(Z)) { // Move Z axis
// SERIAL_ECHOLNPGM("Z now:", getAxisPosition_mm(Z));
// const float currZpos = getAxisPosition_mm(Z);
// setAxisPosition_mm(currZpos-0.05, Z);
// SERIAL_ECHOLNPGM("Z now:", getAxisPosition_mm(Z));
//}
#if ENABLED(BABYSTEPPING)
int16_t steps = mmToWholeSteps(-0.05, Z);
babystepAxis_steps(steps, Z);
#endif
GRID_LOOP(x, y) {
const xy_uint8_t pos { x, y };
const float currval = getMeshPoint(pos);
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("x: ", x, " y: ", y, " z: ", currval);
#endif
setMeshPoint(pos, constrain(currval - 0.05f, AC_LOWEST_MESHPOINT_VAL, 5));
}
z_change = true;
//setSoftEndstopState(true);
} break;
case 3: { // +
float z_off = getZOffset_mm();
//SERIAL_ECHOLNPGM("z_off: ", z_off);
//setSoftEndstopState(false);
if (z_off >= 5) return;
z_off += 0.05f;
setZOffset_mm(z_off);
char str_buf[10];
str_buf[0] = '\0';
strcat(str_buf, ftostr52sprj(getZOffset_mm()) + 2);
sendTxtToTFT(str_buf, TXT_LEVEL_OFFSET);
//sendTxtToTFT(ftostr52sprj(getZOffset_mm()), TXT_LEVEL_OFFSET);
//int16_t steps = mmToWholeSteps(constrain(Zshift,-0.05,0.05), Z);
/*
if (isAxisPositionKnown(Z)) { // Move Z axis
SERIAL_ECHOLNPGM("Z now:", getAxisPosition_mm(Z));
const float currZpos = getAxisPosition_mm(Z);
setAxisPosition_mm(currZpos-0.05, Z);
SERIAL_ECHOLNPGM("Z now:", getAxisPosition_mm(Z));
}
*/
#if ENABLED(BABYSTEPPING)
int16_t steps = mmToWholeSteps(0.05, Z);
babystepAxis_steps(steps, Z);
#endif
GRID_LOOP(x, y) {
const xy_uint8_t pos { x, y };
const float currval = getMeshPoint(pos);
//SERIAL_ECHOLNPGM("x: ", x, " y: ", y, " z: ", currval);
setMeshPoint(pos, constrain(currval + 0.05f, AC_LOWEST_MESHPOINT_VAL, 5));
}
z_change = true;
//setSoftEndstopState(true);
} break;
#endif // MESH_EDIT_MENU
#if ENABLED(CASE_LIGHT_ENABLE)
case 4: { // light control
const bool cls = !getCaseLightState();
sendValueToTFT(cls, ADDRESS_PRINT_SETTING_LED_STATUS);
setCaseLightState(cls);
} break;
#endif
case 5:
changePageOfTFT(PAGE_DONE);
break;
case 6: break;
case 7:
TERN_(HAS_HEATED_BED, requestValueFromTFT(TXT_ADJUST_BED));
requestValueFromTFT(TXT_ADJUST_SPEED);
TERN_(HAS_HOTEND, requestValueFromTFT(TXT_ADJUST_HOTEND));
TERN_(HAS_FAN, requestValueFromTFT(TXT_FAN_SPEED_TARGET));
if (z_change == true) {
injectCommands(F("M500"));
z_change = false;
}
if (AC_printer_printing == printer_state)
changePageOfTFT(PAGE_STATUS2); // show pause
else if (AC_printer_paused == printer_state)
changePageOfTFT(PAGE_STATUS1); // show print
break;
}
}
void DgusTFT::page6() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page6 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: break;
}
}
void DgusTFT::page7() { // tools
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page7 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_MAIN);
break;
case 2:
changePageOfTFT(PAGE_MOVE);
break;
case 3: // set temperature
changePageOfTFT(PAGE_TEMP);
#if HAS_HOTEND
sendValueToTFT(uint16_t(getActualTemp_celsius(E0)), TXT_HOTEND_NOW);
sendValueToTFT(uint16_t(getTargetTemp_celsius(E0)), TXT_HOTEND_TARGET);
#endif
#if HAS_HEATED_BED
sendValueToTFT(uint16_t(getActualTemp_celsius(BED)), TXT_BED_NOW);
sendValueToTFT(uint16_t(getTargetTemp_celsius(BED)), TXT_BED_TARGET);
#endif
break;
case 4:
changePageOfTFT(PAGE_SPEED);
#if HAS_FAN
sendValueToTFT(uint16_t(getActualFan_percent(FAN0)), TXT_FAN_SPEED_NOW);
sendValueToTFT(uint16_t(getTargetFan_percent(FAN0)), TXT_FAN_SPEED_TARGET);
#endif
sendValueToTFT(uint16_t(getFeedrate_percent()), TXT_PRINT_SPEED_NOW);
sendValueToTFT(uint16_t(getFeedrate_percent()), TXT_PRINT_SPEED_TARGET);
break;
case 5: // turn off the xyz motor
if (!isMoving())
stepper.disable_all_steppers();
break;
#if ENABLED(CASE_LIGHT_ENABLE)
case 6: { // light control
const bool cls = !getCaseLightState();
sendValueToTFT(cls, ADDRESS_SYSTEM_LED_STATUS);
setCaseLightState(cls);
} break;
#endif
}
}
void DgusTFT::page8() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page8 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
//static uint16_t movespeed = 50;
static float move_dis = 1.0f;
if (key_value == 2 || key_value == 4
|| key_value == 6 || key_value == 8
|| key_value == 10 || (key_value == 12 && !isMoving())
) {
if (getAxisPosition_mm(Z) < 0) setAxisPosition_mm(0, Z, 8);
}
// if (!planner.movesplanned())return;
switch (key_value) {
case 0:
break;
case 1: // return
changePageOfTFT(PAGE_TOOL);
break;
case 5:
if (!isMoving())
injectCommands(F("G28 X"));
break;
case 9:
if (!isMoving())
injectCommands(F("G28 Y"));
break;
case 13:
if (!isMoving())
injectCommands(F("G28 Z"));
break;
case 17:
if (!isMoving())
injectCommands(F("G28"));
break;
case 2: // X-
if (!isMoving())
setAxisPosition_mm(getAxisPosition_mm(X) - move_dis, X, 50);
break;
case 4: // X+
if (!isMoving())
setAxisPosition_mm(getAxisPosition_mm(X) + move_dis, X, 50);
break;
case 6: // Y+
if (!isMoving())
setAxisPosition_mm(getAxisPosition_mm(Y) - move_dis, Y, 50);
break;
case 8: // Y-
if (!isMoving())
setAxisPosition_mm(getAxisPosition_mm(Y) + move_dis, Y, 50);
break;
case 10: // Z-
if (!isMoving())
setAxisPosition_mm(getAxisPosition_mm(Z) - move_dis, Z, 8);
break;
case 12: // Z+
if (!isMoving())
setAxisPosition_mm(getAxisPosition_mm(Z) + move_dis, Z, 8);
break;
case 3:
move_dis = 0.1f;
sendValueToTFT(1, ADDRESS_MOVE_DISTANCE);
break;
case 7:
move_dis = 1.0f;
sendValueToTFT(2, ADDRESS_MOVE_DISTANCE);
break;
case 11:
move_dis = 10.0f;
sendValueToTFT(3, ADDRESS_MOVE_DISTANCE);
break;
//case 14:
// movespeed = 3000; //SERIAL_ECHOLN(movespeed);
// break;
//
//case 15:
// movespeed = 2000; //SERIAL_ECHOLN(movespeed);
// break;
//
//case 16:
// movespeed = 1000; //SERIAL_ECHOLN(movespeed);
// break;
}
}
void DgusTFT::page9() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page9 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_TOOL);
break;
case 2: break;
case 3: break;
case 4: break;
case 5: break;
case 6: // cooling
setTargetTemp_celsius(0, E0);
setTargetTemp_celsius(0, BED);
changePageOfTFT(PAGE_TOOL);
break;
case 7: // send target temp
requestValueFromTFT(TXT_HOTEND_TARGET);
requestValueFromTFT(TXT_BED_TARGET);
changePageOfTFT(PAGE_TOOL);
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
sendValueToTFT(uint16_t(getActualTemp_celsius(E0)), TXT_HOTEND_NOW);
sendValueToTFT(uint16_t(getActualTemp_celsius(BED)), TXT_BED_NOW);
}
void DgusTFT::page10() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page10 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_TOOL);
break;
case 2: break;
case 3: break;
case 4: break;
case 5: break;
case 6: // ok
requestValueFromTFT(TXT_FAN_SPEED_TARGET);
requestValueFromTFT(TXT_PRINT_SPEED_TARGET);
changePageOfTFT(PAGE_TOOL);
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
sendValueToTFT(uint16_t(getActualFan_percent(FAN0)), TXT_FAN_SPEED_NOW);
sendValueToTFT(uint16_t(getFeedrate_percent()), TXT_PRINT_SPEED_NOW);
}
void DgusTFT::page11() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page11 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_MAIN);
store_changes();
break;
case 2: // language
toggle_language();
goto_system_page();
break;
case 3: break;
case 4: // audio
toggle_audio();
break;
case 5: { // about
char str_ver[32];
//sprintf(str_ver, "%04d-%02d-%02d %02d:%02d:%02d\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY, BUILD_HOUR, BUILD_MIN, BUILD_SEC);
sprintf(str_ver, MAIN_BOARD_FIRMWARE_VER);
sendTxtToTFT(str_ver, TXT_VERSION);
changePageOfTFT(PAGE_ABOUT);
} break;
case 6:
changePageOfTFT(PAGE_RECORD);
break;
}
}
void DgusTFT::page12() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page12 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_SYSTEM_CHS_AUDIO_ON);
break;
}
}
void DgusTFT::page13() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page13 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
goto_system_page();
break;
case 2: break;
}
}
void DgusTFT::page14() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page14 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: break; // return
case 2: break;
case 3: break;
case 4: break;
}
}
void DgusTFT::page15() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page15 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_MAIN);
break;
case 2:
changePageOfTFT(PAGE_PreLEVEL);
break;
#if HAS_HOTEND || HAS_HEATED_BED
case 3: {
changePageOfTFT(PAGE_PREHEAT);
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_PREHEAT_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_PREHEAT_BED));
} break;
#endif
#if HAS_EXTRUDERS
case 4: {
send_temperature_hotend(TXT_FILAMENT_TEMP);
changePageOfTFT(PAGE_FILAMENT);
} break;
#endif
}
}
void DgusTFT::page16() { // AUTO LEVELING
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page16 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_PREPARE);
break;
case 2:
if (!isPrinting()) {
//changePageOfTFT(PAGE_LEVEL_ENSURE);
changePageOfTFT(PAGE_CHS_PROBE_PRECHECK);
}
break;
case 3: {
char str_buf[10];
str_buf[0] = '\0';
strcat(str_buf, ftostr52sprj(getZOffset_mm()) + 2);
sendTxtToTFT(str_buf, TXT_LEVEL_OFFSET);
//sendTxtToTFT(ftostr52sprj(getZOffset_mm()), TXT_LEVEL_OFFSET);
changePageOfTFT(PAGE_LEVEL_ADVANCE);
} break;
case 4:
changePageOfTFT(PAGE_AUTO_OFFSET);
break;
}
}
void DgusTFT::page17() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page17 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
float z_off;
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_PreLEVEL);
break;
case 2: {
setSoftEndstopState(false);
if (getZOffset_mm() <= -5) return;
z_off = getZOffset_mm() - 0.01f;
setZOffset_mm(z_off);
char str_buf[10];
strcat(str_buf, ftostr52sprj(getZOffset_mm()) + 2);
sendTxtToTFT(str_buf, TXT_LEVEL_OFFSET);
//sendTxtToTFT(ftostr52sprj(getZOffset_mm()), TXT_LEVEL_OFFSET);
if (isAxisPositionKnown(Z)) {
const float currZpos = getAxisPosition_mm(Z);
setAxisPosition_mm(currZpos - 0.01f, Z);
}
setSoftEndstopState(true);
} break;
case 3: {
setSoftEndstopState(false);
if (getZOffset_mm() >= 5) return;
z_off = getZOffset_mm() + 0.01f;
setZOffset_mm(z_off);
char str_buf[10];
strcat(str_buf, ftostr52sprj(getZOffset_mm()) + 2);
sendTxtToTFT(str_buf, TXT_LEVEL_OFFSET);
//sendTxtToTFT(ftostr52sprj(getZOffset_mm()), TXT_LEVEL_OFFSET);
if (isAxisPositionKnown(Z)) { // Move Z axis
const float currZpos = getAxisPosition_mm(Z);
setAxisPosition_mm(currZpos + 0.01f, Z);
}
setSoftEndstopState(true);
} break;
case 4:
#if ACDEBUG(AC_MARLIN)
DEBUG_ECHOLNPGM("z off: ", ftostr52sprj(getZOffset_mm()));
#endif
#if HAS_LEVELING
GRID_LOOP(x, y) {
const xy_uint8_t pos { x, y };
const float currval = getMeshPoint(pos);
setMeshPoint(pos, constrain(currval + getZOffset_mm(), AC_LOWEST_MESHPOINT_VAL, 5));
}
injectCommands(F("M500"));
#endif
changePageOfTFT(PAGE_PREPARE);
break;
}
}
#if HAS_HOTEND || HAS_HEATED_BED
void DgusTFT::page18() { // preheat
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page18 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(PAGE_PREPARE);
break;
case 2: // PLA
TERN_(HAS_HOTEND, setTargetTemp_celsius(190, E0));
TERN_(HAS_HEATED_BED, setTargetTemp_celsius(60, BED));
changePageOfTFT(PAGE_PREHEAT);
break;
case 3: // ABS
TERN_(HAS_HOTEND, setTargetTemp_celsius(240, E0));
TERN_(HAS_HEATED_BED, setTargetTemp_celsius(100, BED));
changePageOfTFT(PAGE_PREHEAT);
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_PREHEAT_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_PREHEAT_BED));
}
#endif // HAS_HOTEND || HAS_HEATED_BED
#if HAS_EXTRUDERS
void DgusTFT::page19() { // Filament
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page19 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
static char filament_status = 0;
static millis_t flash_time = 0;
switch (key_value) {
case 0: break;
case 1: // return
filament_status = 0;
injectCommands(F("G90"));
changePageOfTFT(PAGE_PREPARE);
break;
case 2: // Filament in
if (getActualTemp_celsius(E0) < 220) {
filament_status = 0;
changePageOfTFT(PAGE_FILAMENT_HEAT);
}
else {
filament_status = 1;
injectCommands(F("G91"));
}
break;
case 3: // filament out
if (getActualTemp_celsius(E0) < 220) {
filament_status = 0;
changePageOfTFT(PAGE_FILAMENT_HEAT);
}
else {
filament_status = 2;
injectCommands(F("G91"));
}
break;
case 4: // stop
filament_status = 0;
break;
}
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
send_temperature_hotend(TXT_FILAMENT_TEMP);
if (!isPrinting()) {
if (filament_status == 1) {
if (canMove(E0) && !commandsInQueue())
injectCommands(AC_cmnd_manual_load_filament);
}
else if (filament_status == 2) {
if (canMove(E0) && !commandsInQueue())
injectCommands(AC_cmnd_manual_unload_filament);
}
}
}
#endif // HAS_EXTRUDERS
void DgusTFT::page20() { // confirm
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page20 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(page_index_last);
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page21() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page21 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
changePageOfTFT(page_index_last);
break;
case 2: break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page22() { // print finish
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page22 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // OK to finish
TERN_(CASE_LIGHT_ENABLE, setCaseLightState(false));
changePageOfTFT(PAGE_MAIN);
break;
case 2: break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page23() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page23 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: changePageOfTFT(page_index_last); break; // return
case 2: changePageOfTFT(page_index_last); break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page24() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page24 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: changePageOfTFT(page_index_last); break; // return
case 2: changePageOfTFT(page_index_last); break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page25() { // lack filament
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page25 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
#if ACDEBUG(AC_MARLIN)
DEBUG_PRINT_PRINTER_STATE(printer_state);
DEBUG_PRINT_PAUSED_STATE(pause_state);
#endif
if (AC_printer_printing == printer_state)
changePageOfTFT(PAGE_STATUS2); // show pause
else if (AC_printer_paused == printer_state) {
//injectCommands(F("M108"));
changePageOfTFT(PAGE_STATUS1); // show resume
}
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page26() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page26 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: changePageOfTFT(page_index_last); break; // return
case 2: break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page27() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page27 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // print stop confirmed
if (isPrintingFromMedia()) {
printer_state = AC_printer_stopping;
stopPrint();
message_index = 6;
changePageOfTFT(PAGE_MAIN);
}
else {
if (printer_state == AC_printer_resuming_from_power_outage)
injectCommands(F("M1000 C")); // Cancel recovery
printer_state = AC_printer_idle;
}
break;
case 2: // return
if (AC_printer_printing == printer_state)
changePageOfTFT(PAGE_STATUS2); // show pause
else if (AC_printer_paused == printer_state)
changePageOfTFT(PAGE_STATUS1); // show print
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page28() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page28 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: changePageOfTFT(page_index_last); break; // return
case 2: break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page29() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page29 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
TERN_(CASE_LIGHT_ENABLE, setCaseLightState(false));
changePageOfTFT(PAGE_MAIN);
break;
case 2: break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page30() { // Auto heat filament
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page30 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: // return
setTargetTemp_celsius(230, E0);
changePageOfTFT(PAGE_FILAMENT);
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page31() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page31 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: break; // return
case 2: break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page32() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page32 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
#if HAS_LEVELING
void DgusTFT::page33() {
#if ACDEBUG(AC_ALL)
if (page_index_saved != page_index_now) {
DEBUG_ECHOLNPGM("page33 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
}
#endif
switch (key_value) {
case 0: break;
case 1: // auto leveling start
injectCommands(F("G28\nG29"));
printer_state = AC_printer_probing;
// this will cause leveling->preheating->leveling
#if 0
#if ENABLED(PREHEAT_BEFORE_LEVELING)
if (getTargetTemp_celsius(E0) < LEVELING_NOZZLE_TEMP
|| getTargetTemp_celsius(BED) < LEVELING_BED_TEMP
) {
setTargetTemp_celsius(LEVELING_NOZZLE_TEMP, E0);
setTargetTemp_celsius(LEVELING_BED_TEMP, BED);
changePageOfTFT(PAGE_CHS_PROBE_PREHEATING);
}
else
changePageOfTFT(PAGE_LEVELING);
#else
changePageOfTFT(PAGE_LEVELING);
#endif
#endif
changePageOfTFT(PAGE_LEVELING);
break;
case 2:
changePageOfTFT(PAGE_PreLEVEL);
break;
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
}
void DgusTFT::page34() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page34 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
#if HAS_HOTEND || HAS_HEATED_BED
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_MAIN_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_MAIN_BED));
#endif
if (pop_up_index == 25) {
pop_up_index = 100;
changePageOfTFT(PAGE_PreLEVEL);
}
}
#endif // HAS_LEVELING
void DgusTFT::page115() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page115 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1: changePageOfTFT(PAGE_PreLEVEL); break;
case 2: {
injectCommands(F("M1024 S3")); // -1
//char value[20]
//sprintf_P(value, PSTR("G1 Z%iF%i")); enqueue_and_echo_command_now(value); }
} break;
case 3: injectCommands(F("M1024 S4")); break; // 1
case 4: injectCommands(F("M1024 S1")); break; // -0.1
case 5: injectCommands(F("M1024 S2")); break; // 0.1
case 6: injectCommands(F("M1024 S0")); break; // prepare, move x y to center
case 7: injectCommands(F("M1024 S5")); break; // 0.1
}
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1000;
}
void DgusTFT::page117() { // Page CHS Mute handler
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page117 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1:
changePageOfTFT(PAGE_MAIN);
store_changes();
break;
case 2: // language
toggle_language();
goto_system_page();
break;
case 3: break;
case 4: // audio
toggle_audio();
break;
case 5: // about
char str_ver[32];
//sprintf(str_ver, "%04d-%02d-%02d %02d:%02d:%02d\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY, BUILD_HOUR, BUILD_MIN, BUILD_SEC);
sprintf(str_ver, MAIN_BOARD_FIRMWARE_VER);
sendTxtToTFT(str_ver, TXT_VERSION);
changePageOfTFT(PAGE_ABOUT);
break;
case 6:
changePageOfTFT(PAGE_RECORD);
break;
}
}
void DgusTFT::page124() { // first time into page 124 the feedrate percent is not set
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page124 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
//DEBUG_ECHOLNPGM("update feedrate percent");
}
#endif
sendValueToTFT(uint16_t(getFeedrate_percent()), TXT_PRINT_SPEED_NOW);
}
void DgusTFT::page125() { // first time into page 125 the feedrate percent is not set
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page125 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
//DEBUG_ECHOLNPGM("update feedrate percent");
}
#endif
sendValueToTFT(uint16_t(getFeedrate_percent()), TXT_PRINT_SPEED_NOW);
}
void DgusTFT::page170() { // ENG Mute handler
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page170 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 0: break;
case 1:
changePageOfTFT(PAGE_MAIN);
store_changes();
break;
case 2: // language
toggle_language();
goto_system_page();
break;
case 3: break;
case 4: // audio
toggle_audio();
break;
case 5: // about
char str_ver[32];
//sprintf(str_ver, "%04d-%02d-%02d %02d:%02d:%02d\n", BUILD_YEAR, BUILD_MONTH, BUILD_DAY, BUILD_HOUR, BUILD_MIN, BUILD_SEC);
sprintf(str_ver, MAIN_BOARD_FIRMWARE_VER);
sendTxtToTFT(str_ver, TXT_VERSION);
changePageOfTFT(PAGE_ABOUT);
break;
case 6:
changePageOfTFT(PAGE_RECORD);
break;
}
}
#if ENABLED(POWER_LOSS_RECOVERY)
void DgusTFT::page171() { // CHS power outage resume handler
#if ACDEBUG(AC_ALL)
if (page_index_saved != page_index_now) {
DEBUG_ECHOLNPGM("page171 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
}
#endif
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
char filename[64] = { '\0' };
#endif
switch (key_value) {
case 0: break;
case 1: { // resume
changePageOfTFT(PAGE_OUTAGE_RECOVERY);
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
card.getLongPath(filename, recovery.info.sd_filename);
filename[17] = '\0';
sendTxtToTFT(filename, TXT_OUTAGE_RECOVERY_FILE);
#else
sendTxtToTFT(recovery.info.sd_filename, TXT_OUTAGE_RECOVERY_FILE);
#endif
char str_buf[20] = { '\0' };
sprintf(str_buf, "%u", uint16_t(getFeedrate_percent()));
sendTxtToTFT(str_buf, TXT_PRINT_SPEED);
sprintf(str_buf, "%u", uint16_t(getProgress_percent()));
sendTxtToTFT(str_buf, TXT_PRINT_PROGRESS);
changePageOfTFT(PAGE_STATUS2); // show pause
injectCommands(F("M355 S1\nM1000")); // case light on, home and start recovery
} break;
case 2: // cancel
printer_state = AC_printer_idle;
changePageOfTFT(PAGE_MAIN);
injectCommands(F("M355 S0\nM1000 C")); // cancel recovery
break;
}
}
void DgusTFT::page173() { // ENG power outage resume handler
#if ACDEBUG(AC_ALL)
if (page_index_saved != page_index_now) {
DEBUG_ECHOLNPGM("page173 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
}
#endif
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
char filename[64] = { '\0' };
#endif
switch (key_value) {
case 0: break;
case 1: { // resume
changePageOfTFT(PAGE_OUTAGE_RECOVERY);
#if ENABLED(LONG_FILENAME_HOST_SUPPORT)
card.getLongPath(filename, recovery.info.sd_filename);
filename[17] = '\0';
sendTxtToTFT(filename, TXT_OUTAGE_RECOVERY_FILE);
#else
sendTxtToTFT(recovery.info.sd_filename, TXT_OUTAGE_RECOVERY_FILE);
#endif
char str_buf[20] = { '\0' };
sprintf(str_buf, "%u", uint16_t(getFeedrate_percent()));
sendTxtToTFT(str_buf, TXT_PRINT_SPEED);
sprintf(str_buf, "%u", uint16_t(getProgress_percent()));
sendTxtToTFT(str_buf, TXT_PRINT_PROGRESS);
changePageOfTFT(PAGE_STATUS2); // show pause
injectCommands(F("M355 S1\nM1000")); // case light on, home and start recovery
} break;
case 2: // cancel
printer_state = AC_printer_idle;
changePageOfTFT(PAGE_MAIN);
injectCommands(F("M355 S0\nM1000 C")); // cancel recovery
break;
}
}
#endif // POWER_LOSS_RECOVERY
#if HAS_LEVELING
void DgusTFT::page175() { // CHS probe preheating handler
#if ACDEBUG(AC_ALL)
if (page_index_saved != page_index_now) {
DEBUG_ECHOLNPGM("page175 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
}
#endif
#if HAS_HOTEND || HAS_HEATED_BED
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_MAIN_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_MAIN_BED));
#endif
}
void DgusTFT::page176() { // ENG probe preheating handler
#if ACDEBUG(AC_ALL)
if (page_index_saved != page_index_now) {
DEBUG_ECHOLNPGM("page176 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
}
#endif
#if HAS_HOTEND || HAS_HEATED_BED
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_MAIN_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_MAIN_BED));
#endif
}
#endif // HAS_LEVELING
void DgusTFT::page177_to_198() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page177_to_198 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 1: // return
#if ACDEBUG(AC_MARLIN)
//DEBUG_ECHOLNPGM("page_index_now: ", page_index_now);
//DEBUG_ECHOLNPGM("page_index_last: ", page_index_last);
//DEBUG_ECHOLNPGM("page_index_last_2: ", page_index_last_2);
#endif
if ((WITHIN(page_index_now, PAGE_CHS_ABNORMAL_X_ENDSTOP, PAGE_CHS_ABNORMAL_Z_ENDSTOP))
|| (WITHIN(page_index_now, PAGE_ENG_ABNORMAL_X_ENDSTOP, PAGE_ENG_ABNORMAL_Z_ENDSTOP))
) {
if (lcd_info.language == ENG) {
if (page_index_last_2 > 120) page_index_last_2 -= 120;
if (page_index_last > 120) page_index_last -= 120;
}
if (PAGE_STATUS1 == page_index_last_2 || PAGE_STATUS2 == page_index_last_2 || PAGE_PRINT_FINISH == page_index_last)
changePageOfTFT(PAGE_MAIN);
else
changePageOfTFT(page_index_last_2);
}
else {
if (lcd_info.language == ENG && page_index_last > 120)
page_index_last -= 120;
changePageOfTFT(page_index_last);
}
onSurviveInKilled();
stepper.disable_all_steppers();
break;
default: break;
}
}
#if 0
void DgusTFT::page178_to_181_190_to_193() { // temperature abnormal
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page178_to_181_190_to_193 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 1: // return
SERIAL_ECHOLNPGM("page_index_now: ", page_index_now);
SERIAL_ECHOLNPGM("page_index_last: ", page_index_last);
SERIAL_ECHOLNPGM("page_index_last_2: ", page_index_last_2);
if (isPrinting() || isPrintingPaused() || isPrintingFromMedia()) {
printer_state = AC_printer_stopping;
stopPrint();
changePageOfTFT(PAGE_MAIN);
}
else
changePageOfTFT(page_index_last);
onSurviveInKilled();
break;
default: break;
}
}
#endif
void DgusTFT::page199_to_200() {
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page199_to_200 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now, " key: ", key_value);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
switch (key_value) {
case 1: // return
#if ACDEBUG(AC_MARLIN)
//DEBUG_ECHOLNPGM("page_index_now: ", page_index_now);
//DEBUG_ECHOLNPGM("page_index_last: ", page_index_last);
//DEBUG_ECHOLNPGM("page_index_last_2: ", page_index_last_2);
#endif
onSurviveInKilled();
changePageOfTFT(PAGE_PreLEVEL);
break;
default: break;
}
}
inline void ProbeTare() {
#if PIN_EXISTS(AUTO_LEVEL_TX)
OUT_WRITE(AUTO_LEVEL_TX_PIN, LOW);
delay(300);
OUT_WRITE(AUTO_LEVEL_TX_PIN, HIGH);
delay(100);
#endif
}
inline bool getProbeState() { return PROBE_TRIGGERED(); }
void DgusTFT::page201() { // probe precheck
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page201 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
static millis_t probe_check_time = 0;
static millis_t temperature_time = 0;
static uint8_t probe_check_counter = 0;
static uint8_t probe_state_last = 0;
static bool probe_tare_flag = 0;
if (!probe_tare_flag) {
ProbeTare();
delay(100);
if (getProbeState()) { // triggered too early
probe_check_counter = 0;
probe_tare_flag = 0;
changePageOfTFT(PAGE_CHS_PROBE_PRECHECK_FAILED);
}
probe_tare_flag = 1;
}
switch (key_value) {
case 1: // cancel
probe_check_counter = 0;
probe_tare_flag = 0;
changePageOfTFT(PAGE_PreLEVEL);
break;
default: break;
}
if (ELAPSED(millis(), probe_check_time)) {
probe_check_time = millis() + 300;
if (!probe_state_last && getProbeState()) {
probe_check_counter = 0;
probe_tare_flag = 0;
changePageOfTFT(PAGE_CHS_PROBE_PRECHECK_OK);
}
probe_state_last = getProbeState();
if (probe_check_counter++ >= 200) { // waiting for 1 min
probe_check_counter = 0;
probe_tare_flag = 0;
changePageOfTFT(PAGE_CHS_PROBE_PRECHECK_FAILED);
}
}
if (ELAPSED(millis(), temperature_time)) {
temperature_time = millis() + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_MAIN_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_MAIN_BED));
}
}
void DgusTFT::page202() { // probe precheck ok
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page202 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
//static millis_t flash_time = 0;
//static millis_t probe_check_counter = 0;
//static uint8_t probe_state_last = 0;
delay(3000);
injectCommands(F("G28\nG29"));
printer_state = AC_printer_probing;
changePageOfTFT(PAGE_LEVELING);
}
void DgusTFT::page203() { // probe precheck failed
#if ACDEBUG(AC_ALL)
if ((page_index_saved != page_index_now) || (key_value_saved != key_value)) {
DEBUG_ECHOLNPGM("page203 page_index_last_2: ", page_index_last_2, " page_index_last: ", page_index_last, " page_index_now: ", page_index_now);
page_index_saved = page_index_now;
key_value_saved = key_value;
}
#endif
//static millis_t probe_check_counter = 0;
//static uint8_t probe_state_last = 0;
#if HAS_HOTEND || HAS_HEATED_BED
static millis_t flash_time = 0;
const millis_t ms = millis();
if (PENDING(ms, flash_time)) return;
flash_time = ms + 1500;
TERN_(HAS_HOTEND, send_temperature_hotend(TXT_MAIN_HOTEND));
TERN_(HAS_HEATED_BED, send_temperature_bed(TXT_MAIN_BED));
#endif
}
void DgusTFT::pop_up_manager() {
#if ACDEBUG(AC_ALL)
if (pop_up_index_saved != pop_up_index) {
DEBUG_ECHOLNPGM("pop_up_manager pop_up_index: ", pop_up_index);
pop_up_index_saved = pop_up_index;
}
#endif
switch (pop_up_index) {
case 10: // T0 error
if (page_index_now != PAGE_ABNORMAL)
changePageOfTFT(PAGE_ABNORMAL);
pop_up_index = 100;
break;
case 15: // filament lack
case 23:
if (page_index_now != PAGE_FILAMENT_LACK)
changePageOfTFT(PAGE_FILAMENT_LACK);
pop_up_index = 100;
break;
case 16: // stop wait
changePageOfTFT(PAGE_WAIT_STOP);
pop_up_index = 100;
break;
case 18:
changePageOfTFT(PAGE_STATUS1);
pop_up_index = 100;
break;
case 24: { //
uint32_t time = getProgress_seconds_elapsed() / 60;
char str_buf[20];
sprintf(str_buf, "%s H ", utostr3(time / 60));
sprintf(str_buf + strlen(str_buf), "%s M", utostr3(time % 60));
sendTxtToTFT(str_buf, TXT_FINISH_TIME);
changePageOfTFT(PAGE_PRINT_FINISH);
//tftSendLn(AC_msg_print_complete); // no idea why this causes a compile error
pop_up_index = 100;
} break;
case 25: // LEVEL DONE
changePageOfTFT(PAGE_PreLEVEL);
pop_up_index = 100;
break;
}
}
void DEBUG_PRINT_PAUSED_STATE(const paused_state_t state, FSTR_P const msg/*=nullptr*/) {
if (msg) DEBUG_ECHO(msg);
DEBUG_ECHOPGM("Paused state: ", state, " ");
switch (state) {
case AC_paused_heater_timed_out: DEBUG_ECHOPGM("AC_paused_heater_timed_out"); break;
case AC_paused_filament_lack: DEBUG_ECHOPGM("AC_paused_filament_lack"); break;
case AC_paused_purging_filament: DEBUG_ECHOPGM("AC_paused_purging_filament"); break;
case AC_paused_idle: DEBUG_ECHOPGM("AC_paused_idle"); break;
}
DEBUG_EOL();
}
// Human-readable debugging
void DEBUG_PRINT_PRINTER_STATE(const printer_state_t state, FSTR_P const msg/*=nullptr*/) {
if (msg) DEBUG_ECHO(msg);
DEBUG_ECHOPGM("Printer State: ", state, " ");
switch (state) {
case AC_printer_idle: DEBUG_ECHOPGM("AC_printer_idle"); break;
case AC_printer_probing: DEBUG_ECHOPGM("AC_printer_probing"); break;
case AC_printer_printing: DEBUG_ECHOPGM("AC_printer_printing"); break;
case AC_printer_pausing: DEBUG_ECHOPGM("AC_printer_pausing"); break;
case AC_printer_paused: DEBUG_ECHOPGM("AC_printer_paused"); break;
case AC_printer_stopping: DEBUG_ECHOPGM("AC_printer_stopping"); break;
case AC_printer_stopping_from_media_remove: DEBUG_ECHOPGM("AC_printer_stopping_from_media_remove"); break;
case AC_printer_resuming_from_power_outage: DEBUG_ECHOPGM("AC_printer_resuming_from_power_outage"); break;
}
DEBUG_EOL();
}
void DEBUG_PRINT_TIMER_EVENT(const timer_event_t event, FSTR_P const msg/*=nullptr*/) {
if (msg) DEBUG_ECHOPGM(msg, event);
DEBUG_ECHOPGM("timerEvent() ", event, " ");
switch (event) {
case AC_timer_started: DEBUG_ECHOPGM("AC_timer_started"); break;
case AC_timer_paused: DEBUG_ECHOPGM("AC_timer_paused"); break;
case AC_timer_stopped: DEBUG_ECHOPGM("AC_timer_stopped"); break;
}
DEBUG_EOL();
}
void DEBUG_PRINT_MEDIA_EVENT(const media_event_t event, FSTR_P const msg/*=nullptr*/) {
if (msg) DEBUG_ECHOPGM(msg, event);
DEBUG_ECHOPGM("ProcessMediaStatus() ", event, " ");
switch (event) {
case AC_media_inserted: DEBUG_ECHOPGM("AC_media_inserted"); break;
case AC_media_removed: DEBUG_ECHOPGM("AC_media_removed"); break;
case AC_media_error: DEBUG_ECHOPGM("AC_media_error"); break;
}
DEBUG_EOL();
}
} // namespace
#endif // ANYCUBIC_LCD_VYPER
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_vyper/dgus_tft.cpp
|
C++
|
agpl-3.0
| 107,779
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic_vyper/dgus_tft.h
*/
#include "dgus_tft_defs.h"
#include "../../../inc/MarlinConfigPre.h"
#include "../ui_api.h"
#define MAIN_BOARD_FIRMWARE_VER "V2.4.5"
#define DATA_BUF_SIZE 64
/****************** PAGE INDEX***********************/
#define PAGE_OFFSET 0
#define PAGE_MAIN (1+PAGE_OFFSET)
#define PAGE_FILE (2+PAGE_OFFSET)
#define PAGE_STATUS1 (3+PAGE_OFFSET) // show resume
#define PAGE_STATUS2 (4+PAGE_OFFSET) // show pause
#define PAGE_ADJUST (5+PAGE_OFFSET)
#define PAGE_KEYBPARD (6+PAGE_OFFSET)
#define PAGE_TOOL (7+PAGE_OFFSET)
#define PAGE_MOVE (8+PAGE_OFFSET)
#define PAGE_TEMP (9+PAGE_OFFSET)
#define PAGE_SPEED (10+PAGE_OFFSET)
#define PAGE_SYSTEM_CHS_AUDIO_ON (11+PAGE_OFFSET)
#define PAGE_WIFI (12+PAGE_OFFSET)
#define PAGE_ABOUT (13+PAGE_OFFSET)
#define PAGE_RECORD (14+PAGE_OFFSET)
#define PAGE_PREPARE (15+PAGE_OFFSET)
#define PAGE_PreLEVEL (16+PAGE_OFFSET)
#define PAGE_LEVEL_ADVANCE (17+PAGE_OFFSET)
#define PAGE_PREHEAT (18+PAGE_OFFSET)
#define PAGE_FILAMENT (19+PAGE_OFFSET)
#define PAGE_DONE (20+PAGE_OFFSET)
#define PAGE_ABNORMAL (21+PAGE_OFFSET)
#define PAGE_PRINT_FINISH (22+PAGE_OFFSET)
#define PAGE_WAIT_STOP (23+PAGE_OFFSET)
#define PAGE_FILAMENT_LACK (25+PAGE_OFFSET)
#define PAGE_FORBIT (26+PAGE_OFFSET)
#define PAGE_STOP_CONF (27+PAGE_OFFSET)
#define PAGE_NO_SD (29+PAGE_OFFSET)
#define PAGE_FILAMENT_HEAT (30+PAGE_OFFSET)
#define PAGE_WAIT_PAUSE (32+PAGE_OFFSET)
#define PAGE_LEVEL_ENSURE (33+PAGE_OFFSET)
#define PAGE_LEVELING (34+PAGE_OFFSET)
#define PAGE_AUTO_OFFSET (115+PAGE_OFFSET)
#define PAGE_SYSTEM_CHS_AUDIO_OFF (117+PAGE_OFFSET)
#define PAGE_SYSTEM_ENG_AUDIO_ON (131+PAGE_OFFSET)
#define PAGE_SYSTEM_ENG_AUDIO_OFF (170+PAGE_OFFSET)
#define PAGE_OUTAGE_RECOVERY (171+PAGE_OFFSET)
#define PAGE_ENG_OUTAGE_RECOVERY (173+PAGE_OFFSET)
#define PAGE_CHS_PROBE_PREHEATING (176+PAGE_OFFSET)
#define PAGE_ENG_PROBE_PREHEATING (175+PAGE_OFFSET)
#define PAGE_CHS_HOMING (177+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_BED_HEATER (178+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_BED_NTC (179+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_HOTEND_HEATER (180+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_HOTEND_NTC (181+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_ENDSTOP (182+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_X_ENDSTOP (182+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_Y_ENDSTOP (183+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_Z_ENDSTOP (184+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_ZL_ENDSTOP (185+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_ZR_ENDSTOP (186+PAGE_OFFSET)
#define PAGE_CHS_ABNORMAL_LEVELING_SENSOR (187+PAGE_OFFSET)
#define PAGE_CHS_LEVELING_FAILED (188+PAGE_OFFSET)
#define PAGE_ENG_HOMING (189+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_BED_HEATER (190+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_BED_NTC (191+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_HOTEND_HEATER (192+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_HOTEND_NTC (193+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_ENDSTOP (194+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_X_ENDSTOP (194+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_Y_ENDSTOP (195+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_Z_ENDSTOP (196+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_ZL_ENDSTOP (197+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_ZR_ENDSTOP (198+PAGE_OFFSET)
#define PAGE_ENG_ABNORMAL_LEVELING_SENSOR (199+PAGE_OFFSET)
#define PAGE_ENG_LEVELING_FAILED (200+PAGE_OFFSET)
#define PAGE_CHS_PROBE_PRECHECK (201+PAGE_OFFSET)
#define PAGE_CHS_PROBE_PRECHECK_OK (202+PAGE_OFFSET)
#define PAGE_CHS_PROBE_PRECHECK_FAILED (203+PAGE_OFFSET)
#define PAGE_ENG_PROBE_PRECHECK (204+PAGE_OFFSET)
#define PAGE_ENG_PROBE_PRECHECK_OK (205+PAGE_OFFSET)
#define PAGE_ENG_PROBE_PRECHECK_FAILED (206+PAGE_OFFSET)
/****************** Lcd control **************************/
#define REG_LCD_READY 0x0014
/****************** TXT **************************/
// MAIN PAGE TXT
#define TXT_MAIN_BED 0x2000
#define TXT_MAIN_HOTEND 0x2030
#define TXT_MAIN_MESSAGE 0x2060
// FILE TXT
#define TXT_FILE_0 (0x2000+3*0x30)
#define TXT_DESCRIPT_0 0x5000 // DESCRIBE ADDRESS
#define TXT_FILE_1 (0x2000+4*0x30)
#define TXT_DESCRIPT_1 0x5030
#define TXT_FILE_2 (0x2000+5*0x30)
#define TXT_DESCRIPT_2 0x5060
#define TXT_FILE_3 (0x2000+6*0x30)
#define TXT_DESCRIPT_3 0x5090
#define TXT_FILE_4 (0x2000+7*0x30)
#define TXT_DESCRIPT_4 0x50C0
// PRINT TXT
#define TXT_PRINT_NAME 0x2000+8*0x30
#define TXT_PRINT_SPEED 0x2000+9*0x30
#define TXT_PRINT_TIME 0x2000+10*0x30
#define TXT_PRINT_PROGRESS 0x2000+11*0x30
#define TXT_PRINT_HOTEND 0x2000+12*0x30
#define TXT_PRINT_BED 0x2000+13*0x30
// PRINT ADJUST TXT
#define TXT_ADJUST_HOTEND (0x2000+14*0x30)
#define TXT_ADJUST_BED (0x2000+15*0x30)
#define TXT_ADJUST_SPEED (0x2000+16*0x30)
// TEMP SET TXT
#define TXT_BED_NOW (0x2000+17*0x30)
#define TXT_BED_TARGET (0x2000+18*0x30)
#define TXT_HOTEND_NOW (0x2000+19*0x30)
#define TXT_HOTEND_TARGET (0x2000+20*0x30)
// SPEED SET TXT
#define TXT_FAN_SPEED_NOW (0x2000+21*0x30)
#define TXT_FAN_SPEED_TARGET (0x2000+22*0x30)
#define TXT_PRINT_SPEED_NOW (0x2000+23*0x30)
#define TXT_PRINT_SPEED_TARGET (0x2000+24*0x30)
// ABOUT TXT
#define TXT_ABOUT (0x2000+25*0x30)
// RECORT TXT
#define TXT_RECORT_0 (0x2000+26*0x30)
#define TXT_RECORT_1 (0x2000+27*0x30)
#define TXT_RECORT_2 (0x2000+28*0x30)
#define TXT_RECORT_3 (0x2000+29*0x30)
#define TXT_RECORT_4 (0x2000+30*0x30)
#define TXT_RECORT_5 (0x2000+31*0x30)
// ADVANCE LEVEL TXT
#define TXT_LEVEL_OFFSET (0x2000+32*0x30)
// FILAMENT TXT
#define TXT_FILAMENT_TEMP (0x2000+33*0x30)
#define TXT_FINISH_TIME (0x2000+34*0x30)
#define TXT_VERSION (0x2000+35*0x30)
#define TXT_PREHEAT_HOTEND (0x2000+36*0x30)
#define TXT_PREHEAT_BED (0x2000+37*0x30)
#define TXT_OUTAGE_RECOVERY_FILE 0x2180
#define ADDRESS_SYSTEM_AUDIO 0x0080
#define ADDRESS_MOVE_DISTANCE 0x4300
#define ADDRESS_SYSTEM_LED_STATUS 0x4500
#define ADDRESS_PRINT_SETTING_LED_STATUS 0x4550
/*********************** KEY VALUE **************************/
#define KEY_ADDRESS 0x1000
// MAIN PAGE KEY
#define KEY_MAIN_TO_FILE 1
#define KEY_MAIN_TO_TOOL 2
#define KEY_MAIN_TO_PREPARE 3
#define KEY_MAIN_TO_SYSTEM 4
// FILE PAGE KEY
#define KEY_FILE_TO_MAIN 1
#define KEY_PRINT 6
#define KEY_RESUME 5
#define KEY_PgUp 2
#define KEY_pgDn 3
#define KEY_FLASH 4
#define KEY_FILE0 7
#define KEY_FILE1 8
#define KEY_FILE2 9
#define KEY_FILE3 10
#define KEY_FILE4 11
#define KEY_CONTINUE 2
#define KEY_PAUSE 2
#define KEY_STOP 3
#define KEY_TO_ADJUST 4
#define KEY_ADJUST_TO_PRINT 1
#define KEY_ADJUST_ENSURE 7
#define KEY_CHECK_DOOR 2
#define KEY_DONE_OFF 3
// TOOL PAGE KEY
#define KEY_TOOL_TO_MAIN 1
#define KEY_TOOL_TO_MOVE 2
#define KEY_TOOL_TO_TEMP 3
#define KEY_TOOL_TO_SPEED 4
#define KEY_TOOL_LIGHT 5
#define KEY_MOVE_TO_TOLL 1// move page
#define KEY_MOVE_X 2
#define KEY_01 3
#define KEY_MOVE_NX 4
#define KEY_HOME_X 5
#define KEY_MOVE_Y 6
#define KEY_1 7
#define KEY_MOVE_NY 8
#define KEY_HOME_Y 9
#define KEY_MOVE_Z 10
#define KEY_10 11
#define KEY_MOVE_NZ 12
#define KEY_HOME_Z 13
#define KEY_SPEED_LOW 14
#define KEY_SPEED_MIDDLE 15
#define KEY_SPEED_HIGHT 16
#define KEY_HOME_ALL 17
#define KEY_TEMP_TO_TOOL 1 //Temperature setting page
#define KEY_BED_ADD 2
#define KEY_BED_DEC 3
#define KEY_HOTEND_ADD 4
#define KEY_HOTEND_DEC 5
#define KEY_COOL 6
#define KEY_TEMP_ENSURE 7
#define KEY_SPEED_TO_TOOL 1 //speed setting page
#define KEY_FAN_SPEED_ADD 2
#define KEY_FAN_SPEED_DEC 3
#define KEY_PRINT_SPEED_ADD 4
#define KEY_PRINT_SPEED_DEC 5
#define KEY_SPEED_ENSURE 6
#define KEY_PREPARE_TO_MAIN 1 //PREPARE PAGE TO MAIN
#define KEY_PREPARE_TO_PreLEVE 2
#define KEY_PreLEVE_TO_PREPARE 1
#define KEY_PreLEVE_TO_LEVELING 2
#define KEY_PreLEVE_TO_ADVANCE 3
#define KEY_ADVANCE_TO_PreLEVE 1
#define KEY_LEVEL_ADD 3
#define KEY_LEVEL_DEC 2
#define KEY_LEVEL_ENSURE 4
#define KEY_PREPARE_TO_PREHEAT 3
#define KEY_PREHEAT_TO_PREPARE 1
#define KEY_PREHEAT_PLA 2
#define KEY_PREHEAT_ABS 3
#define KEY_PREPARE_TO_FILAMENT 4
#define KEY_FILAMENT_TO_PREPARE 1
#define KEY_RETREAT 3
#define KEY_FORWARD 2
#define KEY_FILAMENT_STOP 4
// SYSTEM PAGE KEY
#define KEY_SYS_TO_MAIN 1
#define KEY_LANGUAGE 2
#define KEY_SYS_TO_WIFI 3
#define KEY_WIFI_TO_SYS 1
#define KEY_BEEP 4
#define KEY_SYS_TO_ABOUT 5
#define KEY_ABOUT_TO_SYS 1
#define KEY_SYS_TO_RECORD 6
#define KEY_RECORD_TO_SYS 1
#define KEY_RECORD_PaUp 2
#define KEY_RECORD_PaDn 3
#define KEY_RECORD_FLASH 4
#define COLOR_RED 0xF800
#define COLOR_BLUE 0x0210
namespace Anycubic {
enum language_t : uint8_t { ENG, CHS };
class DgusTFT;
extern DgusTFT ui;
typedef struct _lcd_info_t {
language_t language;
bool audio_on;
} lcd_info_t;
class DgusTFT {
static printer_state_t printer_state;
static paused_state_t pause_state;
#if HAS_HOTEND
static heater_state_t hotend_state;
#endif
#if HAS_HEATED_BED
static heater_state_t hotbed_state;
#endif
static char panel_command[MAX_CMND_LEN];
static uint8_t command_len;
static char selectedfile[MAX_PATH_LEN];
static file_menu_t file_menu;
static bool data_received;
static uint8_t data_buf[DATA_BUF_SIZE];
static uint8_t data_index;
static uint16_t page_index_last, page_index_last_2;
static uint8_t message_index;
static uint8_t pop_up_index;
static uint32_t key_value;
static uint8_t lcd_txtbox_index;
static uint8_t lcd_txtbox_page;
static int16_t feedrate_back;
static language_t ui_language;
public:
DgusTFT();
static lcd_info_t lcd_info, lcd_info_back;
static uint16_t page_index_now;
static void startup();
static void paramInit();
static void idleLoop();
static void printerKilled(FSTR_P,FSTR_P);
static void mediaEvent(media_event_t);
static void timerEvent(timer_event_t);
static void filamentRunout();
static void confirmationRequest(const char * const);
static void statusChange(const char * const);
static void powerLoss();
static void powerLossRecovery();
static void homingStart();
static void homingComplete();
static void set_descript_color(const uint16_t color, const uint8_t index=lcd_txtbox_index);
static void set_language(language_t);
static void toggle_language();
static void goto_system_page();
static void toggle_audio();
static void store_changes();
#if HAS_HOTEND
static void send_temperature_hotend(uint32_t addr);
#endif
#if HAS_HEATED_BED
static void send_temperature_bed(uint32_t addr);
#endif
typedef void (*p_fun)();
static void page1();
static void page2();
static void page3();
static void page4();
static void page5();
static void page6();
static void page7(); // tool
static void page8();
static void page9();
static void page10(); // fan and print speed
static void page11(); // system
static void page12();
static void page13();
static void page14();
static void page15();
static void page16();
static void page17();
static void page18();
static void page19();
static void page20();
static void page21();
static void page22();
static void page23();
static void page24();
static void page25();
static void page26();
static void page27();
static void page28();
static void page29();
static void page30();
static void page31();
static void page32();
#if HAS_LEVELING
static void page33();
#endif
static void page34();
static void page115();
static void page117(); // CHS Mute handler
static void page124();
static void page125();
static void page170(); // ENG Mute handler
#if ENABLED(POWER_LOSS_RECOVERY)
static void page171(); // CHS power outage resume handler
static void page173(); // ENG power outage resume handler
#endif
#if HAS_LEVELING
static void page175(); // ENG probe preheating handler
static void page176(); // CHS probe preheating handler
#endif
static void page177_to_198();
//static void page178_to_181_190_to_193();
static void page199_to_200();
static void page201();
static void page202();
static void page203();
static void page204();
static void page205();
static void page206();
static void pop_up_manager();
static void tftSend(FSTR_P const=nullptr);
static void tftSendLn(FSTR_P const=nullptr);
static bool readTFTCommand();
static int8_t findCmdPos(const char *, const char);
static void checkHeaters();
static void sendFileList(int8_t);
static void selectFile();
static void processPanelRequest();
static void panelInfo(uint8_t);
static void panelAction(uint8_t);
static void panelProcess(uint8_t);
static void sendValueToTFT(const uint16_t value, const uint16_t address);
static void requestValueFromTFT(const uint16_t address);
static void sendTxtToTFT(const char *pdata, const uint16_t address);
static void sendColorToTFT(const uint16_t color, const uint16_t address);
static void sendReadNumOfTxtToTFT(const uint8_t number, const uint16_t address);
static void changePageOfTFT(const uint16_t page_index, const bool no_send=false);
static void fakeChangePageOfTFT(const uint16_t page_index);
static void lcdAudioSet(const bool audio_on);
private:
};
extern DgusTFT dgus;
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_vyper/dgus_tft.h
|
C++
|
agpl-3.0
| 15,695
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/anycubic_vyper/dgus_defs.h
*/
#include "../anycubic/common_defs.h"
// TFT panel commands
#define AC_msg_bed_temp_abnormal F("J28")
// TFT panel messages
#define MARLIN_msg_probing_point PSTR("Probing Point ")
#define MARLIN_msg_probe_preheat_start PSTR("Probe preheat start")
#define MARLIN_msg_probe_preheat_stop PSTR("Probe preheat stop")
#define MARLIN_msg_media_removed PSTR("Media Removed")
namespace Anycubic {
enum paused_state_t : uint8_t {
AC_paused_heater_timed_out,
AC_paused_filament_lack,
AC_paused_purging_filament,
AC_paused_idle
};
enum printer_state_t : uint8_t {
AC_printer_idle,
AC_printer_probing,
AC_printer_printing,
AC_printer_pausing,
AC_printer_paused,
AC_printer_stopping,
AC_printer_stopping_from_media_remove,
AC_printer_resuming_from_power_outage
};
} // Anycubic
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_vyper/dgus_tft_defs.h
|
C++
|
agpl-3.0
| 1,774
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/anycubic_vyper/vyper_extui.cpp
*
* Anycubic Dgus TFT support for Marlin
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(ANYCUBIC_LCD_VYPER)
#include "../ui_api.h"
#include "dgus_tft.h"
using namespace Anycubic;
namespace ExtUI {
void onStartup() { dgus.startup(); }
void onIdle() { dgus.idleLoop(); }
void onPrinterKilled(FSTR_P const error, FSTR_P const component) {
dgus.printerKilled(error, component);
}
void onMediaInserted() { dgus.mediaEvent(AC_media_inserted); }
void onMediaError() { dgus.mediaEvent(AC_media_error); }
void onMediaRemoved() { dgus.mediaEvent(AC_media_removed); }
void onHeatingError(const heater_id_t header_id) {}
void onMinTempError(const heater_id_t header_id) {}
void onMaxTempError(const heater_id_t header_id) {}
void onPlayTone(const uint16_t frequency, const uint16_t duration/*=0*/) {
#if ENABLED(SPEAKER)
::tone(BEEPER_PIN, frequency, duration);
#endif
}
void onPrintTimerStarted() { dgus.timerEvent(AC_timer_started); }
void onPrintTimerPaused() { dgus.timerEvent(AC_timer_paused); }
void onPrintTimerStopped() { dgus.timerEvent(AC_timer_stopped); }
void onPrintDone() {}
void onFilamentRunout(const extruder_t) { dgus.filamentRunout(); }
void onUserConfirmRequired(const char * const msg) { dgus.confirmationRequest(msg); }
// For fancy LCDs include an icon ID, message, and translated button title
void onUserConfirmRequired(const int icon, const char * const cstr, FSTR_P const fBtn) {
onUserConfirmRequired(cstr);
UNUSED(icon); UNUSED(fBtn);
}
void onUserConfirmRequired(const int icon, FSTR_P const fstr, FSTR_P const fBtn) {
onUserConfirmRequired(fstr);
UNUSED(icon); UNUSED(fBtn);
}
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void onPauseMode(
const PauseMessage message,
const PauseMode mode/*=PAUSE_MODE_SAME*/,
const uint8_t extruder/*=active_extruder*/
) {
stdOnPauseMode(message, mode, extruder);
}
#endif
void onStatusChanged(const char * const msg) { dgus.statusChange(msg); }
void onHomingStart() { dgus.homingStart(); }
void onHomingDone() { dgus.homingComplete(); }
void onFactoryReset() {
dgus.page_index_now = 121;
dgus.lcd_info.audio_on = DISABLED(SPEAKER);
}
void onStoreSettings(char *buff) {
// Called when saving to EEPROM (i.e. M500). If the ExtUI needs
// permanent data to be stored, it can write up to eeprom_data_size bytes
// into buff.
static_assert(sizeof(dgus.lcd_info) <= ExtUI::eeprom_data_size);
memcpy(buff, &dgus.lcd_info, sizeof(dgus.lcd_info));
}
void onLoadSettings(const char *buff) {
// Called while loading settings from EEPROM. If the ExtUI
// needs to retrieve data, it should copy up to eeprom_data_size bytes
// from buff
static_assert(sizeof(dgus.lcd_info) <= ExtUI::eeprom_data_size);
memcpy(&dgus.lcd_info, buff, sizeof(dgus.lcd_info));
memcpy(&dgus.lcd_info_back, buff, sizeof(dgus.lcd_info_back));
}
void onPostprocessSettings() {
// Called after loading or resetting stored settings
dgus.paramInit();
dgus.powerLoss();
}
void onSettingsStored(const bool success) {
// Called after the entire EEPROM has been written,
// whether successful or not.
}
void onSettingsLoaded(const bool success) {
// Called after the entire EEPROM has been read,
// whether successful or not.
}
#if HAS_LEVELING
void onLevelingStart() {}
void onLevelingDone() {}
#if ENABLED(PREHEAT_BEFORE_LEVELING)
celsius_t getLevelingBedTemp() { return LEVELING_BED_TEMP; }
#endif
#endif
#if HAS_MESH
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) {
// Called when any mesh points are updated
//SERIAL_ECHOLNPGM("onMeshUpdate() x:", xpos, " y:", ypos, " z:", zval);
}
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) {
// Called to indicate a special condition
//SERIAL_ECHOLNPGM("onMeshUpdate() x:", xpos, " y:", ypos, " state:", state);
}
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
void onSetMinExtrusionTemp(const celsius_t) {}
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
// Called when power-loss is enabled/disabled
void onSetPowerLoss(const bool) { dgus.powerLoss(); }
// Called when power-loss state is detected
void onPowerLoss() { /* handled internally */ }
// Called on resume from power-loss
void onPowerLossResume() { dgus.powerLossRecovery(); }
#endif
#if HAS_PID_HEATING
void onPIDTuning(const pidresult_t rst) {
// Called for temperature PID tuning result
}
void onStartM303(const int count, const heater_id_t hid, const celsius_t temp) {
// Called by M303 to update the UI
}
#endif
#if ENABLED(MPC_AUTOTUNE)
void onMPCTuning(const mpcresult_t rst) {
// Called for temperature MPC tuning result
}
#endif
#if ENABLED(PLATFORM_M997_SUPPORT)
void onFirmwareFlash() {}
#endif
void onSteppersDisabled() {}
void onSteppersEnabled() {}
void onAxisDisabled(const axis_t) {}
void onAxisEnabled(const axis_t) {}
}
#endif // ANYCUBIC_LCD_VYPER
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/anycubic_vyper/vyper_extui.cpp
|
C++
|
agpl-3.0
| 6,122
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if HAS_DGUS_LCD_CLASSIC
#if HOTENDS > 2
#warning "More than 2 hotends not implemented on DGUS Display UI."
#endif
#include "../ui_api.h"
#include "../../../MarlinCore.h"
#include "../../../module/motion.h"
#include "../../../gcode/queue.h"
#include "../../../module/planner.h"
#include "../../../libs/duration_t.h"
#include "../../../module/printcounter.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../feature/powerloss.h"
#endif
#include "DGUSDisplay.h"
#include "DGUSVPVariable.h"
#include "DGUSDisplayDef.h"
DGUSDisplay dgus;
#ifdef DEBUG_DGUS_COMM
#define DEBUGLCDCOMM_ECHOPGM DEBUG_ECHOPGM
#else
#define DEBUGLCDCOMM_ECHOPGM(...) NOOP
#endif
// Preamble... 2 Bytes, usually 0x5A 0xA5, but configurable
constexpr uint8_t DGUS_HEADER1 = 0x5A;
constexpr uint8_t DGUS_HEADER2 = 0xA5;
constexpr uint8_t DGUS_CMD_WRITEVAR = 0x82;
constexpr uint8_t DGUS_CMD_READVAR = 0x83;
#if ENABLED(DEBUG_DGUSLCD)
bool dguslcd_local_debug; // = false;
#endif
void DGUSDisplay::initDisplay() {
#ifndef LCD_BAUDRATE
#define LCD_BAUDRATE 115200
#endif
LCD_SERIAL.begin(LCD_BAUDRATE);
if (TERN1(POWER_LOSS_RECOVERY, !recovery.valid())) { // If no Power-Loss Recovery is needed...
TERN_(DGUS_LCD_UI_MKS, delay(LOGO_TIME_DELAY)); // Show the logo for a little while
}
requestScreen(TERN(SHOW_BOOTSCREEN, DGUS_SCREEN_BOOT, DGUS_SCREEN_MAIN));
}
void DGUSDisplay::writeVariable(uint16_t adr, const void *values, uint8_t valueslen, bool isstr) {
const char* myvalues = static_cast<const char*>(values);
bool strend = !myvalues;
writeHeader(adr, DGUS_CMD_WRITEVAR, valueslen);
while (valueslen--) {
char x;
if (!strend) x = *myvalues++;
if ((isstr && !x) || strend) {
strend = true;
x = ' ';
}
LCD_SERIAL.write(x);
}
}
void DGUSDisplay::writeVariable(uint16_t adr, uint16_t value) {
value = (value & 0xFFU) << 8U | (value >> 8U);
writeVariable(adr, static_cast<const void*>(&value), sizeof(uint16_t));
}
void DGUSDisplay::writeVariable(uint16_t adr, int16_t value) {
value = (value & 0xFFU) << 8U | (value >> 8U);
writeVariable(adr, static_cast<const void*>(&value), sizeof(uint16_t));
}
void DGUSDisplay::writeVariable(uint16_t adr, uint8_t value) {
writeVariable(adr, static_cast<const void*>(&value), sizeof(uint8_t));
}
void DGUSDisplay::writeVariable(uint16_t adr, int8_t value) {
writeVariable(adr, static_cast<const void*>(&value), sizeof(int8_t));
}
void DGUSDisplay::writeVariable(uint16_t adr, long value) {
union { long l; char lb[4]; } endian;
char tmp[4];
endian.l = value;
tmp[0] = endian.lb[3];
tmp[1] = endian.lb[2];
tmp[2] = endian.lb[1];
tmp[3] = endian.lb[0];
writeVariable(adr, static_cast<const void*>(&tmp), sizeof(long));
}
void DGUSDisplay::writeVariablePGM(uint16_t adr, const void *values, uint8_t valueslen, bool isstr) {
const char* myvalues = static_cast<const char*>(values);
bool strend = !myvalues;
writeHeader(adr, DGUS_CMD_WRITEVAR, valueslen);
while (valueslen--) {
char x;
if (!strend) x = pgm_read_byte(myvalues++);
if ((isstr && !x) || strend) {
strend = true;
x = ' ';
}
LCD_SERIAL.write(x);
}
}
void DGUSDisplay::processRx() {
#if ENABLED(SERIAL_STATS_RX_BUFFER_OVERRUNS)
if (!LCD_SERIAL.available() && LCD_SERIAL.buffer_overruns()) {
// Overrun, but reset the flag only when the buffer is empty
// We want to extract as many as valid datagrams possible...
rx_datagram_state = DGUS_IDLE;
//LCD_SERIAL.reset_rx_overun();
LCD_SERIAL.flush();
}
#endif
uint8_t receivedbyte;
while (LCD_SERIAL.available()) {
switch (rx_datagram_state) {
case DGUS_IDLE: // Waiting for the first header byte
receivedbyte = LCD_SERIAL.read();
//DEBUGLCDCOMM_ECHOPGM("< ", receivedbyte);
if (DGUS_HEADER1 == receivedbyte) rx_datagram_state = DGUS_HEADER1_SEEN;
break;
case DGUS_HEADER1_SEEN: // Waiting for the second header byte
receivedbyte = LCD_SERIAL.read();
//DEBUGLCDCOMM_ECHOPGM(" ", receivedbyte);
rx_datagram_state = (DGUS_HEADER2 == receivedbyte) ? DGUS_HEADER2_SEEN : DGUS_IDLE;
break;
case DGUS_HEADER2_SEEN: // Waiting for the length byte
rx_datagram_len = LCD_SERIAL.read();
//DEBUGLCDCOMM_ECHOPGM(" (", rx_datagram_len, ") ");
// Telegram min len is 3 (command and one word of payload)
rx_datagram_state = WITHIN(rx_datagram_len, 3, DGUS_RX_BUFFER_SIZE) ? DGUS_WAIT_TELEGRAM : DGUS_IDLE;
break;
case DGUS_WAIT_TELEGRAM: // wait for complete datagram to arrive.
if (LCD_SERIAL.available() < rx_datagram_len) return;
initialized = true; // We've talked to it, so we defined it as initialized.
const uint8_t command = LCD_SERIAL.read();
//DEBUGLCDCOMM_ECHOPGM("# ", command);
uint8_t readlen = rx_datagram_len - 1; // command is part of len.
unsigned char tmp[rx_datagram_len - 1];
unsigned char *ptmp = tmp;
while (readlen--) {
receivedbyte = LCD_SERIAL.read();
//DEBUGLCDCOMM_ECHOPGM(" ", receivedbyte);
*ptmp++ = receivedbyte;
}
//DEBUGLCDCOMM_ECHOPGM(" # ");
// mostly we'll get this: 5A A5 03 82 4F 4B -- ACK on 0x82, so discard it.
if (command == DGUS_CMD_WRITEVAR && 'O' == tmp[0] && 'K' == tmp[1]) {
//DEBUGLCDCOMM_ECHOPGM(">");
rx_datagram_state = DGUS_IDLE;
break;
}
/* AutoUpload, (and answer to) Command 0x83 :
| tmp[0 1 2 3 4 ... ]
| Example 5A A5 06 83 20 01 01 78 01 ……
| / / | | \ / | \ \
| Header | | | | \_____\_ DATA (Words!)
| DatagramLen / VPAdr |
| Command DataLen (in Words) */
if (command == DGUS_CMD_READVAR) {
const uint16_t vp = tmp[0] << 8 | tmp[1];
DGUS_VP_Variable ramcopy;
if (populate_VPVar(vp, &ramcopy)) {
if (ramcopy.set_by_display_handler)
ramcopy.set_by_display_handler(ramcopy, &tmp[3]);
}
rx_datagram_state = DGUS_IDLE;
break;
}
// discard anything else
rx_datagram_state = DGUS_IDLE;
}
}
}
size_t DGUSDisplay::getFreeTxBuffer() { return LCD_SERIAL_TX_BUFFER_FREE(); }
void DGUSDisplay::writeHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen) {
LCD_SERIAL.write(DGUS_HEADER1);
LCD_SERIAL.write(DGUS_HEADER2);
LCD_SERIAL.write(payloadlen + 3);
LCD_SERIAL.write(cmd);
LCD_SERIAL.write(adr >> 8);
LCD_SERIAL.write(adr & 0xFF);
}
void DGUSDisplay::writePGM(const char str[], uint8_t len) {
while (len--) LCD_SERIAL.write(pgm_read_byte(str++));
}
void DGUSDisplay::loop() {
// Protect against recursion. processRx() may indirectly call idle() when injecting G-code commands.
if (!no_reentrance) {
no_reentrance = true;
processRx();
no_reentrance = false;
}
}
rx_datagram_state_t DGUSDisplay::rx_datagram_state = DGUS_IDLE;
uint8_t DGUSDisplay::rx_datagram_len = 0;
bool DGUSDisplay::initialized = false,
DGUSDisplay::no_reentrance = false;
// A SW memory barrier, to ensure GCC does not overoptimize loops
#define sw_barrier() asm volatile("": : :"memory");
bool populate_VPVar(const uint16_t VP, DGUS_VP_Variable * const ramcopy) {
const DGUS_VP_Variable *pvp = findVPVar(VP);
if (!pvp) return false;
memcpy_P(ramcopy, pvp, sizeof(DGUS_VP_Variable));
return true;
}
#endif // HAS_DGUS_LCD_CLASSIC
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSDisplay.cpp
|
C++
|
agpl-3.0
| 8,480
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/dgus/DGUSDisplay.h
*/
#include "../../../inc/MarlinConfigPre.h"
#include <stdlib.h> // size_t
//#define DEBUG_DGUSLCD
//#define DEBUG_DGUS_COMM
#if HAS_BED_PROBE
#include "../../../module/probe.h"
#endif
#include "DGUSVPVariable.h"
enum DGUS_ScreenID : uint8_t;
#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD)
#include "../../../core/debug_out.h"
typedef enum : uint8_t {
DGUS_IDLE, //< waiting for DGUS_HEADER1.
DGUS_HEADER1_SEEN, //< DGUS_HEADER1 received
DGUS_HEADER2_SEEN, //< DGUS_HEADER2 received
DGUS_WAIT_TELEGRAM, //< LEN received, Waiting for to receive all bytes.
} rx_datagram_state_t;
constexpr uint16_t swap16(const uint16_t value) { return (value & 0xFFU) << 8U | (value >> 8U); }
// Low-Level access to the display.
class DGUSDisplay {
public:
DGUSDisplay() = default;
static void initDisplay();
// Variable access.
static void writeVariable(uint16_t adr, const void *values, uint8_t valueslen, bool isstr=false);
static void writeVariablePGM(uint16_t adr, const void *values, uint8_t valueslen, bool isstr=false);
static void writeVariable(uint16_t adr, int16_t value);
static void writeVariable(uint16_t adr, uint16_t value);
static void writeVariable(uint16_t adr, uint8_t value);
static void writeVariable(uint16_t adr, int8_t value);
static void writeVariable(uint16_t adr, long value);
// Utility functions for bridging ui_api and dbus
template<typename T, float(*Getter)(const T), T selector, typename WireType=uint16_t>
static void setVariable(DGUS_VP_Variable &var) {
writeVariable(var.VP, (WireType)Getter(selector));
}
template<typename T, void(*Setter)(const float V, const T), T selector>
static void getVariable(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t newvalue = swap16(*(uint16_t*)val_ptr);
Setter(newvalue, selector);
}
// Until now I did not need to actively read from the display. That's why there is no ReadVariable
// (I extensively use the auto upload of the display)
// Force display into another screen.
// (And trigger update of containing VPs)
// (to implement a pop up message, which may not be nested)
static void requestScreen(const DGUS_ScreenID screenID);
// Periodic tasks, eg. Rx-Queue handling.
static void loop();
public:
// Helper for users of this class to estimate if an interaction would be blocking.
static size_t getFreeTxBuffer();
// Checks two things: Can we confirm the presence of the display and has we initialized it.
// (both boils down that the display answered to our chatting)
static bool isInitialized() { return initialized; }
private:
static void writeHeader(uint16_t adr, uint8_t cmd, uint8_t payloadlen);
static void writePGM(const char str[], uint8_t len);
static void processRx();
static rx_datagram_state_t rx_datagram_state;
static uint8_t rx_datagram_len;
static bool initialized, no_reentrance;
};
extern DGUSDisplay dgus;
// compile-time x^y
constexpr float cpow(const float x, const int y) { return y == 0 ? 1.0 : x * cpow(x, y - 1); }
///
const uint16_t* findScreenVPMapList(uint8_t screen);
/// Find the flash address of a DGUS_VP_Variable for the VP.
const DGUS_VP_Variable* findVPVar(const uint16_t vp);
/// Helper to populate a DGUS_VP_Variable for a given VP. Return false if not found.
bool populate_VPVar(const uint16_t VP, DGUS_VP_Variable * const ramcopy);
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSDisplay.h
|
C++
|
agpl-3.0
| 4,280
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/dgus/DGUSDisplayDef.h
* Defines the interaction between Marlin and the display firmware
*/
#include "DGUSVPVariable.h"
#include <stdint.h>
// Information on which screen which VP is displayed.
// As this is a sparse table, two arrays are needed:
// one to list the VPs of one screen and one to map screens to the lists.
// (Strictly this would not be necessary, but allows to only send data the display needs and reducing load on Marlin)
struct VPMapping {
const uint8_t screen;
const uint16_t *VPList; // The list is null-terminated.
};
extern const struct VPMapping VPMap[];
// List of VPs handled by Marlin / The Display.
extern const struct DGUS_VP_Variable ListOfVP[];
#include "../../../inc/MarlinConfig.h"
#if DGUS_LCD_UI_ORIGIN
#include "origin/DGUSDisplayDef.h"
#elif DGUS_LCD_UI_MKS
#include "mks/DGUSDisplayDef.h"
#elif DGUS_LCD_UI_FYSETC
#include "fysetc/DGUSDisplayDef.h"
#elif DGUS_LCD_UI_HIPRECY
#include "hiprecy/DGUSDisplayDef.h"
#endif
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSDisplayDef.h
|
C
|
agpl-3.0
| 1,869
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if HAS_DGUS_LCD_CLASSIC
#include "DGUSScreenHandler.h"
#include "../../../MarlinCore.h"
#include "../../../gcode/queue.h"
#include "../../../libs/duration_t.h"
#include "../../../module/settings.h"
#include "../../../module/temperature.h"
#include "../../../module/motion.h"
#include "../../../module/planner.h"
#include "../../../module/printcounter.h"
#include "../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../feature/powerloss.h"
#endif
DGUSScreenHandlerClass screen;
uint16_t DGUSScreenHandler::confirmVP;
DGUS_ScreenID DGUSScreenHandler::current_screenID;
DGUS_ScreenID DGUSScreenHandler::past_screenIDs[NUM_PAST_SCREENS];
uint8_t DGUSScreenHandler::update_ptr;
uint16_t DGUSScreenHandler::skipVP;
bool DGUSScreenHandler::screenComplete;
void (*DGUSScreenHandler::confirm_action_cb)() = nullptr;
#if HAS_MEDIA
int16_t DGUSScreenHandler::top_file = 0,
DGUSScreenHandler::file_to_print = 0;
ExtUI::FileList filelist;
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
filament_data_t filament_data;
#endif
void DGUSScreenHandler::sendInfoScreen_P(PGM_P const line1, PGM_P const line2, PGM_P const line3, PGM_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool l4inflash) {
DGUS_VP_Variable ramcopy;
if (populate_VPVar(VP_MSGSTR1, &ramcopy)) {
ramcopy.memadr = (void*) line1;
l1inflash ? DGUSScreenHandler::sendStringToDisplayPGM(ramcopy) : DGUSScreenHandler::sendStringToDisplay(ramcopy);
}
if (populate_VPVar(VP_MSGSTR2, &ramcopy)) {
ramcopy.memadr = (void*) line2;
l2inflash ? DGUSScreenHandler::sendStringToDisplayPGM(ramcopy) : DGUSScreenHandler::sendStringToDisplay(ramcopy);
}
if (populate_VPVar(VP_MSGSTR3, &ramcopy)) {
ramcopy.memadr = (void*) line3;
l3inflash ? DGUSScreenHandler::sendStringToDisplayPGM(ramcopy) : DGUSScreenHandler::sendStringToDisplay(ramcopy);
}
#ifdef VP_MSGSTR4
if (populate_VPVar(VP_MSGSTR4, &ramcopy)) {
ramcopy.memadr = (void*) line4;
l4inflash ? DGUSScreenHandler::sendStringToDisplayPGM(ramcopy) : DGUSScreenHandler::sendStringToDisplay(ramcopy);
}
#endif
}
void DGUSScreenHandler::handleUserConfirmationPopUp(uint16_t VP, PGM_P const line1, PGM_P const line2, PGM_P const line3, PGM_P const line4, bool l1, bool l2, bool l3, bool l4) {
if (current_screenID == DGUS_SCREEN_CONFIRM) // Already showing a pop up, so we need to cancel that first.
popToOldScreen();
confirmVP = VP;
sendInfoScreen_P(line1, line2, line3, line4, l1, l2, l3, l4);
gotoScreen(DGUS_SCREEN_CONFIRM);
}
void DGUSScreenHandler::setStatusMessage(const char *msg) {
DGUS_VP_Variable ramcopy;
if (populate_VPVar(VP_M117, &ramcopy)) {
ramcopy.memadr = (void*) msg;
sendStringToDisplay(ramcopy);
}
}
void DGUSScreenHandler::setstatusmessagePGM(PGM_P const msg) {
DGUS_VP_Variable ramcopy;
if (populate_VPVar(VP_M117, &ramcopy)) {
ramcopy.memadr = (void*) msg;
sendStringToDisplayPGM(ramcopy);
}
}
// Send an 8 bit or 16 bit value to the display.
void DGUSScreenHandler::sendWordValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
if (var.size > 1)
dgus.writeVariable(var.VP, *(int16_t*)var.memadr);
else
dgus.writeVariable(var.VP, *(int8_t*)var.memadr);
}
}
// Send an uint8_t between 0 and 255 to the display, but scale to a percentage (0..100)
void DGUSScreenHandler::sendPercentageToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
uint16_t tmp = *(uint8_t *) var.memadr + 1; // +1 -> avoid rounding issues for the display.
tmp = map(tmp, 0, 255, 0, 100);
dgus.writeVariable(var.VP, tmp);
}
}
// Send the current print progress to the display.
void DGUSScreenHandler::sendPrintProgressToDisplay(DGUS_VP_Variable &var) {
uint16_t tmp = ExtUI::getProgress_percent();
dgus.writeVariable(var.VP, tmp);
}
// Send the current print time to the display.
// It is using a hex display for that: It expects BSD coded data in the format xxyyzz
void DGUSScreenHandler::sendPrintTimeToDisplay(DGUS_VP_Variable &var) {
duration_t elapsed = print_job_timer.duration();
char buf[32];
elapsed.toString(buf);
dgus.writeVariable(VP_PrintTime, buf, var.size, true);
}
// Send an uint8_t between 0 and 100 to a variable scale to 0..255
void DGUSScreenHandler::percentageToUint8(DGUS_VP_Variable &var, void *val_ptr) {
if (var.memadr) {
const uint16_t value = BE16_P(val_ptr);
*(uint8_t*)var.memadr = map(constrain(value, 0, 100), 0, 100, 0, 255);
}
}
// Sends a (RAM located) string to the DGUS Display
// (Note: The DGUS Display does not clear after the \0, you have to
// overwrite the remainings with spaces.// var.size has the display buffer size!
void DGUSScreenHandler::sendStringToDisplay(DGUS_VP_Variable &var) {
char *tmp = (char*) var.memadr;
dgus.writeVariable(var.VP, tmp, var.size, true);
}
// Sends a (flash located) string to the DGUS Display
// (Note: The DGUS Display does not clear after the \0, you have to
// overwrite the remainings with spaces.// var.size has the display buffer size!
void DGUSScreenHandler::sendStringToDisplayPGM(DGUS_VP_Variable &var) {
char *tmp = (char*) var.memadr;
dgus.writeVariablePGM(var.VP, tmp, var.size, true);
}
#if HAS_PID_HEATING
void DGUSScreenHandler::sendTemperaturePID(DGUS_VP_Variable &var) {
float value = *(float *)var.memadr;
value /= 10;
float valuesend = 0;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_PID_P: valuesend = value; break;
case VP_E0_PID_I: valuesend = unscalePID_i(value); break;
case VP_E0_PID_D: valuesend = unscalePID_d(value); break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_PID_P: valuesend = value; break;
case VP_E1_PID_I: valuesend = unscalePID_i(value); break;
case VP_E1_PID_D: valuesend = unscalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: valuesend = value; break;
case VP_BED_PID_I: valuesend = unscalePID_i(value); break;
case VP_BED_PID_D: valuesend = unscalePID_d(value); break;
#endif
}
valuesend *= cpow(10, 1);
union { int16_t i; char lb[2]; } endian;
char tmp[2];
endian.i = valuesend;
tmp[0] = endian.lb[1];
tmp[1] = endian.lb[0];
dgus.writeVariable(var.VP, tmp, 2);
}
#endif
#if ENABLED(PRINTCOUNTER)
// Send the accumulate print time to the display.
// It is using a hex display for that: It expects BSD coded data in the format xxyyzz
void DGUSScreenHandler::sendPrintAccTimeToDisplay(DGUS_VP_Variable &var) {
printStatistics state = print_job_timer.getStats();
char buf[22];
duration_t elapsed = state.printTime;
elapsed.toString(buf);
dgus.writeVariable(VP_PrintAccTime, buf, var.size, true);
}
void DGUSScreenHandler::sendPrintsTotalToDisplay(DGUS_VP_Variable &var) {
printStatistics state = print_job_timer.getStats();
char buf[10];
sprintf_P(buf, PSTR("%u"), state.totalPrints);
dgus.writeVariable(VP_PrintsTotal, buf, var.size, true);
}
#endif
// Send fan status value to the display.
#if HAS_FAN
void DGUSScreenHandler::sendFanStatusToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
uint16_t data_to_send = 0;
if (*(uint8_t *) var.memadr) data_to_send = 1;
dgus.writeVariable(var.VP, data_to_send);
}
}
#endif
// Send heater status value to the display.
void DGUSScreenHandler::sendHeaterStatusToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
uint16_t data_to_send = 0;
if (*(int16_t *) var.memadr) data_to_send = 1;
dgus.writeVariable(var.VP, data_to_send);
}
}
#if ENABLED(DGUS_UI_WAITING)
void DGUSScreenHandler::sendWaitingStatusToDisplay(DGUS_VP_Variable &var) {
// In FYSETC UI design there are 10 statuses to loop
static uint16_t period = 0;
static uint16_t index = 0;
if (period++ > DGUS_UI_WAITING_STATUS_PERIOD) {
dgus.writeVariable(var.VP, index);
if (++index >= DGUS_UI_WAITING_STATUS) index = 0;
period = 0;
}
}
#endif
#if HAS_MEDIA
void DGUSScreenHandler::screenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr) {
// default action executed when there is a SD card, but not printing
if (ExtUI::isMediaInserted() && !ExtUI::isPrintingFromMedia()) {
screenChangeHook(var, val_ptr);
dgus.requestScreen(current_screenID);
return;
}
// if we are printing, we jump to two screens after the requested one.
// This should host e.g a print pause / print abort / print resume dialog.
// This concept allows to recycle this hook for other file
if (ExtUI::isPrintingFromMedia() && !card.flag.abort_sd_printing) {
gotoScreen(DGUS_SCREEN_SDPRINTMANIPULATION);
return;
}
// Don't let the user in the dark why there is no reaction.
if (!ExtUI::isMediaInserted()) {
setStatusMessage(GET_TEXT_F(MSG_NO_MEDIA));
return;
}
if (card.flag.abort_sd_printing) {
setStatusMessage(GET_TEXT_F(MSG_MEDIA_ABORTING));
return;
}
}
void DGUSScreenHandler::sdScrollFilelist(DGUS_VP_Variable& var, void *val_ptr) {
auto old_top = top_file;
const int16_t scroll = (int16_t)BE16_P(val_ptr);
if (scroll) {
top_file += scroll;
if (top_file < 0) {
top_file = 0;
}
else {
int16_t max_top = filelist.count() - DGUS_SD_FILESPERSCREEN;
NOLESS(max_top, 0);
NOMORE(top_file, max_top);
}
}
else if (!filelist.isAtRootDir()) {
IF_DISABLED(DGUS_LCD_UI_MKS, filelist.upDir());
top_file = 0;
forceCompleteUpdate();
}
if (old_top != top_file) forceCompleteUpdate();
}
void DGUSScreenHandler::sdReallyAbort(DGUS_VP_Variable &var, void *val_ptr) {
ExtUI::stopPrint();
gotoScreen(DGUS_SCREEN_MAIN);
}
void DGUSScreenHandler::sdPrintTune(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
gotoScreen(DGUS_SCREEN_SDPRINTTUNE);
}
void DGUSScreenHandler::sdCardError() {
DGUSScreenHandler::sdCardRemoved();
sendInfoScreen(F("NOTICE"), nullptr, F("SD card error"), nullptr, true, true, true, true);
setupConfirmAction(nullptr);
gotoScreen(DGUS_SCREEN_POPUP);
}
#endif // HAS_MEDIA
void DGUSScreenHandler::screenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr) {
DGUS_VP_Variable ramcopy;
if (!populate_VPVar(confirmVP, &ramcopy)) return;
if (ramcopy.set_by_display_handler) ramcopy.set_by_display_handler(ramcopy, val_ptr);
}
const uint16_t* findScreenVPMapList(uint8_t screen) {
const uint16_t *ret;
const struct VPMapping *map = VPMap;
while ((ret = (uint16_t*) pgm_read_ptr(&(map->VPList)))) {
if (pgm_read_byte(&(map->screen)) == screen) return ret;
map++;
}
return nullptr;
}
const DGUS_VP_Variable* findVPVar(const uint16_t vp) {
const DGUS_VP_Variable *ret = ListOfVP;
do {
const uint16_t vpcheck = pgm_read_word(&(ret->VP));
if (vpcheck == 0) break;
if (vpcheck == vp) return ret;
++ret;
} while (1);
return nullptr;
}
void DGUSScreenHandler::screenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrinting()) {
screenChangeHook(var, val_ptr);
dgus.requestScreen(current_screenID);
}
}
void DGUSScreenHandler::handleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr) {
thermalManager.disable_all_heaters();
forceCompleteUpdate(); // hint to send all data.
}
void DGUSScreenHandler::handleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr) {
celsius_t newvalue = BE16_P(val_ptr);
celsius_t acceptedvalue;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_T_E0_Set:
NOMORE(newvalue, thermalManager.hotend_max_target(0));
thermalManager.setTargetHotend(newvalue, 0);
acceptedvalue = thermalManager.degTargetHotend(0);
break;
#endif
#if HAS_MULTI_HOTEND
case VP_T_E1_Set:
NOMORE(newvalue, thermalManager.hotend_max_target(1));
thermalManager.setTargetHotend(newvalue, 1);
acceptedvalue = thermalManager.degTargetHotend(1);
break;
#endif
#if HAS_HEATED_BED
case VP_T_Bed_Set:
NOMORE(newvalue, BED_MAX_TARGET);
thermalManager.setTargetBed(newvalue);
acceptedvalue = thermalManager.degTargetBed();
break;
#endif
}
// reply to display the new value to update the view if the new value was rejected by the Thermal Manager.
if (newvalue != acceptedvalue && var.send_to_display_handler) var.send_to_display_handler(var);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandler::handleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr) {
#if HAS_EXTRUDERS
const uint16_t newvalue = BE16_P(val_ptr);
uint8_t target_extruder;
switch (var.VP) {
default: return;
case VP_Flowrate_E0: target_extruder = 0; break;
#if HAS_MULTI_EXTRUDER
case VP_Flowrate_E1: target_extruder = 1; break;
#endif
}
planner.set_flow(target_extruder, newvalue);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
#else
UNUSED(var); UNUSED(val_ptr);
#endif
}
void DGUSScreenHandler::handleManualExtrude(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t movevalue = BE16_P(val_ptr);
float target = movevalue * 0.01f;
ExtUI::extruder_t target_extruder;
switch (var.VP) {
#if HAS_HOTEND
case VP_MOVE_E0: target_extruder = ExtUI::extruder_t::E0; break;
#if HAS_MULTI_EXTRUDER
case VP_MOVE_E1: target_extruder = ExtUI::extruder_t::E1; break;
#endif
#endif
default: return;
}
target += ExtUI::getAxisPosition_mm(target_extruder);
ExtUI::setAxisPosition_mm(target, target_extruder);
skipVP = var.VP;
}
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
void DGUSScreenHandler::handleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr) {
*(uint16_t*)var.memadr = BE16_P(val_ptr);
}
#endif
void DGUSScreenHandler::handleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t lock = BE16_P(val_ptr);
queue.enqueue_one_now(lock ? F("M18") : F("M17"));
}
void DGUSScreenHandler::handleSettings(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value = BE16_P(val_ptr);
switch (value) {
default: break;
case 1:
TERN_(PRINTCOUNTER, print_job_timer.initStats());
settings.reset();
settings.save();
break;
case 2: settings.load(); break;
case 3: settings.save(); break;
}
}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void DGUSScreenHandler::handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value_raw = BE16_P(val_ptr);
const float value = (float)value_raw / 10;
ExtUI::axis_t axis;
switch (var.VP) {
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
case VP_Y_STEP_PER_MM: axis = ExtUI::axis_t::Y; break;
case VP_Z_STEP_PER_MM: axis = ExtUI::axis_t::Z; break;
default: return;
}
ExtUI::setAxisSteps_per_mm(value, axis);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandler::handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value_raw = BE16_P(val_ptr);
const float value = (float)value_raw / 10;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_EXTRUDERS
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#if HAS_MULTI_EXTRUDER
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
#endif
}
ExtUI::setAxisSteps_per_mm(value, extruder);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // EDITABLE_STEPS_PER_UNIT
#if HAS_PID_HEATING
void DGUSScreenHandler::handlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr) {
char buf[32] = {0};
switch (var.VP) {
default: break;
#if ENABLED(PIDTEMP)
#if HAS_HOTEND
case VP_PID_AUTOTUNE_E0: // Autotune Extruder 0
sprintf_P(buf, PSTR("M303 E%d C5 S210 U1"), ExtUI::extruder_t::E0);
queue.enqueue_one_now(buf);
break;
#endif
#if HAS_MULTI_HOTEND
case VP_PID_AUTOTUNE_E1:
sprintf_P(buf, PSTR("M303 E%d C5 S210 U1"), ExtUI::extruder_t::E1);
queue.enqueue_one_now(buf);
break;
#endif
#endif
#if ENABLED(PIDTEMPBED)
case VP_PID_AUTOTUNE_BED:
queue.enqueue_one_now(F("M303 E-1 C5 S70 U1"));
break;
#endif
}
#if ENABLED(DGUS_UI_WAITING)
sendInfoScreen(F("PID is autotuning"), F("please wait"), NUL_STR, NUL_STR, true, true, true, true);
gotoScreen(DGUS_SCREEN_WAITING);
#endif
}
#endif // HAS_PID_HEATING
#if HAS_BED_PROBE
void DGUSScreenHandler::handleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr) {
const float offset = float(int16_t(BE16_P(val_ptr))) / 100.0f;
ExtUI::setZOffset_mm(offset);
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
return;
}
#endif
#if HAS_FAN
void DGUSScreenHandler::handleFanControl(DGUS_VP_Variable &var, void *val_ptr) {
*(uint8_t*)var.memadr = *(uint8_t*)var.memadr > 0 ? 0 : 255;
}
#endif
void DGUSScreenHandler::handleHeaterControl(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t preheat_temp = 0;
switch (var.VP) {
#if HAS_HOTEND
case VP_E0_CONTROL:
#if HAS_MULTI_HOTEND
case VP_E1_CONTROL:
#if HOTENDS >= 3
case VP_E2_CONTROL:
#endif
#endif
preheat_temp = PREHEAT_1_TEMP_HOTEND;
break;
#endif
#if HAS_HEATED_BED
case VP_BED_CONTROL:
preheat_temp = PREHEAT_1_TEMP_BED;
break;
#endif
}
*(int16_t*)var.memadr = *(int16_t*)var.memadr > 0 ? 0 : preheat_temp;
}
#if ENABLED(DGUS_PREHEAT_UI)
void DGUSScreenHandler::handlePreheat(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t preheat_option = BE16_P(val_ptr);
switch (preheat_option) {
default:
switch (var.VP) {
default: return;
case VP_E0_BED_PREHEAT: TERN_(HAS_HOTEND, ui.preheat_all(0)); break;
#if DISABLED(DGUS_LCD_UI_HIPRECY) && HAS_MULTI_HOTEND
case VP_E1_BED_PREHEAT: ui.preheat_all(1); break;
#endif
}
case 7: break; // Custom preheat
case 9: thermalManager.cooldown(); break; // Cool down
}
// Go to the preheat screen to show the heating progress
gotoScreen(DGUS_SCREEN_PREHEAT);
}
#endif // DGUS_PREHEAT_UI
#if ENABLED(POWER_LOSS_RECOVERY)
void DGUSScreenHandler::handlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t value = BE16_P(val_ptr);
if (value) {
queue.inject(F("M1000"));
dgus.writeVariable(VP_SD_Print_Filename, filelist.filename(), 32, true);
gotoScreen(PLR_SCREEN_RECOVER);
}
else {
recovery.cancel();
gotoScreen(PLR_SCREEN_CANCEL);
}
}
#endif
void DGUSScreenHandler::updateNewScreen(const DGUS_ScreenID screenID, const bool popup) {
if (!popup) {
memmove(&past_screenIDs[1], &past_screenIDs[0], sizeof(past_screenIDs) - 1);
past_screenIDs[0] = current_screenID;
}
current_screenID = screenID;
skipVP = 0;
forceCompleteUpdate();
}
void DGUSScreenHandler::popToOldScreen() {
gotoScreen(past_screenIDs[0], true);
memmove(&past_screenIDs[0], &past_screenIDs[1], sizeof(past_screenIDs) - 1);
past_screenIDs[sizeof(past_screenIDs) - 1] = DGUS_SCREEN_MAIN;
}
void DGUSScreenHandler::updateScreenVPData() {
const uint16_t *VPList = findScreenVPMapList(current_screenID);
if (!VPList) {
screenComplete = true;
return; // nothing to do, likely a bug or boring screen.
}
// Round-robin updating of all VPs.
VPList += update_ptr;
bool sent_one = false;
do {
uint16_t VP = pgm_read_word(VPList);
if (!VP) {
update_ptr = 0;
screenComplete = true;
return; // Screen completed.
}
if (VP == skipVP) { skipVP = 0; continue; }
DGUS_VP_Variable rcpy;
if (populate_VPVar(VP, &rcpy)) {
uint8_t expected_tx = 6 + rcpy.size; // expected overhead is 6 bytes + payload.
// Send the VP to the display, but try to avoid overrunning the Tx Buffer.
// But send at least one VP, to avoid getting stalled.
if (rcpy.send_to_display_handler && (!sent_one || expected_tx <= dgus.getFreeTxBuffer())) {
sent_one = true;
rcpy.send_to_display_handler(rcpy);
}
else {
screenComplete = false;
return; // please call again!
}
}
} while (++update_ptr, ++VPList, true);
}
void DGUSScreenHandler::gotoScreen(const DGUS_ScreenID screenID, const bool popup/*=false*/) {
dgus.requestScreen(screenID);
updateNewScreen(screenID, popup);
}
void DGUSDisplay::requestScreen(const DGUS_ScreenID screenID) {
const unsigned char gotoscreen[] = { 0x5A, 0x01, (unsigned char) (screenID >> 8U), (unsigned char) (screenID & 0xFFU) };
writeVariable(0x84, gotoscreen, sizeof(gotoscreen));
}
#endif // HAS_DGUS_LCD_CLASSIC
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 22,396
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* lcd/extui/dgus/DGUSScreenHandler.h
*/
#include "../../../inc/MarlinConfigPre.h"
#include "../ui_api.h"
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
typedef struct {
ExtUI::extruder_t extruder; // which extruder to operate
uint8_t action; // load or unload
bool heated; // heating done ?
float purge_length; // the length to extrude before unload, prevent filament jam
} filament_data_t;
extern filament_data_t filament_data;
#endif
// endianness swap
#define BE16_P(V) ( ((uint8_t*)(V))[0] << 8U | ((uint8_t*)(V))[1] )
#define BE32_P(V) ( ((uint8_t*)(V))[0] << 24U | ((uint8_t*)(V))[1] << 16U | ((uint8_t*)(V))[2] << 8U | ((uint8_t*)(V))[3] )
#if DGUS_LCD_UI_ORIGIN
#include "origin/DGUSScreenHandler.h"
#elif DGUS_LCD_UI_MKS
#include "mks/DGUSScreenHandler.h"
#elif DGUS_LCD_UI_FYSETC
#include "fysetc/DGUSScreenHandler.h"
#elif DGUS_LCD_UI_HIPRECY
#include "hiprecy/DGUSScreenHandler.h"
#endif
extern DGUSScreenHandlerClass screen;
// Helper to define a DGUS_VP_Variable for common use-cases.
#define VPHELPER(VPADR, VPADRVAR, RXFPTR, TXFPTR) { \
.VP = VPADR, \
.memadr = VPADRVAR, \
.size = sizeof(VPADRVAR), \
.set_by_display_handler = RXFPTR, \
.send_to_display_handler = TXFPTR \
}
// Helper to define a DGUS_VP_Variable when the size of the var cannot be determined automatically (e.g., a string)
#define VPHELPER_STR(VPADR, VPADRVAR, STRLEN, RXFPTR, TXFPTR) { \
.VP = VPADR, \
.memadr = VPADRVAR, \
.size = STRLEN, \
.set_by_display_handler = RXFPTR, \
.send_to_display_handler = TXFPTR \
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSScreenHandler.h
|
C
|
agpl-3.0
| 2,438
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2022 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "DGUSDisplay.h"
#include "DGUSVPVariable.h"
#include "DGUSDisplayDef.h"
#include "../../../inc/MarlinConfig.h"
enum DGUS_ScreenID : uint8_t;
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
static bool loop();
// Send all 4 strings that are displayed on the infoscreen, confirmation screen and kill screen
// The bools specifying whether the strings are in RAM or FLASH.
static void sendInfoScreen_P(PGM_P const line1, PGM_P const line2, PGM_P const line3, PGM_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
static void sendInfoScreen(FSTR_P const line1, FSTR_P const line2, PGM_P const line3, PGM_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendInfoScreen_P(FTOP(line1), FTOP(line2), line3, line4, l1inflash, l2inflash, l3inflash, liinflash);
}
static void sendInfoScreen(FSTR_P const line1, FSTR_P const line2, FSTR_P const line3, FSTR_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash) {
sendInfoScreen_P(FTOP(line1), FTOP(line2), FTOP(line3), FTOP(line4), l1inflash, l2inflash, l3inflash, liinflash);
}
static void handleUserConfirmationPopUp(uint16_t confirmVP, PGM_P const line1, PGM_P const line2, PGM_P const line3, PGM_P const line4, bool l1inflash, bool l2inflash, bool l3inflash, bool liinflash);
// "M117" Message -- msg is a RAM ptr.
static void setStatusMessage(const char *msg);
// The same for messages from Flash
static void setstatusmessagePGM(PGM_P const msg);
static void setStatusMessage(FSTR_P const fmsg) { setstatusmessagePGM(FTOP(fmsg)); }
// Callback for VP "Display wants to change screen on idle printer"
static void screenChangeHookIfIdle(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "Screen has been changed"
static void screenChangeHook(DGUS_VP_Variable &var, void *val_ptr);
// Callback for VP "All Heaters Off"
static void handleAllHeatersOff(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change this temperature"
static void handleTemperatureChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for "Change Flowrate"
static void handleFlowRateChanged(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
// Hook for manual move option
static void handleManualMoveOption(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for manual move.
static void handleManualMove(DGUS_VP_Variable &var, void *val_ptr);
// Hook for manual extrude.
static void handleManualExtrude(DGUS_VP_Variable &var, void *val_ptr);
// Hook for motor lock and unlook
static void handleMotorLockUnlock(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(POWER_LOSS_RECOVERY)
// Hook for power loss recovery.
static void handlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for settings
static void handleSettings(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static void handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_PID_HEATING
// Hook for "Change this temperature PID para"
static void handleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr);
// Hook for PID autotune
static void handlePIDAutotune(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_BED_PROBE
// Hook for "Change probe offset z"
static void handleProbeOffsetZChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(BABYSTEPPING)
// Hook for live z adjust action
static void handleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_FAN
// Hook for fan control
static void handleFanControl(DGUS_VP_Variable &var, void *val_ptr);
#endif
// Hook for heater control
static void handleHeaterControl(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(DGUS_PREHEAT_UI)
// Hook for preheat
static void handlePreheat(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
// Hook for filament load and unload filament option
static void handleFilamentOption(DGUS_VP_Variable &var, void *val_ptr);
// Hook for filament load and unload
static void handleFilamentLoadUnload(DGUS_VP_Variable &var);
#endif
#if HAS_MEDIA
// Callback for VP "Display wants to change screen when there is a SD card"
static void screenChangeHookIfSD(DGUS_VP_Variable &var, void *val_ptr);
// Scroll buttons on the file listing screen.
static void sdScrollFilelist(DGUS_VP_Variable &var, void *val_ptr);
// File touched.
static void sdFileSelected(DGUS_VP_Variable &var, void *val_ptr);
// start print after confirmation received.
static void sdStartPrint(DGUS_VP_Variable &var, void *val_ptr);
// User hit the pause, resume or abort button.
static void sdResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr);
// User confirmed the abort action
static void sdReallyAbort(DGUS_VP_Variable &var, void *val_ptr);
// User hit the tune button
static void sdPrintTune(DGUS_VP_Variable &var, void *val_ptr);
// Send a single filename to the display.
static void sdSendFilename(DGUS_VP_Variable &var);
// Marlin informed us that a new SD has been inserted.
static void sdCardInserted();
// Marlin informed us that the SD Card has been removed().
static void sdCardRemoved();
// Marlin informed us about a bad SD Card.
static void sdCardError();
#endif
// OK Button on the Confirm screen.
static void screenConfirmedOK(DGUS_VP_Variable &var, void *val_ptr);
// Update data after going to a new screen (by display or by gotoScreen)
// remember to store the last-displayed screen so it can be restored.
// (e.g., for popup messages)
static void updateNewScreen(const DGUS_ScreenID screenID, const bool popup=false);
// Recall the remembered screen.
static void popToOldScreen();
// Make the display show the screen and update all VPs in it.
static void gotoScreen(const DGUS_ScreenID screenID, const bool popup=false);
static void updateScreenVPData();
// Helpers to convert and transfer data to the display.
static void sendWordValueToDisplay(DGUS_VP_Variable &var);
static void sendStringToDisplay(DGUS_VP_Variable &var);
static void sendStringToDisplayPGM(DGUS_VP_Variable &var);
static void sendTemperaturePID(DGUS_VP_Variable &var);
static void sendPercentageToDisplay(DGUS_VP_Variable &var);
static void sendPrintProgressToDisplay(DGUS_VP_Variable &var);
static void sendPrintTimeToDisplay(DGUS_VP_Variable &var);
#if ENABLED(PRINTCOUNTER)
static void sendPrintAccTimeToDisplay(DGUS_VP_Variable &var);
static void sendPrintsTotalToDisplay(DGUS_VP_Variable &var);
#endif
#if HAS_FAN
static void sendFanStatusToDisplay(DGUS_VP_Variable &var);
#endif
static void sendHeaterStatusToDisplay(DGUS_VP_Variable &var);
#if ENABLED(DGUS_UI_WAITING)
static void sendWaitingStatusToDisplay(DGUS_VP_Variable &var);
#endif
// Send a value from 0..100 to a variable with a range from 0..255
static void percentageToUint8(DGUS_VP_Variable &var, void *val_ptr);
template<typename T>
static void setValueDirectly(DGUS_VP_Variable &var, void *val_ptr) {
if (!var.memadr) return;
union { unsigned char tmp[sizeof(T)]; T t; } x;
unsigned char *ptr = (unsigned char*)val_ptr;
for (uint8_t i = 0; i < sizeof(T); ++i) x.tmp[i] = ptr[sizeof(T) - i - 1];
*(T*)var.memadr = x.t;
}
// Send a float value to the display.
// Display will get a 4-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<uint16_t decimals>
static void sendFloatAsLongValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
f *= cpow(10, decimals);
dgus.writeVariable(var.VP, (long)f);
}
}
// Send a float value to the display.
// Display will get a 2-byte integer scaled to the number of digits:
// Tell the display the number of digits and it cheats by displaying a dot between...
template<uint16_t decimals>
static void sendFloatAsIntValueToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
float f = *(float *)var.memadr;
DEBUG_ECHOLNPGM(" >> ", p_float_t(f, 6));
f *= cpow(10, decimals);
dgus.writeVariable(var.VP, (int16_t)f);
}
}
// Force an update of all VP on the current screen.
static void forceCompleteUpdate() { update_ptr = 0; screenComplete = false; }
// Has all VPs sent to the screen
static bool isScreenComplete() { return screenComplete; }
static DGUS_ScreenID getCurrentScreen() { return current_screenID; }
static void setupConfirmAction( void (*f)()) { confirm_action_cb = f; }
protected:
static DGUS_ScreenID current_screenID; //< currently on screen
static constexpr uint8_t NUM_PAST_SCREENS = 4;
static DGUS_ScreenID past_screenIDs[NUM_PAST_SCREENS]; //< LIFO with past screens for the "back" button.
static uint8_t update_ptr; //< Last sent entry in the VPList for the actual screen.
static uint16_t skipVP; //< When updating the screen data, skip this one, because the user is interacting with it.
static bool screenComplete; //< All VPs sent to screen?
static uint16_t confirmVP; //< context for confirm screen (VP that will be emulated-sent on "OK").
#if HAS_MEDIA
static int16_t top_file; //< file on top of file chooser
static int16_t file_to_print; //< touched file to be confirmed
#endif
static void (*confirm_action_cb)();
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSScreenHandlerBase.h
|
C++
|
agpl-3.0
| 10,616
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include <stdint.h>
/**
* DGUSVPVariable.h
*
* Created on: Feb 9, 2019
* Author: tobi
*/
struct DGUS_VP_Variable {
uint16_t VP;
void* memadr; // If nullptr, the value cannot be uploaded to the display.
uint8_t size;
// Callback that will be called if the display modified the value.
// nullptr makes it readonly for the display.
void (*set_by_display_handler)(DGUS_VP_Variable &var, void *val_ptr);
void (*send_to_display_handler)(DGUS_VP_Variable &var);
template<typename T>
DGUS_VP_Variable& operator =(T &o) {
*(T*)memadr = o; // warning this is not typesafe.
// TODO: Call out the display or mark as dirty for the next update.
return *this;
}
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/DGUSVPVariable.h
|
C++
|
agpl-3.0
| 1,579
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/dgus/dgus_extui.cpp
*/
#include "../../../inc/MarlinConfigPre.h"
#if HAS_DGUS_LCD_CLASSIC
#include "../ui_api.h"
#include "DGUSDisplay.h"
#include "DGUSDisplayDef.h"
#include "DGUSScreenHandler.h"
namespace ExtUI {
void onStartup() {
dgus.initDisplay();
screen.updateScreenVPData();
}
void onIdle() { screen.loop(); }
void onPrinterKilled(FSTR_P const error, FSTR_P const) {
screen.sendInfoScreen(GET_TEXT_F(MSG_HALTED), error, FPSTR(NUL_STR), GET_TEXT_F(MSG_PLEASE_RESET), true, true, true, true);
screen.gotoScreen(DGUS_SCREEN_KILL);
while (!screen.loop()); // Wait while anything is left to be sent
}
void onMediaInserted() { TERN_(HAS_MEDIA, screen.sdCardInserted()); }
void onMediaError() { TERN_(HAS_MEDIA, screen.sdCardError()); }
void onMediaRemoved() { TERN_(HAS_MEDIA, screen.sdCardRemoved()); }
void onHeatingError(const heater_id_t header_id) {}
void onMinTempError(const heater_id_t header_id) {}
void onMaxTempError(const heater_id_t header_id) {}
void onPlayTone(const uint16_t frequency, const uint16_t duration/*=0*/) {}
void onPrintTimerStarted() {}
void onPrintTimerPaused() {}
void onPrintTimerStopped() {}
void onFilamentRunout(const extruder_t extruder) {}
void onUserConfirmRequired(const char * const msg) {
if (msg) {
screen.sendInfoScreen(F("Please confirm."), nullptr, msg, nullptr, true, true, false, true);
screen.setupConfirmAction(setUserConfirmed);
screen.gotoScreen(DGUS_SCREEN_POPUP);
}
else if (screen.getCurrentScreen() == DGUS_SCREEN_POPUP) {
screen.setupConfirmAction(nullptr);
screen.popToOldScreen();
}
}
// For fancy LCDs include an icon ID, message, and translated button title
void onUserConfirmRequired(const int icon, const char * const cstr, FSTR_P const fBtn) {
onUserConfirmRequired(cstr);
UNUSED(icon); UNUSED(fBtn);
}
void onUserConfirmRequired(const int icon, FSTR_P const fstr, FSTR_P const fBtn) {
onUserConfirmRequired(fstr);
UNUSED(icon); UNUSED(fBtn);
}
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void onPauseMode(
const PauseMessage message,
const PauseMode mode/*=PAUSE_MODE_SAME*/,
const uint8_t extruder/*=active_extruder*/
) {
stdOnPauseMode(message, mode, extruder);
}
#endif
void onStatusChanged(const char * const msg) { screen.setStatusMessage(msg); }
void onHomingStart() {}
void onHomingDone() {}
void onPrintDone() {}
void onFactoryReset() {}
void onStoreSettings(char *buff) {
// Called when saving to EEPROM (i.e. M500). If the ExtUI needs
// permanent data to be stored, it can write up to eeprom_data_size bytes
// into buff.
// Example:
// static_assert(sizeof(myDataStruct) <= eeprom_data_size);
// memcpy(buff, &myDataStruct, sizeof(myDataStruct));
}
void onLoadSettings(const char *buff) {
// Called while loading settings from EEPROM. If the ExtUI
// needs to retrieve data, it should copy up to eeprom_data_size bytes
// from buff
// Example:
// static_assert(sizeof(myDataStruct) <= eeprom_data_size);
// memcpy(&myDataStruct, buff, sizeof(myDataStruct));
}
void onPostprocessSettings() {
// Called after loading or resetting stored settings
}
void onSettingsStored(const bool success) {
// Called after the entire EEPROM has been written,
// whether successful or not.
}
void onSettingsLoaded(const bool success) {
// Called after the entire EEPROM has been read,
// whether successful or not.
}
#if HAS_LEVELING
void onLevelingStart() {}
void onLevelingDone() {}
#if ENABLED(PREHEAT_BEFORE_LEVELING)
celsius_t getLevelingBedTemp() { return LEVELING_BED_TEMP; }
#endif
#endif
#if HAS_MESH
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) {
// Called when any mesh points are updated
}
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) {
// Called to indicate a special condition
}
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
void onSetMinExtrusionTemp(const celsius_t) {}
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
void onSetPowerLoss(const bool onoff) {
// Called when power-loss is enabled/disabled
}
void onPowerLoss() {
// Called when power-loss state is detected
}
void onPowerLossResume() {
// Called on resume from power-loss
IF_DISABLED(DGUS_LCD_UI_MKS, screen.gotoScreen(DGUS_SCREEN_POWER_LOSS));
}
#endif
#if HAS_PID_HEATING
void onPIDTuning(const pidresult_t rst) {
// Called for temperature PID tuning result
switch (rst) {
case PID_STARTED:
case PID_BED_STARTED:
case PID_CHAMBER_STARTED:
screen.setStatusMessage(GET_TEXT_F(MSG_PID_AUTOTUNE));
break;
case PID_BAD_HEATER_ID:
screen.setStatusMessage(GET_TEXT_F(MSG_PID_BAD_HEATER_ID));
break;
case PID_TEMP_TOO_HIGH:
screen.setStatusMessage(GET_TEXT_F(MSG_PID_TEMP_TOO_HIGH));
break;
case PID_TUNING_TIMEOUT:
screen.setStatusMessage(GET_TEXT_F(MSG_PID_TIMEOUT));
break;
case PID_DONE:
screen.setStatusMessage(GET_TEXT_F(MSG_PID_AUTOTUNE_DONE));
break;
}
screen.gotoScreen(DGUS_SCREEN_MAIN);
}
void onStartM303(const int count, const heater_id_t hid, const celsius_t temp) {
// Called by M303 to update the UI
}
#endif
#if ENABLED(MPC_AUTOTUNE)
void onMPCTuning(const mpcresult_t rst) {
// Called for temperature MPC tuning result
switch (rst) {
case MPC_STARTED:
screen.setStatusMessage(GET_TEXT_F(MSG_MPC_AUTOTUNE));
break;
case MPC_TEMP_ERROR:
//screen.setStatusMessage(GET_TEXT_F(MSG_MPC_TEMP_ERROR));
break;
case MPC_INTERRUPTED:
//screen.setStatusMessage(GET_TEXT_F(MSG_MPC_INTERRUPTED));
break;
case MPC_DONE:
//screen.setStatusMessage(GET_TEXT_F(MSG_MPC_AUTOTUNE_DONE));
break;
}
screen.gotoScreen(DGUS_SCREEN_MAIN);
}
#endif
#if ENABLED(PLATFORM_M997_SUPPORT)
void onFirmwareFlash() {}
#endif
void onSteppersDisabled() {}
void onSteppersEnabled() {}
void onAxisDisabled(const axis_t) {}
void onAxisEnabled(const axis_t) {}
}
#endif // HAS_DGUS_LCD_CLASSIC
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/dgus_extui.cpp
|
C++
|
agpl-3.0
| 7,333
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/* DGUS VPs changed by George Fu in 2019 for Marlin */
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_FYSETC
#include "DGUSDisplayDef.h"
#include "../DGUSDisplay.h"
#include "../DGUSScreenHandler.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../ui_api.h"
#include "../../../marlinui.h"
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
uint16_t distanceToMove = 10;
#endif
const uint16_t VPList_Boot[] PROGMEM = {
VP_MARLIN_VERSION,
0x0000
};
const uint16_t VPList_Main[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded.
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set, VP_E0_STATUS,
#endif
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS,
#endif
#if HAS_FAN
VP_Fan0_Percentage, VP_FAN0_STATUS,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
#if ENABLED(SET_PROGRESS_PERCENT)
VP_PrintProgress_Percentage,
#endif
0x0000
};
const uint16_t VPList_Temp[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#endif
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_Status[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#endif
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
#if HAS_FAN
VP_Fan0_Percentage,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
VP_PrintProgress_Percentage,
0x0000
};
const uint16_t VPList_Status2[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HAS_HOTEND
VP_Flowrate_E0,
#if HAS_MULTI_EXTRUDER
VP_Flowrate_E1,
#endif
#endif
VP_PrintProgress_Percentage,
VP_PrintTime,
0x0000
};
const uint16_t VPList_Preheat[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#endif
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_ManualMove[] PROGMEM = {
VP_XPos, VP_YPos, VP_ZPos,
0x0000
};
const uint16_t VPList_ManualExtrude[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_EXTRUDER
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
VP_EPos,
0x0000
};
const uint16_t VPList_FanAndFeedrate[] PROGMEM = {
VP_Feedrate_Percentage, VP_Fan0_Percentage,
0x0000
};
const uint16_t VPList_SD_FlowRates[] PROGMEM = {
VP_Flowrate_E0, VP_Flowrate_E1,
0x0000
};
const uint16_t VPList_Filament_heating[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
VP_E0_FILAMENT_LOAD_UNLOAD,
#if HAS_MULTI_EXTRUDER
VP_T_E1_Is, VP_T_E1_Set,
VP_E1_FILAMENT_LOAD_UNLOAD,
#endif
#endif
0x0000
};
const uint16_t VPList_Filament_load_unload[] PROGMEM = {
#if HAS_HOTEND
VP_E0_FILAMENT_LOAD_UNLOAD,
#if HAS_MULTI_EXTRUDER
VP_E1_FILAMENT_LOAD_UNLOAD,
#endif
#endif
0x0000
};
const uint16_t VPList_SDFileList[] PROGMEM = {
VP_SD_FileName0, VP_SD_FileName1, VP_SD_FileName2, VP_SD_FileName3, VP_SD_FileName4,
0x0000
};
const uint16_t VPList_SD_PrintManipulation[] PROGMEM = {
VP_PrintProgress_Percentage, VP_PrintTime,
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#endif
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
#if HAS_FAN
VP_Fan0_Percentage,
#if FAN_COUNT > 1
VP_Fan1_Percentage,
#endif
#endif
VP_Flowrate_E0,
0x0000
};
const uint16_t VPList_SDPrintTune[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set, VP_Flowrate_E0,
#if HAS_MULTI_EXTRUDER
VP_T_E1_Is, VP_T_E1_Set, VP_Flowrate_E1, // ERROR: Flowrate is per-extruder, not per-hotend
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
VP_Feedrate_Percentage,
VP_SD_Print_ProbeOffsetZ,
0x0000
};
const uint16_t VPList_StepPerMM[] PROGMEM = {
VP_X_STEP_PER_MM,
VP_Y_STEP_PER_MM,
VP_Z_STEP_PER_MM,
#if HAS_EXTRUDERS
VP_E0_STEP_PER_MM,
#if HAS_MULTI_EXTRUDER
VP_E1_STEP_PER_MM,
#endif
#endif
0x0000
};
const uint16_t VPList_PIDE0[] PROGMEM = {
#if ENABLED(PIDTEMP)
VP_E0_PID_P,
VP_E0_PID_I,
VP_E0_PID_D,
#endif
0x0000
};
const uint16_t VPList_PIDBED[] PROGMEM = {
#if ENABLED(PIDTEMP)
VP_BED_PID_P,
VP_BED_PID_I,
VP_BED_PID_D,
#endif
0x0000
};
const uint16_t VPList_Infos[] PROGMEM = {
VP_MARLIN_VERSION,
VP_PrintTime,
#if ENABLED(PRINTCOUNTER)
VP_PrintAccTime,
VP_PrintsTotal,
#endif
0x0000
};
const uint16_t VPList_PIDTuningWaiting[] PROGMEM = {
VP_WAITING_STATUS,
0x0000
};
const uint16_t VPList_FLCPreheat[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_FLCPrinting[] PROGMEM = {
#if HAS_HOTEND
VP_SD_Print_ProbeOffsetZ,
#endif
0x0000
};
const uint16_t VPList_Z_Offset[] PROGMEM = {
#if HAS_HOTEND
VP_SD_Print_ProbeOffsetZ,
#endif
0x0000
};
const struct VPMapping VPMap[] PROGMEM = {
{ DGUS_SCREEN_BOOT, VPList_Boot },
{ DGUS_SCREEN_MAIN, VPList_Main },
{ DGUS_SCREEN_TEMPERATURE, VPList_Temp },
{ DGUS_SCREEN_STATUS, VPList_Status },
{ DGUS_SCREEN_STATUS2, VPList_Status2 },
{ DGUS_SCREEN_PREHEAT, VPList_Preheat },
{ DGUS_SCREEN_MANUALMOVE, VPList_ManualMove },
{ DGUS_SCREEN_MANUALEXTRUDE, VPList_ManualExtrude },
{ DGUS_SCREEN_FILAMENT_HEATING, VPList_Filament_heating },
{ DGUS_SCREEN_FILAMENT_LOADING, VPList_Filament_load_unload },
{ DGUS_SCREEN_FILAMENT_UNLOADING, VPList_Filament_load_unload },
{ DGUS_SCREEN_SDPRINTMANIPULATION, VPList_SD_PrintManipulation },
{ DGUS_SCREEN_SDFILELIST, VPList_SDFileList },
{ DGUS_SCREEN_SDPRINTTUNE, VPList_SDPrintTune },
{ DGUS_SCREEN_WAITING, VPList_PIDTuningWaiting },
{ DGUS_SCREEN_FLC_PREHEAT, VPList_FLCPreheat },
{ DGUS_SCREEN_FLC_PRINTING, VPList_FLCPrinting },
{ DGUS_SCREEN_Z_OFFSET, VPList_Z_Offset },
{ DGUS_SCREEN_STEPPERMM, VPList_StepPerMM },
{ DGUS_SCREEN_PID_E, VPList_PIDE0 },
{ DGUS_SCREEN_PID_BED, VPList_PIDBED },
{ DGUS_SCREEN_INFOS, VPList_Infos },
{ 0 , nullptr } // List is terminated with an nullptr as table entry.
};
const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION;
const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
// Helper to detect touch events
VPHELPER(VP_SCREENCHANGE, nullptr, screen.screenChangeHook, nullptr),
VPHELPER(VP_SCREENCHANGE_ASK, nullptr, screen.screenChangeHookIfIdle, nullptr),
#if HAS_MEDIA
VPHELPER(VP_SCREENCHANGE_WHENSD, nullptr, screen.screenChangeHookIfSD, nullptr),
#endif
VPHELPER(VP_CONFIRMED, nullptr, screen.screenConfirmedOK, nullptr),
VPHELPER(VP_TEMP_ALL_OFF, nullptr, screen.handleAllHeatersOff, nullptr),
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
VPHELPER(VP_MOVE_OPTION, &distanceToMove, screen.handleManualMoveOption, nullptr),
#endif
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
VPHELPER(VP_MOVE_X, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, &distanceToMove, screen.handleManualMove, nullptr),
#else
VPHELPER(VP_MOVE_X, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, nullptr, screen.handleManualMove, nullptr),
#endif
VPHELPER(VP_MOTOR_LOCK_UNLOK, nullptr, screen.handleMotorLockUnlock, nullptr),
#if ENABLED(POWER_LOSS_RECOVERY)
VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, screen.handlePowerLossRecovery, nullptr),
#endif
VPHELPER(VP_SETTINGS, nullptr, screen.handleSettings, nullptr),
#if ENABLED(SINGLE_Z_CALIBRATION)
VPHELPER(VP_Z_CALIBRATE, nullptr, screen.handleZCalibration, nullptr),
#endif
#if ENABLED(FIRST_LAYER_CAL)
VPHELPER(VP_Z_FIRST_LAYER_CAL, nullptr, screen.handleFirstLayerCal, nullptr),
#endif
{ .VP = VP_MARLIN_VERSION, .memadr = (void*)MarlinVersion, .size = VP_MARLIN_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
// M117 LCD String (We don't need the string in memory but "just" push it to the display on demand, hence the nullptr
{ .VP = VP_M117, .memadr = nullptr, .size = VP_M117_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay },
// Temperature Data
#if HAS_HOTEND
VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_EPos, &destination.e, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_MOVE_E0, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E0_CONTROL, &thermalManager.temp_hotend[0].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E0_STATUS, &thermalManager.temp_hotend[0].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(DGUS_PREHEAT_UI)
VPHELPER(VP_E0_BED_PREHEAT, nullptr, screen.handlePreheat, nullptr),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_E0_PID_P, &thermalManager.temp_hotend[0].pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_I, &thermalManager.temp_hotend[0].pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_D, &thermalManager.temp_hotend[0].pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_E0, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_E0_FILAMENT_LOAD_UNLOAD, nullptr, screen.handleFilamentOption, screen.handleFilamentLoadUnload),
#endif
#endif
#if HAS_MULTI_HOTEND
VPHELPER(VP_T_E1_Is, &thermalManager.temp_hotend[1].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E1_Set, &thermalManager.temp_hotend[1].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E1, &planner.flow_percentage[ExtUI::extruder_t::E1], screen.handleFlowRateChanged, screen.sendWordValueToDisplay), // ERROR: Flow is per-extruder, not per-hotend
VPHELPER(VP_MOVE_E1, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E1_CONTROL, &thermalManager.temp_hotend[1].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E1_STATUS, &thermalManager.temp_hotend[1].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(PIDTEMP)
VPHELPER(VP_PID_AUTOTUNE_E1, nullptr, screen.handlePIDAutotune, nullptr),
#endif
VPHELPER(VP_E1_FILAMENT_LOAD_UNLOAD, nullptr, screen.handleFilamentOption, screen.handleFilamentLoadUnload),
#endif
#if HAS_HEATED_BED
VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, screen.sendWordValueToDisplay),
VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_BED_CONTROL, &thermalManager.temp_bed.target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_BED_STATUS, &thermalManager.temp_bed.target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(PIDTEMPBED)
VPHELPER(VP_BED_PID_P, &thermalManager.temp_bed.pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_I, &thermalManager.temp_bed.pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_D, &thermalManager.temp_bed.pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_BED, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#endif
// Fan Data
#if HAS_FAN
#define FAN_VPHELPER(N) \
VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], screen.percentageToUint8, screen.sendPercentageToDisplay), \
VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], screen.handleFanControl, nullptr), \
VPHELPER(VP_FAN##N##_STATUS, &thermalManager.fan_speed[N], nullptr, screen.sendFanStatusToDisplay),
REPEAT(FAN_COUNT, FAN_VPHELPER)
#endif
// Feedrate
VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, screen.setValueDirectly<int16_t>, screen.sendWordValueToDisplay),
// Position Data
VPHELPER(VP_XPos, ¤t_position.x, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_YPos, ¤t_position.y, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_ZPos, ¤t_position.z, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
// Print Progress
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, screen.sendPrintProgressToDisplay),
// Print Time
VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, screen.sendPrintTimeToDisplay),
#if ENABLED(PRINTCOUNTER)
VPHELPER_STR(VP_PrintAccTime, nullptr, VP_PrintAccTime_LEN, nullptr, screen.sendPrintAccTimeToDisplay),
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_EXTRUDERS
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_EXTRUDER
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#endif
#endif
#endif
// SDCard File listing.
#if HAS_MEDIA
VPHELPER(VP_SD_ScrollEvent, nullptr, screen.sdScrollFilelist, nullptr),
VPHELPER(VP_SD_FileSelected, nullptr, screen.sdFileSelected, nullptr),
VPHELPER(VP_SD_FileSelectConfirm, nullptr, screen.sdStartPrint, nullptr),
VPHELPER_STR(VP_SD_FileName0, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName1, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName2, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName3, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName4, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER(VP_SD_ResumePauseAbort, nullptr, screen.sdResumePauseAbort, nullptr),
VPHELPER(VP_SD_AbortPrintConfirmed, nullptr, screen.sdReallyAbort, nullptr),
VPHELPER(VP_SD_Print_Setting, nullptr, screen.sdPrintTune, nullptr),
#if HAS_BED_PROBE
VPHELPER(VP_SD_Print_ProbeOffsetZ, &probe.offset.z, screen.handleProbeOffsetZChanged, screen.sendFloatAsIntValueToDisplay<2>),
#if ENABLED(BABYSTEPPING)
VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, screen.handleLiveAdjustZ, nullptr),
#endif
#endif
#endif
#if ENABLED(DGUS_UI_WAITING)
VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, screen.sendWaitingStatusToDisplay),
#endif
// Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
{ .VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
VPHELPER(0, 0, 0, 0) // must be last entry.
};
#endif // DGUS_LCD_UI_FYSETC
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/fysetc/DGUSDisplayDef.cpp
|
C++
|
agpl-3.0
| 18,215
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplayDef.h"
enum DGUS_ScreenID : uint8_t {
DGUS_SCREEN_BOOT = 0,
DGUS_SCREEN_MAIN = 1,
DGUS_SCREEN_STATUS = 1,
DGUS_SCREEN_STATUS2 = 1,
DGUS_SCREEN_TEMPERATURE = 10,
DGUS_SCREEN_PREHEAT = 18,
DGUS_SCREEN_POWER_LOSS = 100,
DGUS_SCREEN_MANUALMOVE = 192,
DGUS_SCREEN_UTILITY = 120,
DGUS_SCREEN_FILAMENT_HEATING = 146,
DGUS_SCREEN_FILAMENT_LOADING = 148,
DGUS_SCREEN_FILAMENT_UNLOADING = 158,
DGUS_SCREEN_MANUALEXTRUDE = 160,
DGUS_SCREEN_SDFILELIST = 71,
DGUS_SCREEN_SDPRINTMANIPULATION = 73,
DGUS_SCREEN_SDPRINTTUNE = 75,
DGUS_SCREEN_FLC_PREHEAT = 94,
DGUS_SCREEN_FLC_PRINTING = 96,
DGUS_SCREEN_STEPPERMM = 212,
DGUS_SCREEN_PID_E = 214,
DGUS_SCREEN_PID_BED = 218,
DGUS_SCREEN_Z_OFFSET = 222,
DGUS_SCREEN_INFOS = 36,
DGUS_SCREEN_CONFIRM = 240,
DGUS_SCREEN_KILL = 250, ///< Kill Screen. Must always be 250 (to be able to display "Error wrong LCD Version")
DGUS_SCREEN_WAITING = 251,
DGUS_SCREEN_POPUP = 252, ///< special target, popup screen will also return this code to say "return to previous screen"
DGUS_SCREEN_UNUSED = 255
};
// Display Memory layout used (T5UID)
// Except system variables this is arbitrary, just to organize stuff....
// 0x0000 .. 0x0FFF -- System variables and reserved by the display
// 0x1000 .. 0x1FFF -- Variables to never change location, regardless of UI Version
// 0x2000 .. 0x2FFF -- Controls (VPs that will trigger some action)
// 0x3000 .. 0x4FFF -- Marlin Data to be displayed
// 0x5000 .. -- SPs (if we want to modify display elements, e.g change color or like) -- currently unused
// As there is plenty of space (at least most displays have >8k RAM), we do not pack them too tight,
// so that we can keep variables nicely together in the address space.
// UI Version always on 0x1000...0x1002 so that the firmware can check this and bail out.
constexpr uint16_t VP_UI_VERSION_MAJOR = 0x1000; // Major -- incremented when incompatible
constexpr uint16_t VP_UI_VERSION_MINOR = 0x1001; // Minor -- incremented on new features, but compatible
constexpr uint16_t VP_UI_VERSION_PATCH = 0x1002; // Patch -- fixed which do not change functionality.
constexpr uint16_t VP_UI_FLAVOUR = 0x1010; // lets reserve 16 bytes here to determine if UI is suitable for this Marlin. tbd.
// Storage space for the Killscreen messages. 0x1100 - 0x1200 . Reused for the popup.
constexpr uint16_t VP_MSGSTR1 = 0x1100;
constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
constexpr uint16_t VP_MSGSTR2 = 0x1140;
constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
constexpr uint16_t VP_MSGSTR3 = 0x1180;
constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
constexpr uint16_t VP_MSGSTR4 = 0x11C0;
constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
// Screenchange request for screens that only make sense when printer is idle.
// e.g movement is only allowed if printer is not printing.
// Marlin must confirm by setting the screen manually.
constexpr uint16_t VP_SCREENCHANGE_ASK = 0x2000;
constexpr uint16_t VP_SCREENCHANGE = 0x2001; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
constexpr uint16_t VP_TEMP_ALL_OFF = 0x2002; // Turn all heaters off. Value arbitrary ;)=
constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x2003; // "Print" Button touched -- go only there if there is an SD Card.
constexpr uint16_t VP_CONFIRMED = 0x2010; // OK on confirm screen.
// Buttons on the SD-Card File listing.
constexpr uint16_t VP_SD_ScrollEvent = 0x2020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
constexpr uint16_t VP_SD_FileSelected = 0x2022; // Number of file field selected.
constexpr uint16_t VP_SD_FileSelectConfirm = 0x2024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
constexpr uint16_t VP_SD_ResumePauseAbort = 0x2026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x2028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
constexpr uint16_t VP_SD_Print_Setting = 0x2040;
constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x2050; // Data: 0 down, 1 up
// Controls for movement (we can't use the incremental / decremental feature of the display at this feature works only with 16 bit values
// (which would limit us to 655.35mm, which is likely not a problem for common setups, but i don't want to rule out hangprinters support)
// A word about the coding: The VP will be per axis and the return code will be an signed 16 bit value in 0.01 mm resolution, telling us
// the relative travel amount t he user wants to do. So eg. if the display sends us VP=2100 with value 100, the user wants us to move X by +1 mm.
constexpr uint16_t VP_MOVE_X = 0x2100;
constexpr uint16_t VP_MOVE_Y = 0x2102;
constexpr uint16_t VP_MOVE_Z = 0x2104;
constexpr uint16_t VP_MOVE_E0 = 0x2110;
constexpr uint16_t VP_MOVE_E1 = 0x2112;
//constexpr uint16_t VP_MOVE_E2 = 0x2114;
//constexpr uint16_t VP_MOVE_E3 = 0x2116;
//constexpr uint16_t VP_MOVE_E4 = 0x2118;
//constexpr uint16_t VP_MOVE_E5 = 0x211A;
constexpr uint16_t VP_HOME_ALL = 0x2120;
constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2130;
// Power loss recovery
constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x2180;
// Fan Control Buttons , switch between "off" and "on"
constexpr uint16_t VP_FAN0_CONTROL = 0x2200;
constexpr uint16_t VP_FAN1_CONTROL = 0x2202;
constexpr uint16_t VP_FAN2_CONTROL = 0x2204;
constexpr uint16_t VP_FAN3_CONTROL = 0x2206;
// Heater Control Buttons , triged between "cool down" and "heat PLA" state
constexpr uint16_t VP_E0_CONTROL = 0x2210;
constexpr uint16_t VP_E1_CONTROL = 0x2212;
//constexpr uint16_t VP_E2_CONTROL = 0x2214;
//constexpr uint16_t VP_E3_CONTROL = 0x2216;
//constexpr uint16_t VP_E4_CONTROL = 0x2218;
//constexpr uint16_t VP_E5_CONTROL = 0x221A;
constexpr uint16_t VP_BED_CONTROL = 0x221C;
// Preheat
constexpr uint16_t VP_E0_BED_PREHEAT = 0x2220;
constexpr uint16_t VP_E1_BED_PREHEAT = 0x2222;
//constexpr uint16_t VP_E2_BED_PREHEAT = 0x2224;
//constexpr uint16_t VP_E3_BED_PREHEAT = 0x2226;
//constexpr uint16_t VP_E4_BED_PREHEAT = 0x2228;
//constexpr uint16_t VP_E5_BED_PREHEAT = 0x222A;
// Filament load and unload
constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2300;
constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2302;
// Settings store , reset
constexpr uint16_t VP_SETTINGS = 0x2400;
// PID autotune
constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x2410;
constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x2412;
//constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x2414;
//constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x2416;
//constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x2418;
//constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x241A;
constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x2420;
// Calibrate Z
constexpr uint16_t VP_Z_CALIBRATE = 0x2430;
// First layer cal
constexpr uint16_t VP_Z_FIRST_LAYER_CAL = 0x2500; // Data: 0 - Cancel first layer cal progress, >0 filament type have loaded
// Firmware version on the boot screen.
constexpr uint16_t VP_MARLIN_VERSION = 0x3000;
constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
// Place for status messages.
constexpr uint16_t VP_M117 = 0x3020;
constexpr uint8_t VP_M117_LEN = 0x20;
// Temperatures.
constexpr uint16_t VP_T_E0_Is = 0x3060; // 4 Byte Integer
constexpr uint16_t VP_T_E0_Set = 0x3062; // 2 Byte Integer
constexpr uint16_t VP_T_E1_Is = 0x3064; // 4 Byte Integer
// reserved to support up to 6 Extruders:
constexpr uint16_t VP_T_E1_Set = 0x3066; // 2 Byte Integer
//constexpr uint16_t VP_T_E2_Is = 0x3068; // 4 Byte Integer
//constexpr uint16_t VP_T_E2_Set = 0x306A; // 2 Byte Integer
//constexpr uint16_t VP_T_E3_Is = 0x306C; // 4 Byte Integer
//constexpr uint16_t VP_T_E3_Set = 0x306E; // 2 Byte Integer
//constexpr uint16_t VP_T_E4_Is = 0x3070; // 4 Byte Integer
//constexpr uint16_t VP_T_E4_Set = 0x3072; // 2 Byte Integer
//constexpr uint16_t VP_T_E4_Is = 0x3074; // 4 Byte Integer
//constexpr uint16_t VP_T_E4_Set = 0x3076; // 2 Byte Integer
//constexpr uint16_t VP_T_E5_Is = 0x3078; // 4 Byte Integer
//constexpr uint16_t VP_T_E5_Set = 0x307A; // 2 Byte Integer
constexpr uint16_t VP_T_Bed_Is = 0x3080; // 4 Byte Integer
constexpr uint16_t VP_T_Bed_Set = 0x3082; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E0 = 0x3090; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E1 = 0x3092; // 2 Byte Integer
// reserved for up to 6 Extruders:
//constexpr uint16_t VP_Flowrate_E2 = 0x3094;
//constexpr uint16_t VP_Flowrate_E3 = 0x3096;
//constexpr uint16_t VP_Flowrate_E4 = 0x3098;
//constexpr uint16_t VP_Flowrate_E5 = 0x309A;
constexpr uint16_t VP_Fan0_Percentage = 0x3100; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan1_Percentage = 0x3102; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan2_Percentage = 0x3104; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan3_Percentage = 0x3106; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Feedrate_Percentage = 0x3108; // 2 Byte Integer (0..100)
// Actual Position
constexpr uint16_t VP_XPos = 0x3110; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_YPos = 0x3112; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_ZPos = 0x3114; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_EPos = 0x3120; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_PrintProgress_Percentage = 0x3130; // 2 Byte Integer (0..100)
constexpr uint16_t VP_PrintTime = 0x3140;
constexpr uint16_t VP_PrintTime_LEN = 32;
constexpr uint16_t VP_PrintAccTime = 0x3160;
constexpr uint16_t VP_PrintAccTime_LEN = 32;
constexpr uint16_t VP_PrintsTotal = 0x3180;
constexpr uint16_t VP_PrintsTotal_LEN = 16;
// SDCard File Listing
constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
constexpr uint16_t DGUS_SD_FILESPERSCREEN = 5; // FIXME move that info to the display and read it from there.
constexpr uint16_t VP_SD_FileName0 = 0x3200;
constexpr uint16_t VP_SD_FileName1 = 0x3220;
constexpr uint16_t VP_SD_FileName2 = 0x3240;
constexpr uint16_t VP_SD_FileName3 = 0x3260;
constexpr uint16_t VP_SD_FileName4 = 0x3280;
constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0; //
constexpr uint16_t VP_SD_Print_Filename = 0x32C0;
// Fan status
constexpr uint16_t VP_FAN0_STATUS = 0x3300;
constexpr uint16_t VP_FAN1_STATUS = 0x3302;
constexpr uint16_t VP_FAN2_STATUS = 0x3304;
constexpr uint16_t VP_FAN3_STATUS = 0x3306;
// Heater status
constexpr uint16_t VP_E0_STATUS = 0x3310;
constexpr uint16_t VP_E1_STATUS = 0x3312;
//constexpr uint16_t VP_E2_STATUS = 0x3314;
//constexpr uint16_t VP_E3_STATUS = 0x3316;
//constexpr uint16_t VP_E4_STATUS = 0x3318;
//constexpr uint16_t VP_E5_STATUS = 0x331A;
constexpr uint16_t VP_BED_STATUS = 0x331C;
constexpr uint16_t VP_MOVE_OPTION = 0x3400;
// Step per mm
constexpr uint16_t VP_X_STEP_PER_MM = 0x3600; // at the moment , uint16_t , 0~1638.4
//constexpr uint16_t VP_X2_STEP_PER_MM = 0x3602;
constexpr uint16_t VP_Y_STEP_PER_MM = 0x3604;
//constexpr uint16_t VP_Y2_STEP_PER_MM = 0x3606;
constexpr uint16_t VP_Z_STEP_PER_MM = 0x3608;
//constexpr uint16_t VP_Z2_STEP_PER_MM = 0x360A;
constexpr uint16_t VP_E0_STEP_PER_MM = 0x3610;
constexpr uint16_t VP_E1_STEP_PER_MM = 0x3612;
//constexpr uint16_t VP_E2_STEP_PER_MM = 0x3614;
//constexpr uint16_t VP_E3_STEP_PER_MM = 0x3616;
//constexpr uint16_t VP_E4_STEP_PER_MM = 0x3618;
//constexpr uint16_t VP_E5_STEP_PER_MM = 0x361A;
// PIDs
constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_E0_PID_I = 0x3702;
constexpr uint16_t VP_E0_PID_D = 0x3704;
constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_E1_PID_I = 0x3708;
constexpr uint16_t VP_E1_PID_D = 0x370A;
constexpr uint16_t VP_BED_PID_P = 0x3710;
constexpr uint16_t VP_BED_PID_I = 0x3712;
constexpr uint16_t VP_BED_PID_D = 0x3714;
// Waiting screen status
constexpr uint16_t VP_WAITING_STATUS = 0x3800;
// SPs for certain variables...
// located at 0x5000 and up
// Not used yet!
// This can be used e.g to make controls / data display invisible
constexpr uint16_t SP_T_E0_Is = 0x5000;
constexpr uint16_t SP_T_E0_Set = 0x5010;
constexpr uint16_t SP_T_E1_Is = 0x5020;
constexpr uint16_t SP_T_Bed_Is = 0x5030;
constexpr uint16_t SP_T_Bed_Set = 0x5040;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/fysetc/DGUSDisplayDef.h
|
C++
|
agpl-3.0
| 13,525
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_FYSETC
#include "../DGUSScreenHandler.h"
#include "../../../../MarlinCore.h"
#include "../../../../gcode/queue.h"
#include "../../../../libs/duration_t.h"
#include "../../../../module/settings.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../../../module/printcounter.h"
#include "../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if HAS_MEDIA
extern ExtUI::FileList filelist;
void DGUSScreenHandler::sdFileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
forceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgus.writeVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
handleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::sdStartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
gotoScreen(DGUS_SCREEN_SDPRINTMANIPULATION);
}
void DGUSScreenHandler::sdResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: // Resume
if (ExtUI::isPrintingFromMediaPaused()) ExtUI::resumePrint();
break;
case 1: // Pause
gotoScreen(DGUS_SCREEN_SDPRINTMANIPULATION);
if (!ExtUI::isPrintingFromMediaPaused()) {
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
handleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::sdSendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
}
sendStringToDisplay(var);
}
void DGUSScreenHandler::sdCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUS_SCREEN_MAIN || cs == DGUS_SCREEN_STATUS)
gotoScreen(DGUS_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::sdCardRemoved() {
if (current_screenID == DGUS_SCREEN_SDFILELIST
|| (current_screenID == DGUS_SCREEN_CONFIRM && (confirmVP == VP_SD_AbortPrintConfirmed || confirmVP == VP_SD_FileSelectConfirm))
|| current_screenID == DGUS_SCREEN_SDPRINTMANIPULATION
) gotoScreen(DGUS_SCREEN_MAIN);
}
#endif // HAS_MEDIA
void DGUSScreenHandler::screenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUS_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUS_ScreenID target = (DGUS_ScreenID)tmp[1];
if (target == DGUS_SCREEN_POPUP) {
// Special handling for popup is to return to previous menu
if (current_screenID == DGUS_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
popToOldScreen();
return;
}
updateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!findScreenVPMapList(target)) DEBUG_ECHOLNPGM("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::handleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
uint16_t speed = manual_feedrate_mm_m.x; // Default feedrate for manual moves
switch (var.VP) {
default: return;
#if HAS_X_AXIS
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
#endif
#if HAS_Y_AXIS
case VP_MOVE_Y:
axiscode = 'Y';
speed = manual_feedrate_mm_m.y;
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
#endif
#if HAS_Z_AXIS
case VP_MOVE_Z:
axiscode = 'Z';
speed = manual_feedrate_mm_m.z;
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
#endif
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
char buf[6] = "G28 X";
buf[4] = axiscode;
queue.enqueue_one_now(buf);
forceCompleteUpdate();
return;
}
else {
// movement
bool old_relative_mode = relative_mode;
if (!relative_mode) queue.enqueue_now(F("G91"));
char buf[32]; // G1 X9999.99 F12345
const uint16_t backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
queue.enqueue_one_now(buf);
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
}
//while (!enqueue_and_echo_command(buf)) idle();
if (!old_relative_mode) queue.enqueue_now(F("G90"));
}
forceCompleteUpdate();
cannotmove:
return;
}
#if HAS_PID_HEATING
void DGUSScreenHandler::handleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
float value = (float)rawvalue / 10;
float newvalue = 0;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
*(float *)var.memadr = newvalue;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::handleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
int16_t flag = swap16(*(uint16_t*)val_ptr),
steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
forceCompleteUpdate();
}
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::handleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) { // Load filament type
filament_data.action = 1;
}
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else { // Cancel filament operation
filament_data.action = 0;
}
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HAS_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#if HAS_MULTI_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
#endif
gotoScreen(DGUS_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
gotoScreen(DGUS_SCREEN_FILAMENT_HEATING);
}
}
void DGUSScreenHandler::handleFilamentLoadUnload(DGUS_VP_Variable &var) {
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
//gotoScreen(DGUS_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
gotoScreen(DGUS_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandler::loop() {
dgus.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!isScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
updateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, BOOTSCREEN_TIMEOUT)) {
booted = true;
gotoScreen(TERN0(POWER_LOSS_RECOVERY, recovery.valid()) ? DGUS_SCREEN_POWER_LOSS : DGUS_SCREEN_MAIN);
}
#endif
return isScreenComplete();
}
#endif // DGUS_LCD_UI_FYSETC
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 13,087
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSScreenHandlerBase.h"
typedef DGUSScreenHandler DGUSScreenHandlerClass;
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER DGUS_SCREEN_SDPRINTMANIPULATION
#define PLR_SCREEN_CANCEL DGUS_SCREEN_STATUS
#endif
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.h
|
C
|
agpl-3.0
| 1,114
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/* DGUS VPs changed by George Fu in 2019 for Marlin */
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_HIPRECY
#include "DGUSDisplayDef.h"
#include "../DGUSDisplay.h"
#include "../DGUSScreenHandler.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../ui_api.h"
#include "../../../marlinui.h"
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
uint16_t distanceToMove = 10;
#endif
const uint16_t VPList_Boot[] PROGMEM = {
VP_MARLIN_VERSION,
0x0000
};
const uint16_t VPList_Main[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded.
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set, VP_E0_STATUS,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS,
#endif
#if HAS_FAN
VP_Fan0_Percentage, VP_FAN0_STATUS,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
#if ENABLED(SET_PROGRESS_PERCENT)
VP_PrintProgress_Percentage,
#endif
0x0000
};
const uint16_t VPList_Temp[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_Status[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
#if HAS_FAN
VP_Fan0_Percentage,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
VP_PrintProgress_Percentage,
0x0000
};
const uint16_t VPList_Status2[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HAS_HOTEND
VP_Flowrate_E0,
#if HAS_MULTI_HOTEND
VP_Flowrate_E1,
#endif
#endif
VP_PrintProgress_Percentage,
VP_PrintTime,
0x0000
};
const uint16_t VPList_Preheat[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_ManualMove[] PROGMEM = {
VP_XPos, VP_YPos, VP_ZPos,
0x0000
};
const uint16_t VPList_ManualExtrude[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
VP_EPos,
0x0000
};
const uint16_t VPList_FanAndFeedrate[] PROGMEM = {
VP_Feedrate_Percentage, VP_Fan0_Percentage,
0x0000
};
const uint16_t VPList_SD_FlowRates[] PROGMEM = {
VP_Flowrate_E0, VP_Flowrate_E1,
0x0000
};
const uint16_t VPList_Filament_heating[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
VP_E0_FILAMENT_LOAD_UNLOAD,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
0x0000
};
const uint16_t VPList_Filament_load_unload[] PROGMEM = {
#if HAS_HOTEND
VP_E0_FILAMENT_LOAD_UNLOAD,
#if HAS_MULTI_HOTEND
VP_E1_FILAMENT_LOAD_UNLOAD,
#endif
#endif
0x0000
};
const uint16_t VPList_SDFileList[] PROGMEM = {
VP_SD_FileName0, VP_SD_FileName1, VP_SD_FileName2, VP_SD_FileName3, VP_SD_FileName4,
0x0000
};
const uint16_t VPList_SD_PrintManipulation[] PROGMEM = {
VP_PrintProgress_Percentage, VP_PrintTime,
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
#if HAS_FAN
VP_Fan0_Percentage,
#if FAN_COUNT > 1
VP_Fan1_Percentage,
#endif
#endif
VP_Flowrate_E0,
0x0000
};
const uint16_t VPList_SDPrintTune[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
VP_Feedrate_Percentage,
#if HAS_FAN
VP_Fan0_Percentage,
#endif
VP_Flowrate_E0,
VP_SD_Print_ProbeOffsetZ,
0x0000
};
const uint16_t VPList_StepPerMM[] PROGMEM = {
VP_X_STEP_PER_MM,
VP_Y_STEP_PER_MM,
VP_Z_STEP_PER_MM,
OPTITEM(HAS_HOTEND, VP_E0_STEP_PER_MM)
OPTITEM(HAS_MULTI_HOTEND, VP_E1_STEP_PER_MM)
0x0000
};
const uint16_t VPList_PIDE0[] PROGMEM = {
#if ENABLED(PIDTEMP)
VP_E0_PID_P, VP_E0_PID_I, VP_E0_PID_D,
#endif
0x0000
};
const uint16_t VPList_PIDBED[] PROGMEM = {
#if ENABLED(PIDTEMP)
VP_BED_PID_P,
VP_BED_PID_I,
VP_BED_PID_D,
#endif
0x0000
};
const uint16_t VPList_Infos[] PROGMEM = {
VP_MARLIN_VERSION,
VP_PrintTime,
#if ENABLED(PRINTCOUNTER)
VP_PrintAccTime,
VP_PrintsTotal,
#endif
0x0000
};
const uint16_t VPList_PIDTuningWaiting[] PROGMEM = {
VP_WAITING_STATUS,
0x0000
};
const uint16_t VPList_FLCPreheat[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_FLCPrinting[] PROGMEM = {
#if HAS_HOTEND
VP_SD_Print_ProbeOffsetZ,
#endif
0x0000
};
const uint16_t VPList_Z_Offset[] PROGMEM = {
#if HAS_HOTEND
VP_SD_Print_ProbeOffsetZ,
#endif
0x0000
};
const struct VPMapping VPMap[] PROGMEM = {
{ DGUS_SCREEN_BOOT, VPList_Boot },
{ DGUS_SCREEN_MAIN, VPList_Main },
{ DGUS_SCREEN_TEMPERATURE, VPList_Temp },
{ DGUS_SCREEN_STATUS, VPList_Status },
{ DGUS_SCREEN_STATUS2, VPList_Status2 },
{ DGUS_SCREEN_PREHEAT, VPList_Preheat },
{ DGUS_SCREEN_MANUALMOVE, VPList_ManualMove },
{ DGUS_SCREEN_Z_OFFSET, VPList_Z_Offset },
{ DGUS_SCREEN_MANUALEXTRUDE, VPList_ManualExtrude },
{ DGUS_SCREEN_FILAMENT_HEATING, VPList_Filament_heating },
{ DGUS_SCREEN_FILAMENT_LOADING, VPList_Filament_load_unload },
{ DGUS_SCREEN_FILAMENT_UNLOADING, VPList_Filament_load_unload },
{ DGUS_SCREEN_SDPRINTMANIPULATION, VPList_SD_PrintManipulation },
{ DGUS_SCREEN_SDFILELIST, VPList_SDFileList },
{ DGUS_SCREEN_SDPRINTTUNE, VPList_SDPrintTune },
{ DGUS_SCREEN_WAITING, VPList_PIDTuningWaiting },
{ DGUS_SCREEN_FLC_PREHEAT, VPList_FLCPreheat },
{ DGUS_SCREEN_FLC_PRINTING, VPList_FLCPrinting },
{ DGUS_SCREEN_STEPPERMM, VPList_StepPerMM },
{ DGUS_SCREEN_PID_E, VPList_PIDE0 },
{ DGUS_SCREEN_PID_BED, VPList_PIDBED },
{ DGUS_SCREEN_INFOS, VPList_Infos },
{ 0 , nullptr } // List is terminated with an nullptr as table entry.
};
const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION;
const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
// Helper to detect touch events
VPHELPER(VP_SCREENCHANGE, nullptr, screen.screenChangeHook, nullptr),
VPHELPER(VP_SCREENCHANGE_ASK, nullptr, screen.screenChangeHookIfIdle, nullptr),
#if HAS_MEDIA
VPHELPER(VP_SCREENCHANGE_WHENSD, nullptr, screen.screenChangeHookIfSD, nullptr),
#endif
VPHELPER(VP_CONFIRMED, nullptr, screen.screenConfirmedOK, nullptr),
VPHELPER(VP_TEMP_ALL_OFF, nullptr, screen.handleAllHeatersOff, nullptr),
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
VPHELPER(VP_MOVE_OPTION, &distanceToMove, screen.handleManualMoveOption, nullptr),
#endif
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
VPHELPER(VP_MOVE_X, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, &distanceToMove, screen.handleManualMove, nullptr),
#else
VPHELPER(VP_MOVE_X, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, nullptr, screen.handleManualMove, nullptr),
#endif
VPHELPER(VP_MOTOR_LOCK_UNLOK, nullptr, screen.handleMotorLockUnlock, nullptr),
#if ENABLED(POWER_LOSS_RECOVERY)
VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, screen.handlePowerLossRecovery, nullptr),
#endif
VPHELPER(VP_SETTINGS, nullptr, screen.handleSettings, nullptr),
#if ENABLED(SINGLE_Z_CALIBRATION)
VPHELPER(VP_Z_CALIBRATE, nullptr, screen.handleZCalibration, nullptr),
#endif
#if ENABLED(FIRST_LAYER_CAL)
VPHELPER(VP_Z_FIRST_LAYER_CAL, nullptr, screen.handleFirstLayerCal, nullptr),
#endif
{ .VP = VP_MARLIN_VERSION, .memadr = (void*)MarlinVersion, .size = VP_MARLIN_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
// M117 LCD String (We don't need the string in memory but "just" push it to the display on demand, hence the nullptr
{ .VP = VP_M117, .memadr = nullptr, .size = VP_M117_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay },
// Temperature Data
#if HAS_HOTEND
VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_EPos, &destination.e, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_MOVE_E0, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E0_CONTROL, &thermalManager.temp_hotend[0].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E0_STATUS, &thermalManager.temp_hotend[0].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(DGUS_PREHEAT_UI)
VPHELPER(VP_E0_BED_PREHEAT, nullptr, screen.handlePreheat, nullptr),
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_E0_FILAMENT_LOAD_UNLOAD, nullptr, screen.handleFilamentOption, screen.handleFilamentLoadUnload),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_E0_PID_P, &thermalManager.temp_hotend[0].pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_I, &thermalManager.temp_hotend[0].pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_D, &thermalManager.temp_hotend[0].pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_E0, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#endif
#if HAS_MULTI_HOTEND
VPHELPER(VP_T_E1_Is, &thermalManager.temp_hotend[1].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E1_Set, &thermalManager.temp_hotend[1].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E1, nullptr, screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_MOVE_E1, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E1_CONTROL, &thermalManager.temp_hotend[1].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E1_STATUS, &thermalManager.temp_hotend[1].target, nullptr, screen.sendHeaterStatusToDisplay),
#endif
#if HAS_HEATED_BED
VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, screen.sendWordValueToDisplay),
VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_BED_CONTROL, &thermalManager.temp_bed.target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_BED_STATUS, &thermalManager.temp_bed.target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(PIDTEMPBED)
VPHELPER(VP_BED_PID_P, &thermalManager.temp_bed.pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_I, &thermalManager.temp_bed.pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_D, &thermalManager.temp_bed.pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_BED, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#endif
// Fan Data
#if HAS_FAN
#define FAN_VPHELPER(N) \
VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], screen.percentageToUint8, screen.sendPercentageToDisplay), \
VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], screen.handleFanControl, nullptr), \
VPHELPER(VP_FAN##N##_STATUS, &thermalManager.fan_speed[N], nullptr, screen.sendFanStatusToDisplay),
REPEAT(FAN_COUNT, FAN_VPHELPER)
#endif
// Feedrate
VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, screen.setValueDirectly<int16_t>, screen.sendWordValueToDisplay),
// Position Data
VPHELPER(VP_XPos, ¤t_position.x, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_YPos, ¤t_position.y, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_ZPos, ¤t_position.z, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
// Print Progress
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, screen.sendPrintProgressToDisplay),
// Print Time
VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, screen.sendPrintTimeToDisplay),
#if ENABLED(PRINTCOUNTER)
VPHELPER_STR(VP_PrintAccTime, nullptr, VP_PrintAccTime_LEN, nullptr, screen.sendPrintAccTimeToDisplay),
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#endif
#endif
#endif
// SDCard File listing.
#if HAS_MEDIA
VPHELPER(VP_SD_ScrollEvent, nullptr, screen.sdScrollFilelist, nullptr),
VPHELPER(VP_SD_FileSelected, nullptr, screen.sdFileSelected, nullptr),
VPHELPER(VP_SD_FileSelectConfirm, nullptr, screen.sdStartPrint, nullptr),
VPHELPER_STR(VP_SD_FileName0, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName1, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName2, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName3, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName4, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER(VP_SD_ResumePauseAbort, nullptr, screen.sdResumePauseAbort, nullptr),
VPHELPER(VP_SD_AbortPrintConfirmed, nullptr, screen.sdReallyAbort, nullptr),
VPHELPER(VP_SD_Print_Setting, nullptr, screen.sdPrintTune, nullptr),
#if HAS_BED_PROBE
VPHELPER(VP_SD_Print_ProbeOffsetZ, &probe.offset.z, screen.handleProbeOffsetZChanged, screen.sendFloatAsIntValueToDisplay<2>),
#if ENABLED(BABYSTEPPING)
VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, screen.handleLiveAdjustZ, nullptr),
#endif
#endif
#endif
#if ENABLED(DGUS_UI_WAITING)
VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, screen.sendWaitingStatusToDisplay),
#endif
// Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
{ .VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
VPHELPER(0, 0, 0, 0) // must be last entry.
};
#endif // DGUS_LCD_UI_HIPRECY
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/hiprecy/DGUSDisplayDef.cpp
|
C++
|
agpl-3.0
| 17,833
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplayDef.h"
enum DGUS_ScreenID : uint8_t {
DGUS_SCREEN_BOOT = 160,
DGUS_SCREEN_MAIN = 1,
DGUS_SCREEN_STATUS = 1,
DGUS_SCREEN_STATUS2 = 1,
DGUS_SCREEN_POWER_LOSS = 17,
DGUS_SCREEN_TEMPERATURE = 40,
DGUS_SCREEN_MANUALMOVE = 86,
DGUS_SCREEN_PREHEAT = 48,
DGUS_SCREEN_UTILITY = 70,
DGUS_SCREEN_FILAMENT_HEATING = 80,
DGUS_SCREEN_FILAMENT_LOADING = 76,
DGUS_SCREEN_FILAMENT_UNLOADING = 82,
DGUS_SCREEN_MANUALEXTRUDE = 84,
DGUS_SCREEN_Z_OFFSET = 88,
DGUS_SCREEN_SDFILELIST = 3,
DGUS_SCREEN_SDPRINTMANIPULATION = 7,
DGUS_SCREEN_SDPRINTTUNE = 9,
DGUS_SCREEN_FLC_PREHEAT = 94,
DGUS_SCREEN_FLC_PRINTING = 96,
DGUS_SCREEN_STEPPERMM = 122,
DGUS_SCREEN_PID_E = 126,
DGUS_SCREEN_PID_BED = 128,
DGUS_SCREEN_INFOS = 131,
DGUS_SCREEN_CONFIRM = 240,
DGUS_SCREEN_KILL = 250, ///< Kill Screen. Must always be 250 (to be able to display "Error wrong LCD Version")
DGUS_SCREEN_WAITING = 251,
DGUS_SCREEN_POPUP = 252, ///< special target, popup screen will also return this code to say "return to previous screen"
DGUS_SCREEN_UNUSED = 255
};
// Display Memory layout used (T5UID)
// Except system variables this is arbitrary, just to organize stuff....
// 0x0000 .. 0x0FFF -- System variables and reserved by the display
// 0x1000 .. 0x1FFF -- Variables to never change location, regardless of UI Version
// 0x2000 .. 0x2FFF -- Controls (VPs that will trigger some action)
// 0x3000 .. 0x4FFF -- Marlin Data to be displayed
// 0x5000 .. -- SPs (if we want to modify display elements, e.g change color or like) -- currently unused
// As there is plenty of space (at least most displays have >8k RAM), we do not pack them too tight,
// so that we can keep variables nicely together in the address space.
// UI Version always on 0x1000...0x1002 so that the firmware can check this and bail out.
constexpr uint16_t VP_UI_VERSION_MAJOR = 0x1000; // Major -- incremented when incompatible
constexpr uint16_t VP_UI_VERSION_MINOR = 0x1001; // Minor -- incremented on new features, but compatible
constexpr uint16_t VP_UI_VERSION_PATCH = 0x1002; // Patch -- fixed which do not change functionality.
constexpr uint16_t VP_UI_FLAVOUR = 0x1010; // lets reserve 16 bytes here to determine if UI is suitable for this Marlin. tbd.
// Storage space for the Killscreen messages. 0x1100 - 0x1200 . Reused for the popup.
constexpr uint16_t VP_MSGSTR1 = 0x1100;
constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
constexpr uint16_t VP_MSGSTR2 = 0x1140;
constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
constexpr uint16_t VP_MSGSTR3 = 0x1180;
constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
constexpr uint16_t VP_MSGSTR4 = 0x11C0;
constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
// Screenchange request for screens that only make sense when printer is idle.
// e.g movement is only allowed if printer is not printing.
// Marlin must confirm by setting the screen manually.
constexpr uint16_t VP_SCREENCHANGE_ASK = 0x2000;
constexpr uint16_t VP_SCREENCHANGE = 0x2001; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
constexpr uint16_t VP_TEMP_ALL_OFF = 0x2002; // Turn all heaters off. Value arbitrary ;)=
constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x2003; // "Print" Button touched -- go only there if there is an SD Card.
constexpr uint16_t VP_CONFIRMED = 0x2010; // OK on confirm screen.
// Buttons on the SD-Card File listing.
constexpr uint16_t VP_SD_ScrollEvent = 0x2020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
constexpr uint16_t VP_SD_FileSelected = 0x2022; // Number of file field selected.
constexpr uint16_t VP_SD_FileSelectConfirm = 0x2024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
constexpr uint16_t VP_SD_ResumePauseAbort = 0x2026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x2028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
constexpr uint16_t VP_SD_Print_Setting = 0x2040;
constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x2050; // Data: 0 down, 1 up
// Controls for movement (we can't use the incremental / decremental feature of the display at this feature works only with 16 bit values
// (which would limit us to 655.35mm, which is likely not a problem for common setups, but i don't want to rule out hangprinters support)
// A word about the coding: The VP will be per axis and the return code will be an signed 16 bit value in 0.01 mm resolution, telling us
// the relative travel amount t he user wants to do. So eg. if the display sends us VP=2100 with value 100, the user wants us to move X by +1 mm.
constexpr uint16_t VP_MOVE_X = 0x2100;
constexpr uint16_t VP_MOVE_Y = 0x2102;
constexpr uint16_t VP_MOVE_Z = 0x2104;
constexpr uint16_t VP_MOVE_E0 = 0x2110;
constexpr uint16_t VP_MOVE_E1 = 0x2112;
//constexpr uint16_t VP_MOVE_E2 = 0x2114;
//constexpr uint16_t VP_MOVE_E3 = 0x2116;
//constexpr uint16_t VP_MOVE_E4 = 0x2118;
//constexpr uint16_t VP_MOVE_E5 = 0x211A;
constexpr uint16_t VP_HOME_ALL = 0x2120;
constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2130;
// Power loss recovery
constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x2180;
// Fan Control Buttons , switch between "off" and "on"
constexpr uint16_t VP_FAN0_CONTROL = 0x2200;
constexpr uint16_t VP_FAN1_CONTROL = 0x2202;
//constexpr uint16_t VP_FAN2_CONTROL = 0x2204;
//constexpr uint16_t VP_FAN3_CONTROL = 0x2206;
// Heater Control Buttons , triged between "cool down" and "heat PLA" state
constexpr uint16_t VP_E0_CONTROL = 0x2210;
constexpr uint16_t VP_E1_CONTROL = 0x2212;
//constexpr uint16_t VP_E2_CONTROL = 0x2214;
//constexpr uint16_t VP_E3_CONTROL = 0x2216;
//constexpr uint16_t VP_E4_CONTROL = 0x2218;
//constexpr uint16_t VP_E5_CONTROL = 0x221A;
constexpr uint16_t VP_BED_CONTROL = 0x221C;
// Preheat
constexpr uint16_t VP_E0_BED_PREHEAT = 0x2220;
//constexpr uint16_t VP_E1_BED_PREHEAT = 0x2222;
//constexpr uint16_t VP_E2_BED_PREHEAT = 0x2224;
//constexpr uint16_t VP_E3_BED_PREHEAT = 0x2226;
//constexpr uint16_t VP_E4_BED_PREHEAT = 0x2228;
//constexpr uint16_t VP_E5_BED_PREHEAT = 0x222A;
// Filament load and unload
constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2300;
// Settings store , reset
constexpr uint16_t VP_SETTINGS = 0x2400;
// PID autotune
constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x2410;
//constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x2412;
//constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x2414;
//constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x2416;
//constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x2418;
//constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x241A;
constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x2420;
// Calibrate Z
constexpr uint16_t VP_Z_CALIBRATE = 0x2430;
// First layer cal
constexpr uint16_t VP_Z_FIRST_LAYER_CAL = 0x2500; // Data: 0 - Cancel first layer cal progress, >0 filament type have loaded
// Firmware version on the boot screen.
constexpr uint16_t VP_MARLIN_VERSION = 0x3000;
constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
// Place for status messages.
constexpr uint16_t VP_M117 = 0x3020;
constexpr uint8_t VP_M117_LEN = 0x20;
// Temperatures.
constexpr uint16_t VP_T_E0_Is = 0x3060; // 4 Byte Integer
constexpr uint16_t VP_T_E0_Set = 0x3062; // 2 Byte Integer
constexpr uint16_t VP_T_E1_Is = 0x3064; // 4 Byte Integer
// reserved to support up to 6 Extruders:
//constexpr uint16_t VP_T_E1_Set = 0x3066; // 2 Byte Integer
//constexpr uint16_t VP_T_E2_Is = 0x3068; // 4 Byte Integer
//constexpr uint16_t VP_T_E2_Set = 0x306A; // 2 Byte Integer
//constexpr uint16_t VP_T_E3_Is = 0x306C; // 4 Byte Integer
//constexpr uint16_t VP_T_E3_Set = 0x306E; // 2 Byte Integer
//constexpr uint16_t VP_T_E4_Is = 0x3070; // 4 Byte Integer
//constexpr uint16_t VP_T_E4_Set = 0x3072; // 2 Byte Integer
//constexpr uint16_t VP_T_E4_Is = 0x3074; // 4 Byte Integer
//constexpr uint16_t VP_T_E4_Set = 0x3076; // 2 Byte Integer
//constexpr uint16_t VP_T_E5_Is = 0x3078; // 4 Byte Integer
//constexpr uint16_t VP_T_E5_Set = 0x307A; // 2 Byte Integer
constexpr uint16_t VP_T_Bed_Is = 0x3080; // 4 Byte Integer
constexpr uint16_t VP_T_Bed_Set = 0x3082; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E0 = 0x3090; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E1 = 0x3092; // 2 Byte Integer
// reserved for up to 6 Extruders:
//constexpr uint16_t VP_Flowrate_E2 = 0x3094;
//constexpr uint16_t VP_Flowrate_E3 = 0x3096;
//constexpr uint16_t VP_Flowrate_E4 = 0x3098;
//constexpr uint16_t VP_Flowrate_E5 = 0x309A;
constexpr uint16_t VP_Fan0_Percentage = 0x3100; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan1_Percentage = 0x3102; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan2_Percentage = 0x3104; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan3_Percentage = 0x3106; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Feedrate_Percentage = 0x3108; // 2 Byte Integer (0..100)
// Actual Position
constexpr uint16_t VP_XPos = 0x3110; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_YPos = 0x3112; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_ZPos = 0x3114; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_EPos = 0x3120; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_PrintProgress_Percentage = 0x3130; // 2 Byte Integer (0..100)
constexpr uint16_t VP_PrintTime = 0x3140;
constexpr uint16_t VP_PrintTime_LEN = 32;
constexpr uint16_t VP_PrintAccTime = 0x3160;
constexpr uint16_t VP_PrintAccTime_LEN = 32;
constexpr uint16_t VP_PrintsTotal = 0x3180;
constexpr uint16_t VP_PrintsTotal_LEN = 16;
// SDCard File Listing
constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
constexpr uint16_t DGUS_SD_FILESPERSCREEN = 5; // FIXME move that info to the display and read it from there.
constexpr uint16_t VP_SD_FileName0 = 0x3200;
constexpr uint16_t VP_SD_FileName1 = 0x3220;
constexpr uint16_t VP_SD_FileName2 = 0x3240;
constexpr uint16_t VP_SD_FileName3 = 0x3260;
constexpr uint16_t VP_SD_FileName4 = 0x3280;
constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0; //
constexpr uint16_t VP_SD_Print_Filename = 0x32C0; //
// Fan status
constexpr uint16_t VP_FAN0_STATUS = 0x3300;
constexpr uint16_t VP_FAN1_STATUS = 0x3302;
//constexpr uint16_t VP_FAN2_STATUS = 0x3304;
//constexpr uint16_t VP_FAN3_STATUS = 0x3306;
// Heater status
constexpr uint16_t VP_E0_STATUS = 0x3310;
//constexpr uint16_t VP_E1_STATUS = 0x3312;
//constexpr uint16_t VP_E2_STATUS = 0x3314;
//constexpr uint16_t VP_E3_STATUS = 0x3316;
//constexpr uint16_t VP_E4_STATUS = 0x3318;
//constexpr uint16_t VP_E5_STATUS = 0x331A;
constexpr uint16_t VP_BED_STATUS = 0x331C;
constexpr uint16_t VP_MOVE_OPTION = 0x3400;
// Step per mm
constexpr uint16_t VP_X_STEP_PER_MM = 0x3600; // at the moment , uint16_t , 0~1638.4
//constexpr uint16_t VP_X2_STEP_PER_MM = 0x3602;
constexpr uint16_t VP_Y_STEP_PER_MM = 0x3604;
//constexpr uint16_t VP_Y2_STEP_PER_MM = 0x3606;
constexpr uint16_t VP_Z_STEP_PER_MM = 0x3608;
//constexpr uint16_t VP_Z2_STEP_PER_MM = 0x360A;
constexpr uint16_t VP_E0_STEP_PER_MM = 0x3610;
//constexpr uint16_t VP_E1_STEP_PER_MM = 0x3612;
//constexpr uint16_t VP_E2_STEP_PER_MM = 0x3614;
//constexpr uint16_t VP_E3_STEP_PER_MM = 0x3616;
//constexpr uint16_t VP_E4_STEP_PER_MM = 0x3618;
//constexpr uint16_t VP_E5_STEP_PER_MM = 0x361A;
// PIDs
constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_E0_PID_I = 0x3702;
constexpr uint16_t VP_E0_PID_D = 0x3704;
constexpr uint16_t VP_BED_PID_P = 0x3710;
constexpr uint16_t VP_BED_PID_I = 0x3712;
constexpr uint16_t VP_BED_PID_D = 0x3714;
// Waiting screen status
constexpr uint16_t VP_WAITING_STATUS = 0x3800;
// SPs for certain variables...
// located at 0x5000 and up
// Not used yet!
// This can be used e.g to make controls / data display invisible
constexpr uint16_t SP_T_E0_Is = 0x5000;
constexpr uint16_t SP_T_E0_Set = 0x5010;
constexpr uint16_t SP_T_E1_Is = 0x5020;
constexpr uint16_t SP_T_Bed_Is = 0x5030;
constexpr uint16_t SP_T_Bed_Set = 0x5040;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/hiprecy/DGUSDisplayDef.h
|
C++
|
agpl-3.0
| 13,356
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_HIPRECY
#include "../DGUSScreenHandler.h"
#include "../../../../MarlinCore.h"
#include "../../../../gcode/queue.h"
#include "../../../../libs/duration_t.h"
#include "../../../../module/settings.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../../../module/printcounter.h"
#include "../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if HAS_MEDIA
extern ExtUI::FileList filelist;
void DGUSScreenHandler::sdFileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
forceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgus.writeVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
handleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::sdStartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
gotoScreen(DGUS_SCREEN_SDPRINTMANIPULATION);
}
void DGUSScreenHandler::sdResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: { // Resume
if (ExtUI::isPrintingFromMediaPaused()) {
ExtUI::resumePrint();
}
} break;
case 1: // Pause
gotoScreen(MKSLCD_SCREEN_PAUSE);
if (!ExtUI::isPrintingFromMediaPaused()) {
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
handleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::sdSendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
}
sendStringToDisplay(var);
}
void DGUSScreenHandler::sdCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUS_SCREEN_MAIN || cs == DGUS_SCREEN_STATUS)
gotoScreen(DGUS_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::sdCardRemoved() {
if (current_screenID == DGUS_SCREEN_SDFILELIST
|| (current_screenID == DGUS_SCREEN_CONFIRM && (confirmVP == VP_SD_AbortPrintConfirmed || confirmVP == VP_SD_FileSelectConfirm))
|| current_screenID == DGUS_SCREEN_SDPRINTMANIPULATION
) gotoScreen(DGUS_SCREEN_MAIN);
}
#endif // HAS_MEDIA
void DGUSScreenHandler::screenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUS_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUS_ScreenID target = (DGUS_ScreenID)tmp[1];
if (target == DGUS_SCREEN_POPUP) {
// Special handling for popup is to return to previous menu
if (current_screenID == DGUS_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
popToOldScreen();
return;
}
updateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!findScreenVPMapList(target)) DEBUG_ECHOLNPGM("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::handleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
uint16_t speed = manual_feedrate_mm_m.x; // Default feedrate for manual moves
switch (var.VP) {
default: return;
#if HAS_X_AXIS
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
#endif
#if HAS_Y_AXIS
case VP_MOVE_Y:
axiscode = 'Y';
speed = manual_feedrate_mm_m.y;
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
#endif
#if HAS_Z_AXIS
case VP_MOVE_Z:
axiscode = 'Z';
speed = manual_feedrate_mm_m.z;
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
#endif
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
char buf[6] = "G28 X";
buf[4] = axiscode;
queue.enqueue_one_now(buf);
forceCompleteUpdate();
return;
}
else {
// movement
const bool old_relative_mode = relative_mode;
if (!relative_mode) queue.enqueue_now(F("G91"));
char buf[32]; // G1 X9999.99 F12345
const uint16_t backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
queue.enqueue_one_now(buf);
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
}
//while (!enqueue_and_echo_command(buf)) idle();
if (!old_relative_mode) queue.enqueue_now(F("G90"));
}
forceCompleteUpdate();
cannotmove:
return;
}
#if HAS_PID_HEATING
void DGUSScreenHandler::handleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
float value = (float)rawvalue / 10;
float newvalue = 0;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
*(float *)var.memadr = newvalue;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::handleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
int16_t flag = swap16(*(uint16_t*)val_ptr),
steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
forceCompleteUpdate();
}
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::handleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) { // Load filament type
filament_data.action = 1;
}
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else { // Cancel filament operation
filament_data.action = 0;
}
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HAS_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#if HAS_MULTI_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
#endif
gotoScreen(DGUS_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
gotoScreen(DGUS_SCREEN_FILAMENT_HEATING);
}
}
void DGUSScreenHandler::handleFilamentLoadUnload(DGUS_VP_Variable &var) {
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
//gotoScreen(DGUS_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
gotoScreen(DGUS_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandler::loop() {
dgus.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!isScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
updateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, BOOTSCREEN_TIMEOUT)) {
booted = true;
gotoScreen(TERN0(POWER_LOSS_RECOVERY, recovery.valid()) ? DGUS_SCREEN_POWER_LOSS : DGUS_SCREEN_MAIN);
}
#endif
return isScreenComplete();
}
#endif // DGUS_LCD_UI_HIPRECY
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 13,105
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSScreenHandlerBase.h"
typedef DGUSScreenHandler DGUSScreenHandlerClass;
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER DGUS_SCREEN_SDPRINTMANIPULATION
#define PLR_SCREEN_CANCEL DGUS_SCREEN_STATUS
#endif
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.h
|
C
|
agpl-3.0
| 1,114
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_MKS
#include "DGUSDisplayDef.h"
#include "../DGUSDisplay.h"
#include "../DGUSScreenHandler.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../ui_api.h"
#include "../../../marlinui.h" // For material presets
#if HAS_STEALTHCHOP
#include "../../../../module/stepper/trinamic.h"
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
uint16_t distanceToMove = 10;
#endif
uint16_t manualMoveStep = 1;
uint16_t distanceFilament = 10;
uint16_t filamentSpeed_mm_s = 25;
float ZOffset_distance = 0.1;
float mesh_adj_distance = 0.01;
float Z_distance = 0.1;
//struct { uint16_t h, m, s; } dgus_time;
//
// Persistent settings
//
xy_int_t mks_corner_offsets[5]; // Initialized by settings.load()
xyz_int_t mks_park_pos; // Initialized by settings.load()
celsius_t mks_min_extrusion_temp; // Initialized by settings.load()
void MKS_reset_settings() {
constexpr xy_int_t init_dgus_level_offsets[5] = {
{ 20, 20 }, { 20, 20 },
{ 20, 20 }, { 20, 20 },
{ X_CENTER, Y_CENTER }
};
mks_language_index = MKS_SimpleChinese;
COPY(mks_corner_offsets, init_dgus_level_offsets);
mks_park_pos.set(20, 20, 10);
mks_min_extrusion_temp = 0;
}
xyz_pos_t position_before_pause;
constexpr feedRate_t park_speed_xy = TERN(NOZZLE_PARK_FEATURE, NOZZLE_PARK_XY_FEEDRATE, 100),
park_speed_z = TERN(NOZZLE_PARK_FEATURE, NOZZLE_PARK_Z_FEEDRATE, 5);
void MKS_pause_print_move() {
queue.exhaust();
position_before_pause = current_position;
// Save the current position, the raise amount, and 'already raised'
TERN_(POWER_LOSS_RECOVERY, if (recovery.enabled) recovery.save(true, mks_park_pos.z, true));
destination.z = _MIN(current_position.z + mks_park_pos.z, Z_MAX_POS);
prepare_internal_move_to_destination(park_speed_z);
destination.set(X_MIN_POS + mks_park_pos.x, Y_MIN_POS + mks_park_pos.y);
prepare_internal_move_to_destination(park_speed_xy);
}
void MKS_resume_print_move() {
destination.set(position_before_pause.x, position_before_pause.y);
prepare_internal_move_to_destination(park_speed_xy);
destination.z = position_before_pause.z;
prepare_internal_move_to_destination(park_speed_z);
TERN_(POWER_LOSS_RECOVERY, if (recovery.enabled) recovery.save(true));
}
float z_offset_add = 0;
xyz_int_t tmc_step; // = { 0, 0, 0 }
uint16_t lcd_default_light = 50;
EX_FILAMENT_DEF ex_filament;
RUNOUT_MKS_DEF runout_mks;
NOZZLE_PARK_DEF nozzle_park_mks;
const uint16_t VPList_Boot[] PROGMEM = {
VP_MARLIN_VERSION,
0x0000
};
#define MKSLIST_E_ITEM(N) VP_T_E##N##_Is, VP_T_E##N##_Set,
const uint16_t VPList_Main[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded.
#if HAS_HOTEND
MKSLIST_E_ITEM(0) VP_E0_STATUS,
#if HAS_MULTI_HOTEND
MKSLIST_E_ITEM(1) VP_E1_STATUS,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set, VP_BED_STATUS,
#endif
#if HAS_FAN
VP_Fan0_Percentage, VP_FAN0_STATUS,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
#if ENABLED(SET_PROGRESS_PERCENT)
VP_PrintProgress_Percentage,
#endif
0x0000
};
const uint16_t MKSList_Home[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Language
// VP_HOME_Dis,
0x0000
};
const uint16_t MKSList_Setting[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Language
VP_Setting_Dis,
0x0000
};
const uint16_t MKSList_Tool[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Language
VP_Tool_Dis,
// LCD BLK
VP_LCD_BLK,
0x0000
};
const uint16_t MKSList_EXTRUE[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
VP_Filament_distance,
VP_Filament_speed,
0x0000
};
const uint16_t MKSList_LEVEL[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
0x0000
};
const uint16_t MKSList_MOVE[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
0x0000
};
const uint16_t MKSList_Print[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Print Percent
VP_PrintProgress_Percentage,
VP_PrintTime,
VP_Flowrate_E0,
VP_Flowrate_E1,
VP_Feedrate_Percentage,
VP_PrintTime_H,
VP_PrintTime_M,
VP_PrintTime_S,
VP_XPos,
VP_YPos,
VP_ZPos,
0x0000
};
const uint16_t MKSList_SD_File[] PROGMEM = {
VP_SD_FileName0, VP_SD_FileName1,
VP_SD_FileName2, VP_SD_FileName3,
VP_SD_FileName4, VP_SD_FileName5,
VP_SD_FileName6, VP_SD_FileName7,
VP_SD_FileName8, VP_SD_FileName9,
0x0000
};
const uint16_t MKSList_TempOnly[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// LCD BLK
VP_LCD_BLK,
0x0000
};
const uint16_t MKSList_Pluse[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Pluse
VP_X_STEP_PER_MM,
VP_Y_STEP_PER_MM,
VP_Z_STEP_PER_MM,
VP_E0_STEP_PER_MM,
VP_E1_STEP_PER_MM,
0x0000
};
const uint16_t MKSList_MaxSpeed[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Pluse
VP_X_MAX_SPEED,
VP_Y_MAX_SPEED,
VP_Z_MAX_SPEED,
VP_E0_MAX_SPEED,
VP_E1_MAX_SPEED,
0x0000
};
const uint16_t MKSList_MaxAcc[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// ACC
VP_ACC_SPEED,
VP_X_ACC_MAX_SPEED,
VP_Y_ACC_MAX_SPEED,
VP_Z_ACC_MAX_SPEED,
VP_E0_ACC_MAX_SPEED,
VP_E1_ACC_MAX_SPEED,
0x0000
};
const uint16_t MKSList_PID[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// PID
VP_E0_PID_P,
VP_E0_PID_I,
VP_E0_PID_D,
0x0000
};
const uint16_t MKSList_Level_Point[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
// FAN
VP_Fan0_Percentage,
// Level Point
VP_Level_Point_One_X,
VP_Level_Point_One_Y,
VP_Level_Point_Two_X,
VP_Level_Point_Two_Y,
VP_Level_Point_Three_X,
VP_Level_Point_Three_Y,
VP_Level_Point_Four_X,
VP_Level_Point_Four_Y,
VP_Level_Point_Five_X,
VP_Level_Point_Five_Y,
0x0000
};
const uint16_t MKSList_Level_PrintConfig[] PROGMEM = {
VP_T_E0_Set,
VP_T_E1_Set,
VP_T_Bed_Set,
VP_Flowrate_E0,
VP_Flowrate_E1,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
0x0000
};
const uint16_t MKSList_PrintPauseConfig[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_X_PARK_POS,
VP_Y_PARK_POS,
VP_Z_PARK_POS,
0x0000
};
const uint16_t MKSList_MotoConfig[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_TRAVEL_SPEED,
VP_FEEDRATE_MIN_SPEED,
VP_T_F_SPEED,
0x0000
};
const uint16_t MKSList_EX_Config[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_MIN_EX_T,VP_Min_EX_T_E,
0x0000
};
const uint16_t MKSTMC_Config[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
// HB Temp
VP_T_Bed_Is, VP_T_Bed_Set,
VP_MIN_EX_T,
VP_TMC_X_STEP,
VP_TMC_Y_STEP,
VP_TMC_Z_STEP,
VP_TMC_X1_Current,
VP_TMC_Y1_Current,
VP_TMC_X_Current,
VP_TMC_Y_Current,
VP_TMC_Z_Current,
VP_TMC_E0_Current,
VP_TMC_E1_Current,
VP_TMC_Z1_Current,
0x0000
};
const uint16_t MKSAuto_Level[] PROGMEM = {
VP_MESH_LEVEL_POINT_DIS,
VP_ZPos,
0x0000
};
const uint16_t MKSOffset_Config[] PROGMEM = {
// E Temp
REPEAT(EXTRUDERS, MKSLIST_E_ITEM)
VP_OFFSET_X,
VP_OFFSET_Y,
VP_OFFSET_Z,
0x0000
};
const uint16_t MKSBabyStep[] PROGMEM = {
VP_ZOffset_DE_DIS,
0x0000
};
const uint16_t MKSList_About[] PROGMEM = {
// Marlin version
VP_MARLIN_VERSION,
// H43 Version
VP_MKS_H43_VERSION,
VP_MKS_H43_UpdataVERSION,
0x0000
};
// Page data updata
const struct VPMapping VPMap[] PROGMEM = {
{ MKSLCD_SCREEN_BOOT, VPList_Boot }, // Boot Page to show logo 0
{ MKSLCD_SCREEN_HOME, MKSList_Home }, // Home, Page 1
{ MKSLCD_SCREEN_SETTING, MKSList_Setting }, // Setting, Page 2
{ MKSLCD_SCREEM_TOOL, MKSList_Tool }, // Page 3
{ MKSLCD_SCREEN_EXTRUDE_P1, MKSList_EXTRUE }, // Page 4
{ MKSLCD_SCREEN_EXTRUDE_P2, MKSList_EXTRUE }, // Page 11
{ MKSLCD_PAUSE_SETTING_EX, MKSList_EXTRUE }, // Page 57
{ MKSLCD_PAUSE_SETTING_EX2, MKSList_EXTRUE }, // Page 61
{ MKSLCD_SCREEN_LEVEL, MKSList_LEVEL }, // Page 5
{ MKSLCD_SCREEN_MOVE, MKSList_MOVE }, // Page 6
{ MKSLCD_SCREEN_PRINT, MKSList_Print }, // Page 7
{ MKSLCD_SCREEN_PAUSE, MKSList_Print }, // Page 26
{ MKSLCD_SCREEN_CHOOSE_FILE, MKSList_SD_File }, // Page 15
{ MKSLCD_SCREEN_MOTOR_PLUSE, MKSList_Pluse }, // Page 51
{ MKSLCD_SCREEN_MOTOR_SPEED, MKSList_MaxSpeed }, // Page 55
{ MKSLCD_SCREEN_MOTOR_ACC_MAX, MKSList_MaxAcc }, // Page 53
{ MKSLCD_SCREEN_LEVEL_DATA, MKSList_Level_Point }, // Page 48
{ MKSLCD_PrintPause_SET, MKSList_PrintPauseConfig }, // Page 49
{ MKSLCD_FILAMENT_DATA, MKSList_SD_File }, // Page 50
{ MKSLCD_SCREEN_Config, MKSList_TempOnly }, // Page 46
{ MKSLCD_SCREEN_Config_MOTOR, MKSList_MotoConfig }, // Page 47
{ MKSLCD_PID, MKSList_PID }, // Page 56
{ MKSLCD_ABOUT, MKSList_About }, // Page 36
{ MKSLCD_SCREEN_PRINT_CONFIG, MKSList_Level_PrintConfig }, // Page 60
{ MKSLCD_SCREEN_EX_CONFIG, MKSList_EX_Config }, // Page 65
{ MKSLCD_SCREEN_TMC_Config, MKSTMC_Config }, // Page 70
{ MKSLCD_AUTO_LEVEL, MKSAuto_Level }, // Page 73
{ MKSLCD_Screen_Offset_Config, MKSOffset_Config }, // Page 30
{ MKSLCD_Screen_PMove, MKSList_MOVE }, // Page 64
{ MKSLCD_Screen_Baby, MKSBabyStep }, // Page 71
//{ MKSLCD_SCREEN_LEVEL_DATA, MKSList_SD_File},
//{ MKSLCD_SCREEN_HOME, VPList_Boot },
{ 0, nullptr } // List is terminated with an nullptr as table entry.
};
const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION;
const char H43Version[] PROGMEM = "MKS H43_V1.30";
const char Updata_Time[] PROGMEM = STRING_DISTRIBUTION_DATE;
const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
// Helper to detect touch events
VPHELPER(VP_SCREENCHANGE, nullptr, screen.screenChangeHook, nullptr),
VPHELPER(VP_SCREENCHANGE_ASK, nullptr, screen.screenChangeHookIfIdle, nullptr),
#if HAS_MEDIA
VPHELPER(VP_SCREENCHANGE_WHENSD, nullptr, screen.screenChangeHookIfSD, nullptr),
#endif
VPHELPER(VP_CONFIRMED, nullptr, screen.screenConfirmedOK, nullptr),
// Back Button
VPHELPER(VP_BACK_PAGE, nullptr, screen.screenBackChange, nullptr),
VPHELPER(VP_TEMP_ALL_OFF, nullptr, screen.handleAllHeatersOff, nullptr),
VPHELPER(VP_MOVE_X, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_X_HOME, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_Y_HOME, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_Z_HOME, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_DISTANCE, &manualMoveStep, screen.getManualMovestep, nullptr),
VPHELPER(VP_MOTOR_LOCK_UNLOK, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_LEVEL_POINT, nullptr, screen.manualAssistLeveling, nullptr),
#if ENABLED(POWER_LOSS_RECOVERY)
VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, screen.handlePowerLossRecovery, nullptr),
#endif
VPHELPER(VP_SETTINGS, nullptr, screen.handleSettings, nullptr),
#if ENABLED(SINGLE_Z_CALIBRATION)
VPHELPER(VP_Z_CALIBRATE, nullptr, screen.handleZCalibration, nullptr),
#endif
#if ENABLED(FIRST_LAYER_CAL)
VPHELPER(VP_Z_FIRST_LAYER_CAL, nullptr, screen.handleFirstLayerCal, nullptr),
#endif
{.VP = VP_MARLIN_VERSION, .memadr = (void *)MarlinVersion, .size = VP_MARLIN_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
// M117 LCD String (We don't need the string in memory but "just" push it to the display on demand, hence the nullptr
{.VP = VP_M117, .memadr = nullptr, .size = VP_M117_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay},
{.VP = VP_MKS_H43_VERSION, .memadr = (void *)H43Version, .size = VP_MKS_H43_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
{.VP = VP_MKS_H43_UpdataVERSION, .memadr = (void *)Updata_Time, .size = VP_MKS_H43_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
// Temperature Data
#if HAS_HOTEND
VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E0, &planner.flow_percentage[ExtUI::extruder_t::E0], screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_EPos, &destination.e, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_MOVE_E0, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E0_CONTROL, &thermalManager.temp_hotend[0].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E0_STATUS, &thermalManager.temp_hotend[0].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(DGUS_PREHEAT_UI)
VPHELPER(VP_E0_BED_PREHEAT, nullptr, screen.handlePreheat, nullptr),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_E0_PID_P, &thermalManager.temp_hotend[0].pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_I, &thermalManager.temp_hotend[0].pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_D, &thermalManager.temp_hotend[0].pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_E0, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_LOAD_Filament, nullptr, screen.filamentLoad, nullptr),
VPHELPER(VP_UNLOAD_Filament, nullptr, screen.filamentUnload, nullptr),
VPHELPER(VP_Filament_distance, &distanceFilament, screen.getManualFilament, screen.sendWordValueToDisplay),
VPHELPER(VP_Filament_speed, &filamentSpeed_mm_s, screen.getManualFilamentSpeed, screen.sendWordValueToDisplay),
#endif
#endif
#if HAS_MULTI_HOTEND
VPHELPER(VP_T_E1_Is, &thermalManager.temp_hotend[1].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E1_Set, &thermalManager.temp_hotend[1].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E1, &planner.flow_percentage[ExtUI::extruder_t::E1], screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_MOVE_E1, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E1_CONTROL, &thermalManager.temp_hotend[1].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E1_STATUS, &thermalManager.temp_hotend[1].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_Filament_distance, &distanceFilament, screen.getManualFilament, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Filament_speed, &filamentSpeed_mm_s, screen.getManualFilamentSpeed, screen.sendWordValueToDisplay),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_PID_AUTOTUNE_E1, nullptr, screen.handlePIDAutotune, nullptr),
#endif
VPHELPER(VP_E1_FILAMENT_LOAD_UNLOAD, nullptr, screen.handleFilamentOption, screen.handleFilamentLoadUnload),
#endif
#if HAS_HEATED_BED
VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_BED_CONTROL, &thermalManager.temp_bed.target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_BED_STATUS, &thermalManager.temp_bed.target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(PIDTEMPBED)
VPHELPER(VP_BED_PID_P, &thermalManager.temp_bed.pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_I, &thermalManager.temp_bed.pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_D, &thermalManager.temp_bed.pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_BED, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#endif
// Fan Data
#if HAS_FAN
#define FAN_VPHELPER(N) \
VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], screen.setUint8, screen.sendFanToDisplay), \
VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], screen.handleFanControl, nullptr), \
VPHELPER(VP_FAN##N##_STATUS, &thermalManager.fan_speed[N], nullptr, screen.sendFanStatusToDisplay),
REPEAT(FAN_COUNT, FAN_VPHELPER)
#endif
// Feedrate
VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, screen.setValueDirectly<int16_t>, screen.sendWordValueToDisplay),
// Position Data
VPHELPER(VP_XPos, ¤t_position.x, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_YPos, ¤t_position.y, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_ZPos, ¤t_position.z, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
// Level Point Set
VPHELPER(VP_Level_Point_One_X, &mks_corner_offsets[0].x, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_One_Y, &mks_corner_offsets[0].y, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_X, &mks_corner_offsets[1].x, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Two_Y, &mks_corner_offsets[1].y, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_X, &mks_corner_offsets[2].x, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Three_Y, &mks_corner_offsets[2].y, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_X, &mks_corner_offsets[3].x, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Four_Y, &mks_corner_offsets[3].y, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_X, &mks_corner_offsets[4].x, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
VPHELPER(VP_Level_Point_Five_Y, &mks_corner_offsets[4].y, screen.handleChangeLevelPoint, screen.sendWordValueToDisplay),
// Print Progress
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, screen.sendPrintProgressToDisplay),
// LCD Control
VPHELPER(VP_LCD_BLK, &lcd_default_light, screen.lcdBLKAdjust, screen.sendWordValueToDisplay),
// SD File - Back
VPHELPER(VP_SD_FileSelect_Back, nullptr, screen.sdFileBack, nullptr),
// Print Time
VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, screen.sendPrintTimeToDisplay),
#if ENABLED(PRINTCOUNTER)
VPHELPER_STR(VP_PrintAccTime, nullptr, VP_PrintAccTime_LEN, nullptr, screen.sendPrintAccTimeToDisplay),
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<0>),
#endif
VPHELPER(VP_X_MAX_SPEED, &planner.settings.max_feedrate_mm_s[X_AXIS], screen.handleMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Y_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Y_AXIS], screen.handleMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_Z_MAX_SPEED, &planner.settings.max_feedrate_mm_s[Z_AXIS], screen.handleMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
#if HAS_HOTEND
VPHELPER(VP_E0_MAX_SPEED, &planner.settings.max_feedrate_mm_s[E_AXIS_N(0)], screen.handleExtruderMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_MAX_SPEED, &planner.settings.max_feedrate_mm_s[E_AXIS_N(1)], screen.handleExtruderMaxSpeedChange, screen.sendFloatAsIntValueToDisplay<0>),
#endif
#endif
VPHELPER(VP_X_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[X_AXIS], screen.handleMaxAccChange, screen.sendWordValueToDisplay),
VPHELPER(VP_Y_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[Y_AXIS], screen.handleMaxAccChange, screen.sendWordValueToDisplay),
VPHELPER(VP_Z_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[Z_AXIS], screen.handleMaxAccChange, screen.sendWordValueToDisplay),
#if HAS_HOTEND
VPHELPER(VP_E0_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(0)], screen.handleExtruderAccChange, screen.sendWordValueToDisplay),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_ACC_MAX_SPEED, (uint16_t *)&planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(1)], screen.handleExtruderAccChange, screen.sendWordValueToDisplay),
#endif
#endif
VPHELPER(VP_TRAVEL_SPEED, (uint16_t *)&planner.settings.travel_acceleration, screen.handleTravelAccChange, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_FEEDRATE_MIN_SPEED, (uint16_t *)&planner.settings.min_feedrate_mm_s, screen.handleFeedRateMinChange, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_T_F_SPEED, (uint16_t *)&planner.settings.min_travel_feedrate_mm_s, screen.handleMin_T_F, screen.sendFloatAsIntValueToDisplay<0>),
VPHELPER(VP_ACC_SPEED, (uint16_t *)&planner.settings.acceleration, screen.handleAccChange, screen.sendWordValueToDisplay),
VPHELPER(VP_X_PARK_POS, &mks_park_pos.x, screen.getParkPos, screen.sendWordValueToDisplay),
VPHELPER(VP_Y_PARK_POS, &mks_park_pos.y, screen.getParkPos, screen.sendWordValueToDisplay),
VPHELPER(VP_Z_PARK_POS, &mks_park_pos.z, screen.getParkPos, screen.sendWordValueToDisplay),
#if ENABLED(PREVENT_COLD_EXTRUSION)
VPHELPER(VP_MIN_EX_T, &thermalManager.extrude_min_temp, screen.handleGetExMinTemp, screen.sendWordValueToDisplay),
#endif
#if ENABLED(SENSORLESS_HOMING) // TMC SENSORLESS Setting
#if X_HAS_STEALTHCHOP
VPHELPER(VP_TMC_X_STEP, &tmc_step.x, screen.tmcChangeConfig, screen.sendTMCStepValue),
#endif
#if Y_HAS_STEALTHCHOP
VPHELPER(VP_TMC_Y_STEP, &tmc_step.y, screen.tmcChangeConfig, screen.sendTMCStepValue),
#endif
#if Z_HAS_STEALTHCHOP
VPHELPER(VP_TMC_Z_STEP, &tmc_step.z, screen.tmcChangeConfig, screen.sendTMCStepValue),
#endif
#endif
#if HAS_TRINAMIC_CONFIG // TMC Current Setting
#if AXIS_IS_TMC(X)
VPHELPER(VP_TMC_X_Current, &stepperX.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Y)
VPHELPER(VP_TMC_Y_Current, &stepperY.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Z)
VPHELPER(VP_TMC_Z_Current, &stepperZ.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(E0)
VPHELPER(VP_TMC_E0_Current, &stepperE0.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(E1)
VPHELPER(VP_TMC_E1_Current, &stepperE1.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(X2)
VPHELPER(VP_TMC_X1_Current, &stepperX2.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Y2)
VPHELPER(VP_TMC_Y1_Current, &stepperY2.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#if AXIS_IS_TMC(Z2)
VPHELPER(VP_TMC_Z1_Current, &stepperZ2.val_mA, screen.tmcChangeConfig, screen.sendWordValueToDisplay),
#endif
#endif
VPHELPER(VP_EEPROM_CTRL, nullptr, screen.eepromControl, nullptr),
VPHELPER(VP_LEVEL_BUTTON, nullptr, screen.levelControl, nullptr),
VPHELPER(VP_LANGUAGE_CHANGE, nullptr, screen.languageChange, nullptr),
//VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, screen.handleLiveAdjustZ, nullptr),
VPHELPER(VP_SD_Print_LiveAdjustZ_Confirm, nullptr, screen.zOffsetConfirm, nullptr),
VPHELPER(VP_ZOffset_Distance,nullptr ,screen.getZoffsetDistance, nullptr),
VPHELPER(VP_MESH_LEVEL_ADJUST, nullptr, screen.meshLevelDistanceConfig, nullptr),
VPHELPER(VP_MESH_LEVEL_POINT,nullptr, screen.meshLevel, nullptr),
#if ENABLED(PREVENT_COLD_EXTRUSION)
VPHELPER(VP_Min_EX_T_E, &thermalManager.extrude_min_temp, screen.getMinExtrudeTemp, screen.sendWordValueToDisplay),
#endif
VPHELPER(VP_AutoTurnOffSw, nullptr, screen.getTurnOffCtrl, nullptr),
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<0>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<0>),
#endif
#endif
#endif
// SDCard File listing
#if HAS_MEDIA
VPHELPER(VP_SD_FileSelected, nullptr, screen.sdFileSelected, nullptr),
VPHELPER(VP_SD_ScrollEvent, nullptr, screen.sdScrollFilelist, nullptr),
VPHELPER(VP_SD_FileSelectConfirm, nullptr, screen.sdStartPrint, nullptr),
VPHELPER_STR(VP_SD_FileName0, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName1, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName2, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName3, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName4, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName5, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName6, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName7, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName8, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName9, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER(VP_SD_ResumePauseAbort, nullptr, screen.sdResumePauseAbort, nullptr),
VPHELPER(VP_SD_AbortPrintConfirmed, nullptr, screen.sdReallyAbort, nullptr),
VPHELPER(VP_SD_Print_Setting, nullptr, screen.sdPrintTune, nullptr),
#if ENABLED(BABYSTEPPING)
VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, screen.handleLiveAdjustZ, screen.sendFloatAsIntValueToDisplay<2>),
VPHELPER(VP_ZOffset_DE_DIS, &z_offset_add, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
#endif
#if HAS_BED_PROBE
VPHELPER(VP_OFFSET_X, &probe.offset.x, screen.getOffsetValue,screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_OFFSET_Y, &probe.offset.y, screen.getOffsetValue,screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_OFFSET_Z, &probe.offset.z, screen.getOffsetValue,screen.sendFloatAsLongValueToDisplay<2>),
#endif
#else
VPHELPER(VP_SD_FileSelected, nullptr, screen.printReturn, nullptr),
#endif
#if ENABLED(DGUS_UI_WAITING)
VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, screen.sendWaitingStatusToDisplay),
#endif
// Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
//{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
//{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
//{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
//{.VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM},
{.VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay_Language},
{.VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay_Language},
{.VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay_Language},
{.VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay_Language},
VPHELPER(0, 0, 0, 0) // must be last entry.
};
#endif // DGUS_LCD_UI_MKS
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/mks/DGUSDisplayDef.cpp
|
C++
|
agpl-3.0
| 31,670
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplayDef.h"
//#define DGUS_MKS_RUNOUT_SENSOR
#define LOGO_TIME_DELAY TERN(USE_MKS_GREEN_UI, 8000, 1500)
#if ENABLED(DGUS_MKS_RUNOUT_SENSOR)
#define MT_DET_1_PIN 1
#define MT_DET_2_PIN 2
#define MT_DET_PIN_STATE LOW
#endif
#define MKS_FINSH
extern uint16_t manualMoveStep;
extern uint16_t distanceFilament;
extern uint16_t filamentSpeed_mm_s;
extern float ZOffset_distance;
extern float mesh_adj_distance;
extern float Z_distance;
//extern struct { uint16_t h, m, s; } dgus_time;
extern xy_int_t mks_corner_offsets[5];
extern xyz_int_t mks_park_pos;
extern celsius_t mks_min_extrusion_temp;
void MKS_reset_settings(); // Restore persistent settings to defaults
void MKS_pause_print_move();
void MKS_resume_print_move();
extern float z_offset_add;
extern xyz_int_t tmc_step;
extern uint16_t lcd_default_light;
#if X_HAS_STEALTHCHOP
extern uint16_t tmc_x_current;
#endif
#if Y_HAS_STEALTHCHOP
extern uint16_t tmc_y_current;
#endif
#if Z_HAS_STEALTHCHOP
extern uint16_t tmc_z_current;
#endif
#if E0_HAS_STEALTHCHOP
extern uint16_t tmc_e0_current;
#endif
#if E1_HAS_STEALTHCHOP
extern uint16_t tmc_e1_current;
#endif
typedef enum {
EX_HEATING,
EX_HEAT_STARUS,
EX_CHANGING,
EX_CHANGE_STATUS,
EX_NONE,
} EX_STATUS_DEF;
typedef struct {
//uint8_t ex_change_flag:1;
//uint8_t ex_heat_flag:1;
uint8_t ex_load_unload_flag:1; //0:unload 1:load
EX_STATUS_DEF ex_status;
uint32_t ex_tick_start;
uint32_t ex_tick_end;
uint32_t ex_speed;
uint32_t ex_length;
uint32_t ex_need_time;
} EX_FILAMENT_DEF;
extern EX_FILAMENT_DEF ex_filament;
typedef enum {
UNRUNOUT_STATUS,
RUNOUT_STATUS,
RUNOUT_WAITING_STATUS,
RUNOUT_BEGIN_STATUS,
} RUNOUT_MKS_STATUS_DEF;
typedef struct {
RUNOUT_MKS_STATUS_DEF runout_status;
uint8_t pin_status;
uint8_t de_count;
uint8_t de_times;
} RUNOUT_MKS_DEF;
extern RUNOUT_MKS_DEF runout_mks;
typedef struct {
uint8_t print_pause_start_flag:1;
uint8_t runout_flag:1;
bool blstatus;
uint16_t x_pos;
uint16_t y_pos;
uint16_t z_pos;
} NOZZLE_PARK_DEF;
extern NOZZLE_PARK_DEF nozzle_park_mks;
enum DGUS_ScreenID : uint8_t {
#if ENABLED(USE_MKS_GREEN_UI)
DGUS_SCREEN_BOOT = 33,
DGUS_SCREEN_MAIN = 60,
DGUS_SCREEN_STATUS = 60,
DGUS_SCREEN_STATUS2 = 60,
DGUS_SCREEN_PREHEAT = 18,
DGUS_SCREEN_POWER_LOSS = 100,
DGUS_SCREEN_MANUALMOVE = 192,
DGUS_SCREEN_UTILITY = 120,
DGUS_SCREEN_FILAMENT_UNLOADING = 158,
DGUS_SCREEN_SDFILELIST = 15,
DGUS_SCREEN_SDPRINTMANIPULATION = 15,
DGUS_SCREEN_SDPRINTTUNE = 17,
MKSLCD_SCREEN_BOOT = 33,
MKSLCD_SCREEN_HOME = 60, // MKS main page
MKSLCD_SCREEN_SETTING = 62, // MKS Setting page / no wifi whit
MKSLCD_SCREEM_TOOL = 64, // MKS Tool page
MKSLCD_SCREEN_EXTRUDE_P1 = 75,
MKSLCD_SCREEN_EXTRUDE_P2 = 77,
MKSLCD_SCREEN_LEVEL = 73,
MKSLCD_AUTO_LEVEL = 81,
MKSLCD_SCREEN_MOVE = 66,
MKSLCD_SCREEN_PRINT = 68,
MKSLCD_SCREEN_PAUSE = 70,
MKSLCD_SCREEN_CHOOSE_FILE = 87,
MKSLCD_SCREEN_NO_CHOOSE_FILE = 88,
MKSLCD_SCREEN_Config = 101,
MKSLCD_SCREEN_Config_MOTOR = 103,
MKSLCD_SCREEN_MOTOR_PLUSE = 104,
MKSLCD_SCREEN_MOTOR_SPEED = 102,
MKSLCD_SCREEN_MOTOR_ACC_MAX = 105,
MKSLCD_SCREEN_PRINT_CONFIG = 72,
MKSLCD_SCREEN_LEVEL_DATA = 106,
MKSLCD_PrintPause_SET = 107,
MKSLCD_FILAMENT_DATA = 50,
MKSLCD_ABOUT = 83,
MKSLCD_PID = 108,
MKSLCD_PAUSE_SETTING_MOVE = 98,
MKSLCD_PAUSE_SETTING_EX = 96,
MKSLCD_PAUSE_SETTING_EX2 = 97,
MKSLCD_SCREEN_PRINT_CONFIRM = 94,
MKSLCD_SCREEN_EX_CONFIG = 112,
MKSLCD_SCREEN_EEP_Config = 89,
MKSLCD_SCREEN_PrintDone = 92,
MKSLCD_SCREEN_TMC_Config = 111,
MKSLCD_Screen_Offset_Config = 109,
MKSLCD_Screen_PMove = 98,
MKSLCD_Screen_Baby = 79,
#else
DGUS_SCREEN_BOOT = 120,
DGUS_SCREEN_MAIN = 1,
DGUS_SCREEN_STATUS = 1,
DGUS_SCREEN_STATUS2 = 1,
DGUS_SCREEN_PREHEAT = 18,
DGUS_SCREEN_POWER_LOSS = 100,
DGUS_SCREEN_MANUALMOVE = 192,
DGUS_SCREEN_UTILITY = 120,
DGUS_SCREEN_FILAMENT_UNLOADING = 158,
DGUS_SCREEN_SDFILELIST = 15,
DGUS_SCREEN_SDPRINTMANIPULATION = 15,
DGUS_SCREEN_SDPRINTTUNE = 17,
MKSLCD_SCREEN_BOOT = 0,
MKSLCD_SCREEN_HOME = 1, // MKS main page
MKSLCD_SCREEN_SETTING = 2, // MKS Setting page / no wifi whit
MKSLCD_SCREEM_TOOL = 3, // MKS Tool page
MKSLCD_SCREEN_EXTRUDE_P1 = 4,
MKSLCD_SCREEN_EXTRUDE_P2 = 11,
MKSLCD_SCREEN_LEVEL = 5,
MKSLCD_AUTO_LEVEL = 73,
MKSLCD_SCREEN_LEVEL_PRESS = 9,
MKSLCD_SCREEN_MOVE = 6,
MKSLCD_SCREEN_PRINT = 7,
MKSLCD_SCREEN_PRINT_PRESS = 13,
MKSLCD_SCREEN_PAUSE = 26,
MKSLCD_SCREEN_PAUSE_PRESS = 26,
MKSLCD_SCREEN_CHOOSE_FILE = 15,
MKSLCD_SCREEN_NO_CHOOSE_FILE = 17,
MKSLCD_SCREEN_Config = 46,
MKSLCD_SCREEN_Config_MOTOR = 47,
MKSLCD_SCREEN_MOTOR_PLUSE = 51,
MKSLCD_SCREEN_MOTOR_SPEED = 55,
MKSLCD_SCREEN_MOTOR_ACC_MAX = 53,
MKSLCD_SCREEN_PRINT_CONFIG = 60,
MKSLCD_SCREEN_LEVEL_DATA = 48,
MKSLCD_PrintPause_SET = 49,
MKSLCD_FILAMENT_DATA = 50,
MKSLCD_ABOUT = 36,
MKSLCD_PID = 56,
MKSLCD_PAUSE_SETTING_MOVE = 58,
MKSLCD_PAUSE_SETTING_EX = 57,
MKSLCD_PAUSE_SETTING_EX2 = 61,
MKSLCD_SCREEN_NO_FILE = 42,
MKSLCD_SCREEN_PRINT_CONFIRM = 43,
MKSLCD_SCREEN_EX_CONFIG = 65,
MKSLCD_SCREEN_EEP_Config = 20,
MKSLCD_SCREEN_PrintDone = 25,
MKSLCD_SCREEN_TMC_Config = 70,
MKSLCD_Screen_Offset_Config = 30,
MKSLCD_Screen_PMove = 64,
MKSLCD_Screen_Baby = 71,
#endif
DGUS_SCREEN_CONFIRM = 240,
DGUS_SCREEN_KILL = 250, ///< Kill Screen. Must always be 250 (to be able to display "Error wrong LCD Version")
DGUS_SCREEN_WAITING = 251,
DGUS_SCREEN_POPUP = 252, ///< special target, popup screen will also return this code to say "return to previous screen"
DGUS_SCREEN_UNUSED = 255
};
// Place for status messages.
constexpr uint16_t VP_M117 = 0x7020;
constexpr uint8_t VP_M117_LEN = 0x20;
// Heater status
constexpr uint16_t VP_E0_STATUS = 0x3410;
constexpr uint16_t VP_E1_STATUS = 0x3412;
//constexpr uint16_t VP_E2_STATUS = 0x3414;
//constexpr uint16_t VP_E3_STATUS = 0x3416;
//constexpr uint16_t VP_E4_STATUS = 0x3418;
//constexpr uint16_t VP_E5_STATUS = 0x341A;
constexpr uint16_t VP_MOVE_OPTION = 0x3500;
// // PIDs
// constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , uint16_t , 0~1638.4
// constexpr uint16_t VP_E0_PID_I = 0x3702;
// constexpr uint16_t VP_E0_PID_D = 0x3704;
// constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , uint16_t , 0~1638.4
// constexpr uint16_t VP_E1_PID_I = 0x3708;
// constexpr uint16_t VP_E1_PID_D = 0x370A;
// constexpr uint16_t VP_BED_PID_P = 0x3710;
// constexpr uint16_t VP_BED_PID_I = 0x3712;
// constexpr uint16_t VP_BED_PID_D = 0x3714;
// Waiting screen status
constexpr uint16_t VP_WAITING_STATUS = 0x3800;
// SPs for certain variables...
// located at 0x5000 and up
// Not used yet!
// This can be used e.g to make controls / data display invisible
constexpr uint16_t SP_T_E0_Is = 0x5000;
constexpr uint16_t SP_T_E0_Set = 0x5010;
constexpr uint16_t SP_T_E1_Is = 0x5020;
constexpr uint16_t SP_T_Bed_Is = 0x5030;
constexpr uint16_t SP_T_Bed_Set = 0x5040;
/*************************************************************************************************************************
*************************************************************************************************************************
* DGUS for MKS Mem layout
************************************************************************************************************************
************************************************************************************************************************/
#if ENABLED(MKS_FINSH)
/* -------------------------------0x1000-0x1FFF------------------------------- */
constexpr uint16_t VP_MSGSTR1 = 0x1100;
constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
constexpr uint16_t VP_MSGSTR2 = 0x1140;
constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
constexpr uint16_t VP_MSGSTR3 = 0x1180;
constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
constexpr uint16_t VP_MSGSTR4 = 0x11C0;
constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
constexpr uint16_t VP_MARLIN_VERSION = 0x1A00;
constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
constexpr uint16_t VP_SCREENCHANGE_ASK = 0x1500;
constexpr uint16_t VP_SCREENCHANGE = 0x1501; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
constexpr uint16_t VP_TEMP_ALL_OFF = 0x1502; // Turn all heaters off. Value arbitrary ;)=
constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x1503; // "Print" Button touched -- go only there if there is an SD Card.
constexpr uint16_t VP_CONFIRMED = 0x1510; // OK on confirm screen.
constexpr uint16_t VP_BACK_PAGE = 0x1600;
constexpr uint16_t VP_SETTINGS = 0x1620;
// Power loss recovery
constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x1680;
/* -------------------------------0x2000-0x2FFF------------------------------- */
// Temperatures.
constexpr uint16_t VP_T_E0_Is = 0x2000; // 4 Byte Integer
constexpr uint16_t VP_T_E0_Set = 0x2004; // 2 Byte Integer
constexpr uint16_t VP_T_E1_Is = 0x2008; // 4 Byte Integer
constexpr uint16_t VP_T_E1_Set = 0x200B; // 2 Byte Integer
constexpr uint16_t VP_T_E2_Is = 0x2010; // 4 Byte Integer
constexpr uint16_t VP_T_E2_Set = 0x2014; // 2 Byte Integer
constexpr uint16_t VP_T_E3_Is = 0x2018; // 4 Byte Integer
constexpr uint16_t VP_T_E3_Set = 0x201B; // 2 Byte Integer
constexpr uint16_t VP_T_E4_Is = 0x2020; // 4 Byte Integer
constexpr uint16_t VP_T_E4_Set = 0x2024; // 2 Byte Integer
constexpr uint16_t VP_T_E5_Is = 0x2028; // 4 Byte Integer
constexpr uint16_t VP_T_E5_Set = 0x202B; // 2 Byte Integer
constexpr uint16_t VP_T_E6_Is = 0x2030; // 4 Byte Integer
constexpr uint16_t VP_T_E6_Set = 0x2034; // 2 Byte Integer
constexpr uint16_t VP_T_E7_Is = 0x2038; // 4 Byte Integer
constexpr uint16_t VP_T_E7_Set = 0x203B; // 2 Byte Integer
constexpr uint16_t VP_T_Bed_Is = 0x2040; // 4 Byte Integer
constexpr uint16_t VP_T_Bed_Set = 0x2044; // 2 Byte Integer
constexpr uint16_t VP_Min_EX_T_E = 0x2100;
constexpr uint16_t VP_Flowrate_E0 = 0x2200; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E1 = 0x2202; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E2 = 0x2204;
constexpr uint16_t VP_Flowrate_E3 = 0x2206;
constexpr uint16_t VP_Flowrate_E4 = 0x2208;
constexpr uint16_t VP_Flowrate_E5 = 0x220A;
constexpr uint16_t VP_Flowrate_E6 = 0x220C;
constexpr uint16_t VP_Flowrate_E7 = 0x220E;
// Move
constexpr uint16_t VP_MOVE_X = 0x2300;
constexpr uint16_t VP_MOVE_Y = 0x2302;
constexpr uint16_t VP_MOVE_Z = 0x2304;
constexpr uint16_t VP_MOVE_E0 = 0x2310;
constexpr uint16_t VP_MOVE_E1 = 0x2312;
constexpr uint16_t VP_MOVE_E2 = 0x2314;
constexpr uint16_t VP_MOVE_E3 = 0x2316;
constexpr uint16_t VP_MOVE_E4 = 0x2318;
constexpr uint16_t VP_MOVE_E5 = 0x231A;
constexpr uint16_t VP_MOVE_E6 = 0x231C;
constexpr uint16_t VP_MOVE_E7 = 0x231E;
constexpr uint16_t VP_HOME_ALL = 0x2320;
constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2330;
constexpr uint16_t VP_MOVE_DISTANCE = 0x2334;
constexpr uint16_t VP_X_HOME = 0x2336;
constexpr uint16_t VP_Y_HOME = 0x2338;
constexpr uint16_t VP_Z_HOME = 0x233A;
// Fan Control Buttons , switch between "off" and "on"
constexpr uint16_t VP_FAN0_CONTROL = 0x2350;
constexpr uint16_t VP_FAN1_CONTROL = 0x2352;
constexpr uint16_t VP_FAN2_CONTROL = 0x2354;
constexpr uint16_t VP_FAN3_CONTROL = 0x2356;
constexpr uint16_t VP_FAN4_CONTROL = 0x2358;
constexpr uint16_t VP_FAN5_CONTROL = 0x235A;
constexpr uint16_t VP_LANGUAGE_CHANGE = 0x2380;
constexpr uint16_t VP_LANGUAGE_CHANGE1 = 0x2382;
constexpr uint16_t VP_LANGUAGE_CHANGE2 = 0x2384;
constexpr uint16_t VP_LANGUAGE_CHANGE3 = 0x2386;
constexpr uint16_t VP_LANGUAGE_CHANGE4 = 0x2388;
constexpr uint16_t VP_LANGUAGE_CHANGE5 = 0x238A;
// LEVEL
constexpr uint16_t VP_LEVEL_POINT = 0x2400;
constexpr uint16_t VP_MESH_LEVEL_POINT = 0x2410;
constexpr uint16_t VP_MESH_LEVEL_ADJUST = 0x2412;
constexpr uint16_t VP_MESH_LEVEL_DIP = 0x2414;
constexpr uint16_t VP_MESH_LEVEL_POINT_X = 0x2416;
constexpr uint16_t VP_MESH_LEVEL_POINT_Y = 0x2418;
constexpr uint16_t VP_LEVEL_BUTTON = 0x2420;
constexpr uint16_t VP_MESH_LEVEL_POINT_DIS = 0x2422;
constexpr uint16_t VP_MESH_LEVEL_BACK = 0x2424;
constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2500;
constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2504;
constexpr uint16_t VP_LOAD_Filament = 0x2508;
// constexpr uint16_t VP_LOAD_UNLOAD_Cancle = 0x250A;
constexpr uint16_t VP_UNLOAD_Filament = 0x250B;
constexpr uint16_t VP_Filament_distance = 0x2600;
constexpr uint16_t VP_Filament_speed = 0x2604;
constexpr uint16_t VP_MIN_EX_T = 0x2606;
constexpr uint16_t VP_E1_Filament_distance = 0x2614;
constexpr uint16_t VP_E1_Filament_speed = 0x2616;
constexpr uint16_t VP_E1_MIN_EX_T = 0x2618;
constexpr uint16_t VP_Fan0_Percentage = 0x2700; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan1_Percentage = 0x2702; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan2_Percentage = 0x2704; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan3_Percentage = 0x2706; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Feedrate_Percentage = 0x2708; // 2 Byte Integer (0..100)
// Fan status
constexpr uint16_t VP_FAN0_STATUS = 0x2710;
constexpr uint16_t VP_FAN1_STATUS = 0x2712;
constexpr uint16_t VP_FAN2_STATUS = 0x2714;
constexpr uint16_t VP_FAN3_STATUS = 0x2716;
// Step per mm
constexpr uint16_t VP_X_STEP_PER_MM = 0x2900; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_Y_STEP_PER_MM = 0x2904;
constexpr uint16_t VP_Z_STEP_PER_MM = 0x2908;
constexpr uint16_t VP_E0_STEP_PER_MM = 0x2910;
constexpr uint16_t VP_E1_STEP_PER_MM = 0x2912;
constexpr uint16_t VP_E2_STEP_PER_MM = 0x2914;
constexpr uint16_t VP_E3_STEP_PER_MM = 0x2916;
constexpr uint16_t VP_E4_STEP_PER_MM = 0x2918;
constexpr uint16_t VP_E5_STEP_PER_MM = 0x291A;
constexpr uint16_t VP_E6_STEP_PER_MM = 0x291C;
constexpr uint16_t VP_E7_STEP_PER_MM = 0x291E;
constexpr uint16_t VP_X_MAX_SPEED = 0x2A00;
constexpr uint16_t VP_Y_MAX_SPEED = 0x2A04;
constexpr uint16_t VP_Z_MAX_SPEED = 0x2A08;
constexpr uint16_t VP_E0_MAX_SPEED = 0x2A0C;
constexpr uint16_t VP_E1_MAX_SPEED = 0x2A10;
constexpr uint16_t VP_X_ACC_MAX_SPEED = 0x2A28;
constexpr uint16_t VP_Y_ACC_MAX_SPEED = 0x2A2C;
constexpr uint16_t VP_Z_ACC_MAX_SPEED = 0x2A30;
constexpr uint16_t VP_E0_ACC_MAX_SPEED = 0x2A34;
constexpr uint16_t VP_E1_ACC_MAX_SPEED = 0x2A38;
constexpr uint16_t VP_TRAVEL_SPEED = 0x2A3C;
constexpr uint16_t VP_FEEDRATE_MIN_SPEED = 0x2A40;
constexpr uint16_t VP_T_F_SPEED = 0x2A44;
constexpr uint16_t VP_ACC_SPEED = 0x2A48;
/* -------------------------------0x3000-0x3FFF------------------------------- */
// Buttons on the SD-Card File listing.
constexpr uint16_t VP_SD_ScrollEvent = 0x3020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
constexpr uint16_t VP_SD_FileSelected = 0x3022; // Number of file field selected.
constexpr uint16_t VP_SD_FileSelectConfirm = 0x3024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
constexpr uint16_t VP_SD_ResumePauseAbort = 0x3026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x3028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
constexpr uint16_t VP_SD_Print_Setting = 0x3040;
constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x3050; // Data: 0 down, 1 up
constexpr uint16_t VP_SD_Print_LiveAdjustZ_Confirm = 0x3060;
constexpr uint16_t VP_ZOffset_Distance = 0x3070;
constexpr uint16_t VP_ZOffset_DE_DIS = 0x3080;
constexpr uint16_t VP_SD_FileSelect_Back = 0x3082;
// SDCard File Listing
constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
constexpr uint16_t DGUS_SD_FILESPERSCREEN = 10; // FIXME move that info to the display and read it from there.
constexpr uint16_t VP_SD_FileName0 = 0x3100;
constexpr uint16_t VP_SD_FileName1 = 0x3120;
constexpr uint16_t VP_SD_FileName2 = 0x3140;
constexpr uint16_t VP_SD_FileName3 = 0x3160;
constexpr uint16_t VP_SD_FileName4 = 0x3180;
constexpr uint16_t VP_SD_FileName5 = 0x31A0;
constexpr uint16_t VP_SD_FileName6 = 0x31C0;
constexpr uint16_t VP_SD_FileName7 = 0x31E0;
constexpr uint16_t VP_SD_FileName8 = 0x3200;
constexpr uint16_t VP_SD_FileName9 = 0x3220;
constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0;
constexpr uint16_t VP_SD_Print_Baby = 0x32B0;
constexpr uint16_t VP_SD_Print_Filename = 0x32C0;
// X Y Z Point
constexpr uint16_t VP_XPos = 0x3300; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_YPos = 0x3302; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_ZPos = 0x3304; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_EPos = 0x3306; // 4 Byte Fixed point number; format xxx.yy
// Print
constexpr uint16_t VP_PrintProgress_Percentage = 0x3330; // 2 Byte Integer (0..100)
constexpr uint16_t VP_PrintTime = 0x3340;
constexpr uint16_t VP_PrintTime_LEN = 32;
constexpr uint16_t VP_PrintAccTime = 0x3360;
constexpr uint16_t VP_PrintAccTime_LEN = 32;
constexpr uint16_t VP_PrintsTotal = 0x3380;
constexpr uint16_t VP_PrintsTotal_LEN = 16;
constexpr uint16_t VP_File_Pictutr0 = 0x3400;
constexpr uint16_t VP_File_Pictutr1 = 0x3402;
constexpr uint16_t VP_File_Pictutr2 = 0x3404;
constexpr uint16_t VP_File_Pictutr3 = 0x3406;
constexpr uint16_t VP_File_Pictutr4 = 0x3408;
constexpr uint16_t VP_File_Pictutr5 = 0x340A;
constexpr uint16_t VP_File_Pictutr6 = 0x340C;
constexpr uint16_t VP_File_Pictutr7 = 0x340E;
constexpr uint16_t VP_File_Pictutr8 = 0x3410;
constexpr uint16_t VP_File_Pictutr9 = 0x3412;
constexpr uint16_t VP_BED_STATUS = 0x341C;
constexpr uint16_t VP_TMC_X_STEP = 0x3430;
constexpr uint16_t VP_TMC_Y_STEP = 0x3432;
constexpr uint16_t VP_TMC_Z_STEP = 0x3434;
constexpr uint16_t VP_TMC_X1_Current = 0x3436;
constexpr uint16_t VP_TMC_Y1_Current = 0x3438;
constexpr uint16_t VP_TMC_X_Current = 0x343A;
constexpr uint16_t VP_TMC_Y_Current = 0x343C;
constexpr uint16_t VP_TMC_Z_Current = 0x343E;
constexpr uint16_t VP_TMC_E0_Current = 0x3440;
constexpr uint16_t VP_TMC_E1_Current = 0x3442;
constexpr uint16_t VP_TMC_Z1_Current = 0x3444;
constexpr uint16_t VP_PrintTime_H = 0x3500;
constexpr uint16_t VP_PrintTime_M = 0x3502;
constexpr uint16_t VP_PrintTime_S = 0x3504;
// PIDs
constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_E0_PID_I = 0x3702;
constexpr uint16_t VP_E0_PID_D = 0x3704;
constexpr uint16_t VP_E1_PID_P = 0x3706; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_E1_PID_I = 0x3708;
constexpr uint16_t VP_E1_PID_D = 0x370A;
constexpr uint16_t VP_BED_PID_P = 0x3710;
constexpr uint16_t VP_BED_PID_I = 0x3712;
constexpr uint16_t VP_BED_PID_D = 0x3714;
constexpr uint16_t VP_EEPROM_CTRL = 0x3720;
constexpr uint16_t VP_OFFSET_X = 0x3724;
constexpr uint16_t VP_OFFSET_Y = 0x3728;
constexpr uint16_t VP_OFFSET_Z = 0x372B;
// PID autotune
constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x3800;
constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x3802;
constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x3804;
constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x3806;
constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x3808;
constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x380A;
constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x380C;
// Calibrate Z
constexpr uint16_t VP_Z_CALIBRATE = 0x3810;
constexpr uint16_t VP_AutoTurnOffSw = 0x3812;
constexpr uint16_t VP_LCD_BLK = 0x3814;
constexpr uint16_t VP_X_PARK_POS = 0x3900;
constexpr uint16_t VP_Y_PARK_POS = 0x3902;
constexpr uint16_t VP_Z_PARK_POS = 0x3904;
/* -------------------------------0x4000-0x4FFF------------------------------- */
// Heater Control Buttons , triged between "cool down" and "heat PLA" state
constexpr uint16_t VP_E0_CONTROL = 0x4010;
constexpr uint16_t VP_E1_CONTROL = 0x4012;
//constexpr uint16_t VP_E2_CONTROL = 0x2214;
//constexpr uint16_t VP_E3_CONTROL = 0x2216;
//constexpr uint16_t VP_E4_CONTROL = 0x2218;
//constexpr uint16_t VP_E5_CONTROL = 0x221A;
constexpr uint16_t VP_BED_CONTROL = 0x401C;
// Preheat
constexpr uint16_t VP_E0_BED_PREHEAT = 0x4020;
constexpr uint16_t VP_E1_BED_PREHEAT = 0x4022;
//constexpr uint16_t VP_E2_BED_PREHEAT = 0x4024;
//constexpr uint16_t VP_E3_BED_PREHEAT = 0x4026;
//constexpr uint16_t VP_E4_BED_PREHEAT = 0x4028;
//constexpr uint16_t VP_E5_BED_PREHEAT = 0x402A;
// Filament load and unload
// constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x4030;
// constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x4032;
// Settings store , reset
// Level data
constexpr uint16_t VP_Level_Point_One_X = 0x4100;
constexpr uint16_t VP_Level_Point_One_Y = 0x4102;
constexpr uint16_t VP_Level_Point_Two_X = 0x4104;
constexpr uint16_t VP_Level_Point_Two_Y = 0x4106;
constexpr uint16_t VP_Level_Point_Three_X = 0x4108;
constexpr uint16_t VP_Level_Point_Three_Y = 0x410A;
constexpr uint16_t VP_Level_Point_Four_X = 0x410C;
constexpr uint16_t VP_Level_Point_Four_Y = 0x410E;
constexpr uint16_t VP_Level_Point_Five_X = 0x4110;
constexpr uint16_t VP_Level_Point_Five_Y = 0x4112;
/* H43 Version */
constexpr uint16_t VP_MKS_H43_VERSION = 0x4A00; // MKS H43 V1.0.0
constexpr uint16_t VP_MKS_H43_VERSION_LEN = 16;
constexpr uint16_t VP_MKS_H43_UpdataVERSION = 0x4A10; // MKS H43 V1.0.0
constexpr uint16_t VP_MKS_H43_UpdataVERSION_LEN = 16;
/* -------------------------------0x5000-0xFFFF------------------------------- */
constexpr uint16_t VP_HOME_Dis = 0x5000;
constexpr uint16_t VP_Setting_Dis = 0x5010;
constexpr uint16_t VP_Tool_Dis = 0x5020;
constexpr uint16_t VP_Printing_Dis = 0x5030;
constexpr uint16_t VP_Language_Dis = 0x5080;
constexpr uint16_t VP_LossPoint_Dis = 0x5090;
constexpr uint16_t VP_PrintPauseConfig_Dis = 0x5120;
constexpr uint16_t VP_MotorPluse_Dis = 0x5140;
constexpr uint16_t VP_MotorMaxSpeed_Dis = 0x5150;
constexpr uint16_t VP_MotorMaxAcc_Dis = 0x5160;
constexpr uint16_t VP_X_Pluse_Dis = 0x5170;
constexpr uint16_t VP_Y_Pluse_Dis = 0x5180;
constexpr uint16_t VP_Z_Pluse_Dis = 0x5190;
constexpr uint16_t VP_E0_Pluse_Dis = 0x51A0;
constexpr uint16_t VP_E1_Pluse_Dis = 0x51B0;
constexpr uint16_t VP_X_Max_Speed_Dis = 0x5280;
constexpr uint16_t VP_Y_Max_Speed_Dis = 0x5290;
constexpr uint16_t VP_Z_Max_Speed_Dis = 0x52A0;
constexpr uint16_t VP_E0_Max_Speed_Dis = 0x52B0;
constexpr uint16_t VP_E1_Max_Speed_Dis = 0x52C0;
constexpr uint16_t VP_X_Max_Acc_Speed_Dis = 0x51E0;
constexpr uint16_t VP_Y_Max_Acc_Speed_Dis = 0x51F0;
constexpr uint16_t VP_Z_Max_Acc_Speed_Dis = 0x5200;
constexpr uint16_t VP_E0_Max_Acc_Speed_Dis = 0x5210;
constexpr uint16_t VP_E1_Max_Acc_Speed_Dis = 0x5220;
constexpr uint16_t VP_PrintTime_Dis = 0x5470;
constexpr uint16_t VP_E0_Temp_Dis = 0x5310;
constexpr uint16_t VP_E1_Temp_Dis = 0x5320;
constexpr uint16_t VP_HB_Temp_Dis = 0x5330;
constexpr uint16_t VP_Feedrate_Dis = 0x5350;
constexpr uint16_t VP_PrintAcc_Dis = 0x5340;
constexpr uint16_t VP_Fan_Speed_Dis = 0x5360;
constexpr uint16_t VP_Min_Ex_Temp_Dis = 0x5380;
constexpr uint16_t VP_X_PARK_POS_Dis = 0x53E0;
constexpr uint16_t VP_Y_PARK_POS_Dis = 0x53F0;
constexpr uint16_t VP_Z_PARK_POS_Dis = 0x5400;
constexpr uint16_t VP_TravelAcc_Dis = 0x5440;
constexpr uint16_t VP_FeedRateMin_Dis = 0x5450;
constexpr uint16_t VP_TravelFeeRateMin_Dis = 0x5460;
constexpr uint16_t VP_ACC_Dis = 0x5480;
constexpr uint16_t VP_Extrusion_Dis = 0x5230;
constexpr uint16_t VP_HeatBed_Dis = 0x5240;
constexpr uint16_t VP_Printting_Dis = 0x5430;
constexpr uint16_t VP_FactoryDefaults_Dis = 0x54C0;
constexpr uint16_t VP_StoreSetting_Dis = 0x54B0;
constexpr uint16_t VP_Info_EEPROM_2_Dis = 0x54D0;
constexpr uint16_t VP_Info_EEPROM_1_Dis = 0x54E0;
constexpr uint16_t VP_AutoLevel_1_Dis = 0x55F0;
constexpr uint16_t VP_TMC_X_Step_Dis = 0x5530;
constexpr uint16_t VP_TMC_Y_Step_Dis = 0x5540;
constexpr uint16_t VP_TMC_Z_Step_Dis = 0x5550;
constexpr uint16_t VP_TMC_X1_Current_Dis = 0x5560;
constexpr uint16_t VP_TMC_Y1_Current_Dis = 0x5570;
constexpr uint16_t VP_TMC_X_Current_Dis = 0x5580;
constexpr uint16_t VP_TMC_Y_Current_Dis = 0x5590;
constexpr uint16_t VP_TMC_Z_Current_Dis = 0x55A0;
constexpr uint16_t VP_TMC_E0_Current_Dis = 0x55B0;
constexpr uint16_t VP_TMC_E1_Current_Dis = 0x55C0;
constexpr uint16_t VP_TMC_Z1_Current_Dis = 0x55E0;
constexpr uint16_t VP_AutoLEVEL_INFO1 = 0x5600;
constexpr uint16_t VP_EX_TEMP_INFO1_Dis = 0x5610;
constexpr uint16_t VP_EX_TEMP_INFO2_Dis = 0x5620;
constexpr uint16_t VP_EX_TEMP_INFO3_Dis = 0x5630;
constexpr uint16_t VP_LCD_BLK_Dis = 0x56A0;
constexpr uint16_t VP_Info_PrintFinish_1_Dis = 0x5C00;
constexpr uint16_t VP_Info_PrintFinish_2_Dis = 0x5C10;
constexpr uint16_t VP_Length_Dis = 0x5B00;
constexpr uint16_t VP_PrintConfrim_Info_Dis = 0x5B90;
constexpr uint16_t VP_StopPrintConfrim_Info_Dis = 0x5B80;
constexpr uint16_t VP_Point_One_Dis = 0x5BA0;
constexpr uint16_t VP_Point_Two_Dis = 0x5BB0;
constexpr uint16_t VP_Point_Three_Dis = 0x5BC0;
constexpr uint16_t VP_Point_Four_Dis = 0x5BD0;
constexpr uint16_t VP_Point_Five_Dis = 0x5BE0;
constexpr uint16_t VP_Print_Dis = 0x5250;
constexpr uint16_t VP_About_Dis = 0x5A00;
constexpr uint16_t VP_Config_Dis = 0x5A10;
constexpr uint16_t VP_Filament_Dis = 0x5A20;
constexpr uint16_t VP_Move_Dis = 0x5A30;
constexpr uint16_t VP_Level_Dis = 0x5A50;
constexpr uint16_t VP_Speed_Dis = 0x5A70;
constexpr uint16_t VP_InOut_Dis = 0x5A80;
constexpr uint16_t VP_MotorConfig_Dis = 0x5100;
constexpr uint16_t VP_LevelConfig_Dis = 0x5110;
constexpr uint16_t VP_Advance_Dis = 0x5130;
constexpr uint16_t VP_TemperatureConfig_Dis = 0x5390;
#endif // MKS_FINSH
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/mks/DGUSDisplayDef.h
|
C++
|
agpl-3.0
| 33,215
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_MKS
#include "../DGUSScreenHandler.h"
#include "../../../../inc/MarlinConfig.h"
#include "../../../../MarlinCore.h"
#include "../../../../module/settings.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../../../module/printcounter.h"
#include "../../../../gcode/gcode.h"
#if HAS_STEALTHCHOP
#include "../../../../module/stepper/trinamic.h"
#include "../../../../module/stepper/indirection.h"
#endif
#include "../../../../module/probe.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if HAS_MEDIA
extern ExtUI::FileList filelist;
#endif
bool DGUSAutoTurnOff = false;
MKS_Language mks_language_index; // Initialized by settings.load()
#if 0
void DGUSScreenHandlerMKS::sendinfoscreen_ch(const uint16_t *line1, const uint16_t *line2, const uint16_t *line3, const uint16_t *line4) {
dgus.writeVariable(VP_MSGSTR1, line1, 32, true);
dgus.writeVariable(VP_MSGSTR2, line2, 32, true);
dgus.writeVariable(VP_MSGSTR3, line3, 32, true);
dgus.writeVariable(VP_MSGSTR4, line4, 32, true);
}
void DGUSScreenHandlerMKS::sendinfoscreen_en(PGM_P const line1, PGM_P const line2, PGM_P const line3, PGM_P const line4) {
dgus.writeVariable(VP_MSGSTR1, line1, 32, true);
dgus.writeVariable(VP_MSGSTR2, line2, 32, true);
dgus.writeVariable(VP_MSGSTR3, line3, 32, true);
dgus.writeVariable(VP_MSGSTR4, line4, 32, true);
}
void DGUSScreenHandlerMKS::sendInfoScreen(const void *line1, const void *line2, const void *line3, const void *line4, uint16_t language) {
if (language == MKS_English)
DGUSScreenHandlerMKS::sendinfoscreen_en((char *)line1, (char *)line2, (char *)line3, (char *)line4);
else if (language == MKS_SimpleChinese)
DGUSScreenHandlerMKS::sendinfoscreen_ch((uint16_t *)line1, (uint16_t *)line2, (uint16_t *)line3, (uint16_t *)line4);
}
#endif
void DGUSScreenHandlerMKS::sendFanToDisplay(DGUS_VP_Variable &var) {
if (var.memadr) {
uint16_t tmp = *(uint8_t *) var.memadr; // +1 -> avoid rounding issues for the display.
// tmp = map(tmp, 0, 255, 0, 100);
dgus.writeVariable(var.VP, tmp);
}
}
void DGUSScreenHandlerMKS::sendBabyStepToDisplay(DGUS_VP_Variable &var) {
float value = current_position.z;
value *= cpow(10, 2);
dgus.writeVariable(VP_SD_Print_Baby, (uint16_t)value);
}
void DGUSScreenHandlerMKS::sendPrintTimeToDisplay(DGUS_VP_Variable &var) {
duration_t elapsed = print_job_timer.duration();
uint32_t time = elapsed.value;
dgus.writeVariable(VP_PrintTime_H, uint16_t(time / 3600));
dgus.writeVariable(VP_PrintTime_M, uint16_t(time % 3600 / 60));
dgus.writeVariable(VP_PrintTime_S, uint16_t((time % 3600) % 60));
}
void DGUSScreenHandlerMKS::setUint8(DGUS_VP_Variable &var, void *val_ptr) {
if (var.memadr) {
const uint16_t value = BE16_P(val_ptr);
*(uint8_t*)var.memadr = map(constrain(value, 0, 255), 0, 255, 0, 255);
}
}
void DGUSScreenHandlerMKS::sendGbkToDisplay(DGUS_VP_Variable &var) {
uint16_t *tmp = (uint16_t*) var.memadr;
dgus.writeVariable(var.VP, tmp, var.size, true);
}
void DGUSScreenHandlerMKS::sendStringToDisplay_Language(DGUS_VP_Variable &var) {
if (mks_language_index == MKS_English) {
char *tmp = (char*) var.memadr;
dgus.writeVariable(var.VP, tmp, var.size, true);
}
else if (mks_language_index == MKS_SimpleChinese) {
uint16_t *tmp = (uint16_t *)var.memadr;
dgus.writeVariable(var.VP, tmp, var.size, true);
}
}
void DGUSScreenHandlerMKS::sendTMCStepValue(DGUS_VP_Variable &var) {
#if ENABLED(SENSORLESS_HOMING)
#if X_HAS_STEALTHCHOP
tmc_step.x = stepperX.homing_threshold();
dgus.writeVariable(var.VP, *(int16_t*)var.memadr);
#endif
#if Y_HAS_STEALTHCHOP
tmc_step.y = stepperY.homing_threshold();
dgus.writeVariable(var.VP, *(int16_t*)var.memadr);
#endif
#if Z_HAS_STEALTHCHOP
tmc_step.z = stepperZ.homing_threshold();
dgus.writeVariable(var.VP, *(int16_t*)var.memadr);
#endif
#endif
}
#if HAS_MEDIA
void DGUSScreenHandler::sdFileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)BE16_P(val_ptr) + top_file;
if (touched_nr != 0x0F && touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr) && touched_nr != 0x0F) return;
if (touched_nr == 0x0F) {
if (filelist.isAtRootDir())
gotoScreen(DGUS_SCREEN_MAIN);
else
filelist.upDir();
return;
}
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
forceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgus.writeVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
gotoScreen(MKSLCD_SCREEN_PRINT_CONFIRM);
}
void DGUSScreenHandler::sdStartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
gotoScreen(MKSLCD_SCREEN_PRINT);
z_offset_add = 0;
}
void DGUSScreenHandler::sdResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (BE16_P(val_ptr)) {
case 0: { // Resume
auto cs = getCurrentScreen();
if (runout_mks.runout_status != RUNOUT_WAITING_STATUS && runout_mks.runout_status != UNRUNOUT_STATUS) {
if (cs == MKSLCD_SCREEN_PRINT || cs == MKSLCD_SCREEN_PAUSE)
gotoScreen(MKSLCD_SCREEN_PAUSE);
return;
}
else
runout_mks.runout_status = UNRUNOUT_STATUS;
gotoScreen(MKSLCD_SCREEN_PRINT);
if (ExtUI::isPrintingFromMediaPaused()) {
nozzle_park_mks.print_pause_start_flag = 0;
nozzle_park_mks.blstatus = true;
ExtUI::resumePrint();
}
} break;
case 1: // Pause
gotoScreen(MKSLCD_SCREEN_PAUSE);
if (!ExtUI::isPrintingFromMediaPaused()) {
nozzle_park_mks.print_pause_start_flag = 1;
nozzle_park_mks.blstatus = true;
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
handleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::sdSendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
uint16_t dir_icon_val = 25;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
dir_icon_val = filelist.isDir() ? 0 : 1;
}
sendStringToDisplay(var);
dgus.writeVariable(VP_File_Pictutr0 + target_line * 2, dir_icon_val);
}
void DGUSScreenHandler::sdCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUS_SCREEN_MAIN || cs == DGUS_SCREEN_STATUS)
gotoScreen(MKSLCD_SCREEN_CHOOSE_FILE);
}
void DGUSScreenHandler::sdCardRemoved() {
if (current_screenID == DGUS_SCREEN_SDFILELIST
|| (current_screenID == DGUS_SCREEN_CONFIRM && (confirmVP == VP_SD_AbortPrintConfirmed || confirmVP == VP_SD_FileSelectConfirm))
|| current_screenID == DGUS_SCREEN_SDPRINTMANIPULATION
) filelist.refresh();
}
void DGUSScreenHandlerMKS::sdPrintingFinished() {
if (DGUSAutoTurnOff) {
queue.exhaust();
gcode.process_subcommands_now(F("M81"));
}
gotoScreen(MKSLCD_SCREEN_PrintDone);
}
#else
void DGUSScreenHandlerMKS::printReturn(DGUS_VP_Variable& var, void *val_ptr) {
const uint16_t value = BE16_P(val_ptr);
if (value == 0x0F) gotoScreen(DGUS_SCREEN_MAIN);
}
#endif // HAS_MEDIA
void DGUSScreenHandler::screenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUS_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUS_ScreenID target = (DGUS_ScreenID)tmp[1];
// when the dgus had reboot, it will enter the DGUS_SCREEN_MAIN page,
// so user can change any page to use this function, an it will check
// if robin nano is printing. when it is, dgus will enter the printing
// page to continue print;
//
//if (printJobOngoing() || printingIsPaused()) {
// if (target == MKSLCD_PAUSE_SETTING_MOVE || target == MKSLCD_PAUSE_SETTING_EX
// || target == MKSLCD_SCREEN_PRINT || target == MKSLCD_SCREEN_PAUSE
// ) {
// }
// else
// gotoScreen(MKSLCD_SCREEN_PRINT);
// return;
//}
if (target == DGUS_SCREEN_POPUP) {
setupConfirmAction(ExtUI::setUserConfirmed);
// Special handling for popup is to return to previous menu
if (current_screenID == DGUS_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
popToOldScreen();
return;
}
updateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!findScreenVPMapList(target)) DEBUG_ECHOLNPGM("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandlerMKS::screenBackChange(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t target = BE16_P(val_ptr);
switch (target) {
}
}
void DGUSScreenHandlerMKS::zOffsetConfirm(DGUS_VP_Variable &var, void *val_ptr) {
settings.save();
if (printJobOngoing())
gotoScreen(MKSLCD_SCREEN_PRINT);
else if (print_job_timer.isPaused)
gotoScreen(MKSLCD_SCREEN_PAUSE);
}
void DGUSScreenHandlerMKS::getTurnOffCtrl(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value = BE16_P(val_ptr);
switch (value) {
case 0 ... 1: DGUSAutoTurnOff = (bool)value; break;
default: break;
}
}
void DGUSScreenHandlerMKS::getMinExtrudeTemp(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value = BE16_P(val_ptr);
TERN_(PREVENT_COLD_EXTRUSION, thermalManager.extrude_min_temp = value);
mks_min_extrusion_temp = value;
settings.save();
}
void DGUSScreenHandlerMKS::getZoffsetDistance(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t value = BE16_P(val_ptr);
float val_distance = 0;
switch (value) {
case 0: val_distance = 0.01; break;
case 1: val_distance = 0.1; break;
case 2: val_distance = 0.5; break;
case 3: val_distance = 1; break;
default: val_distance = 0.01; break;
}
ZOffset_distance = val_distance;
}
void DGUSScreenHandlerMKS::getManualMovestep(DGUS_VP_Variable &var, void *val_ptr) {
*(uint16_t *)var.memadr = BE16_P(val_ptr);
}
void DGUSScreenHandlerMKS::eepromControl(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t eep_flag = BE16_P(val_ptr);
switch (eep_flag) {
case 0:
settings.save();
settings.load(); // load eeprom data to check the data is right
gotoScreen(MKSLCD_SCREEN_EEP_Config);
break;
case 1:
settings.reset();
gotoScreen(MKSLCD_SCREEN_EEP_Config);
break;
default: break;
}
}
void DGUSScreenHandlerMKS::zOffsetSelect(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t z = BE16_P(val_ptr);
switch (z) {
case 0: Z_distance = 0.01; break;
case 1: Z_distance = 0.1; break;
case 2: Z_distance = 0.5; break;
default: Z_distance = 1; break;
}
}
void DGUSScreenHandlerMKS::getOffsetValue(DGUS_VP_Variable &var, void *val_ptr) {
#if HAS_BED_PROBE
const int32_t value = BE32_P(val_ptr);
const float Offset = value / 100.0f;
switch (var.VP) {
default: break;
case VP_OFFSET_X: probe.offset.x = Offset; break;
case VP_OFFSET_Y: probe.offset.y = Offset; break;
case VP_OFFSET_Z: probe.offset.z = Offset; break;
}
settings.save();
#endif
}
void DGUSScreenHandlerMKS::languageChange(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t lag_flag = BE16_P(val_ptr);
switch (lag_flag) {
case MKS_SimpleChinese:
languageDisplay(MKS_SimpleChinese);
mks_language_index = MKS_SimpleChinese;
dgus.writeVariable(VP_LANGUAGE_CHANGE1, (uint8_t)MKS_Language_Choose);
dgus.writeVariable(VP_LANGUAGE_CHANGE2, (uint8_t)MKS_Language_NoChoose);
settings.save();
break;
case MKS_English:
languageDisplay(MKS_English);
mks_language_index = MKS_English;
dgus.writeVariable(VP_LANGUAGE_CHANGE1, (uint8_t)MKS_Language_NoChoose);
dgus.writeVariable(VP_LANGUAGE_CHANGE2, (uint8_t)MKS_Language_Choose);
settings.save();
break;
default: break;
}
}
#if ENABLED(MESH_BED_LEVELING)
grid_count_t mesh_point_count = GRID_MAX_POINTS;
#endif
void DGUSScreenHandlerMKS::levelControl(DGUS_VP_Variable &var, void *val_ptr) {
#if ENABLED(MESH_BED_LEVELING)
auto cs = getCurrentScreen();
#endif
const uint16_t lev_but = BE16_P(val_ptr);
switch (lev_but) {
case 0:
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
static uint8_t a_first_level = 1;
if (a_first_level == 1) {
a_first_level = 0;
queue.enqueue_now_P(G28_STR);
}
queue.enqueue_now(F("G29"));
#elif ENABLED(MESH_BED_LEVELING)
mesh_point_count = GRID_MAX_POINTS;
if (mks_language_index == MKS_English) {
const char level_buf_en[] = "Start Level";
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_en, 32, true);
}
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch[] = {0xAABF, 0xBCCA, 0xF7B5, 0xBDC6, 0x2000};
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_ch, 32, true);
}
cs = getCurrentScreen();
if (cs != MKSLCD_AUTO_LEVEL) gotoScreen(MKSLCD_AUTO_LEVEL);
#else
gotoScreen(MKSLCD_SCREEN_LEVEL);
#endif
break;
case 1:
soft_endstop._enabled = true;
gotoScreen(MKSLCD_SCREEM_TOOL);
break;
default: break;
}
}
void DGUSScreenHandlerMKS::meshLevelDistanceConfig(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t mesh_dist = BE16_P(val_ptr);
switch (mesh_dist) {
case 0: mesh_adj_distance = 0.01; break;
case 1: mesh_adj_distance = 0.1; break;
case 2: mesh_adj_distance = 1; break;
default: mesh_adj_distance = 0.1; break;
}
}
void DGUSScreenHandlerMKS::meshLevel(DGUS_VP_Variable &var, void *val_ptr) {
#if ENABLED(MESH_BED_LEVELING)
const uint16_t mesh_val = BE16_P(val_ptr);
// static uint8_t a_first_level = 1;
char cmd_buf[30];
float offset = mesh_adj_distance;
int16_t integer, Deci, Deci2;
if (!queue.ring_buffer.empty()) return;
switch (mesh_val) {
case 0:
offset = mesh_adj_distance;
integer = offset; // get int
Deci = (offset * 10);
Deci = Deci % 10;
Deci2 = offset * 100;
Deci2 = Deci2 % 10;
soft_endstop._enabled = false;
queue.enqueue_now(F("G91"));
snprintf_P(cmd_buf, 30, PSTR("G1 Z%d.%d%d"), integer, Deci, Deci2);
queue.enqueue_one_now(cmd_buf);
queue.enqueue_now(F("G90"));
//soft_endstop._enabled = true;
break;
case 1:
offset = mesh_adj_distance;
integer = offset; // get int
Deci = (offset * 10);
Deci = Deci % 10;
Deci2 = offset * 100;
Deci2 = Deci2 % 10;
soft_endstop._enabled = false;
queue.enqueue_now(F("G91"));
snprintf_P(cmd_buf, 30, PSTR("G1 Z-%d.%d%d"), integer, Deci, Deci2);
queue.enqueue_one_now(cmd_buf);
queue.enqueue_now(F("G90"));
break;
case 2:
if (mesh_point_count == GRID_MAX_POINTS) { // The first point
queue.enqueue_now(F("G28"));
queue.enqueue_now(F("G29S1"));
mesh_point_count--;
if (mks_language_index == MKS_English) {
const char level_buf_en1[] = "Next Point";
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_en1, 32, true);
}
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch1[] = {0xC2CF, 0xBBD2, 0xE3B5, 0x2000};
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_ch1, 32, true);
}
}
else if (mesh_point_count > 1) { // 倒数第二个点
queue.enqueue_now(F("G29S2"));
mesh_point_count--;
if (mks_language_index == MKS_English) {
const char level_buf_en2[] = "Next Point";
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_en2, 32, true);
}
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch2[] = {0xC2CF, 0xBBD2, 0xE3B5, 0x2000};
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_ch2, 32, true);
}
}
else if (mesh_point_count == 1) {
queue.enqueue_now(F("G29S2"));
mesh_point_count--;
if (mks_language_index == MKS_English) {
const char level_buf_en2[] = "Leveling Done";
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_en2, 32, true);
}
else if (mks_language_index == MKS_SimpleChinese) {
const uint16_t level_buf_ch2[] = {0xF7B5, 0xBDC6, 0xEACD, 0xC9B3, 0x2000};
dgus.writeVariable(VP_AutoLevel_1_Dis, level_buf_ch2, 32, true);
}
settings.save();
}
else if (mesh_point_count == 0) {
mesh_point_count = GRID_MAX_POINTS;
soft_endstop._enabled = true;
settings.save();
gotoScreen(MKSLCD_SCREEM_TOOL);
}
break;
default:
break;
}
#endif // MESH_BED_LEVELING
}
void DGUSScreenHandlerMKS::sdFileBack(DGUS_VP_Variable&, void*) {
gotoScreen(MKSLCD_SCREEN_HOME);
}
void DGUSScreenHandlerMKS::lcdBLKAdjust(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t lcd_val = BE16_P(val_ptr);
lcd_default_light = constrain(lcd_val, 10, 100);
const uint16_t lcd_data[2] = { lcd_default_light, lcd_default_light };
dgus.writeVariable(0x0082, &lcd_data, 5, true);
}
void DGUSScreenHandlerMKS::manualAssistLeveling(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t point_val = BE16_P(val_ptr);
// Insist on leveling first time at this screen
static bool first_level_flag = false;
if (!first_level_flag || point_val == 0x0001) {
queue.enqueue_now_P(G28_STR);
first_level_flag = true;
}
constexpr uint16_t level_speed = 1500;
auto enqueue_corner_move = [](int16_t lx, int16_t ly, uint16_t fr) {
char buf_level[32];
sprintf_P(buf_level, "G0X%dY%dF%d", lx, ly, fr);
queue.enqueue_one_now(buf_level);
};
if (WITHIN(point_val, 0x0001, 0x0005))
queue.enqueue_now(F("G1Z10"));
switch (point_val) {
case 0x0001:
enqueue_corner_move(X_MIN_POS + ABS(mks_corner_offsets[0].x),
Y_MIN_POS + ABS(mks_corner_offsets[0].y), level_speed);
queue.enqueue_now(F("G28Z"));
break;
case 0x0002:
enqueue_corner_move(X_MAX_POS - ABS(mks_corner_offsets[1].x),
Y_MIN_POS + ABS(mks_corner_offsets[1].y), level_speed);
break;
case 0x0003:
enqueue_corner_move(X_MAX_POS - ABS(mks_corner_offsets[2].x),
Y_MAX_POS - ABS(mks_corner_offsets[2].y), level_speed);
break;
case 0x0004:
enqueue_corner_move(X_MIN_POS + ABS(mks_corner_offsets[3].x),
Y_MAX_POS - ABS(mks_corner_offsets[3].y), level_speed);
break;
case 0x0005:
enqueue_corner_move(ABS(mks_corner_offsets[4].x),
ABS(mks_corner_offsets[4].y), level_speed);
break;
}
if (WITHIN(point_val, 0x0002, 0x0005)) {
//queue.enqueue_now(F("G28Z"));
queue.enqueue_now(F("G1Z-10"));
}
}
#define mks_min(a, b) ((a) < (b)) ? (a) : (b)
#define mks_max(a, b) ((a) > (b)) ? (a) : (b)
void DGUSScreenHandlerMKS::tmcChangeConfig(DGUS_VP_Variable &var, void *val_ptr) {
#if ANY(HAS_TRINAMIC_CONFIG, HAS_STEALTHCHOP)
const uint16_t tmc_val = BE16_P(val_ptr);
#endif
switch (var.VP) {
case VP_TMC_X_STEP:
#if USE_SENSORLESS
#if X_HAS_STEALTHCHOP
stepperX.homing_threshold(mks_min(tmc_val, 255));
settings.save();
//tmc_step.x = stepperX.homing_threshold();
#endif
#endif
break;
case VP_TMC_Y_STEP:
#if USE_SENSORLESS
#if Y_HAS_STEALTHCHOP
stepperY.homing_threshold(mks_min(tmc_val, 255));
settings.save();
//tmc_step.y = stepperY.homing_threshold();
#endif
#endif
break;
case VP_TMC_Z_STEP:
#if USE_SENSORLESS
#if Z_HAS_STEALTHCHOP
stepperZ.homing_threshold(mks_min(tmc_val, 255));
settings.save();
//tmc_step.z = stepperZ.homing_threshold();
#endif
#endif
break;
case VP_TMC_X_Current:
#if AXIS_IS_TMC(X)
stepperX.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_X1_Current:
#if AXIS_IS_TMC(X2)
stepperX2.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_Y_Current:
#if AXIS_IS_TMC(Y)
stepperY.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_Y1_Current:
#if AXIS_IS_TMC(X2)
stepperY2.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_Z_Current:
#if AXIS_IS_TMC(Z)
stepperZ.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_Z1_Current:
#if AXIS_IS_TMC(Z2)
stepperZ2.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_E0_Current:
#if AXIS_IS_TMC(E0)
stepperE0.rms_current(tmc_val);
settings.save();
#endif
break;
case VP_TMC_E1_Current:
#if AXIS_IS_TMC(E1)
stepperE1.rms_current(tmc_val);
settings.save();
#endif
break;
default:
break;
}
#if USE_SENSORLESS
TERN_(X_HAS_STEALTHCHOP, tmc_step.x = stepperX.homing_threshold());
TERN_(Y_HAS_STEALTHCHOP, tmc_step.y = stepperY.homing_threshold());
TERN_(Z_HAS_STEALTHCHOP, tmc_step.z = stepperZ.homing_threshold());
#endif
}
void DGUSScreenHandler::handleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
int16_t movevalue = BE16_P(val_ptr);
// Choose Move distance
if (manualMoveStep == 0x01) manualMoveStep = 10;
else if (manualMoveStep == 0x02) manualMoveStep = 100;
else if (manualMoveStep == 0x03) manualMoveStep = 1000;
if (!print_job_timer.isPaused() && !queue.ring_buffer.empty())
return;
char axiscode;
uint16_t speed = manual_feedrate_mm_m.x; // Default feedrate for manual moves
switch (var.VP) { // switch X Y Z or Home
default: return;
#if HAS_X_AXIS
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
#endif
#if HAS_Y_AXIS
case VP_MOVE_Y:
axiscode = 'Y';
speed = manual_feedrate_mm_m.y;
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
#endif
#if HAS_Z_AXIS
case VP_MOVE_Z:
axiscode = 'Z';
speed = manual_feedrate_mm_m.z;
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
#endif
case VP_MOTOR_LOCK_UNLOK:
movevalue = 5;
break;
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
#if HAS_X_AXIS
case VP_X_HOME:
axiscode = 'X';
movevalue = 0;
break;
#endif
#if HAS_Y_AXIS
case VP_Y_HOME:
axiscode = 'Y';
movevalue = 0;
break;
#endif
#if HAS_Z_AXIS
case VP_Z_HOME:
axiscode = 'Z';
movevalue = 0;
break;
#endif
}
if (movevalue != 0 && movevalue != 5) { // get move distance
switch (movevalue) {
case 0x0001: movevalue = manualMoveStep; break;
case 0x0002: movevalue = -manualMoveStep; break;
default: movevalue = 0; break;
}
}
if (!movevalue) {
// char buf[6] = "G28 X";
// buf[4] = axiscode;
char buf[6];
sprintf(buf, "G28 %c", axiscode);
queue.enqueue_one_now(buf);
forceCompleteUpdate();
return;
}
else if (movevalue == 5) {
char buf[6];
snprintf_P(buf,6,PSTR("M84 %c"), axiscode);
queue.enqueue_one_now(buf);
forceCompleteUpdate();
return;
}
else {
// movement
const bool old_relative_mode = relative_mode;
if (!relative_mode) queue.enqueue_now(F("G91"));
char buf[32]; // G1 X9999.99 F12345
//const uint16_t backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
const int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
queue.enqueue_one_now(buf);
//if (backup_speed != speed) {
// snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
// queue.enqueue_one_now(buf);
//}
//while (!enqueue_and_echo_command(buf)) idle();
if (!old_relative_mode) queue.enqueue_now(F("G90"));
}
forceCompleteUpdate();
cannotmove:
return;
}
void DGUSScreenHandlerMKS::getParkPos(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t pos = BE16_P(val_ptr);
switch (var.VP) {
case VP_X_PARK_POS: mks_park_pos.x = pos; break;
case VP_Y_PARK_POS: mks_park_pos.y = pos; break;
case VP_Z_PARK_POS: mks_park_pos.z = pos; break;
default: break;
}
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleChangeLevelPoint(DGUS_VP_Variable &var, void *val_ptr) {
const int16_t raw = BE16_P(val_ptr);
*(int16_t*)var.memadr = raw;
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
void DGUSScreenHandlerMKS::handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::axis_t axis;
switch (var.VP) {
default: return;
case VP_X_STEP_PER_MM: axis = ExtUI::axis_t::X; break;
case VP_Y_STEP_PER_MM: axis = ExtUI::axis_t::Y; break;
case VP_Z_STEP_PER_MM: axis = ExtUI::axis_t::Z; break;
}
ExtUI::setAxisSteps_per_mm(value, axis);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_STEP_PER_MM: extruder = ExtUI::extruder_t::E0; break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_STEP_PER_MM: extruder = ExtUI::extruder_t::E1; break;
#endif
}
ExtUI::setAxisSteps_per_mm(value, extruder);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // EDITABLE_STEPS_PER_UNIT
void DGUSScreenHandlerMKS::handleMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::axis_t axis;
switch (var.VP) {
case VP_X_MAX_SPEED: axis = ExtUI::axis_t::X; break;
case VP_Y_MAX_SPEED: axis = ExtUI::axis_t::Y; break;
case VP_Z_MAX_SPEED: axis = ExtUI::axis_t::Z; break;
default: return;
}
ExtUI::setAxisMaxFeedrate_mm_s(value, axis);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleExtruderMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_MAX_SPEED: extruder = ExtUI::extruder_t::E0; break;
#endif
#if HAS_MULTI_HOTEND
#endif
case VP_E1_MAX_SPEED: extruder = ExtUI::extruder_t::E1; break;
}
ExtUI::setAxisMaxFeedrate_mm_s(value, extruder);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleMaxAccChange(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t raw = BE16_P(val_ptr);
const float value = (float)raw;
ExtUI::axis_t axis;
switch (var.VP) {
default: return;
case VP_X_ACC_MAX_SPEED: axis = ExtUI::axis_t::X; break;
case VP_Y_ACC_MAX_SPEED: axis = ExtUI::axis_t::Y; break;
case VP_Z_ACC_MAX_SPEED: axis = ExtUI::axis_t::Z; break;
}
ExtUI::setAxisMaxAcceleration_mm_s2(value, axis);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleExtruderAccChange(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t raw = BE16_P(val_ptr);
float value = (float)raw;
ExtUI::extruder_t extruder;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_ACC_MAX_SPEED: extruder = ExtUI::extruder_t::E0; settings.load(); break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_ACC_MAX_SPEED: extruder = ExtUI::extruder_t::E1; settings.load(); break;
#endif
}
ExtUI::setAxisMaxAcceleration_mm_s2(value, extruder);
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleTravelAccChange(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t travel = BE16_P(val_ptr);
planner.settings.travel_acceleration = (float)travel;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleFeedRateMinChange(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t t = BE16_P(val_ptr);
planner.settings.min_feedrate_mm_s = (float)t;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleMin_T_F(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t t_f = BE16_P(val_ptr);
planner.settings.min_travel_feedrate_mm_s = (float)t_f;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::handleAccChange(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t acc = BE16_P(val_ptr);
planner.settings.acceleration = (float)acc;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#if ENABLED(PREVENT_COLD_EXTRUSION)
void DGUSScreenHandlerMKS::handleGetExMinTemp(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t ex_min_temp = BE16_P(val_ptr);
thermalManager.extrude_min_temp = ex_min_temp;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif
#if HAS_PID_HEATING
void DGUSScreenHandler::handleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t rawvalue = BE16_P(val_ptr);
const float value = float(rawvalue);
float newvalue = 0;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
*(float *)var.memadr = newvalue;
settings.save();
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::handleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
const float step = ZOffset_distance;
const uint16_t flag = BE16_P(val_ptr);
switch (flag) {
case 0:
if (step == 0.01)
queue.inject(F("M290 Z-0.01"));
else if (step == 0.1)
queue.inject(F("M290 Z-0.1"));
else if (step == 0.5)
queue.inject(F("M290 Z-0.5"));
else if (step == 1)
queue.inject(F("M290 Z-1"));
else
queue.inject(F("M290 Z-0.01"));
z_offset_add -= ZOffset_distance;
break;
case 1:
if (step == 0.01)
queue.inject(F("M290 Z0.01"));
else if (step == 0.1)
queue.inject(F("M290 Z0.1"));
else if (step == 0.5)
queue.inject(F("M290 Z0.5"));
else if (step == 1)
queue.inject(F("M290 Z1"));
else
queue.inject(F("M290 Z-0.01"));
z_offset_add += ZOffset_distance;
break;
default: break;
}
forceCompleteUpdate();
}
#endif // BABYSTEPPING
void DGUSScreenHandlerMKS::getManualFilament(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t len = BE16_P(val_ptr);
const float value = (float)len;
distanceFilament = value;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::getManualFilamentSpeed(DGUS_VP_Variable &var, void *val_ptr) {
const uint16_t len = BE16_P(val_ptr);
filamentSpeed_mm_s = len;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
void DGUSScreenHandlerMKS::filamentLoadUnload(DGUS_VP_Variable &var, void *val_ptr, const int filamentDir) {
#if ANY(HAS_MULTI_HOTEND, SINGLENOZZLE)
uint8_t swap_tool = 0;
#else
constexpr uint8_t swap_tool = 1; // T0 (or none at all)
#endif
#if HAS_HOTEND
uint8_t hotend_too_cold = 0;
#endif
if (!print_job_timer.isPaused() && !queue.ring_buffer.empty())
return;
const uint16_t val_t = BE16_P(val_ptr);
switch (val_t) {
default: break;
case 0:
#if HAS_HOTEND
if (thermalManager.tooColdToExtrude(0))
hotend_too_cold = 1;
else {
#if ANY(HAS_MULTI_HOTEND, SINGLENOZZLE)
swap_tool = 1;
#endif
}
#endif
break;
case 1:
#if HAS_MULTI_HOTEND
if (thermalManager.tooColdToExtrude(1)) hotend_too_cold = 2; else swap_tool = 2;
#elif ENABLED(SINGLENOZZLE)
if (thermalManager.tooColdToExtrude(0)) hotend_too_cold = 1; else swap_tool = 2;
#endif
break;
}
#if ALL(HAS_HOTEND, PREVENT_COLD_EXTRUSION)
if (hotend_too_cold) {
if (thermalManager.targetTooColdToExtrude(hotend_too_cold - 1)) thermalManager.setTargetHotend(thermalManager.extrude_min_temp, hotend_too_cold - 1);
sendInfoScreen(F("NOTICE"), nullptr, F("Please wait."), F("Nozzle heating!"), true, true, true, true);
setupConfirmAction(nullptr);
gotoScreen(DGUS_SCREEN_POPUP);
}
#endif
if (swap_tool) {
char buf[30];
snprintf_P(buf, 30
#if ANY(HAS_MULTI_HOTEND, SINGLENOZZLE)
, PSTR("M1002T%cE%dF%d"), char('0' + swap_tool - 1)
#else
, PSTR("M1002E%dF%d")
#endif
, (int)distanceFilament * filamentDir, filamentSpeed_mm_s * 60
);
queue.inject(buf);
}
}
/**
* M1002: Do a tool-change and relative move for filamentLoadUnload
* within the G-code execution window for best concurrency.
*/
void GcodeSuite::M1002() {
#if ANY(HAS_MULTI_HOTEND, SINGLENOZZLE)
{
char buf[3];
sprintf_P(buf, PSTR("T%c"), char('0' + parser.intval('T')));
process_subcommands_now(buf);
}
#endif
const uint8_t old_axis_relative = axis_relative;
set_e_relative(); // M83
{
char buf[20];
snprintf_P(buf, 20, PSTR("G1E%dF%d"), parser.intval('E'), parser.intval('F'));
process_subcommands_now(buf);
}
axis_relative = old_axis_relative;
}
void DGUSScreenHandlerMKS::filamentLoad(DGUS_VP_Variable &var, void *val_ptr) {
filamentLoadUnload(var, val_ptr, 1);
}
void DGUSScreenHandlerMKS::filamentUnload(DGUS_VP_Variable &var, void *val_ptr) {
filamentLoadUnload(var, val_ptr, -1);
}
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::handleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = BE16_P(val_ptr);
if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else if (preheat_option <= 8) // Load filament type
filament_data.action = 1;
else // Cancel filament operation
filament_data.action = 0;
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HAS_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#endif
#if HAS_MULTI_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
gotoScreen(DGUS_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
}
}
void DGUSScreenHandler::handleFilamentLoadUnload(DGUS_VP_Variable &var) {
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
gotoScreen(DGUS_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandlerMKS::loop() {
dgus.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
static uint8_t language_times = 2;
if (!isScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
updateScreenVPData();
}
if (language_times != 0) {
languagePInit();
languageDisplay(mks_language_index);
language_times--;
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && ELAPSED(ms, TERN(USE_MKS_GREEN_UI, 1000, BOOTSCREEN_TIMEOUT))) {
booted = true;
#if USE_SENSORLESS
TERN_(X_HAS_STEALTHCHOP, tmc_step.x = stepperX.homing_threshold());
TERN_(Y_HAS_STEALTHCHOP, tmc_step.y = stepperY.homing_threshold());
TERN_(Z_HAS_STEALTHCHOP, tmc_step.z = stepperZ.homing_threshold());
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
if (mks_min_extrusion_temp != 0)
thermalManager.extrude_min_temp = mks_min_extrusion_temp;
#endif
extrudeLoadInit();
TERN_(DGUS_MKS_RUNOUT_SENSOR, runoutInit());
if (TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
gotoScreen(DGUS_SCREEN_POWER_LOSS);
else
gotoScreen(DGUS_SCREEN_MAIN);
}
#if ENABLED(DGUS_MKS_RUNOUT_SENSOR)
if (booted && printingIsActive()) runoutIdle();
#endif
#endif // SHOW_BOOTSCREEN
return isScreenComplete();
}
void DGUSScreenHandlerMKS::languagePInit() {
switch (mks_language_index) {
case MKS_SimpleChinese:
dgus.writeVariable(VP_LANGUAGE_CHANGE1, (uint8_t)MKS_Language_Choose);
dgus.writeVariable(VP_LANGUAGE_CHANGE2, (uint8_t)MKS_Language_NoChoose);
break;
case MKS_English:
dgus.writeVariable(VP_LANGUAGE_CHANGE1, (uint8_t)MKS_Language_NoChoose);
dgus.writeVariable(VP_LANGUAGE_CHANGE2, (uint8_t)MKS_Language_Choose);
break;
default:
break;
}
}
void DGUSScreenHandlerMKS::extrudeLoadInit() {
ex_filament.ex_length = distanceFilament;
ex_filament.ex_load_unload_flag = 0;
ex_filament.ex_need_time = filamentSpeed_mm_s;
ex_filament.ex_speed = 0;
ex_filament.ex_status = EX_NONE;
ex_filament.ex_tick_end = 0;
ex_filament.ex_tick_start = 0;
}
void DGUSScreenHandlerMKS::runoutInit() {
#if PIN_EXISTS(MT_DET_1)
SET_INPUT_PULLUP(MT_DET_1_PIN);
#endif
runout_mks.de_count = 0;
runout_mks.de_times = 10;
runout_mks.pin_status = 1;
runout_mks.runout_status = UNRUNOUT_STATUS;
}
void DGUSScreenHandlerMKS::runoutIdle() {
#if ENABLED(DGUS_MKS_RUNOUT_SENSOR)
// scanf runout pin
switch (runout_mks.runout_status) {
case RUNOUT_STATUS:
runout_mks.runout_status = RUNOUT_BEGIN_STATUS;
queue.inject(F("M25"));
gotoScreen(MKSLCD_SCREEN_PAUSE);
sendInfoScreen(F("NOTICE"), nullptr, F("Please change filament!"), nullptr, true, true, true, true);
//setupConfirmAction(nullptr);
gotoScreen(DGUS_SCREEN_POPUP);
break;
case UNRUNOUT_STATUS:
if (READ(MT_DET_1_PIN) == MT_DET_PIN_STATE)
runout_mks.runout_status = RUNOUT_STATUS;
break;
case RUNOUT_BEGIN_STATUS:
if (READ(MT_DET_1_PIN) != MT_DET_PIN_STATE)
runout_mks.runout_status = RUNOUT_WAITING_STATUS;
break;
case RUNOUT_WAITING_STATUS:
if (READ(MT_DET_1_PIN) == MT_DET_PIN_STATE)
runout_mks.runout_status = RUNOUT_BEGIN_STATUS;
break;
default: break;
}
#endif
}
void DGUSScreenHandlerMKS::languageDisplay(uint8_t var) {
if (var == MKS_English) {
const char home_buf_en[] = "Home";
dgus.writeVariable(VP_HOME_Dis, home_buf_en, 32, true);
const char setting_buf_en[] = "Setting";
dgus.writeVariable(VP_Setting_Dis, setting_buf_en, 32, true);
const char Tool_buf_en[] = "Tool";
dgus.writeVariable(VP_Tool_Dis, Tool_buf_en, 32, true);
const char Print_buf_en[] = "Print";
dgus.writeVariable(VP_Print_Dis, Print_buf_en, 32, true);
const char Language_buf_en[] = "Language";
dgus.writeVariable(VP_Language_Dis, Language_buf_en, 32, true);
const char About_buf_en[] = "About";
dgus.writeVariable(VP_About_Dis, About_buf_en, 32, true);
const char Config_buf_en[] = "Config";
dgus.writeVariable(VP_Config_Dis, Config_buf_en, 32, true);
const char MotorConfig_buf_en[] = "MotorConfig";
dgus.writeVariable(VP_MotorConfig_Dis, MotorConfig_buf_en, 32, true);
const char LevelConfig_buf_en[] = "LevelConfig";
dgus.writeVariable(VP_LevelConfig_Dis, LevelConfig_buf_en, 32, true);
const char TemperatureConfig_buf_en[] = "Temperature";
dgus.writeVariable(VP_TemperatureConfig_Dis, TemperatureConfig_buf_en, 32, true);
const char Advance_buf_en[] = "Advance";
dgus.writeVariable(VP_Advance_Dis, Advance_buf_en, 32, true);
const char Filament_buf_en[] = "Extrude";
dgus.writeVariable(VP_Filament_Dis, Filament_buf_en, 32, true);
const char Move_buf_en[] = "Move";
dgus.writeVariable(VP_Move_Dis, Move_buf_en, 32, true);
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
const char Level_buf_en[] = "AutoLevel";
dgus.writeVariable(VP_Level_Dis, Level_buf_en, 32, true);
#elif ENABLED(MESH_BED_LEVELING)
const char Level_buf_en[] = "MeshLevel";
dgus.writeVariable(VP_Level_Dis, Level_buf_en, 32, true);
#else
const char Level_buf_en[] = "Level";
dgus.writeVariable(VP_Level_Dis, Level_buf_en, 32, true);
#endif
const char MotorPluse_buf_en[] = "MotorPluse";
dgus.writeVariable(VP_MotorPluse_Dis, MotorPluse_buf_en, 32, true);
const char MotorMaxSpeed_buf_en[] = "MotorMaxSpeed";
dgus.writeVariable(VP_MotorMaxSpeed_Dis, MotorMaxSpeed_buf_en, 32, true);
const char MotorMaxAcc_buf_en[] = "MotorAcc";
dgus.writeVariable(VP_MotorMaxAcc_Dis, MotorMaxAcc_buf_en, 32, true);
const char TravelAcc_buf_en[] = "TravelAcc";
dgus.writeVariable(VP_TravelAcc_Dis, TravelAcc_buf_en, 32, true);
const char FeedRateMin_buf_en[] = "FeedRateMin";
dgus.writeVariable(VP_FeedRateMin_Dis, FeedRateMin_buf_en, 32, true);
const char TravelFeeRateMin_buf_en[] = "TravelFeedRateMin";
dgus.writeVariable(VP_TravelFeeRateMin_Dis, TravelFeeRateMin_buf_en, 32, true);
const char Acc_buf_en[] = "Acc";
dgus.writeVariable(VP_ACC_Dis, Acc_buf_en, 32, true);
const char Point_One_buf_en[] = "Point_First";
dgus.writeVariable(VP_Point_One_Dis, Point_One_buf_en, 32, true);
const char Point_Two_buf_en[] = "Point_Second";
dgus.writeVariable(VP_Point_Two_Dis, Point_Two_buf_en, 32, true);
const char Point_Three_buf_en[] = "Point_Third";
dgus.writeVariable(VP_Point_Three_Dis, Point_Three_buf_en, 32, true);
const char Point_Four_buf_en[] = "Point_Fourth";
dgus.writeVariable(VP_Point_Four_Dis, Point_Four_buf_en, 32, true);
const char Point_Five_buf_en[] = "Point_Fifth";
dgus.writeVariable(VP_Point_Five_Dis, Point_Five_buf_en, 32, true);
const char Extrusion_buf_en[] = "Extrusion";
dgus.writeVariable(VP_Extrusion_Dis, Extrusion_buf_en, 32, true);
const char HeatBed_buf_en[] = "HeatBed";
dgus.writeVariable(VP_HeatBed_Dis, HeatBed_buf_en, 32, true);
const char FactoryDefaults_buf_en[] = "FactoryDefaults";
dgus.writeVariable(VP_FactoryDefaults_Dis, FactoryDefaults_buf_en, 32, true);
const char StoreSetting_buf_en[] = "StoreSetting";
dgus.writeVariable(VP_StoreSetting_Dis, StoreSetting_buf_en, 32, true);
const char PrintPauseConfig_buf_en[] = "PrintPauseConfig";
dgus.writeVariable(VP_PrintPauseConfig_Dis, PrintPauseConfig_buf_en, 32, true);
const char X_Pluse_buf_en[] = "X_Pluse";
dgus.writeVariable(VP_X_Pluse_Dis, X_Pluse_buf_en, 32, true);
const char Y_Pluse_buf_en[] = "Y_Pluse";
dgus.writeVariable(VP_Y_Pluse_Dis, Y_Pluse_buf_en, 32, true);
const char Z_Pluse_buf_en[] = "Z_Pluse";
dgus.writeVariable(VP_Z_Pluse_Dis, Z_Pluse_buf_en, 32, true);
const char E0_Pluse_buf_en[] = "E0_Pluse";
dgus.writeVariable(VP_E0_Pluse_Dis, E0_Pluse_buf_en, 32, true);
const char E1_Pluse_buf_en[] = "E1_Pluse";
dgus.writeVariable(VP_E1_Pluse_Dis, E1_Pluse_buf_en, 32, true);
const char X_Max_Speed_buf_en[] = "X_Max_Speed";
dgus.writeVariable(VP_X_Max_Speed_Dis, X_Max_Speed_buf_en, 32, true);
const char Y_Max_Speed_buf_en[] = "Y_Max_Speed";
dgus.writeVariable(VP_Y_Max_Speed_Dis, Y_Max_Speed_buf_en, 32, true);
const char Z_Max_Speed_buf_en[] = "Z_Max_Speed";
dgus.writeVariable(VP_Z_Max_Speed_Dis, Z_Max_Speed_buf_en, 32, true);
const char E0_Max_Speed_buf_en[] = "E0_Max_Speed";
dgus.writeVariable(VP_E0_Max_Speed_Dis, E0_Max_Speed_buf_en, 32, true);
const char E1_Max_Speed_buf_en[] = "E1_Max_Speed";
dgus.writeVariable(VP_E1_Max_Speed_Dis, E1_Max_Speed_buf_en, 32, true);
const char X_Max_Acc_Speed_buf_en[] = "X_Max_Acc_Speed";
dgus.writeVariable(VP_X_Max_Acc_Speed_Dis, X_Max_Acc_Speed_buf_en, 32, true);
const char Y_Max_Acc_Speed_buf_en[] = "Y_Max_Acc_Speed";
dgus.writeVariable(VP_Y_Max_Acc_Speed_Dis, Y_Max_Acc_Speed_buf_en, 32, true);
const char Z_Max_Acc_Speed_buf_en[] = "Z_Max_Acc_Speed";
dgus.writeVariable(VP_Z_Max_Acc_Speed_Dis, Z_Max_Acc_Speed_buf_en, 32, true);
const char E0_Max_Acc_Speed_buf_en[] = "E0_Max_Acc_Speed";
dgus.writeVariable(VP_E0_Max_Acc_Speed_Dis, E0_Max_Acc_Speed_buf_en, 32, true);
const char E1_Max_Acc_Speed_buf_en[] = "E1_Max_Acc_Speed";
dgus.writeVariable(VP_E1_Max_Acc_Speed_Dis, E1_Max_Acc_Speed_buf_en, 32, true);
const char X_PARK_POS_buf_en[] = "X_PARK_POS";
dgus.writeVariable(VP_X_PARK_POS_Dis, X_PARK_POS_buf_en, 32, true);
const char Y_PARK_POS_buf_en[] = "Y_PARK_POS";
dgus.writeVariable(VP_Y_PARK_POS_Dis, Y_PARK_POS_buf_en, 32, true);
const char Z_PARK_POS_buf_en[] = "Z_PARK_POS";
dgus.writeVariable(VP_Z_PARK_POS_Dis, Z_PARK_POS_buf_en, 32, true);
const char Length_buf_en[] = "Length";
dgus.writeVariable(VP_Length_Dis, Length_buf_en, 32, true);
const char Speed_buf_en[] = "Speed";
dgus.writeVariable(VP_Speed_Dis, Speed_buf_en, 32, true);
const char InOut_buf_en[] = "InOut";
dgus.writeVariable(VP_InOut_Dis, InOut_buf_en, 32, true);
const char PrintTimet_buf_en[] = "PrintTime";
dgus.writeVariable(VP_PrintTime_Dis, PrintTimet_buf_en, 32, true);
const char E0_Temp_buf_en[] = "E0_Temp";
dgus.writeVariable(VP_E0_Temp_Dis, E0_Temp_buf_en, 32, true);
const char E1_Temp_buf_en[] = "E1_Temp";
dgus.writeVariable(VP_E1_Temp_Dis, E1_Temp_buf_en, 32, true);
const char HB_Temp_buf_en[] = "HB_Temp";
dgus.writeVariable(VP_HB_Temp_Dis, HB_Temp_buf_en, 32, true);
const char Feedrate_buf_en[] = "Feedrate";
dgus.writeVariable(VP_Feedrate_Dis, Feedrate_buf_en, 32, true);
const char PrintAcc_buf_en[] = "PrintSpeed";
dgus.writeVariable(VP_PrintAcc_Dis, PrintAcc_buf_en, 32, true);
const char FAN_Speed_buf_en[] = "FAN_Speed";
dgus.writeVariable(VP_Fan_Speed_Dis, FAN_Speed_buf_en, 32, true);
const char Printing_buf_en[] = "Printing";
dgus.writeVariable(VP_Printing_Dis, Printing_buf_en, 32, true);
const char Info_EEPROM_1_buf_en[] = "Store setting?";
dgus.writeVariable(VP_Info_EEPROM_1_Dis, Info_EEPROM_1_buf_en, 32, true);
const char Info_EEPROM_2_buf_en[] = "Revert setting?";
dgus.writeVariable(VP_Info_EEPROM_2_Dis, Info_EEPROM_2_buf_en, 32, true);
const char Info_PrintFinish_1_buf_en[] = "Print Done";
dgus.writeVariable(VP_Info_PrintFinish_1_Dis, Info_PrintFinish_1_buf_en, 32, true);
const char TMC_X_Step_buf_en[] = "X_SenSitivity";
dgus.writeVariable(VP_TMC_X_Step_Dis, TMC_X_Step_buf_en, 32, true);
const char TMC_Y_Step_buf_en[] = "Y_SenSitivity";
dgus.writeVariable(VP_TMC_Y_Step_Dis, TMC_Y_Step_buf_en, 32, true);
const char TMC_Z_Step_buf_en[] = "Z_SenSitivity";
dgus.writeVariable(VP_TMC_Z_Step_Dis, TMC_Z_Step_buf_en, 32, true);
const char TMC_X_Current_buf_en[] = "X_Current";
dgus.writeVariable(VP_TMC_X_Current_Dis, TMC_X_Current_buf_en, 32, true);
const char TMC_Y_Current_buf_en[] = "Y_Current";
dgus.writeVariable(VP_TMC_Y_Current_Dis, TMC_Y_Current_buf_en, 32, true);
const char TMC_Z_Current_buf_en[] = "Z_Current";
dgus.writeVariable(VP_TMC_Z_Current_Dis, TMC_Z_Current_buf_en, 32, true);
const char TMC_E0_Current_buf_en[] = "E0_Current";
dgus.writeVariable(VP_TMC_E0_Current_Dis, TMC_E0_Current_buf_en, 32, true);
const char TMC_X1_Current_buf_en[] = "X1_Current";
dgus.writeVariable(VP_TMC_X1_Current_Dis, TMC_X1_Current_buf_en, 32, true);
const char TMC_Y1_Current_buf_en[] = "Y1_Current";
dgus.writeVariable(VP_TMC_Y1_Current_Dis, TMC_Y1_Current_buf_en, 32, true);
const char TMC_Z1_Current_buf_en[] = "Z1_Current";
dgus.writeVariable(VP_TMC_Z1_Current_Dis, TMC_Z1_Current_buf_en, 32, true);
const char TMC_E1_Current_buf_en[] = "E1_Current";
dgus.writeVariable(VP_TMC_E1_Current_Dis, TMC_E1_Current_buf_en, 32, true);
const char Min_Ex_Temp_buf_en[] = "Min_Ex_Temp";
dgus.writeVariable(VP_Min_Ex_Temp_Dis, Min_Ex_Temp_buf_en, 32, true);
const char AutoLEVEL_INFO1_buf_en[] = "Please Press Button!";
dgus.writeVariable(VP_AutoLEVEL_INFO1, AutoLEVEL_INFO1_buf_en, 32, true);
const char EX_TEMP_INFO2_buf_en[] = "Please wait a monent";
dgus.writeVariable(VP_EX_TEMP_INFO2_Dis, EX_TEMP_INFO2_buf_en, 32, true);
const char EX_TEMP_INFO3_buf_en[] = "Cancle";
dgus.writeVariable(VP_EX_TEMP_INFO3_Dis, EX_TEMP_INFO3_buf_en, 32, true);
const char PrintConfrim_Info_buf_en[] = "Start Print?";
dgus.writeVariable(VP_PrintConfrim_Info_Dis, PrintConfrim_Info_buf_en, 32, true);
const char StopPrintConfrim_Info_buf_en[] = "Stop Print?";
dgus.writeVariable(VP_StopPrintConfrim_Info_Dis, StopPrintConfrim_Info_buf_en, 32, true);
const char Printting_buf_en[] = "Printing";
dgus.writeVariable(VP_Printting_Dis, Printting_buf_en, 32, true);
const char LCD_BLK_buf_en[] = "Backlight";
dgus.writeVariable(VP_LCD_BLK_Dis, LCD_BLK_buf_en, 32, true);
}
else if (var == MKS_SimpleChinese) {
uint16_t home_buf_ch[] = { 0xF7D6, 0xB3D2 };
dgus.writeVariable(VP_HOME_Dis, home_buf_ch, 4, true);
const uint16_t Setting_Dis[] = { 0xE8C9, 0xC3D6, 0x2000, 0x2000, 0x2000 };
dgus.writeVariable(VP_Setting_Dis, Setting_Dis, 7, true);
const uint16_t Tool_Dis[] = { 0xA4B9, 0xDFBE };
dgus.writeVariable(VP_Tool_Dis, Tool_Dis, 4, true);
const uint16_t Print_buf_ch[] = { 0xF2B4, 0xA1D3, 0x2000 };
dgus.writeVariable(VP_Print_Dis, Print_buf_ch, 6, true);
const uint16_t Language_buf_ch[] = { 0xEFD3, 0xD4D1, 0x2000, 0x2000 };
dgus.writeVariable(VP_Language_Dis, Language_buf_ch, 8, true);
const uint16_t About_buf_ch[] = { 0xD8B9, 0xDAD3, 0x2000 };
dgus.writeVariable(VP_About_Dis, About_buf_ch, 6, true);
const uint16_t Config_buf_ch[] = { 0xE4C5, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_Config_Dis, Config_buf_ch, 6, true);
const uint16_t MotorConfig_buf_ch[] = { 0xE7B5, 0xFABB, 0xE4C5, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_MotorConfig_Dis, MotorConfig_buf_ch, 12, true);
const uint16_t LevelConfig_buf_ch[] = { 0xD6CA, 0xAFB6, 0xF7B5, 0xBDC6, 0xE8C9, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_LevelConfig_Dis, LevelConfig_buf_ch, 32, true);
const uint16_t TemperatureConfig_buf_ch[] = { 0xC2CE, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_TemperatureConfig_Dis, TemperatureConfig_buf_ch, 11, true);
const uint16_t Advance_buf_ch[] = { 0xDFB8, 0xB6BC, 0xE8C9, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_Advance_Dis, Advance_buf_ch, 16, true);
const uint16_t Filament_buf_ch[] = { 0xB7BC, 0xF6B3, 0x2000 };
dgus.writeVariable(VP_Filament_Dis, Filament_buf_ch, 8, true);
const uint16_t Move_buf_ch[] = { 0xC6D2, 0xAFB6, 0x2000 };
dgus.writeVariable(VP_Move_Dis, Move_buf_ch, 4, true);
#if ENABLED(AUTO_BED_LEVELING_BILINEAR)
const uint16_t Level_buf_ch[] = { 0xD4D7, 0xAFB6, 0xF7B5, 0xBDC6, 0x2000 };
dgus.writeVariable(VP_Level_Dis, Level_buf_ch, 32, true);
#elif ENABLED(MESH_BED_LEVELING)
const uint16_t Level_buf_ch[] = { 0xF8CD, 0xF1B8, 0xF7B5, 0xBDC6, 0x2000 };
dgus.writeVariable(VP_Level_Dis, Level_buf_ch, 32, true);
#else
const uint16_t Level_buf_ch[] = { 0xD6CA, 0xAFB6, 0xF7B5, 0xBDC6, 0x2000 };
dgus.writeVariable(VP_Level_Dis, Level_buf_ch, 32, true);
#endif
const uint16_t MotorPluse_buf_ch[] = { 0xF6C2, 0xE5B3, 0x2000 };
dgus.writeVariable(VP_MotorPluse_Dis, MotorPluse_buf_ch, 16, true);
const uint16_t MotorMaxSpeed_buf_ch[] = { 0xEED7, 0xF3B4, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_MotorMaxSpeed_Dis, MotorMaxSpeed_buf_ch, 16, true);
const uint16_t MotorMaxAcc_buf_ch[] = { 0xEED7, 0xF3B4, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_MotorMaxAcc_Dis, MotorMaxAcc_buf_ch, 16, true);
const uint16_t TravelAcc_buf_ch[] = { 0xD5BF, 0xD0D0, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_TravelAcc_Dis, TravelAcc_buf_ch, 16, true);
const uint16_t FeedRateMin_buf_ch[] = { 0xEED7, 0xA1D0, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_FeedRateMin_Dis, FeedRateMin_buf_ch, 12, true);
const uint16_t TravelFeeRateMin_buf_ch[] = { 0xD5BF, 0xD0D0, 0xEED7, 0xA1D0, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_TravelFeeRateMin_Dis, TravelFeeRateMin_buf_ch, 24, true);
const uint16_t Acc_buf_ch[] = { 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_ACC_Dis, Acc_buf_ch, 16, true);
const uint16_t Point_One_buf_ch[] = { 0xDAB5, 0xBBD2, 0xE3B5, 0x2000 };
dgus.writeVariable(VP_Point_One_Dis, Point_One_buf_ch, 12, true);
const uint16_t Point_Two_buf_ch[] = { 0xDAB5, 0xFEB6, 0xE3B5, 0x2000 };
dgus.writeVariable(VP_Point_Two_Dis, Point_Two_buf_ch, 12, true);
const uint16_t Point_Three_buf_ch[] = { 0xDAB5, 0xFDC8, 0xE3B5, 0x2000 };
dgus.writeVariable(VP_Point_Three_Dis, Point_Three_buf_ch, 12, true);
const uint16_t Point_Four_buf_ch[] = { 0xDAB5, 0xC4CB, 0xE3B5, 0x2000 };
dgus.writeVariable(VP_Point_Four_Dis, Point_Four_buf_ch, 12, true);
const uint16_t Point_Five_buf_ch[] = { 0xDAB5, 0xE5CE, 0xE3B5, 0x2000 };
dgus.writeVariable(VP_Point_Five_Dis, Point_Five_buf_ch, 12, true);
const uint16_t Extrusion_buf_ch[] = { 0xB7BC, 0xF6B3, 0xB7CD, 0x2000 };
dgus.writeVariable(VP_Extrusion_Dis, Extrusion_buf_ch, 12, true);
const uint16_t HeatBed_buf_ch[] = { 0xC8C8, 0xB2B4, 0x2000 };
dgus.writeVariable(VP_HeatBed_Dis, HeatBed_buf_ch, 12, true);
const uint16_t FactoryDefaults_buf_ch[] = { 0xD6BB, 0xB4B8, 0xF6B3, 0xA7B3, 0xE8C9, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_FactoryDefaults_Dis, FactoryDefaults_buf_ch, 16, true);
const uint16_t StoreSetting_buf_ch[] = { 0xA3B1, 0xE6B4, 0xE8C9, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_StoreSetting_Dis, StoreSetting_buf_ch, 16, true);
const uint16_t PrintPauseConfig_buf_ch[] = { 0xDDD4, 0xA3CD, 0xBBCE, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_PrintPauseConfig_Dis, PrintPauseConfig_buf_ch, 32, true);
const uint16_t X_Pluse_buf_ch[] = { 0x2058, 0xE1D6, 0xF6C2, 0xE5B3, 0x2000 };
dgus.writeVariable(VP_X_Pluse_Dis, X_Pluse_buf_ch, 16, true);
const uint16_t Y_Pluse_buf_ch[] = { 0x2059, 0xE1D6, 0xF6C2, 0xE5B3, 0x2000 };
dgus.writeVariable(VP_Y_Pluse_Dis, Y_Pluse_buf_ch, 16, true);
const uint16_t Z_Pluse_buf_ch[] = { 0x205A, 0xE1D6, 0xF6C2, 0xE5B3, 0x2000 };
dgus.writeVariable(VP_Z_Pluse_Dis, Z_Pluse_buf_ch, 16, true);
const uint16_t E0_Pluse_buf_ch[] = { 0x3045, 0xE1D6, 0xF6C2, 0xE5B3, 0x2000 };
dgus.writeVariable(VP_E0_Pluse_Dis, E0_Pluse_buf_ch, 16, true);
const uint16_t E1_Pluse_buf_ch[] = { 0x3145, 0xE1D6, 0xF6C2, 0xE5B3, 0x2000 };
dgus.writeVariable(VP_E1_Pluse_Dis, E1_Pluse_buf_ch, 16, true);
const uint16_t X_Max_Speed_buf_ch[] = { 0x2058, 0xEED7, 0xF3B4, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_X_Max_Speed_Dis, X_Max_Speed_buf_ch, 16, true);
const uint16_t Y_Max_Speed_buf_ch[] = { 0x2059, 0xEED7, 0xF3B4, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Y_Max_Speed_Dis, Y_Max_Speed_buf_ch, 16, true);
const uint16_t Z_Max_Speed_buf_ch[] = { 0x205A, 0xEED7, 0xF3B4, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Z_Max_Speed_Dis, Z_Max_Speed_buf_ch, 16, true);
const uint16_t E0_Max_Speed_buf_ch[] = { 0x3045, 0xEED7, 0xF3B4, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_E0_Max_Speed_Dis, E0_Max_Speed_buf_ch, 16, true);
const uint16_t E1_Max_Speed_buf_ch[] = { 0x3145, 0xEED7, 0xF3B4, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_E1_Max_Speed_Dis, E1_Max_Speed_buf_ch, 16, true);
const uint16_t X_Max_Acc_Speed_buf_ch[] = { 0x2058, 0xEED7, 0xF3B4, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_X_Max_Acc_Speed_Dis, X_Max_Acc_Speed_buf_ch, 16, true);
const uint16_t Y_Max_Acc_Speed_buf_ch[] = { 0x2059, 0xEED7, 0xF3B4, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Y_Max_Acc_Speed_Dis, Y_Max_Acc_Speed_buf_ch, 16, true);
const uint16_t Z_Max_Acc_Speed_buf_ch[] = { 0x205A, 0xEED7, 0xF3B4, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Z_Max_Acc_Speed_Dis, Z_Max_Acc_Speed_buf_ch, 16, true);
const uint16_t E0_Max_Acc_Speed_buf_ch[] = { 0x3045, 0xEED7, 0xF3B4, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_E0_Max_Acc_Speed_Dis, E0_Max_Acc_Speed_buf_ch, 16, true);
const uint16_t E1_Max_Acc_Speed_buf_ch[] = { 0x3145, 0xEED7, 0xF3B4, 0xD3BC, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_E1_Max_Acc_Speed_Dis, E1_Max_Acc_Speed_buf_ch, 16, true);
const uint16_t X_PARK_POS_buf_ch[] = { 0x2058, 0xDDD4, 0xA3CD, 0xBBCE, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_X_PARK_POS_Dis, X_PARK_POS_buf_ch, 16, true);
const uint16_t Y_PARK_POS_buf_ch[] = { 0x2059, 0xDDD4, 0xA3CD, 0xBBCE, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_Y_PARK_POS_Dis, Y_PARK_POS_buf_ch, 16, true);
const uint16_t Z_PARK_POS_buf_ch[] = { 0x205A, 0xDDD4, 0xA3CD, 0xBBCE, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_Z_PARK_POS_Dis, Z_PARK_POS_buf_ch, 16, true);
const uint16_t Length_buf_ch[] = { 0xBDB2, 0xA4B3, 0x2000 };
dgus.writeVariable(VP_Length_Dis, Length_buf_ch, 8, true);
const uint16_t Speed_buf_ch[] = { 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Speed_Dis, Speed_buf_ch, 8, true);
const uint16_t InOut_buf_ch[] = { 0xF8BD, 0xF6B3, 0x2000 };
dgus.writeVariable(VP_InOut_Dis, InOut_buf_ch, 8, true);
const uint16_t PrintTimet_buf_en[] = { 0xF2B4, 0xA1D3, 0xB1CA, 0xE4BC, 0x2000 };
dgus.writeVariable(VP_PrintTime_Dis, PrintTimet_buf_en, 16, true);
const uint16_t E0_Temp_buf_ch[] = { 0x3045, 0xC2CE, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_E0_Temp_Dis, E0_Temp_buf_ch, 16, true);
const uint16_t E1_Temp_buf_ch[] = { 0x3145, 0xC2CE, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_E1_Temp_Dis, E1_Temp_buf_ch, 16, true);
const uint16_t HB_Temp_buf_ch[] = { 0xC8C8, 0xB2B4, 0xC2CE, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_HB_Temp_Dis, HB_Temp_buf_ch, 16, true);
const uint16_t Feedrate_buf_ch[] = { 0xB7BC, 0xF6B3, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Feedrate_Dis, Feedrate_buf_ch, 16, true);
const uint16_t PrintAcc_buf_ch[] = { 0xF2B4, 0xA1D3, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_PrintAcc_Dis, PrintAcc_buf_ch, 16, true);
const uint16_t FAN_Speed_buf_ch[] = { 0xE7B7, 0xC8C9, 0xD9CB, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Fan_Speed_Dis, FAN_Speed_buf_ch, 16, true);
const uint16_t Printing_buf_ch[] = { 0xF2B4, 0xA1D3, 0xD0D6, 0x2000 };
dgus.writeVariable(VP_Printing_Dis, Printing_buf_ch, 16, true);
const uint16_t Info_EEPROM_1_buf_ch[] = { 0xC7CA, 0xF1B7, 0xA3B1, 0xE6B4, 0xE8C9, 0xC3D6, 0xBFA3, 0x2000 };
dgus.writeVariable(VP_Info_EEPROM_1_Dis, Info_EEPROM_1_buf_ch, 32, true);
const uint16_t Info_EEPROM_2_buf_ch[] = { 0xC7CA, 0xF1B7, 0xD6BB, 0xB4B8, 0xF6B3, 0xA7B3, 0xE8C9, 0xC3D6, 0xBFA3, 0x2000 };
dgus.writeVariable(VP_Info_EEPROM_2_Dis, Info_EEPROM_2_buf_ch, 32, true);
const uint16_t TMC_X_Step_buf_ch[] = { 0x2058, 0xE9C1, 0xF4C3, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_TMC_X_Step_Dis, TMC_X_Step_buf_ch, 16, true);
const uint16_t TMC_Y_Step_buf_ch[] = { 0x2059, 0xE9C1, 0xF4C3, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_TMC_Y_Step_Dis, TMC_Y_Step_buf_ch, 16, true);
const uint16_t TMC_Z_Step_buf_ch[] = { 0x205A, 0xE9C1, 0xF4C3, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_TMC_Z_Step_Dis, TMC_Z_Step_buf_ch, 16, true);
const uint16_t Info_PrintFinish_1_buf_ch[] = { 0xF2B4, 0xA1D3, 0xEACD, 0xC9B3, 0x2000 };
dgus.writeVariable(VP_Info_PrintFinish_1_Dis, Info_PrintFinish_1_buf_ch, 32, true);
const uint16_t TMC_X_Current_buf_ch[] = { 0x2058, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_X_Current_Dis, TMC_X_Current_buf_ch, 16, true);
const uint16_t TMC_Y_Current_buf_ch[] = { 0x2059, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_Y_Current_Dis, TMC_Y_Current_buf_ch, 16, true);
const uint16_t TMC_Z_Current_buf_ch[] = { 0x205A, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_Z_Current_Dis, TMC_Z_Current_buf_ch, 16, true);
const uint16_t TMC_E0_Current_buf_ch[] = { 0x3045, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_E0_Current_Dis, TMC_E0_Current_buf_ch, 16, true);
const uint16_t TMC_X1_Current_buf_ch[] = { 0x3158, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_X1_Current_Dis, TMC_X1_Current_buf_ch, 16, true);
const uint16_t TMC_Y1_Current_buf_ch[] = { 0x3159, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_Y1_Current_Dis, TMC_Y1_Current_buf_ch, 16, true);
const uint16_t TMC_Z1_Current_buf_ch[] = { 0x315A, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_Z1_Current_Dis, TMC_Z1_Current_buf_ch, 16, true);
const uint16_t TMC_E1_Current_buf_ch[] = { 0x3145, 0xE1D6, 0xE7B5, 0xF7C1, 0x2000 };
dgus.writeVariable(VP_TMC_E1_Current_Dis, TMC_E1_Current_buf_ch, 16, true);
const uint16_t Min_Ex_Temp_buf_ch[] = { 0xEED7, 0xA1D0, 0xB7BC, 0xF6B3, 0xC2CE, 0xC8B6, 0x2000 };
dgus.writeVariable(VP_Min_Ex_Temp_Dis, Min_Ex_Temp_buf_ch, 32, true);
const uint16_t AutoLEVEL_INFO1_buf_ch[] = { 0xEBC7, 0xB4B0, 0xC2CF, 0xB4B0, 0xA5C5, 0x2000 };
dgus.writeVariable(VP_AutoLEVEL_INFO1, AutoLEVEL_INFO1_buf_ch, 32, true);
const uint16_t EX_TEMP_INFO2_buf_ch[] = { 0xEBC7, 0xD4C9, 0xC8B5, 0x2000 };
dgus.writeVariable(VP_EX_TEMP_INFO2_Dis, EX_TEMP_INFO2_buf_ch, 32, true);
const uint16_t EX_TEMP_INFO3_buf_ch[] = { 0xA1C8, 0xFBCF, 0xD3BC, 0xC8C8, 0x2000 };
dgus.writeVariable(VP_EX_TEMP_INFO3_Dis, EX_TEMP_INFO3_buf_ch, 32, true);
const uint16_t PrintConfrim_Info_buf_ch[] = { 0xC7CA, 0xF1B7, 0xAABF, 0xBCCA, 0xF2B4, 0xA1D3, 0x2000 };
dgus.writeVariable(VP_PrintConfrim_Info_Dis, PrintConfrim_Info_buf_ch, 32, true);
const uint16_t StopPrintConfrim_Info_buf_ch[] = { 0xC7CA, 0xF1B7, 0xA3CD, 0xB9D6, 0xF2B4, 0xA1D3, 0x2000 };
dgus.writeVariable(VP_StopPrintConfrim_Info_Dis, StopPrintConfrim_Info_buf_ch, 32, true);
const uint16_t Printting_buf_ch[] = { 0xF2B4, 0xA1D3, 0xD0D6, 0x2000 };
dgus.writeVariable(VP_Printting_Dis, Printting_buf_ch, 32, true);
const uint16_t LCD_BLK_buf_ch[] = { 0xB3B1, 0xE2B9, 0xE8C9, 0xC3D6, 0x2000 };
dgus.writeVariable(VP_LCD_BLK_Dis, LCD_BLK_buf_ch, 32, true);
}
}
#endif // DGUS_LCD_UI_MKS
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 69,546
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSScreenHandlerBase.h"
enum DGUS_ScreenID : uint8_t;
class DGUSScreenHandlerMKS : public DGUSScreenHandler {
public:
DGUSScreenHandlerMKS() = default;
#if 0
static void sendinfoscreen_ch(const uint16_t *line1, const uint16_t *line2, const uint16_t *line3, const uint16_t *line4);
static void sendinfoscreen_en(PGM_P const line1, PGM_P const line2, PGM_P const line3, PGM_P const line4);
static void sendInfoScreen(const void *line1, const void *line2, const void *line3, const void *line4, uint16_t language);
#endif
static void screenBackChange(DGUS_VP_Variable &var, void *val_ptr);
static void eepromControl(DGUS_VP_Variable &var, void *val_ptr);
static void languageChange(DGUS_VP_Variable &var, void *val_ptr);
static void getOffsetValue(DGUS_VP_Variable &var, void *val_ptr);
static void levelControl(DGUS_VP_Variable &var, void *val_ptr);
static void meshLevel(DGUS_VP_Variable &var, void *val_ptr);
static void meshLevelDistanceConfig(DGUS_VP_Variable &var, void *val_ptr);
static void manualAssistLeveling(DGUS_VP_Variable &var, void *val_ptr);
static void zOffsetConfirm(DGUS_VP_Variable &var, void *val_ptr);
static void zOffsetSelect(DGUS_VP_Variable &var, void *val_ptr);
static void getManualMovestep(DGUS_VP_Variable &var, void *val_ptr);
static void getZoffsetDistance(DGUS_VP_Variable &var, void *val_ptr);
static void getMinExtrudeTemp(DGUS_VP_Variable &var, void *val_ptr);
static void getParkPos(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(PREVENT_COLD_EXTRUSION)
static void handleGetExMinTemp(DGUS_VP_Variable &var, void *val_ptr);
#endif
static void languageDisplay(uint8_t var);
static void tmcChangeConfig(DGUS_VP_Variable &var, void *val_ptr);
static void getTurnOffCtrl(DGUS_VP_Variable &var, void *val_ptr);
static void languagePInit();
static void runoutIdle();
static void runoutInit();
static void extrudeLoadInit();
static void lcdBLKAdjust(DGUS_VP_Variable &var, void *val_ptr);
static void sdFileBack(DGUS_VP_Variable &var, void *val_ptr);
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
static void handleStepPerMMChanged(DGUS_VP_Variable &var, void *val_ptr);
static void handleStepPerMMExtruderChanged(DGUS_VP_Variable &var, void *val_ptr);
#endif
static void handleMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleExtruderMaxSpeedChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleAccChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleMaxAccChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleExtruderAccChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleChangeLevelPoint(DGUS_VP_Variable &var, void *val_ptr);
static void handleTravelAccChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleFeedRateMinChange(DGUS_VP_Variable &var, void *val_ptr);
static void handleMin_T_F(DGUS_VP_Variable &var, void *val_ptr);
#if HAS_PID_HEATING
static void filamentLoadUnload(DGUS_VP_Variable &var, void *val_ptr, const int filamentDir);
static void filamentLoad(DGUS_VP_Variable &var, void *val_ptr);
static void filamentUnload(DGUS_VP_Variable &var, void *val_ptr);
static void getManualFilament(DGUS_VP_Variable &var, void *val_ptr);
static void getManualFilamentSpeed(DGUS_VP_Variable &var, void *val_ptr);
#endif
#if HAS_MEDIA
// Marlin informed us about SD print completion.
static void sdPrintingFinished();
#else
static void printReturn(DGUS_VP_Variable &var, void *val_ptr);
#endif
static void sendPrintTimeToDisplay(DGUS_VP_Variable &var);
static void sendBabyStepToDisplay(DGUS_VP_Variable &var);
static void sendFanToDisplay(DGUS_VP_Variable &var);
static void sendGbkToDisplay(DGUS_VP_Variable &var);
static void sendStringToDisplay_Language(DGUS_VP_Variable &var);
static void sendTMCStepValue(DGUS_VP_Variable &var);
static void setUint8(DGUS_VP_Variable &var, void *val_ptr);
static bool loop();
};
enum MKS_Choose : uint8_t { MKS_Language_Choose, MKS_Language_NoChoose };
enum MKS_Language : uint8_t { MKS_SimpleChinese, MKS_English };
extern MKS_Language mks_language_index;
extern bool DGUSAutoTurnOff;
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER MKSLCD_SCREEN_PRINT
#define PLR_SCREEN_CANCEL MKSLCD_SCREEN_HOME
#endif
typedef DGUSScreenHandlerMKS DGUSScreenHandlerClass;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.h
|
C++
|
agpl-3.0
| 5,279
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/dgus/origin/DGUSDisplayDef.cpp
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_ORIGIN
#include "DGUSDisplayDef.h"
#include "../DGUSDisplay.h"
#include "../DGUSScreenHandler.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../../marlinui.h"
#include "../../ui_api.h"
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
uint16_t distanceToMove = 10;
#endif
using namespace ExtUI;
const uint16_t VPList_Boot[] PROGMEM = {
VP_MARLIN_VERSION,
0x0000
};
const uint16_t VPList_Main[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded.
0x0000
};
const uint16_t VPList_Temp[] PROGMEM = {
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
0x0000
};
const uint16_t VPList_Status[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HAS_HOTEND
VP_T_E0_Is, VP_T_E0_Set,
#if HAS_MULTI_HOTEND
VP_T_E1_Is, VP_T_E1_Set,
#endif
#endif
#if HAS_HEATED_BED
VP_T_Bed_Is, VP_T_Bed_Set,
#endif
#if HAS_FAN
VP_Fan0_Percentage,
#endif
VP_XPos, VP_YPos, VP_ZPos,
VP_Fan0_Percentage,
VP_Feedrate_Percentage,
VP_PrintProgress_Percentage,
0x0000
};
const uint16_t VPList_Status2[] PROGMEM = {
// VP_M117, for completeness, but it cannot be auto-uploaded
#if HAS_HOTEND
VP_Flowrate_E0,
#if HAS_MULTI_HOTEND
VP_Flowrate_E1,
#endif
#endif
VP_PrintProgress_Percentage,
VP_PrintTime,
0x0000
};
const uint16_t VPList_ManualMove[] PROGMEM = { VP_XPos, VP_YPos, VP_ZPos, 0x0000 };
const uint16_t VPList_ManualExtrude[] PROGMEM = { VP_EPos, 0x0000 };
const uint16_t VPList_FanAndFeedrate[] PROGMEM = { VP_Feedrate_Percentage, VP_Fan0_Percentage, 0x0000 };
const uint16_t VPList_SD_FlowRates[] PROGMEM = { VP_Flowrate_E0, VP_Flowrate_E1, 0x0000 };
const uint16_t VPList_SDFileList[] PROGMEM = { VP_SD_FileName0, VP_SD_FileName1, VP_SD_FileName2, VP_SD_FileName3, VP_SD_FileName4, 0x0000 };
const uint16_t VPList_SD_PrintManipulation[] PROGMEM = { VP_PrintProgress_Percentage, VP_PrintTime, 0x0000 };
const struct VPMapping VPMap[] PROGMEM = {
{ DGUS_SCREEN_BOOT, VPList_Boot },
{ DGUS_SCREEN_MAIN, VPList_Main },
{ DGUS_SCREEN_TEMPERATURE, VPList_Temp },
{ DGUS_SCREEN_STATUS, VPList_Status },
{ DGUS_SCREEN_STATUS2, VPList_Status2 },
{ DGUS_SCREEN_MANUALMOVE, VPList_ManualMove },
{ DGUS_SCREEN_MANUALEXTRUDE, VPList_ManualExtrude },
{ DGUS_SCREEN_FANANDFEEDRATE, VPList_FanAndFeedrate },
{ DGUS_SCREEN_FLOWRATES, VPList_SD_FlowRates },
{ DGUS_SCREEN_SDPRINTMANIPULATION, VPList_SD_PrintManipulation },
{ DGUS_SCREEN_SDFILELIST, VPList_SDFileList },
{ 0 , nullptr } // List is terminated with an nullptr as table entry.
};
const char MarlinVersion[] PROGMEM = SHORT_BUILD_VERSION;
const struct DGUS_VP_Variable ListOfVP[] PROGMEM = {
// Helper to detect touch events
VPHELPER(VP_SCREENCHANGE, nullptr, screen.screenChangeHook, nullptr),
VPHELPER(VP_SCREENCHANGE_ASK, nullptr, screen.screenChangeHookIfIdle, nullptr),
#if HAS_MEDIA
VPHELPER(VP_SCREENCHANGE_WHENSD, nullptr, screen.screenChangeHookIfSD, nullptr),
#endif
VPHELPER(VP_CONFIRMED, nullptr, screen.screenConfirmedOK, nullptr),
VPHELPER(VP_TEMP_ALL_OFF, nullptr, screen.handleAllHeatersOff, nullptr),
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
VPHELPER(VP_MOVE_OPTION, &distanceToMove, screen.handleManualMoveOption, nullptr),
#endif
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
VPHELPER(VP_MOVE_X, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, &distanceToMove, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, &distanceToMove, screen.handleManualMove, nullptr),
#else
VPHELPER(VP_MOVE_X, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Y, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_MOVE_Z, nullptr, screen.handleManualMove, nullptr),
VPHELPER(VP_HOME_ALL, nullptr, screen.handleManualMove, nullptr),
#endif
VPHELPER(VP_MOTOR_LOCK_UNLOK, nullptr, screen.handleMotorLockUnlock, nullptr),
#if ENABLED(POWER_LOSS_RECOVERY)
VPHELPER(VP_POWER_LOSS_RECOVERY, nullptr, screen.handlePowerLossRecovery, nullptr),
#endif
VPHELPER(VP_SETTINGS, nullptr, screen.handleSettings, nullptr),
{ .VP = VP_MARLIN_VERSION, .memadr = (void*)MarlinVersion, .size = VP_MARLIN_VERSION_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
// M117 LCD String (We don't need the string in memory but "just" push it to the display on demand, hence the nullptr
{ .VP = VP_M117, .memadr = nullptr, .size = VP_M117_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplay },
// Temperature Data
#if HAS_HOTEND
VPHELPER(VP_T_E0_Is, &thermalManager.temp_hotend[0].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E0_Set, &thermalManager.temp_hotend[0].target, screen.handleTemperatureChanged, &screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E0, nullptr, screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_EPos, &destination.e, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_MOVE_E0, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E0_CONTROL, &thermalManager.temp_hotend[0].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E0_STATUS, &thermalManager.temp_hotend[0].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(DGUS_PREHEAT_UI)
VPHELPER(VP_E0_BED_PREHEAT, nullptr, screen.handlePreheat, nullptr),
#endif
#if ENABLED(PIDTEMP)
VPHELPER(VP_E0_PID_P, &thermalManager.temp_hotend[0].pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_I, &thermalManager.temp_hotend[0].pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_E0_PID_D, &thermalManager.temp_hotend[0].pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_PID_AUTOTUNE_E0, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
VPHELPER(VP_E0_FILAMENT_LOAD_UNLOAD, nullptr, screen.handleFilamentOption, screen.handleFilamentLoadUnload),
#endif
#endif
#if HAS_MULTI_HOTEND
VPHELPER(VP_T_E1_Is, &thermalManager.temp_hotend[1].celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_E1_Set, &thermalManager.temp_hotend[1].target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_Flowrate_E1, nullptr, screen.handleFlowRateChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_MOVE_E1, nullptr, screen.handleManualExtrude, nullptr),
VPHELPER(VP_E1_CONTROL, &thermalManager.temp_hotend[1].target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_E1_STATUS, &thermalManager.temp_hotend[1].target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(PIDTEMP)
VPHELPER(VP_PID_AUTOTUNE_E1, nullptr, screen.handlePIDAutotune, nullptr),
#endif
#endif
#if HAS_HEATED_BED
VPHELPER(VP_T_Bed_Is, &thermalManager.temp_bed.celsius, nullptr, screen.sendFloatAsLongValueToDisplay<0>),
VPHELPER(VP_T_Bed_Set, &thermalManager.temp_bed.target, screen.handleTemperatureChanged, screen.sendWordValueToDisplay),
VPHELPER(VP_BED_CONTROL, &thermalManager.temp_bed.target, screen.handleHeaterControl, nullptr),
VPHELPER(VP_BED_STATUS, &thermalManager.temp_bed.target, nullptr, screen.sendHeaterStatusToDisplay),
#if ENABLED(PIDTEMPBED)
VPHELPER(VP_BED_PID_P, &thermalManager.temp_bed.pid.Kp, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_I, &thermalManager.temp_bed.pid.Ki, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
VPHELPER(VP_BED_PID_D, &thermalManager.temp_bed.pid.Kd, screen.handleTemperaturePIDChanged, screen.sendTemperaturePID),
#endif
#endif
// Fan Data
#if HAS_FAN
#define FAN_VPHELPER(N) \
VPHELPER(VP_Fan##N##_Percentage, &thermalManager.fan_speed[N], screen.percentageToUint8, screen.sendPercentageToDisplay), \
VPHELPER(VP_FAN##N##_CONTROL, &thermalManager.fan_speed[N], screen.handleFanControl, nullptr), \
VPHELPER(VP_FAN##N##_STATUS, &thermalManager.fan_speed[N], nullptr, screen.sendFanStatusToDisplay),
REPEAT(FAN_COUNT, FAN_VPHELPER)
#endif
// Feedrate
VPHELPER(VP_Feedrate_Percentage, &feedrate_percentage, screen.setValueDirectly<int16_t>, screen.sendWordValueToDisplay),
// Position Data
VPHELPER(VP_XPos, ¤t_position.x, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_YPos, ¤t_position.y, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
VPHELPER(VP_ZPos, ¤t_position.z, nullptr, screen.sendFloatAsLongValueToDisplay<2>),
// Print Progress
VPHELPER(VP_PrintProgress_Percentage, nullptr, nullptr, screen.sendPrintProgressToDisplay),
// Print Time
VPHELPER_STR(VP_PrintTime, nullptr, VP_PrintTime_LEN, nullptr, screen.sendPrintTimeToDisplay),
#if ENABLED(PRINTCOUNTER)
VPHELPER_STR(VP_PrintAccTime, nullptr, VP_PrintAccTime_LEN, nullptr, screen.sendPrintAccTimeToDisplay),
VPHELPER_STR(VP_PrintsTotal, nullptr, VP_PrintsTotal_LEN, nullptr, screen.sendPrintsTotalToDisplay),
#endif
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
VPHELPER(VP_X_STEP_PER_MM, &planner.settings.axis_steps_per_mm[X_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Y_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Y_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
VPHELPER(VP_Z_STEP_PER_MM, &planner.settings.axis_steps_per_mm[Z_AXIS], screen.handleStepPerMMChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_HOTEND
VPHELPER(VP_E0_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(0)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#if HAS_MULTI_HOTEND
VPHELPER(VP_E1_STEP_PER_MM, &planner.settings.axis_steps_per_mm[E_AXIS_N(1)], screen.handleStepPerMMExtruderChanged, screen.sendFloatAsIntValueToDisplay<1>),
#endif
#endif
#endif
// SDCard File listing.
#if HAS_MEDIA
VPHELPER(VP_SD_ScrollEvent, nullptr, screen.sdScrollFilelist, nullptr),
VPHELPER(VP_SD_FileSelected, nullptr, screen.sdFileSelected, nullptr),
VPHELPER(VP_SD_FileSelectConfirm, nullptr, screen.sdStartPrint, nullptr),
VPHELPER_STR(VP_SD_FileName0, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName1, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName2, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName3, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER_STR(VP_SD_FileName4, nullptr, VP_SD_FileName_LEN, nullptr, screen.sdSendFilename),
VPHELPER(VP_SD_ResumePauseAbort, nullptr, screen.sdResumePauseAbort, nullptr),
VPHELPER(VP_SD_AbortPrintConfirmed, nullptr, screen.sdReallyAbort, nullptr),
VPHELPER(VP_SD_Print_Setting, nullptr, screen.sdPrintTune, nullptr),
#if HAS_BED_PROBE
VPHELPER(VP_SD_Print_ProbeOffsetZ, &probe.offset.z, screen.handleProbeOffsetZChanged, screen.sendFloatAsIntValueToDisplay<2>),
#if ENABLED(BABYSTEPPING)
VPHELPER(VP_SD_Print_LiveAdjustZ, nullptr, screen.handleLiveAdjustZ, nullptr),
#endif
#endif
#endif
#if ENABLED(DGUS_UI_WAITING)
VPHELPER(VP_WAITING_STATUS, nullptr, nullptr, screen.sendWaitingStatusToDisplay),
#endif
// Messages for the User, shared by the popup and the kill screen. They can't be autouploaded as we do not buffer content.
{ .VP = VP_MSGSTR1, .memadr = nullptr, .size = VP_MSGSTR1_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR2, .memadr = nullptr, .size = VP_MSGSTR2_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR3, .memadr = nullptr, .size = VP_MSGSTR3_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
{ .VP = VP_MSGSTR4, .memadr = nullptr, .size = VP_MSGSTR4_LEN, .set_by_display_handler = nullptr, .send_to_display_handler = screen.sendStringToDisplayPGM },
VPHELPER(0, 0, 0, 0) // must be last entry.
};
#endif // DGUS_LCD_UI_ORIGIN
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/origin/DGUSDisplayDef.cpp
|
C++
|
agpl-3.0
| 13,850
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSDisplayDef.h"
enum DGUS_ScreenID : uint8_t {
DGUS_SCREEN_BOOT = 0,
DGUS_SCREEN_MAIN = 10,
DGUS_SCREEN_TEMPERATURE = 20,
DGUS_SCREEN_STATUS = 30,
DGUS_SCREEN_STATUS2 = 32,
DGUS_SCREEN_MANUALMOVE = 40,
DGUS_SCREEN_MANUALEXTRUDE = 42,
DGUS_SCREEN_FANANDFEEDRATE = 44,
DGUS_SCREEN_FLOWRATES = 46,
DGUS_SCREEN_SDFILELIST = 50,
DGUS_SCREEN_SDPRINTMANIPULATION = 52,
DGUS_SCREEN_POWER_LOSS = 100,
DGUS_SCREEN_PREHEAT = 120,
DGUS_SCREEN_UTILITY = 110,
DGUS_SCREEN_FILAMENT_HEATING = 146,
DGUS_SCREEN_FILAMENT_LOADING = 148,
DGUS_SCREEN_FILAMENT_UNLOADING = 158,
DGUS_SCREEN_SDPRINTTUNE = 170,
DGUS_SCREEN_CONFIRM = 240,
DGUS_SCREEN_KILL = 250, ///< Kill Screen. Must always be 250 (to be able to display "Error wrong LCD Version")
DGUS_SCREEN_WAITING = 251,
DGUS_SCREEN_POPUP = 252, ///< special target, popup screen will also return this code to say "return to previous screen"
DGUS_SCREEN_UNUSED = 255
};
// Display Memory layout used (T5UID)
// Except system variables this is arbitrary, just to organize stuff....
// 0x0000 .. 0x0FFF -- System variables and reserved by the display
// 0x1000 .. 0x1FFF -- Variables to never change location, regardless of UI Version
// 0x2000 .. 0x2FFF -- Controls (VPs that will trigger some action)
// 0x3000 .. 0x4FFF -- Marlin Data to be displayed
// 0x5000 .. -- SPs (if we want to modify display elements, e.g change color or like) -- currently unused
// As there is plenty of space (at least most displays have >8k RAM), we do not pack them too tight,
// so that we can keep variables nicely together in the address space.
// UI Version always on 0x1000...0x1002 so that the firmware can check this and bail out.
constexpr uint16_t VP_UI_VERSION_MAJOR = 0x1000; // Major -- incremented when incompatible
constexpr uint16_t VP_UI_VERSION_MINOR = 0x1001; // Minor -- incremented on new features, but compatible
constexpr uint16_t VP_UI_VERSION_PATCH = 0x1002; // Patch -- fixed which do not change functionality.
constexpr uint16_t VP_UI_FLAVOUR = 0x1010; // lets reserve 16 bytes here to determine if UI is suitable for this Marlin. tbd.
// Storage space for the Killscreen messages. 0x1100 - 0x1200 . Reused for the popup.
constexpr uint16_t VP_MSGSTR1 = 0x1100;
constexpr uint8_t VP_MSGSTR1_LEN = 0x20; // might be more place for it...
constexpr uint16_t VP_MSGSTR2 = 0x1140;
constexpr uint8_t VP_MSGSTR2_LEN = 0x20;
constexpr uint16_t VP_MSGSTR3 = 0x1180;
constexpr uint8_t VP_MSGSTR3_LEN = 0x20;
constexpr uint16_t VP_MSGSTR4 = 0x11C0;
constexpr uint8_t VP_MSGSTR4_LEN = 0x20;
// Screenchange request for screens that only make sense when printer is idle.
// e.g movement is only allowed if printer is not printing.
// Marlin must confirm by setting the screen manually.
constexpr uint16_t VP_SCREENCHANGE_ASK = 0x2000;
constexpr uint16_t VP_SCREENCHANGE = 0x2001; // Key-Return button to new menu pressed. Data contains target screen in low byte and info in high byte.
constexpr uint16_t VP_TEMP_ALL_OFF = 0x2002; // Turn all heaters off. Value arbitrary ;)=
constexpr uint16_t VP_SCREENCHANGE_WHENSD = 0x2003; // "Print" Button touched -- go only there if there is an SD Card.
constexpr uint16_t VP_CONFIRMED = 0x2010; // OK on confirm screen.
// Buttons on the SD-Card File listing.
constexpr uint16_t VP_SD_ScrollEvent = 0x2020; // Data: 0 for "up a directory", numbers are the amount to scroll, e.g -1 one up, 1 one down
constexpr uint16_t VP_SD_FileSelected = 0x2022; // Number of file field selected.
constexpr uint16_t VP_SD_FileSelectConfirm = 0x2024; // (This is a virtual VP and emulated by the Confirm Screen when a file has been confirmed)
constexpr uint16_t VP_SD_ResumePauseAbort = 0x2026; // Resume(Data=0), Pause(Data=1), Abort(Data=2) SD Card prints
constexpr uint16_t VP_SD_AbortPrintConfirmed = 0x2028; // Abort print confirmation (virtual, will be injected by the confirm dialog)
constexpr uint16_t VP_SD_Print_Setting = 0x2040;
constexpr uint16_t VP_SD_Print_LiveAdjustZ = 0x2050; // Data: 0 down, 1 up
// Controls for movement (we can't use the incremental / decremental feature of the display at this feature works only with 16 bit values
// (which would limit us to 655.35mm, which is likely not a problem for common setups, but i don't want to rule out hangprinters support)
// A word about the coding: The VP will be per axis and the return code will be an signed 16 bit value in 0.01 mm resolution, telling us
// the relative travel amount t he user wants to do. So eg. if the display sends us VP=2100 with value 100, the user wants us to move X by +1 mm.
constexpr uint16_t VP_MOVE_X = 0x2100;
constexpr uint16_t VP_MOVE_Y = 0x2102;
constexpr uint16_t VP_MOVE_Z = 0x2104;
constexpr uint16_t VP_MOVE_E0 = 0x2110;
constexpr uint16_t VP_MOVE_E1 = 0x2112;
//constexpr uint16_t VP_MOVE_E2 = 0x2114;
//constexpr uint16_t VP_MOVE_E3 = 0x2116;
//constexpr uint16_t VP_MOVE_E4 = 0x2118;
//constexpr uint16_t VP_MOVE_E5 = 0x211A;
constexpr uint16_t VP_HOME_ALL = 0x2120;
constexpr uint16_t VP_MOTOR_LOCK_UNLOK = 0x2130;
// Power loss recovery
constexpr uint16_t VP_POWER_LOSS_RECOVERY = 0x2180;
// Fan Control Buttons , switch between "off" and "on"
constexpr uint16_t VP_FAN0_CONTROL = 0x2200;
constexpr uint16_t VP_FAN1_CONTROL = 0x2202;
//constexpr uint16_t VP_FAN2_CONTROL = 0x2204;
//constexpr uint16_t VP_FAN3_CONTROL = 0x2206;
// Heater Control Buttons , triged between "cool down" and "heat PLA" state
constexpr uint16_t VP_E0_CONTROL = 0x2210;
constexpr uint16_t VP_E1_CONTROL = 0x2212;
//constexpr uint16_t VP_E2_CONTROL = 0x2214;
//constexpr uint16_t VP_E3_CONTROL = 0x2216;
//constexpr uint16_t VP_E4_CONTROL = 0x2218;
//constexpr uint16_t VP_E5_CONTROL = 0x221A;
constexpr uint16_t VP_BED_CONTROL = 0x221C;
// Preheat
constexpr uint16_t VP_E0_BED_PREHEAT = 0x2220;
constexpr uint16_t VP_E1_BED_CONTROL = 0x2222;
//constexpr uint16_t VP_E2_BED_CONTROL = 0x2224;
//constexpr uint16_t VP_E3_BED_CONTROL = 0x2226;
//constexpr uint16_t VP_E4_BED_CONTROL = 0x2228;
//constexpr uint16_t VP_E5_BED_CONTROL = 0x222A;
// Filament load and unload
constexpr uint16_t VP_E0_FILAMENT_LOAD_UNLOAD = 0x2300;
constexpr uint16_t VP_E1_FILAMENT_LOAD_UNLOAD = 0x2302;
// Settings store , reset
constexpr uint16_t VP_SETTINGS = 0x2400;
// PID autotune
constexpr uint16_t VP_PID_AUTOTUNE_E0 = 0x2410;
//constexpr uint16_t VP_PID_AUTOTUNE_E1 = 0x2412;
//constexpr uint16_t VP_PID_AUTOTUNE_E2 = 0x2414;
//constexpr uint16_t VP_PID_AUTOTUNE_E3 = 0x2416;
//constexpr uint16_t VP_PID_AUTOTUNE_E4 = 0x2418;
//constexpr uint16_t VP_PID_AUTOTUNE_E5 = 0x241A;
constexpr uint16_t VP_PID_AUTOTUNE_BED = 0x2420;
// Firmware version on the boot screen.
constexpr uint16_t VP_MARLIN_VERSION = 0x3000;
constexpr uint8_t VP_MARLIN_VERSION_LEN = 16; // there is more space on the display, if needed.
// Place for status messages.
constexpr uint16_t VP_M117 = 0x3020;
constexpr uint8_t VP_M117_LEN = 0x20;
// Temperatures.
constexpr uint16_t VP_T_E0_Is = 0x3060; // 4 Byte Integer
constexpr uint16_t VP_T_E0_Set = 0x3062; // 2 Byte Integer
constexpr uint16_t VP_T_E1_Is = 0x3064; // 4 Byte Integer
// reserved to support up to 6 Extruders:
//constexpr uint16_t VP_T_E1_Set = 0x3066; // 2 Byte Integer
//constexpr uint16_t VP_T_E2_Is = 0x3068; // 4 Byte Integer
//constexpr uint16_t VP_T_E2_Set = 0x306A; // 2 Byte Integer
//constexpr uint16_t VP_T_E3_Is = 0x306C; // 4 Byte Integer
//constexpr uint16_t VP_T_E3_Set = 0x306E; // 2 Byte Integer
//constexpr uint16_t VP_T_E4_Is = 0x3070; // 4 Byte Integer
//constexpr uint16_t VP_T_E4_Set = 0x3072; // 2 Byte Integer
//constexpr uint16_t VP_T_E4_Is = 0x3074; // 4 Byte Integer
//constexpr uint16_t VP_T_E4_Set = 0x3076; // 2 Byte Integer
//constexpr uint16_t VP_T_E5_Is = 0x3078; // 4 Byte Integer
//constexpr uint16_t VP_T_E5_Set = 0x307A; // 2 Byte Integer
constexpr uint16_t VP_T_Bed_Is = 0x3080; // 4 Byte Integer
constexpr uint16_t VP_T_Bed_Set = 0x3082; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E0 = 0x3090; // 2 Byte Integer
constexpr uint16_t VP_Flowrate_E1 = 0x3092; // 2 Byte Integer
// reserved for up to 6 Extruders:
//constexpr uint16_t VP_Flowrate_E2 = 0x3094;
//constexpr uint16_t VP_Flowrate_E3 = 0x3096;
//constexpr uint16_t VP_Flowrate_E4 = 0x3098;
//constexpr uint16_t VP_Flowrate_E5 = 0x309A;
constexpr uint16_t VP_Fan0_Percentage = 0x3100; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Fan1_Percentage = 0x33A2; // 2 Byte Integer (0..100)
//constexpr uint16_t VP_Fan2_Percentage = 0x33A4; // 2 Byte Integer (0..100)
//constexpr uint16_t VP_Fan3_Percentage = 0x33A6; // 2 Byte Integer (0..100)
constexpr uint16_t VP_Feedrate_Percentage = 0x3102; // 2 Byte Integer (0..100)
constexpr uint16_t VP_PrintProgress_Percentage = 0x3104; // 2 Byte Integer (0..100)
constexpr uint16_t VP_PrintTime = 0x3106;
constexpr uint16_t VP_PrintTime_LEN = 10;
constexpr uint16_t VP_PrintAccTime = 0x3160;
constexpr uint16_t VP_PrintAccTime_LEN = 32;
constexpr uint16_t VP_PrintsTotal = 0x3180;
constexpr uint16_t VP_PrintsTotal_LEN = 16;
// Actual Position
constexpr uint16_t VP_XPos = 0x3110; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_YPos = 0x3112; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_ZPos = 0x3114; // 4 Byte Fixed point number; format xxx.yy
constexpr uint16_t VP_EPos = 0x3120; // 4 Byte Fixed point number; format xxx.yy
// SDCard File Listing
constexpr uint16_t VP_SD_FileName_LEN = 32; // LEN is shared for all entries.
constexpr uint16_t DGUS_SD_FILESPERSCREEN = 5; // FIXME move that info to the display and read it from there.
constexpr uint16_t VP_SD_FileName0 = 0x3200;
constexpr uint16_t VP_SD_FileName1 = 0x3220;
constexpr uint16_t VP_SD_FileName2 = 0x3240;
constexpr uint16_t VP_SD_FileName3 = 0x3260;
constexpr uint16_t VP_SD_FileName4 = 0x3280;
constexpr uint16_t VP_SD_Print_ProbeOffsetZ = 0x32A0; //
constexpr uint16_t VP_SD_Print_Filename = 0x32C0; //
// Fan status
constexpr uint16_t VP_FAN0_STATUS = 0x3300;
constexpr uint16_t VP_FAN1_STATUS = 0x3302;
//constexpr uint16_t VP_FAN2_STATUS = 0x3304;
//constexpr uint16_t VP_FAN3_STATUS = 0x3306;
// Heater status
constexpr uint16_t VP_E0_STATUS = 0x3310;
//constexpr uint16_t VP_E1_STATUS = 0x3312;
//constexpr uint16_t VP_E2_STATUS = 0x3314;
//constexpr uint16_t VP_E3_STATUS = 0x3316;
//constexpr uint16_t VP_E4_STATUS = 0x3318;
//constexpr uint16_t VP_E5_STATUS = 0x331A;
constexpr uint16_t VP_BED_STATUS = 0x331C;
constexpr uint16_t VP_MOVE_OPTION = 0x3400;
// Step per mm
constexpr uint16_t VP_X_STEP_PER_MM = 0x3600; // at the moment , uint16_t , 0~1638.4
//constexpr uint16_t VP_X2_STEP_PER_MM = 0x3602;
constexpr uint16_t VP_Y_STEP_PER_MM = 0x3604;
//constexpr uint16_t VP_Y2_STEP_PER_MM = 0x3606;
constexpr uint16_t VP_Z_STEP_PER_MM = 0x3608;
//constexpr uint16_t VP_Z2_STEP_PER_MM = 0x360A;
constexpr uint16_t VP_E0_STEP_PER_MM = 0x3610;
//constexpr uint16_t VP_E1_STEP_PER_MM = 0x3612;
//constexpr uint16_t VP_E2_STEP_PER_MM = 0x3614;
//constexpr uint16_t VP_E3_STEP_PER_MM = 0x3616;
//constexpr uint16_t VP_E4_STEP_PER_MM = 0x3618;
//constexpr uint16_t VP_E5_STEP_PER_MM = 0x361A;
// PIDs
constexpr uint16_t VP_E0_PID_P = 0x3700; // at the moment , uint16_t , 0~1638.4
constexpr uint16_t VP_E0_PID_I = 0x3702;
constexpr uint16_t VP_E0_PID_D = 0x3704;
constexpr uint16_t VP_BED_PID_P = 0x3710;
constexpr uint16_t VP_BED_PID_I = 0x3712;
constexpr uint16_t VP_BED_PID_D = 0x3714;
// Waiting screen status
constexpr uint16_t VP_WAITING_STATUS = 0x3800;
// SPs for certain variables...
// located at 0x5000 and up
// Not used yet!
// This can be used e.g to make controls / data display invisible
constexpr uint16_t SP_T_E0_Is = 0x5000;
constexpr uint16_t SP_T_E0_Set = 0x5010;
constexpr uint16_t SP_T_E1_Is = 0x5020;
constexpr uint16_t SP_T_Bed_Is = 0x5030;
constexpr uint16_t SP_T_Bed_Set = 0x5040;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/origin/DGUSDisplayDef.h
|
C++
|
agpl-3.0
| 12,976
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_ORIGIN
#include "../DGUSScreenHandler.h"
#include "../../../../MarlinCore.h"
#include "../../../../gcode/queue.h"
#include "../../../../libs/duration_t.h"
#include "../../../../module/settings.h"
#include "../../../../module/temperature.h"
#include "../../../../module/motion.h"
#include "../../../../module/planner.h"
#include "../../../../module/printcounter.h"
#include "../../../../sd/cardreader.h"
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../../feature/powerloss.h"
#endif
#if HAS_MEDIA
extern ExtUI::FileList filelist;
void DGUSScreenHandler::sdFileSelected(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t touched_nr = (int16_t)swap16(*(uint16_t*)val_ptr) + top_file;
if (touched_nr > filelist.count()) return;
if (!filelist.seek(touched_nr)) return;
if (filelist.isDir()) {
filelist.changeDir(filelist.filename());
top_file = 0;
forceCompleteUpdate();
return;
}
#if ENABLED(DGUS_PRINT_FILENAME)
// Send print filename
dgus.writeVariable(VP_SD_Print_Filename, filelist.filename(), VP_SD_FileName_LEN, true);
#endif
// Setup Confirmation screen
file_to_print = touched_nr;
handleUserConfirmationPopUp(VP_SD_FileSelectConfirm, nullptr, PSTR("Print file"), filelist.filename(), PSTR("from SD Card?"), true, true, false, true);
}
void DGUSScreenHandler::sdStartPrint(DGUS_VP_Variable &var, void *val_ptr) {
if (!filelist.seek(file_to_print)) return;
ExtUI::printFile(filelist.shortFilename());
gotoScreen(DGUS_SCREEN_STATUS);
}
void DGUSScreenHandler::sdResumePauseAbort(DGUS_VP_Variable &var, void *val_ptr) {
if (!ExtUI::isPrintingFromMedia()) return; // avoid race condition when user stays in this menu and printer finishes.
switch (swap16(*(uint16_t*)val_ptr)) {
case 0: { // Resume
if (ExtUI::isPrintingFromMediaPaused()) {
ExtUI::resumePrint();
}
} break;
case 1: // Pause
gotoScreen(DGUS_SCREEN_SDPRINTMANIPULATION);
if (!ExtUI::isPrintingFromMediaPaused()) {
ExtUI::pausePrint();
//ExtUI::mks_pausePrint();
}
break;
case 2: // Abort
handleUserConfirmationPopUp(VP_SD_AbortPrintConfirmed, nullptr, PSTR("Abort printing"), filelist.filename(), PSTR("?"), true, true, false, true);
break;
}
}
void DGUSScreenHandler::sdSendFilename(DGUS_VP_Variable& var) {
uint16_t target_line = (var.VP - VP_SD_FileName0) / VP_SD_FileName_LEN;
if (target_line > DGUS_SD_FILESPERSCREEN) return;
char tmpfilename[VP_SD_FileName_LEN + 1] = "";
var.memadr = (void*)tmpfilename;
if (filelist.seek(top_file + target_line)) {
snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s%c"), filelist.filename(), filelist.isDir() ? '/' : 0); // snprintf_P(tmpfilename, VP_SD_FileName_LEN, PSTR("%s"), filelist.filename());
}
sendStringToDisplay(var);
}
void DGUSScreenHandler::sdCardInserted() {
top_file = 0;
filelist.refresh();
auto cs = getCurrentScreen();
if (cs == DGUS_SCREEN_MAIN || cs == DGUS_SCREEN_STATUS)
gotoScreen(DGUS_SCREEN_SDFILELIST);
}
void DGUSScreenHandler::sdCardRemoved() {
if (current_screenID == DGUS_SCREEN_SDFILELIST
|| (current_screenID == DGUS_SCREEN_CONFIRM && (confirmVP == VP_SD_AbortPrintConfirmed || confirmVP == VP_SD_FileSelectConfirm))
|| current_screenID == DGUS_SCREEN_SDPRINTMANIPULATION
) gotoScreen(DGUS_SCREEN_MAIN);
}
#endif // HAS_MEDIA
void DGUSScreenHandler::screenChangeHook(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t *tmp = (uint8_t*)val_ptr;
// The keycode in target is coded as <from-frame><to-frame>, so 0x0100A means
// from screen 1 (main) to 10 (temperature). DGUS_SCREEN_POPUP is special,
// meaning "return to previous screen"
DGUS_ScreenID target = (DGUS_ScreenID)tmp[1];
if (target == DGUS_SCREEN_POPUP) {
// Special handling for popup is to return to previous menu
if (current_screenID == DGUS_SCREEN_POPUP && confirm_action_cb) confirm_action_cb();
popToOldScreen();
return;
}
updateNewScreen(target);
#ifdef DEBUG_DGUSLCD
if (!findScreenVPMapList(target)) DEBUG_ECHOLNPGM("WARNING: No screen Mapping found for ", target);
#endif
}
void DGUSScreenHandler::handleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
int16_t movevalue = swap16(*(uint16_t*)val_ptr);
#if ENABLED(DGUS_UI_MOVE_DIS_OPTION)
if (movevalue) {
const uint16_t choice = *(uint16_t*)var.memadr;
movevalue = movevalue < 0 ? -choice : choice;
}
#endif
char axiscode;
uint16_t speed = manual_feedrate_mm_m.x; // Default feedrate for manual moves
switch (var.VP) {
default: return;
#if HAS_X_AXIS
case VP_MOVE_X:
axiscode = 'X';
if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
break;
#endif
#if HAS_Y_AXIS
case VP_MOVE_Y:
axiscode = 'Y';
speed = manual_feedrate_mm_m.y;
if (!ExtUI::canMove(ExtUI::axis_t::Y)) goto cannotmove;
break;
#endif
#if HAS_Z_AXIS
case VP_MOVE_Z:
axiscode = 'Z';
speed = manual_feedrate_mm_m.z;
if (!ExtUI::canMove(ExtUI::axis_t::Z)) goto cannotmove;
break;
#endif
case VP_HOME_ALL: // only used for homing
axiscode = '\0';
movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
break;
}
if (!movevalue) {
// homing
char buf[6] = "G28 X";
buf[4] = axiscode;
queue.enqueue_one_now(buf);
forceCompleteUpdate();
return;
}
else {
// movement
const bool old_relative_mode = relative_mode;
if (!relative_mode) queue.enqueue_now(F("G91"));
char buf[32]; // G1 X9999.99 F12345
const uint16_t backup_speed = MMS_TO_MMM(feedrate_mm_s);
char sign[] = "\0";
int16_t value = movevalue / 100;
if (movevalue < 0) { value = -value; sign[0] = '-'; }
int16_t fraction = ABS(movevalue) % 100;
snprintf_P(buf, 32, PSTR("G0 %c%s%d.%02d F%d"), axiscode, sign, value, fraction, speed);
queue.enqueue_one_now(buf);
if (backup_speed != speed) {
snprintf_P(buf, 32, PSTR("G0 F%d"), backup_speed);
queue.enqueue_one_now(buf);
}
//while (!enqueue_and_echo_command(buf)) idle();
if (!old_relative_mode) queue.enqueue_now(F("G90"));
}
forceCompleteUpdate();
cannotmove:
return;
}
#if HAS_PID_HEATING
void DGUSScreenHandler::handleTemperaturePIDChanged(DGUS_VP_Variable &var, void *val_ptr) {
uint16_t rawvalue = swap16(*(uint16_t*)val_ptr);
float value = (float)rawvalue / 10;
float newvalue = 0;
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_PID_P: newvalue = value; break;
case VP_E0_PID_I: newvalue = scalePID_i(value); break;
case VP_E0_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_PID_P: newvalue = value; break;
case VP_E1_PID_I: newvalue = scalePID_i(value); break;
case VP_E1_PID_D: newvalue = scalePID_d(value); break;
#endif
#if HAS_HEATED_BED
case VP_BED_PID_P: newvalue = value; break;
case VP_BED_PID_I: newvalue = scalePID_i(value); break;
case VP_BED_PID_D: newvalue = scalePID_d(value); break;
#endif
}
*(float *)var.memadr = newvalue;
skipVP = var.VP; // don't overwrite value the next update time as the display might autoincrement in parallel
}
#endif // HAS_PID_HEATING
#if ENABLED(BABYSTEPPING)
void DGUSScreenHandler::handleLiveAdjustZ(DGUS_VP_Variable &var, void *val_ptr) {
int16_t flag = swap16(*(uint16_t*)val_ptr),
steps = flag ? -20 : 20;
ExtUI::smartAdjustAxis_steps(steps, ExtUI::axis_t::Z, true);
forceCompleteUpdate();
}
#endif
#if ENABLED(DGUS_FILAMENT_LOADUNLOAD)
void DGUSScreenHandler::handleFilamentOption(DGUS_VP_Variable &var, void *val_ptr) {
uint8_t e_temp = 0;
filament_data.heated = false;
uint16_t preheat_option = swap16(*(uint16_t*)val_ptr);
if (preheat_option <= 8) { // Load filament type
filament_data.action = 1;
}
else if (preheat_option >= 10) { // Unload filament type
preheat_option -= 10;
filament_data.action = 2;
filament_data.purge_length = DGUS_FILAMENT_PURGE_LENGTH;
}
else { // Cancel filament operation
filament_data.action = 0;
}
switch (preheat_option) {
case 0: // Load PLA
#ifdef PREHEAT_1_TEMP_HOTEND
e_temp = PREHEAT_1_TEMP_HOTEND;
#endif
break;
case 1: // Load ABS
TERN_(PREHEAT_2_TEMP_HOTEND, e_temp = PREHEAT_2_TEMP_HOTEND);
break;
case 2: // Load PET
#ifdef PREHEAT_3_TEMP_HOTEND
e_temp = PREHEAT_3_TEMP_HOTEND;
#endif
break;
case 3: // Load FLEX
#ifdef PREHEAT_4_TEMP_HOTEND
e_temp = PREHEAT_4_TEMP_HOTEND;
#endif
break;
case 9: // Cool down
default:
e_temp = 0;
break;
}
if (filament_data.action == 0) { // Go back to utility screen
#if HAS_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E0);
#if HAS_MULTI_HOTEND
thermalManager.setTargetHotend(e_temp, ExtUI::extruder_t::E1);
#endif
#endif
gotoScreen(DGUS_SCREEN_UTILITY);
}
else { // Go to the preheat screen to show the heating progress
switch (var.VP) {
default: return;
#if HAS_HOTEND
case VP_E0_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E0;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
#if HAS_MULTI_HOTEND
case VP_E1_FILAMENT_LOAD_UNLOAD:
filament_data.extruder = ExtUI::extruder_t::E1;
thermalManager.setTargetHotend(e_temp, filament_data.extruder);
break;
#endif
}
gotoScreen(DGUS_SCREEN_FILAMENT_HEATING);
}
}
void DGUSScreenHandler::handleFilamentLoadUnload(DGUS_VP_Variable &var) {
if (filament_data.action <= 0) return;
// If we close to the target temperature, we can start load or unload the filament
if (thermalManager.hotEnoughToExtrude(filament_data.extruder) && \
thermalManager.targetHotEnoughToExtrude(filament_data.extruder)) {
float movevalue = DGUS_FILAMENT_LOAD_LENGTH_PER_TIME;
if (filament_data.action == 1) { // load filament
if (!filament_data.heated) {
//gotoScreen(DGUS_SCREEN_FILAMENT_LOADING);
filament_data.heated = true;
}
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
}
else { // unload filament
if (!filament_data.heated) {
gotoScreen(DGUS_SCREEN_FILAMENT_UNLOADING);
filament_data.heated = true;
}
// Before unloading extrude to prevent jamming
if (filament_data.purge_length >= 0) {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) + movevalue;
filament_data.purge_length -= movevalue;
}
else {
movevalue = ExtUI::getAxisPosition_mm(filament_data.extruder) - movevalue;
}
}
ExtUI::setAxisPosition_mm(movevalue, filament_data.extruder);
}
}
#endif // DGUS_FILAMENT_LOADUNLOAD
bool DGUSScreenHandler::loop() {
dgus.loop();
const millis_t ms = millis();
static millis_t next_event_ms = 0;
if (!isScreenComplete() || ELAPSED(ms, next_event_ms)) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
updateScreenVPData();
}
#if ENABLED(SHOW_BOOTSCREEN)
static bool booted = false;
if (!booted && TERN0(POWER_LOSS_RECOVERY, recovery.valid()))
booted = true;
if (!booted && ELAPSED(ms, BOOTSCREEN_TIMEOUT)) {
booted = true;
gotoScreen(TERN0(POWER_LOSS_RECOVERY, recovery.valid()) ? DGUS_SCREEN_POWER_LOSS : DGUS_SCREEN_MAIN);
}
#endif
return isScreenComplete();
}
#endif // DGUS_LCD_UI_ORIGIN
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 13,102
|
/**
* 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../DGUSScreenHandlerBase.h"
typedef DGUSScreenHandler DGUSScreenHandlerClass;
#if ENABLED(POWER_LOSS_RECOVERY)
#define PLR_SCREEN_RECOVER DGUS_SCREEN_SDPRINTMANIPULATION
#define PLR_SCREEN_CANCEL DGUS_SCREEN_STATUS
#endif
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.h
|
C
|
agpl-3.0
| 1,114
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
/* DGUS implementation written by coldtobi in 2019 for Marlin */
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUSDisplay.h"
#include "config/DGUS_Addr.h"
#include "config/DGUS_Constants.h"
#include "definition/DGUS_VPList.h"
#include "../ui_api.h"
long map_precise(float x, long in_min, long in_max, long out_min, long out_max) {
return LROUND((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min);
}
uint8_t DGUSDisplay::gui_version = 0;
uint8_t DGUSDisplay::os_version = 0;
uint8_t DGUSDisplay::volume = 255;
uint8_t DGUSDisplay::brightness = 100;
DGUSDisplay::rx_datagram_state_t DGUSDisplay::rx_datagram_state = DGUS_IDLE;
uint8_t DGUSDisplay::rx_datagram_len = 0;
bool DGUSDisplay::initialized = false;
void DGUSDisplay::loop() {
processRx();
}
void DGUSDisplay::init() {
LCD_SERIAL.begin(LCD_BAUDRATE);
readVersions();
}
void DGUSDisplay::read(uint16_t addr, uint8_t size) {
writeHeader(addr, DGUS_READVAR, size);
LCD_SERIAL.write(size);
}
void DGUSDisplay::write(uint16_t addr, const void* data_ptr, uint8_t size) {
if (!data_ptr) return;
writeHeader(addr, DGUS_WRITEVAR, size);
const char* data = static_cast<const char*>(data_ptr);
while (size--) LCD_SERIAL.write(*data++);
}
void DGUSDisplay::writeString(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) {
if (!data_ptr) return;
writeHeader(addr, DGUS_WRITEVAR, size);
const char* data = static_cast<const char*>(data_ptr);
size_t len = strlen(data);
uint8_t left_spaces = 0;
uint8_t right_spaces = 0;
if (len < size) {
if (!len) {
right_spaces = size;
}
else {
const uint8_t rem = size - len;
if ((left && right) || (!left && !right)) {
left_spaces = rem / 2;
right_spaces = rem - left_spaces;
}
else if (left)
right_spaces = rem;
else
left_spaces = rem;
}
}
else {
len = size;
}
while (left_spaces--) LCD_SERIAL.write(' ');
while (len--) LCD_SERIAL.write(*data++);
while (right_spaces--) LCD_SERIAL.write(use_space ? ' ' : '\0');
}
void DGUSDisplay::writeStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) {
if (!data_ptr) return;
writeHeader(addr, DGUS_WRITEVAR, size);
const char* data = static_cast<const char*>(data_ptr);
size_t len = strlen_P(data);
uint8_t left_spaces = 0, right_spaces = 0;
if (len < size) {
if (!len) {
right_spaces = size;
}
else if ((left && right) || (!left && !right)) {
left_spaces = (size - len) / 2;
right_spaces = size - len - left_spaces;
}
else if (left) {
right_spaces = size - len;
}
else {
left_spaces = size - len;
}
}
else {
len = size;
}
while (left_spaces--) LCD_SERIAL.write(' ');
while (len--) LCD_SERIAL.write(pgm_read_byte(data++));
while (right_spaces--) LCD_SERIAL.write(use_space ? ' ' : '\0');
}
void DGUSDisplay::readVersions() {
if (gui_version != 0 && os_version != 0) return;
read(DGUS_VERSION, 1);
}
void DGUSDisplay::switchScreen(DGUS_ScreenID screen) {
const uint8_t command[] = { 0x5A, 0x01, 0x00, (uint8_t)screen };
write(0x84, command, sizeof(command));
}
void DGUSDisplay::playSound(uint8_t start, uint8_t len, uint8_t volume) {
if (volume == 0) volume = DGUSDisplay::volume;
else volume = map_precise(constrain(volume, 0, 100), 0, 100, 0, 0x40);
if (volume == 0) return;
const uint8_t command[] = { start, len, volume, 0x00 };
write(0xA0, command, sizeof(command));
}
void DGUSDisplay::enableControl(DGUS_ScreenID screen, DGUS_ControlType type, DGUS_Control control) {
const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screen, (uint8_t)control, type, 0x00, 0x01 };
write(0xB0, command, sizeof(command));
flushTx();
delay(50);
}
void DGUSDisplay::disableControl(DGUS_ScreenID screen, DGUS_ControlType type, DGUS_Control control) {
const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screen, (uint8_t)control, type, 0x00, 0x00 };
write(0xB0, command, sizeof(command));
flushTx();
delay(50);
}
uint8_t DGUSDisplay::getBrightness() {
return brightness;
}
uint8_t DGUSDisplay::getVolume() {
return map_precise(volume, 0, 0x40, 0, 100);
}
void DGUSDisplay::setBrightness(uint8_t new_brightness) {
brightness = constrain(new_brightness, 0, 100);
new_brightness = map_precise(brightness, 0, 100, 5, 100);
const uint8_t command[] = { new_brightness, new_brightness };
write(0x82, command, sizeof(command));
}
void DGUSDisplay::setVolume(uint8_t new_volume) {
volume = map_precise(constrain(new_volume, 0, 100), 0, 100, 0, 0x40);
const uint8_t command[] = { volume, 0x00 };
write(0xA1, command, sizeof(command));
}
void DGUSDisplay::processRx() {
#if ENABLED(LCD_SERIAL_STATS_RX_BUFFER_OVERRUNS)
if (!LCD_SERIAL.available() && LCD_SERIAL.buffer_overruns()) {
// Overrun, but reset the flag only when the buffer is empty
// We want to extract as many as valid datagrams possible...
rx_datagram_state = DGUS_IDLE;
//LCD_SERIAL.reset_rx_overun();
LCD_SERIAL.flush();
}
#endif
uint8_t receivedbyte;
while (LCD_SERIAL.available()) {
switch (rx_datagram_state) {
case DGUS_IDLE: // Waiting for the first header byte
receivedbyte = LCD_SERIAL.read();
if (DGUS_HEADER1 == receivedbyte) rx_datagram_state = DGUS_HEADER1_SEEN;
break;
case DGUS_HEADER1_SEEN: // Waiting for the second header byte
receivedbyte = LCD_SERIAL.read();
rx_datagram_state = (DGUS_HEADER2 == receivedbyte) ? DGUS_HEADER2_SEEN : DGUS_IDLE;
break;
case DGUS_HEADER2_SEEN: // Waiting for the length byte
rx_datagram_len = LCD_SERIAL.read();
// Telegram min len is 3 (command and one word of payload)
rx_datagram_state = WITHIN(rx_datagram_len, 3, DGUS_RX_BUFFER_SIZE) ? DGUS_WAIT_TELEGRAM : DGUS_IDLE;
break;
case DGUS_WAIT_TELEGRAM: // wait for complete datagram to arrive.
if (LCD_SERIAL.available() < rx_datagram_len) return;
initialized = true; // We've talked to it, so we defined it as initialized.
uint8_t command = LCD_SERIAL.read();
uint8_t readlen = rx_datagram_len - 1; // command is part of len.
unsigned char tmp[rx_datagram_len - 1];
unsigned char *ptmp = tmp;
while (readlen--) {
receivedbyte = LCD_SERIAL.read();
*ptmp++ = receivedbyte;
}
// mostly we'll get this: 5A A5 03 82 4F 4B -- ACK on 0x82, so discard it.
if (command == DGUS_WRITEVAR && 'O' == tmp[0] && 'K' == tmp[1]) {
rx_datagram_state = DGUS_IDLE;
break;
}
/**
* AutoUpload, (and answer to) Command 0x83 :
* tmp[0 1 2 3 4 ... ]
* Example 5A A5 06 83 20 01 01 78 01 ……
* / / | | \ / | \ \
* Header | | | | \_____\_ DATA (Words!)
* DatagramLen / VPAdr |
* Command DataLen (in Words)
*/
if (command == DGUS_READVAR) {
const uint16_t addr = Endianness::fromBE_P<uint16_t>(tmp);
const uint8_t dlen = tmp[2] << 1; // Convert to Bytes. (Display works with words)
if (addr == DGUS_VERSION && dlen == 2) {
gui_version = tmp[3];
os_version = tmp[4];
#if ENABLED(DEBUG_DGUSLCD)
DEBUG_ECHOLNPGM("DGUS version: GUI ", gui_version, "OS ", os_version);
#endif
rx_datagram_state = DGUS_IDLE;
break;
}
DGUS_VP vp;
if (!DGUS_PopulateVP((DGUS_Addr)addr, &vp)) {
rx_datagram_state = DGUS_IDLE;
break;
}
if (!vp.rx_handler) {
rx_datagram_state = DGUS_IDLE;
break;
}
gcode.reset_stepper_timeout();
if (!vp.size) {
DEBUG_EOL();
vp.rx_handler(vp, nullptr);
rx_datagram_state = DGUS_IDLE;
break;
}
if (vp.flags & VPFLAG_RXSTRING) {
unsigned char buffer[vp.size];
memset(buffer, 0, vp.size);
for (uint8_t i = 0; i < dlen; i++) {
if (i >= vp.size) break;
if (i + 1 < dlen && tmp[i + 3] == 0xFF && tmp[i + 4] == 0xFF)
break;
buffer[i] = tmp[i + 3];
}
DEBUG_EOL();
vp.rx_handler(vp, buffer);
rx_datagram_state = DGUS_IDLE;
break;
}
if (dlen != vp.size) {
rx_datagram_state = DGUS_IDLE;
break;
}
DEBUG_EOL();
vp.rx_handler(vp, &tmp[3]);
rx_datagram_state = DGUS_IDLE;
break;
}
#if ENABLED(DEBUG_DGUSLCD)
DEBUG_ECHOLNPGM("DGUS unknown command ", command);
#endif
rx_datagram_state = DGUS_IDLE;
break;
}
}
}
size_t DGUSDisplay::getFreeTxBuffer() {
return (
#ifdef LCD_SERIAL_GET_TX_BUFFER_FREE
LCD_SERIAL_GET_TX_BUFFER_FREE()
#else
SIZE_MAX
#endif
);
}
void DGUSDisplay::flushTx() {
TERN(ARDUINO_ARCH_STM32, LCD_SERIAL.flush(), LCD_SERIAL.flushTX());
}
void DGUSDisplay::writeHeader(uint16_t addr, uint8_t command, uint8_t len) {
LCD_SERIAL.write(DGUS_HEADER1);
LCD_SERIAL.write(DGUS_HEADER2);
LCD_SERIAL.write(len + 3);
LCD_SERIAL.write(command);
union {
uint16_t u16;
uint8_t u8[2];
} data = { Endianness::toBE(addr) };
for (uint8_t i = 0; i < sizeof(data.u8); ++i) LCD_SERIAL.write(data.u8[i]);
}
bool DGUS_PopulateVP(const DGUS_Addr addr, DGUS_VP * const buffer) {
const DGUS_VP *ret = vp_list;
do {
const uint16_t *paddr = (uint16_t *)(&ret->addr);
const uint16_t addrcheck = pgm_read_word(paddr);
if (addrcheck == 0) break;
if ((DGUS_Addr)addrcheck == addr) {
memcpy_P(buffer, ret, sizeof(*ret));
return true;
}
} while (++ret);
return false;
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.cpp
|
C++
|
agpl-3.0
| 11,034
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* DGUS implementation written by coldtobi in 2019.
* Updated for STM32G0B1RE by Protomosh in 2022.
*/
#include "config/DGUS_Screen.h"
#include "config/DGUS_Control.h"
#include "definition/DGUS_VP.h"
#include "../ui_api.h"
#include "../../../inc/MarlinConfigPre.h"
#include "../../../MarlinCore.h"
//#define DEBUG_DGUSLCD // Uncomment for debug messages
#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD)
#include "../../../core/debug_out.h"
// Low-Level access to the display.
class DGUSDisplay {
public:
enum DGUS_ControlType : uint8_t {
VARIABLE_DATA_INPUT = 0x00,
POPUP_WINDOW = 0x01,
INCREMENTAL_ADJUST = 0x02,
SLIDER_ADJUST = 0x03,
RTC_SETTINGS = 0x04,
RETURN_KEY_CODE = 0x05,
TEXT_INPUT = 0x06,
FIRMWARE_SETTINGS = 0x07
};
DGUSDisplay() = default;
static void init();
static void read(uint16_t addr, uint8_t size);
static void write(uint16_t addr, const void* data_ptr, uint8_t size);
static void writeString(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true);
static void writeStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true);
static void writeString(uint16_t addr, FSTR_P const fstr, uint8_t size, bool left=true, bool right=false, bool use_space=true) {
writeStringPGM(addr, FTOP(fstr), size, left, right, use_space);
}
template<typename T>
static void write(uint16_t addr, T data) {
write(addr, static_cast<const void*>(&data), sizeof(T));
}
// Until now I did not need to actively read from the display. That's why there is no readVariable
// (I extensively use the auto upload of the display)
// Read GUI and OS version from screen
static void readVersions();
// Force display into another screen.
static void switchScreen(DGUS_ScreenID screen);
// Play sounds using the display speaker.
// start: position at which the sound was stored on the display.
// len: how many sounds to play. Sounds will play consecutively from start to start+len-1.
// volume: playback volume. 0 keeps the current volume.
static void playSound(uint8_t start, uint8_t len=1, uint8_t volume=0);
// Enable/disable a specific touch control.
// type: control type.
// control: index of the control on the page (set during screen development).
static void enableControl(DGUS_ScreenID screen, DGUS_ControlType type, DGUS_Control control);
static void disableControl(DGUS_ScreenID screen, DGUS_ControlType type, DGUS_Control control);
static uint8_t getBrightness();
static uint8_t getVolume();
// Set the display brightness/volume, ranging 0 - 100
static void setBrightness(uint8_t brightness);
static void setVolume(uint8_t volume);
// Periodic tasks, eg. Rx-Queue handling.
static void loop();
// Helper for users of this class to estimate if an interaction would be blocking.
static size_t getFreeTxBuffer();
static void flushTx();
// Checks two things: Can we confirm the presence of the display and has we initialized it.
// (both boils down that the display answered to our chatting)
static bool isInitialized() {
return initialized;
}
static uint8_t gui_version;
static uint8_t os_version;
template<typename T_in, typename T_out, uint8_t decimals>
T_out fromFixedPoint(const T_in value) {
return (T_out)((float)value / POW(10, decimals));
}
template<typename T_in, typename T_out, uint8_t decimals>
T_out toFixedPoint(const T_in value) {
return (T_out)LROUND((float)value * POW(10, decimals));
}
private:
enum dgus_header : uint8_t {
DGUS_HEADER1 = 0x5A,
DGUS_HEADER2 = 0xA5
};
enum dgus_command : uint8_t {
DGUS_WRITEVAR = 0x82,
DGUS_READVAR = 0x83
};
enum rx_datagram_state_t : uint8_t {
DGUS_IDLE, //< waiting for DGUS_HEADER1.
DGUS_HEADER1_SEEN, //< DGUS_HEADER1 received
DGUS_HEADER2_SEEN, //< DGUS_HEADER2 received
DGUS_WAIT_TELEGRAM, //< LEN received, Waiting for to receive all bytes.
};
enum dgus_system_addr : uint16_t {
DGUS_VERSION = 0x000F // OS/GUI version
};
static void writeHeader(uint16_t addr, uint8_t command, uint8_t len);
static void processRx();
static uint8_t volume;
static uint8_t brightness;
static rx_datagram_state_t rx_datagram_state;
static uint8_t rx_datagram_len;
static bool initialized;
};
extern DGUSDisplay dgus;
/// Helper to populate a DGUS_VP for a given VP. Return false if not found.
extern bool DGUS_PopulateVP(const DGUS_Addr addr, DGUS_VP * const buffer);
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSDisplay.h
|
C++
|
agpl-3.0
| 5,498
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUSReturnKeyCodeHandler.h"
#include "DGUSDisplay.h"
#include "DGUSScreenHandler.h"
#include "config/DGUS_Screen.h"
#include "../ui_api.h"
#include "../../../core/language.h"
#include "../../../module/temperature.h"
#include "../../../module/printcounter.h"
#include "../../../module/stepper.h"
#include "../../../gcode/queue.h"
#if ENABLED(ADVANCED_PAUSE_FEATURE)
#include "../../../feature/pause.h"
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../feature/powerloss.h"
#endif
#define DGUS_UNKNOWN_COMMAND_DEBUG // uncomment to debug unknown commands
static uint16_t plaExtruderTempSave = 0;
static uint16_t plaBedTempSave = 0;
static uint16_t absExtruderTempSave = 0;
static uint16_t absBedTempSave = 0;
static DGUS_ScreenID GetJogScreenForSavedJogLength() {
DGUS_ScreenID jogscreen = DGUS_ScreenID::MOVEAXIS_10;
switch (screen.config.jogLength) {
case DGUS_Data::AxisControlCommand::Jog_10mm: jogscreen = DGUS_ScreenID::MOVEAXIS_10; break;
case DGUS_Data::AxisControlCommand::Jog_1mm: jogscreen = DGUS_ScreenID::MOVEAXIS_1; break;
case DGUS_Data::AxisControlCommand::Jog_0_1mm: jogscreen = DGUS_ScreenID::MOVEAXIS_01; break;
default: break;
}
return jogscreen;
}
// 1002
void DGUSReturnKeyCodeHandler::Command_MenuSelect(DGUS_VP &vp, void *data) {
DGUS_Data::MenuSelectCommand submenu = Endianness::fromBE_P<DGUS_Data::MenuSelectCommand>(data);
switch (submenu) {
case DGUS_Data::MenuSelectCommand::Main:
screen.triggerScreenChange(DGUS_ScreenID::MAIN);
break;
case DGUS_Data::MenuSelectCommand::Print:
if (ExtUI::isMediaInserted()) {
dgus_sdcard_handler.Reset();
screen.triggerScreenChange(DGUS_ScreenID::FILE1);
}
else
screen.triggerTempScreenChange(DGUS_ScreenID::SDCARDCHECK, screen.getCurrentScreen());
break;
case DGUS_Data::MenuSelectCommand::Ready: {
DGUS_ScreenID jogscreen = GetJogScreenForSavedJogLength();
if (ExtUI::isPositionKnown())
screen.triggerScreenChange(jogscreen);
else
screen.homeThenChangeScreen(jogscreen);
} break;
case DGUS_Data::MenuSelectCommand::Settings:
screen.triggerScreenChange(DGUS_ScreenID::TEMP);
break;
case DGUS_Data::MenuSelectCommand::StartAutoLevel:
if (!ExtUI::isPositionKnown())
screen.homeThenChangeScreen(screen.getCurrentScreen());
ExtUI::injectCommands(F("M420 S0\n" TERN(AUTO_BED_LEVELING_UBL, "G29 P1", "G29")));
break;
case DGUS_Data::MenuSelectCommand::PrintFinished:
screen.triggerScreenChange(DGUS_ScreenID::HOME);
break;
case DGUS_Data::MenuSelectCommand::PausePrint:
screen.triggerTempScreenChange(DGUS_ScreenID::PAUSE_STOP, DGUS_ScreenID::PAUSE);
break;
case DGUS_Data::MenuSelectCommand::PauseStopPrint:
screen.triggerTempScreenChange(DGUS_ScreenID::CONTINUE_STOP, DGUS_ScreenID::RESUME);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_MenuSelect: unknown id ", (uint16_t)submenu);
#endif
break;
}
}
// 1004
void DGUSReturnKeyCodeHandler::Command_Adjust(DGUS_VP &vp, void *data) {
DGUS_Data::AdjustCommand command = Endianness::fromBE_P<DGUS_Data::AdjustCommand>(data);
switch (command) {
case DGUS_Data::AdjustCommand::Show_Adjust:
screen.triggerScreenChange(DGUS_ScreenID::ADJUST);
break;
case DGUS_Data::AdjustCommand::Show_PrintStatus:
screen.triggerScreenChange(DGUS_ScreenID::PAUSE);
break;
case DGUS_Data::AdjustCommand::Show_Adjust_ZOffset:
screen.triggerScreenChange(DGUS_ScreenID::PREPARE);
break;
case DGUS_Data::AdjustCommand::Validate_ZOffset:
screen.triggerScreenChange(DGUS_ScreenID::ADJUST);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_Adjust: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 1008
void DGUSReturnKeyCodeHandler::Command_CheckKO(DGUS_VP &vp, void *data) {
DGUS_Data::CheckKOCommand command = Endianness::fromBE_P<DGUS_Data::CheckKOCommand>(data);
if (command != DGUS_Data::CheckKOCommand::KO && command != DGUS_Data::CheckKOCommand::SDCard_No) {
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_CheckKO: unknown id ", (uint16_t)command);
#endif
return;
}
switch (screen.getCurrentScreen()) {
case DGUS_ScreenID::CONTINUE_STOP:
case DGUS_ScreenID::STOP_CONFIRM:
case DGUS_ScreenID::PAUSE_STOP:
case DGUS_ScreenID::FILAMENTUSEUP:
case DGUS_ScreenID::FILAMENTLOAD:
ExtUI::stopPrint();
TERN_(HAS_FILAMENT_SENSOR,ExtUI::setFilamentRunoutState(false));
screen.triggerScreenChange(DGUS_ScreenID::FINISH);
break;
case DGUS_ScreenID::SDCARDCHECK:
case DGUS_ScreenID::PAUSE_LASER:
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_CheckKO: unknown src screen ", (uint16_t)screen.getCurrentScreen());
#endif
return;
}
screen.triggerScreenChange(DGUS_ScreenID::HOME);
}
// 100A
void DGUSReturnKeyCodeHandler::Command_StopPause(DGUS_VP &vp, void *data) {
DGUS_Data::StopPauseCommand command = Endianness::fromBE_P<DGUS_Data::StopPauseCommand>(data);
switch (command) {
case DGUS_Data::StopPauseCommand::Pause:
ExtUI::pausePrint();
screen.triggerScreenChange(DGUS_ScreenID::RESUME);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_StopPause: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 100C
void DGUSReturnKeyCodeHandler::Command_CheckOK(DGUS_VP &vp, void *data) {
DGUS_Data::CheckOKCommand command = Endianness::fromBE_P<DGUS_Data::CheckOKCommand>(data);
switch (command) {
case DGUS_Data::CheckOKCommand::ContinueStop_Continue:
#if HAS_FILAMENT_SENSOR
if (ExtUI::getFilamentRunoutEnabled() && READ(FIL_RUNOUT1_PIN) == FIL_RUNOUT1_STATE) {
screen.triggerScreenChange(DGUS_ScreenID::FILAMENTUSEUP);
break;
}
#endif
ExtUI::resumePrint();
screen.triggerScreenChange(DGUS_ScreenID::PAUSE);
break;
#if HAS_FILAMENT_SENSOR
case DGUS_Data::CheckOKCommand::FilamentRunout_Yes:
if (ExtUI::getTargetTemp_celsius(ExtUI::E0) < EXTRUDE_MINTEMP)
ExtUI::setTargetTemp_celsius(EXTRUDE_MINTEMP, ExtUI::E0);
if (ExtUI::getFilamentRunoutEnabled() && READ(FIL_RUNOUT1_PIN) == FIL_RUNOUT1_STATE)
screen.triggerScreenChange(DGUS_ScreenID::FILAMENTUSEUP);
else
screen.triggerScreenChange(DGUS_ScreenID::FILAMENTLOAD);
break;
case DGUS_Data::CheckOKCommand::FilamentLoad_Yes:
if (ExtUI::getFilamentRunoutEnabled() && READ(FIL_RUNOUT1_PIN) == FIL_RUNOUT1_STATE) {
screen.triggerScreenChange(DGUS_ScreenID::FILAMENTLOAD);
break;
}
ExtUI::setFilamentRunoutState(false);
ExtUI::resumePrint();
break;
#endif // HAS_FILAMENT_SENSOR
case DGUS_Data::CheckOKCommand::SDCardCheck_Yes:
if (ExtUI::isMediaInserted()) {
dgus_sdcard_handler.Reset();
screen.triggerScreenChange(DGUS_ScreenID::FILE1);
}
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_CheckOK: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 1030
void DGUSReturnKeyCodeHandler::Command_PresetControl(DGUS_VP &vp, void *data) {
DGUS_Data::PresetControlCommand command = Endianness::fromBE_P<DGUS_Data::PresetControlCommand>(data);
switch (command) {
case DGUS_Data::PresetControlCommand::Show_Ready_Manual:
screen.triggerScreenChange(DGUS_ScreenID::CONTROL);
break;
case DGUS_Data::PresetControlCommand::Show_Settings_PLA_Settings:
plaExtruderTempSave = screen.config.plaExtruderTemp;
plaBedTempSave = screen.config.plaBedTemp;
absExtruderTempSave = screen.config.absExtruderTemp;
absBedTempSave = screen.config.absBedTemp;
screen.triggerScreenChange(DGUS_ScreenID::PLA_TEMP);
break;
case DGUS_Data::PresetControlCommand::Show_Settings_ABS_Settings:
plaExtruderTempSave = screen.config.plaExtruderTemp;
plaBedTempSave = screen.config.plaBedTemp;
absExtruderTempSave = screen.config.absExtruderTemp;
absBedTempSave = screen.config.absBedTemp;
screen.triggerScreenChange(DGUS_ScreenID::ABS_TEMP);
break;
case DGUS_Data::PresetControlCommand::Apply_PLA_Settings:
ExtUI::setTargetTemp_celsius(screen.config.plaExtruderTemp, ExtUI::E0);
ExtUI::setTargetTemp_celsius(screen.config.plaBedTemp, ExtUI::BED);
break;
case DGUS_Data::PresetControlCommand::Apply_ABS_Settings:
ExtUI::setTargetTemp_celsius(screen.config.absExtruderTemp, ExtUI::E0);
ExtUI::setTargetTemp_celsius(screen.config.absBedTemp, ExtUI::BED);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Settings_Submenu: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 1032
void DGUSReturnKeyCodeHandler::Control_TemperatureCommand(DGUS_VP &vp, void *data) {
DGUS_Data::TemperatureControlCommand command = Endianness::fromBE_P<DGUS_Data::TemperatureControlCommand>(data);
switch (command) {
case DGUS_Data::TemperatureControlCommand::Cooldown:
ExtUI::coolDown();
break;
case DGUS_Data::TemperatureControlCommand::Exit_Temperature_Preset_And_Discard_Temperature:
screen.config.plaExtruderTemp = plaExtruderTempSave;
screen.config.plaBedTemp = plaBedTempSave;
screen.config.absExtruderTemp = absExtruderTempSave;
screen.config.absBedTemp = absBedTempSave;
screen.triggerScreenChange(DGUS_ScreenID::TEMP);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Control_TemperatureCommand: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 103E
void DGUSReturnKeyCodeHandler::Command_SettingsMenu(DGUS_VP &vp, void *data) {
DGUS_Data::SettingsMenuCommand command = Endianness::fromBE_P<DGUS_Data::SettingsMenuCommand>(data);
switch (command) {
case DGUS_Data::SettingsMenuCommand::DisableStepperMotors: {
const bool areSteppersEnabled = stepper.axis_enabled.bits & (_BV(NUM_AXES) - 1);
if (areSteppersEnabled)
stepper.disable_all_steppers();
else
stepper.enable_all_steppers();
} break;
case DGUS_Data::SettingsMenuCommand::Reset_All_Settings:
screen.triggerScreenChange(DGUS_ScreenID::FACTORYRESET_CONFIRM);
break;
case DGUS_Data::SettingsMenuCommand::FactoryReset_Validate:
ExtUI::injectCommands(F("M502"));
case DGUS_Data::SettingsMenuCommand::FactoryReset_Cancel:
screen.triggerScreenChange(DGUS_ScreenID::CONTROL_DEVICE);
break;
case DGUS_Data::SettingsMenuCommand::Show_Settings_Device_and_Save_Temperatures:
screen.triggerEEPROMSave();
screen.triggerScreenChange(DGUS_ScreenID::TEMP);
break;
case DGUS_Data::SettingsMenuCommand::Show_Settings_Device_and_Discard_Temperatures:
screen.config.plaExtruderTemp = plaExtruderTempSave;
screen.config.plaBedTemp = plaBedTempSave;
screen.config.absExtruderTemp = absExtruderTempSave;
screen.config.absBedTemp = absBedTempSave;
screen.triggerScreenChange(DGUS_ScreenID::TEMP);
break;
case DGUS_Data::SettingsMenuCommand::Show_Settings_Device_Language:
screen.triggerScreenChange(DGUS_ScreenID::LANGUAGE);
break;
case DGUS_Data::SettingsMenuCommand::Show_Settings_About:
screen.triggerScreenChange(DGUS_ScreenID::INFORMATION);
break;
case DGUS_Data::SettingsMenuCommand::Show_Settings_Advanced:
screen.triggerScreenChange(DGUS_ScreenID::CONTROL_DEVICE);
break;
case DGUS_Data::SettingsMenuCommand::Show_Ready_Jog:
screen.triggerScreenChange(GetJogScreenForSavedJogLength());
break;
case DGUS_Data::SettingsMenuCommand::Exit_Settings_Tramming:
screen.triggerEEPROMSave();
screen.triggerScreenChange(DGUS_ScreenID::TEMP);
break;
case DGUS_Data::SettingsMenuCommand::Exit_Settings_Leveling:
screen.triggerEEPROMSave();
screen.triggerScreenChange(DGUS_ScreenID::TEMP);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_SettingsMenu: unknown id ", (uint16_t)command);
#endif
break;
}
}
static void _gotoTrammingPoint(unsigned char point) {
constexpr float lfrb[4] = BED_TRAMMING_INSET_LFRB;
float x, y;
switch (point) {
default: return;
case 1: x = X_CENTER; y = Y_CENTER; break;
case 2: x = X_MIN_POS + lfrb[0]; y = Y_MIN_POS + lfrb[1]; break;
case 3: x = X_MAX_POS - lfrb[2]; y = Y_MIN_POS + lfrb[1]; break;
case 4: x = X_MAX_POS - lfrb[2]; y = Y_MAX_POS - lfrb[3]; break;
case 5: x = X_MIN_POS + lfrb[0]; y = Y_MAX_POS - lfrb[3]; break;
}
if (ExtUI::getAxisPosition_mm(ExtUI::Z) < (Z_MIN_POS) + (BED_TRAMMING_Z_HOP))
ExtUI::setAxisPosition_mm((Z_MIN_POS) + (BED_TRAMMING_Z_HOP), ExtUI::Z);
ExtUI::setAxisPosition_mm(x, ExtUI::X);
ExtUI::setAxisPosition_mm(y, ExtUI::Y);
ExtUI::setAxisPosition_mm((Z_MIN_POS) + (BED_TRAMMING_HEIGHT), ExtUI::Z);
}
// 1044
void DGUSReturnKeyCodeHandler::Command_Leveling(DGUS_VP &vp, void *data) {
DGUS_Data::LevelingCommand command = Endianness::fromBE_P<DGUS_Data::LevelingCommand>(data);
switch (command) {
case DGUS_Data::LevelingCommand::Show_AuxLeveling:
if (ExtUI::isPositionKnown())
screen.triggerScreenChange(DGUS_ScreenID::LEVELINGMODE);
_gotoTrammingPoint(1);
break;
case DGUS_Data::LevelingCommand::Show_Settings_Leveling:
case DGUS_Data::LevelingCommand::Show_AutoLeveling:
screen.homeThenChangeScreen(DGUS_ScreenID::LEVELING);
break;
case DGUS_Data::LevelingCommand::Goto_Center:
_gotoTrammingPoint(1);
break;
case DGUS_Data::LevelingCommand::Goto_LF:
_gotoTrammingPoint(2);
break;
case DGUS_Data::LevelingCommand::Goto_RF:
_gotoTrammingPoint(3);
break;
case DGUS_Data::LevelingCommand::Goto_RB:
_gotoTrammingPoint(4);
break;
case DGUS_Data::LevelingCommand::Goto_LB:
_gotoTrammingPoint(5);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_Leveling: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 1046
void DGUSReturnKeyCodeHandler::Command_AxisControl(DGUS_VP &vp, void *data) {
DGUS_Data::AxisControlCommand control = Endianness::fromBE_P<DGUS_Data::AxisControlCommand>(data);
switch (control) {
case DGUS_Data::AxisControlCommand::Jog_10mm:
case DGUS_Data::AxisControlCommand::Jog_1mm:
case DGUS_Data::AxisControlCommand::Jog_0_1mm:
screen.config.jogLength = control;
break;
case DGUS_Data::AxisControlCommand::Home_XY:
ExtUI::injectCommands(F("G28XY"));
break;
case DGUS_Data::AxisControlCommand::Home_Z:
ExtUI::injectCommands(F("G28Z"));
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_AxisControl: unknown id ", (uint16_t)control);
#endif
break;
}
}
// 1056
void DGUSReturnKeyCodeHandler::Command_FilamentIO(DGUS_VP &vp, void *data) {
DGUS_Data::FilamentIoCommand command = Endianness::fromBE_P<DGUS_Data::FilamentIoCommand>(data);
switch (command) {
case DGUS_Data::FilamentIoCommand::FilamentCheck_Yes:
case DGUS_Data::FilamentIoCommand::FilamentCheck_No:
screen.triggerReturnScreen();
break;
case DGUS_Data::FilamentIoCommand::Show_Ready_IO:
screen.triggerScreenChange(DGUS_ScreenID::FEEDRETURN);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_FilamentIO: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 105F
void DGUSReturnKeyCodeHandler::Command_PowerLoss(DGUS_VP &vp, void *data) {
DGUS_Data::PowerLossCommand command = Endianness::fromBE_P<DGUS_Data::PowerLossCommand>(data);
switch (command) {
case DGUS_Data::PowerLossCommand::PowerLoss_Continue:
if (!recovery.valid()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_INVALID_RECOVERY_DATA));
screen.triggerScreenChange(DGUS_ScreenID::HOME);
return;
}
screen.triggerScreenChange(DGUS_ScreenID::PAUSE);
ExtUI::injectCommands(F("M1000"));
break;
case DGUS_Data::PowerLossCommand::PowerLoss_No:
screen.triggerScreenChange(DGUS_ScreenID::HOME);
ExtUI::injectCommands(F("M1000 C"));
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_PowerLoss: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 1098
void DGUSReturnKeyCodeHandler::Command_AdvancedSettings(DGUS_VP &vp, void *data) {
DGUS_Data::AdvancedSettingsCommand command = Endianness::fromBE_P<DGUS_Data::AdvancedSettingsCommand>(data);
switch (command) {
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement:
screen.triggerScreenChange(DGUS_ScreenID::MOTION);
break;
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_PID:
#if NONE(PIDTEMP, PIDTEMPBED)
screen.angryBeeps(2);
screen.triggerScreenChange(DGUS_ScreenID::CONTROL_DEVICE);
#else
screen.triggerScreenChange(DGUS_ScreenID::PIDCONTROL);
#endif
break;
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_MaxFeedrate:
screen.triggerScreenChange(DGUS_ScreenID::MAX_FEEDRATE);
break;
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_Acceleration:
screen.triggerScreenChange(DGUS_ScreenID::ACCELERATION);
break;
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_Jerk:
screen.triggerScreenChange(DGUS_ScreenID::JERK);
break;
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings_Movement_StepsPerMm:
screen.triggerScreenChange(DGUS_ScreenID::STEPSMM);
break;
case DGUS_Data::AdvancedSettingsCommand::Exit_AdvSettings_Movement_Submenu:
screen.triggerScreenChange(DGUS_ScreenID::MOTION);
break;
case DGUS_Data::AdvancedSettingsCommand::Show_AdvSettings:
screen.triggerScreenChange(DGUS_ScreenID::CONTROL_DEVICE);
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_AdvancedSettings: unknown id ", (uint16_t)command);
#endif
break;
}
}
// 2198
void DGUSReturnKeyCodeHandler::Command_FilelistControl(DGUS_VP &vp, void *data) {
DGUS_Data::FilelistControlCommand control = Endianness::fromBE_P<DGUS_Data::FilelistControlCommand>(data);
DGUS_SDCardHandler::page_t newPage;
switch (control) {
#if HAS_MEDIA
case DGUS_Data::FilelistControlCommand::Start_Print:
if (!screen.getSDCardPrintFilename()[0]) {
screen.angryBeeps(2);
return;
}
#if HAS_FILAMENT_SENSOR
if (ExtUI::getFilamentRunoutEnabled() && READ(FIL_RUNOUT1_PIN) == FIL_RUNOUT1_STATE) {
screen.triggerTempScreenChange(DGUS_ScreenID::FILAMENTCHECK, DGUS_ScreenID::HOME);
return;
}
#endif
ExtUI::printFile(screen.getSDCardPrintFilename());
screen.triggerScreenChange(DGUS_ScreenID::PAUSE);
return;
#endif
case DGUS_Data::FilelistControlCommand::F1_Up:
//case DGUS_Data::FilelistControlCommand::F2_Up:
case DGUS_Data::FilelistControlCommand::F3_Up:
case DGUS_Data::FilelistControlCommand::F4_Up:
newPage = dgus_sdcard_handler.onPreviousPage();
break;
case DGUS_Data::FilelistControlCommand::F1_Down:
case DGUS_Data::FilelistControlCommand::F2_Down:
case DGUS_Data::FilelistControlCommand::F3_Down:
case DGUS_Data::FilelistControlCommand::F4_Down:
newPage = dgus_sdcard_handler.onNextPage();
break;
case DGUS_Data::FilelistControlCommand::Begin:
newPage = dgus_sdcard_handler.onFirstPage();
break;
case DGUS_Data::FilelistControlCommand::End:
newPage = dgus_sdcard_handler.onLastPage();
break;
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_FilelistControl: unknown id ", (uint16_t)control);
#endif
return;
}
screen.triggerScreenChange(DGUS_PAGE_TO_SCREEN(newPage));
}
// 2201
void DGUSReturnKeyCodeHandler::Command_LaserControl(DGUS_VP &vp, void *data) {
DGUS_Data::LaserControlCommand control = Endianness::fromBE_P<DGUS_Data::LaserControlCommand>(data);
switch (control) {
case DGUS_Data::LaserControlCommand::Mode_FDM:
screen.triggerScreenChange(DGUS_ScreenID::SW_FDM_TIPS);
break;
case DGUS_Data::LaserControlCommand::Mode_FDM_Confirm:
screen.triggerScreenChange(DGUS_ScreenID::SW_FDM_TIPS);
break;
#if HAS_CUTTER
case DGUS_Data::LaserControlCommand::Mode_Cutter:
screen.triggerScreenChange(DGUS_ScreenID::SW_LASER_TIPS);
break;
case DGUS_Data::LaserControlCommand::Mode_Cutter_Confirm:
screen.triggerScreenChange(DGUS_ScreenID::SW_LASER_TIPS);
break;
#endif
case DGUS_Data::LaserControlCommand::Mode_Change:
#if HAS_CUTTER
screen.triggerScreenChange(DGUS_ScreenID::LASER_FDM);
#else
screen.angryBeeps(2);
#endif
default:
#if ALL(DEBUG_DGUSLCD, DGUS_UNKNOWN_COMMAND_DEBUG)
DEBUG_ECHOLNPGM("Command_LaserControl: unknown id ", (uint16_t)control);
#endif
return;
}
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.cpp
|
C++
|
agpl-3.0
| 22,852
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "definition/DGUS_VP.h"
namespace DGUSReturnKeyCodeHandler {
void Command_MenuSelect(DGUS_VP &vp, void *data);
void Command_Adjust(DGUS_VP &vp, void *data);
void Command_CheckKO(DGUS_VP &vp, void *data);
void Command_StopPause(DGUS_VP &vp, void *data);
void Command_CheckOK(DGUS_VP &vp, void *data);
void Command_PresetControl(DGUS_VP &vp, void *data);
void Control_TemperatureCommand(DGUS_VP &vp, void *data);
void Command_SettingsMenu(DGUS_VP &vp, void *data);
void Command_Leveling(DGUS_VP &vp, void *data);
void Command_AxisControl(DGUS_VP &vp, void *data);
void Command_FilamentIO(DGUS_VP &vp, void *data);
void Command_PowerLoss(DGUS_VP &vp, void *data);
void Command_AdvancedSettings(DGUS_VP &vp, void *data);
void Command_FilelistControl(DGUS_VP &vp, void *data);
void Command_LaserControl(DGUS_VP &vp, void *data);
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSReturnKeyCodeHandler.h
|
C++
|
agpl-3.0
| 1,741
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUSRxHandler.h"
#include "DGUSScreenHandler.h"
#include "config/DGUS_Screen.h"
#include "../ui_api.h"
#include "../../../core/language.h"
#include "../../../module/stepper.h"
void DGUSRxHandler::printSpeedPercentage(DGUS_VP &vp, void *data) {
const_float_t feedratePercentage = dgus.fromFixedPoint<int16_t, const_float_t, 0>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setFeedrate_percent(feedratePercentage);
}
void DGUSRxHandler::zOffset(DGUS_VP &vp, void *data) {
const_float_t zoffset = dgus.fromFixedPoint<int16_t, const_float_t, 2>(Endianness::fromBE_P<int16_t>(data));
const_float_t currentzOffset = ExtUI::getZOffset_mm();
const_float_t zStepsPerMm = ExtUI::getAxisSteps_per_mm(ExtUI::Z);
int16_t zStepsDiff = zStepsPerMm * (zoffset - currentzOffset);
ExtUI::babystepAxis_steps(zStepsDiff, ExtUI::Z);
ExtUI::setZOffset_mm(zoffset);
}
void DGUSRxHandler::extruderTargetTemp(DGUS_VP &vp, void *data) {
const_float_t temperature = dgus.fromFixedPoint<int16_t, const_float_t, 0>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setTargetTemp_celsius(temperature, ExtUI::H0);
}
void DGUSRxHandler::bedTargetTemp(DGUS_VP &vp, void *data) {
const_float_t temperature = dgus.fromFixedPoint<int16_t, const_float_t, 0>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setTargetTemp_celsius(temperature, ExtUI::BED);
}
void DGUSRxHandler::axis_X(DGUS_VP &vp, void *data) {
const_float_t axisValue = dgus.fromFixedPoint<int16_t, float, 1>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setAxisPosition_mm(axisValue, ExtUI::X);
}
void DGUSRxHandler::axis_Y(DGUS_VP &vp, void *data) {
const_float_t axisValue = dgus.fromFixedPoint<int16_t, float, 1>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setAxisPosition_mm(axisValue, ExtUI::Y);
}
void DGUSRxHandler::axis_Z(DGUS_VP &vp, void *data) {
const_float_t axisValue = dgus.fromFixedPoint<int16_t, float, 1>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setAxisPosition_mm(axisValue, ExtUI::Z);
}
void DGUSRxHandler::extrudeLength(DGUS_VP &vp, void *data) {
const_float_t length = dgus.fromFixedPoint<int16_t, const_float_t, 1>(Endianness::fromBE_P<int16_t>(data));
const_float_t currentPosition = ExtUI::getAxisPosition_mm(ExtUI::E0);
#if HAS_FILAMENT_SENSOR
if (ExtUI::getFilamentRunoutEnabled() && ExtUI::getFilamentRunoutState()) {
screen.triggerTempScreenChange(DGUS_ScreenID::FILAMENTCHECK, DGUS_ScreenID::CONTROL_DEVICE);
return;
}
#endif
ExtUI::setAxisPosition_mm(currentPosition+length, ExtUI::E0);
}
void DGUSRxHandler::retractLength(DGUS_VP &vp, void *data) {
const_float_t length = dgus.fromFixedPoint<int16_t, const_float_t, 1>(Endianness::fromBE_P<int16_t>(data));
const_float_t currentPosition = ExtUI::getAxisPosition_mm(ExtUI::E0);
#if HAS_FILAMENT_SENSOR
if (ExtUI::getFilamentRunoutEnabled() && ExtUI::getFilamentRunoutState()) {
screen.triggerTempScreenChange(DGUS_ScreenID::FILAMENTCHECK, DGUS_ScreenID::CONTROL_DEVICE);
return;
}
#endif
ExtUI::setAxisPosition_mm(currentPosition-length, ExtUI::E0);
}
void DGUSRxHandler::setLanguage(DGUS_VP &vp, void *data) {
DGUS_Data::Language language = (DGUS_Data::Language)Endianness::fromBE_P<uint16_t>(data);
screen.config.language = language;
screen.triggerEEPROMSave();
screen.triggerFullUpdate();
}
#if ENABLED(PIDTEMPBED)
void DGUSRxHandler::bed_PID_P(DGUS_VP &vp, void *data) {
float pidValue = dgus.fromFixedPoint<int16_t, float, 2>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setBedPID(
pidValue,
ExtUI::getBedPID_Ki(),
ExtUI::getBedPID_Kd()
);
}
void DGUSRxHandler::bed_PID_I(DGUS_VP &vp, void *data) {
float pidValue = dgus.fromFixedPoint<int16_t, float, 2>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setBedPID(
ExtUI::getBedPID_Kp(),
pidValue,
ExtUI::getBedPID_Kd()
);
}
void DGUSRxHandler::bed_PID_D(DGUS_VP &vp, void *data) {
float pidValue = dgus.fromFixedPoint<int16_t, float, 1>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setBedPID(
ExtUI::getBedPID_Kp(),
ExtUI::getBedPID_Ki(),
pidValue
);
}
#endif // PIDTEMPBED
void DGUSRxHandler::fanSpeed(DGUS_VP &vp, void *data) {
const_float_t percentage = dgus.fromFixedPoint<int16_t, float, 0>(Endianness::fromBE_P<int16_t>(data));
ExtUI::setTargetFan_percent(percentage, ExtUI::FAN0);
}
void DGUSRxHandler::sdCardFileSection(DGUS_VP &vp, void *data) {
uint8_t sdFileIndex = Endianness::fromBE_P<int16_t>(data) - 1;
#if ENABLED(DGUS_USERCONFIRM)
if (screen.isOnUserConfirmationScreen()) {
screen.userConfirmation();
return;
}
#endif
dgus_sdcard_handler.onFileSelect(DGUS_FILE_FROM_INDEX(sdFileIndex % 5));
}
void DGUSRxHandler::stringToExtra(DGUS_VP &vp, void *data_ptr) {
if (!vp.size || !vp.extra) return;
memcpy(vp.extra, data_ptr, vp.size);
}
void DGUSRxHandler::disabled(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
screen.angryBeeps(2);
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.cpp
|
C++
|
agpl-3.0
| 5,974
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "DGUSDisplay.h"
#include "definition/DGUS_VP.h"
namespace DGUSRxHandler {
void printSpeedPercentage(DGUS_VP &vp, void *data);
void zOffset(DGUS_VP &vp, void *data);
void extruderTargetTemp(DGUS_VP &vp, void *data);
void bedTargetTemp(DGUS_VP &vp, void *data);
void axis_X(DGUS_VP &vp, void *data);
void axis_Y(DGUS_VP &vp, void *data);
void axis_Z(DGUS_VP &vp, void *data);
void extrudeLength(DGUS_VP &vp, void *data);
void retractLength(DGUS_VP &vp, void *data);
void setLanguage(DGUS_VP &vp, void *data);
template <typename T, T axis>
void maxFeedrate(DGUS_VP &vp, void *data) {
feedRate_t maxSpeed = (float)Endianness::fromBE_P<uint16_t>(data);
ExtUI::setAxisMaxFeedrate_mm_s(maxSpeed, axis);
}
template <typename T, T axis>
void maxAcceleration(DGUS_VP &vp, void *data) {
float maxAcceleration = (float)Endianness::fromBE_P<uint16_t>(data);
ExtUI::setAxisMaxAcceleration_mm_s2(maxAcceleration, axis);
}
template <typename T, T axis>
void maxJerk(DGUS_VP &vp, void *data) {
float maxJerk = dgus.fromFixedPoint<uint16_t, float, 2>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setAxisMaxJerk_mm_s(maxJerk, axis);
}
#if ENABLED(EDITABLE_STEPS_PER_UNIT)
template <typename T, T axis>
void stepsPerMM(DGUS_VP &vp, void *data) {
float stepsPerMm = dgus.fromFixedPoint<uint16_t, float, 1>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setAxisSteps_per_mm(stepsPerMm, axis);
}
#endif
#if ENABLED(PIDTEMP)
template <ExtUI::extruder_t extruder>
void PID_P(DGUS_VP &vp, void *data) {
float pidValue = dgus.fromFixedPoint<uint16_t, float, 2>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setPID(
pidValue,
ExtUI::getPID_Ki(extruder),
ExtUI::getPID_Kd(extruder),
extruder
);
}
template <ExtUI::extruder_t extruder>
void PID_I(DGUS_VP &vp, void *data) {
float pidValue = dgus.fromFixedPoint<uint16_t, float, 2>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setPID(
ExtUI::getPID_Kp(extruder),
pidValue,
ExtUI::getPID_Kd(extruder),
extruder
);
}
template <ExtUI::extruder_t extruder>
void PID_D(DGUS_VP &vp, void *data) {
float pidValue = dgus.fromFixedPoint<uint16_t, float, 2>(Endianness::fromBE_P<uint16_t>(data));
ExtUI::setPID(
ExtUI::getPID_Kp(extruder),
ExtUI::getPID_Ki(extruder),
pidValue,
extruder
);
}
#endif // PIDTEMP
#if ENABLED(PIDTEMPBED)
void bed_PID_P(DGUS_VP &vp, void *data);
void bed_PID_I(DGUS_VP &vp, void *data);
void bed_PID_D(DGUS_VP &vp, void *data);
#endif
void fanSpeed(DGUS_VP &vp, void *data);
void sdCardFileSection(DGUS_VP &vp, void *data);
void stringToExtra(DGUS_VP &vp, void *data);
void disabled(DGUS_VP &vp, void *data);
template<typename T>
void integerToExtra(DGUS_VP &vp, void *data_ptr) {
if (!vp.size || !vp.extra) return;
switch (vp.size) {
default: return;
case 1: {
const uint8_t data = *(uint8_t*)data_ptr;
*(T*)vp.extra = (T)data;
break;
}
case 2: {
const uint16_t data = Endianness::fromBE_P<uint16_t>(data_ptr);
*(T*)vp.extra = (T)data;
break;
}
case 4: {
const uint32_t data = Endianness::fromBE_P<uint32_t>(data_ptr);
*(T*)vp.extra = (T)data;
break;
}
}
}
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSRxHandler.h
|
C++
|
agpl-3.0
| 4,329
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "../../../sd/cardreader.h"
#include "DGUSSDCardHandler.h"
char DGUS_SDCardHandler::filenames[5][LONG_FILENAME_LENGTH] = {0};
void DGUS_SDCardHandler::setFilename(file_t file, const char* filename, bool isDir) {
const uint8_t fileIndex = DGUS_FILE_TO_INDEX(file);
filenames[fileIndex][0] = '\0';
if (filename) strcat(filenames[fileIndex], filename);
if (isDir) strcat(filenames[fileIndex], "/");
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler.cpp
|
C++
|
agpl-3.0
| 1,387
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include <inttypes.h>
#include "../../../sd/cardreader.h"
#define DGUS_E3S1PRO_BASIC_SDCARD_MAX_FILES 20
#define DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE 5
#define DGUS_PAGE_TO_SCREEN(page) (DGUS_ScreenID)((uint8_t)DGUS_ScreenID::FILE1 + ((uint8_t)page - (uint8_t)DGUS_SDCardHandler::page_t::PAGE_1))
#define DGUS_SCREEN_TO_PAGE(screen) (DGUS_SDCardHandler::page_t)((uint8_t)DGUS_SDCardHandler::page_t::PAGE_1 + ((uint8_t)screen - (uint8_t)DGUS_ScreenID::FILE1))
#define DGUS_PAGE_TO_INDEX(page) (uint8_t)((uint8_t)page - (uint8_t)DGUS_SDCardHandler::page_t::PAGE_1)
#define DGUS_FILE_TO_INDEX(file) (uint8_t)((uint8_t)file - (uint8_t)DGUS_SDCardHandler::file_t::FILE_1)
#define DGUS_PAGE_FROM_INDEX(index) (DGUS_SDCardHandler::page_t)(index + (uint8_t)DGUS_SDCardHandler::page_t::PAGE_1)
#define DGUS_FILE_FROM_INDEX(index) (DGUS_SDCardHandler::file_t)(index + (uint8_t)DGUS_SDCardHandler::file_t::FILE_1)
class DGUS_SDCardHandler {
public:
enum class page_t : uint8_t {
PAGE_1 = 1,
PAGE_2,
PAGE_3,
PAGE_4
};
enum class file_t : uint8_t {
FILE_1 = 1,
FILE_2,
FILE_3,
FILE_4,
FILE_5,
FILE_Max = FILE_5,
FILE_Count
};
static char filenames[5][LONG_FILENAME_LENGTH];
public:
static void Reset();
static void onPageLoad(page_t page);
static bool onFileSelect(file_t file);
static page_t onFirstPage();
static page_t onLastPage();
static page_t onPreviousPage();
static page_t onNextPage();
private:
static void setFilename(file_t file, const char* filename, bool isDir = false) PROGMEM;
};
extern DGUS_SDCardHandler dgus_sdcard_handler;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler.h
|
C++
|
agpl-3.0
| 2,538
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ALL(DGUS_LCD_UI_E3S1PRO, DGUS_ADVANCED_SDCARD)
#include "DGUSSDCardHandler.h"
#include "DGUSScreenHandler.h"
#include "DGUSDisplay.h"
static DGUS_SDCardHandler::page_t currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
static uint8_t currentVirtualPage = 0;
static size_t fileCount = 0;
static ExtUI::FileList fileList = ExtUI::FileList();
void DGUS_SDCardHandler::Reset() {
currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
currentVirtualPage = 0;
while (!fileList.isAtRootDir())
fileList.upDir();
fileList.refresh();
fileCount = fileList.count();
}
void DGUS_SDCardHandler::onPageLoad(DGUS_SDCardHandler::page_t page) {
setFilename(file_t::FILE_1, NULL);
setFilename(file_t::FILE_2, NULL);
setFilename(file_t::FILE_3, NULL);
setFilename(file_t::FILE_4, NULL);
setFilename(file_t::FILE_5, NULL);
uint8_t pageIndex = currentVirtualPage;
uint16_t currentSeekPos = 0;
currentSeekPos += pageIndex * DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE;
file_t currentFile = file_t::FILE_1;
if (!fileList.isAtRootDir()) {
if (currentPage == page_t::PAGE_1) {
setFilename(currentFile, "-- dir up --");
currentFile = DGUS_FILE_FROM_INDEX(DGUS_FILE_TO_INDEX(currentFile) + 1);
}
else
currentSeekPos -= 1; // account for the updir entry on page 1
}
while (currentFile <= file_t::FILE_5
&& fileList.seek(currentSeekPos, true)
&& currentSeekPos < fileCount) {
++currentSeekPos;
setFilename(currentFile, fileList.filename(), fileList.isDir());
currentFile = DGUS_FILE_FROM_INDEX(DGUS_FILE_TO_INDEX(currentFile) + 1);
}
}
bool DGUS_SDCardHandler::onFileSelect(DGUS_SDCardHandler::file_t file) {
uint8_t fileIndex = DGUS_FILE_TO_INDEX(file);
if (!filenames[fileIndex][0])
return false;
bool changeDir = false;
if (!fileList.isAtRootDir()
&& currentPage == page_t::PAGE_1
&& file == file_t::FILE_1) {
fileList.upDir();
changeDir = true;
}
else if (filenames[fileIndex][strlen(filenames[fileIndex])-1] == '/') {
filenames[fileIndex][strlen(filenames[fileIndex])-1] = '\0';
fileList.changeDir(filenames[fileIndex]);
changeDir = true;
}
if (changeDir) {
fileList.refresh();
currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
currentVirtualPage = 0;
fileCount = fileList.count();
if (currentPage == page_t::PAGE_1)
onPageLoad(page_t::PAGE_1);
else
screen.triggerScreenChange(DGUS_ScreenID::FILE1);
return true;
}
screen.startPrintFromSD(filenames[fileIndex]);
return true;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onFirstPage() {
currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
currentVirtualPage = 0;
return currentPage;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onLastPage() {
currentVirtualPage = (fileCount - 1 + (fileList.isAtRootDir() ? 0 : 1)) / DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE;
if (currentVirtualPage >= 4) {
currentPage = page_t::PAGE_4;
onPageLoad(page_t::PAGE_4);
}
else
currentPage = DGUS_PAGE_FROM_INDEX(currentVirtualPage);
return currentPage;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onPreviousPage() {
if (currentVirtualPage > 0) {
currentVirtualPage -= 1;
if (currentVirtualPage >= 4)
currentPage = page_t::PAGE_4;
else
currentPage = DGUS_PAGE_FROM_INDEX(currentVirtualPage);
}
return currentPage;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onNextPage() {
if (currentVirtualPage < (fileCount - 1 + (fileList.isAtRootDir() ? 0 : 1)) / DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE) {
if (++currentVirtualPage >= 4) {
currentPage = page_t::PAGE_4;
onPageLoad(page_t::PAGE_4);
}
else
currentPage = DGUS_PAGE_FROM_INDEX(currentVirtualPage);
}
return currentPage;
}
#endif // DGUS_LCD_UI_E3S1PRO && DGUS_ADVANCED_SDCARD
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Advanced.cpp
|
C++
|
agpl-3.0
| 4,747
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#define DGUS_E3S1PRO_BASIC_SDCARD_MAX_FILES 20
#define DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE 5
#if ENABLED(DGUS_LCD_UI_E3S1PRO) && DISABLED(DGUS_ADVANCED_SDCARD)
#include "DGUSSDCardHandler.h"
#include "DGUSScreenHandler.h"
#include "DGUSDisplay.h"
static DGUS_SDCardHandler::page_t currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
static size_t fileCount = 0;
static ExtUI::FileList fileList = ExtUI::FileList();
void DGUS_SDCardHandler::Reset() {
currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
while (!fileList.isAtRootDir())
fileList.upDir();
fileCount = 0;
uint16_t currentSeekPos = 0;
uint16_t entriesCount = fileList.count();
while (currentSeekPos < entriesCount
&& fileCount < DGUS_E3S1PRO_BASIC_SDCARD_MAX_FILES
&& fileList.seek(currentSeekPos, true)
) {
if (!fileList.isDir()) fileCount++;
currentSeekPos++;
}
#ifdef DEBUG_DGUSLCD
DEBUG_ECHOPGM("Reset() :", fileCount);
DEBUG_CHAR('/');
DEBUG_ECHOLN(currentSeekPos);
#endif
}
void DGUS_SDCardHandler::onPageLoad(DGUS_SDCardHandler::page_t page) {
setFilename(file_t::FILE_1, NULL);
setFilename(file_t::FILE_2, NULL);
setFilename(file_t::FILE_3, NULL);
setFilename(file_t::FILE_4, NULL);
setFilename(file_t::FILE_5, NULL);
uint8_t pageIndex = DGUS_PAGE_TO_INDEX(page);
uint16_t currentFilePos = 0;
uint16_t currentSeekPos = 0;
uint16_t entriesCount = fileList.count();
#ifdef DEBUG_DGUSLCD
DEBUG_ECHOLNPGM("onPageLoad(): seek page ", pageIndex);
#endif
while (currentFilePos < pageIndex * DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE
&& fileList.seek(currentSeekPos, true)
&& currentSeekPos < entriesCount
) {
++currentSeekPos;
if (!fileList.isDir())
currentFilePos++;
}
#ifdef DEBUG_DGUSLCD
DEBUG_ECHOPGM("onPageLoad() :", currentFilePos);
DEBUG_CHAR('/');
DEBUG_ECHOLN(currentSeekPos - 1);
#endif
file_t currentFile = file_t::FILE_1;
while (currentFilePos < (pageIndex + 1) * DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE
&& fileList.seek(currentSeekPos, true)
&& currentSeekPos < entriesCount
) {
++currentSeekPos;
if (!fileList.isDir()) {
++currentFilePos;
setFilename(currentFile, fileList.longFilename());
currentFile = DGUS_FILE_FROM_INDEX(DGUS_FILE_TO_INDEX(currentFile) + 1);
}
}
}
bool DGUS_SDCardHandler::onFileSelect(DGUS_SDCardHandler::file_t file) {
uint8_t fileIndex = DGUS_FILE_TO_INDEX(file);
if (!filenames[fileIndex][0])
return false;
screen.startPrintFromSD(filenames[fileIndex]);
return true;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onFirstPage() {
currentPage = DGUS_SDCardHandler::page_t::PAGE_1;
return currentPage;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onLastPage() {
currentPage = DGUS_PAGE_FROM_INDEX(fileCount / DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE);
return currentPage;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onPreviousPage() {
if (currentPage > page_t::PAGE_1)
currentPage = DGUS_PAGE_FROM_INDEX(DGUS_PAGE_TO_INDEX(currentPage) - 1);
return currentPage;
}
DGUS_SDCardHandler::page_t DGUS_SDCardHandler::onNextPage() {
if (DGUS_PAGE_TO_INDEX(currentPage) < (fileCount / DGUS_E3S1PRO_BASIC_SDCARD_FILES_PER_PAGE) - 1)
currentPage = DGUS_PAGE_FROM_INDEX(DGUS_PAGE_TO_INDEX(currentPage) + 1);
return currentPage;
}
#endif // DGUS_LCD_UI_E3S1PRO && !DGUS_ADVANCED_SDCARD
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSDCardHandler_Basic.cpp
|
C++
|
agpl-3.0
| 4,321
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUSDisplay.h"
#include "DGUSScreenHandler.h"
#include "DGUSSDCardHandler.h"
#include "definition/DGUS_ScreenAddrList.h"
#include "definition/DGUS_ScreenSetup.h"
#include "../../../gcode/queue.h"
#define DGUS_SCREEN_PAGE_DEBUG // uncomment to debug page changes
DGUSScreenHandler::eeprom_data_t DGUSScreenHandler::config = {};
uint16_t DGUSScreenHandler::currentMeshPointIndex = 0;
bool DGUSScreenHandler::isLeveling = false;
char DGUSScreenHandler::homeStatusMessage[128];
bool DGUSScreenHandler::settings_ready = false;
bool DGUSScreenHandler::booted = false;
DGUS_ScreenID DGUSScreenHandler::current_screen = DGUS_ScreenID::BOOT;
DGUS_ScreenID DGUSScreenHandler::new_screen = DGUS_ScreenID::BOOT;
DGUS_ScreenID DGUSScreenHandler::wait_return_screen = DGUS_ScreenID::BOOT;
DGUS_ScreenID DGUSScreenHandler::confirm_return_screen = DGUS_ScreenID::BOOT;
bool DGUSScreenHandler::full_update = false;
uint8_t DGUSScreenHandler::angry_beeps = 0;
#if HAS_MEDIA
static const char* const noFileSelected = "";
const char* DGUSScreenHandler::sdPrintFilename = noFileSelected;
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
bool DGUSScreenHandler::powerLossRecoveryAvailable = false;
#endif
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
ssize_t DGUSScreenHandler::currentScrollIndex = 0;
size_t DGUSScreenHandler::pageMaxStringLen = 0;
size_t DGUSScreenHandler::pageMaxControlLen = 0;
#endif
millis_t DGUSScreenHandler::status_expire = 0;
millis_t DGUSScreenHandler::eeprom_save = 0;
void DGUSScreenHandler::init() {
dgus.init();
moveToScreen(DGUS_ScreenID::BOOT, true);
}
void DGUSScreenHandler::ready() {
dgus.playSound(1);
}
void DGUSScreenHandler::loop() {
const millis_t ms = ExtUI::safe_millis();
static millis_t next_event_ms = 0, next_beep_ms = 0;
static bool wasLeveling = isLeveling;
if (new_screen != DGUS_ScreenID::BOOT) {
const DGUS_ScreenID screen = new_screen;
new_screen = DGUS_ScreenID::BOOT;
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
currentScrollIndex = -DGUS_AUTOSCROLL_START_CYCLES;
pageMaxStringLen = 0;
pageMaxControlLen = 0;
#endif
if (current_screen == screen)
triggerFullUpdate();
else
moveToScreen(screen);
return;
}
if (!booted && current_screen == DGUS_ScreenID::HOME) {
// Boot complete
booted = true;
dgus.readVersions();
return;
}
#if ENABLED(POWER_LOSS_RECOVERY)
if (booted && powerLossRecoveryAvailable) {
triggerScreenChange(DGUS_ScreenID::POWERCONTINUE);
powerLossRecoveryAvailable = false;
}
#endif
if (ELAPSED(ms, next_event_ms) || full_update) {
next_event_ms = ms + (booted ? DGUS_UPDATE_INTERVAL_MS : 50);
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
currentScrollIndex += 1;
if (currentScrollIndex > (ssize_t)(pageMaxStringLen - pageMaxControlLen) + DGUS_AUTOSCROLL_END_CYCLES)
currentScrollIndex = -DGUS_AUTOSCROLL_START_CYCLES;
#endif
if (angry_beeps) {
--angry_beeps;
dgus.playSound(3);
}
if (!sendScreenVPData(current_screen, full_update))
DEBUG_ECHOLNPGM("SendScreenVPData failed");
return;
}
if (ELAPSED(ms, next_beep_ms)) {
next_beep_ms = ms + 300;
if (angry_beeps) {
--angry_beeps;
dgus.playSound(0, 500/8, 100);
}
}
if (wasLeveling && !isLeveling) {
#if ENABLED(AUTO_BED_LEVELING_UBL)
ExtUI::injectCommands(ExtUI::getLevelingIsValid() ? F("G29 S0") : F("G29 S1\nG29 P3\nG29 S0"));
#endif
config.levelingEnabled = ExtUI::getLevelingIsValid();
ExtUI::setLevelingActive(config.levelingEnabled);
triggerEEPROMSave();
}
wasLeveling = isLeveling;
if (!settings_ready && booted) return;
if (status_expire > 0 && ELAPSED(ms, status_expire)) {
setStatusMessage(FPSTR(NUL_STR), 0);
return;
}
if (eeprom_save > 0 && ELAPSED(ms, eeprom_save) && isPrinterIdle()) {
eeprom_save = 0;
ExtUI::injectCommands(F("M500"));
return;
}
dgus.loop();
}
void DGUSScreenHandler::printerKilled(FSTR_P const error, FSTR_P const component) {
dgus.playSound(0, (uint8_t)(3000/8), 100);
setStatusMessage(error);
moveToScreen(DGUS_ScreenID::ABNORMAL);
}
void DGUSScreenHandler::userConfirmRequired(const char * const msg) {
#if ENABLED(DGUS_USERCONFIRM)
if (confirm_return_screen == DGUS_ScreenID::BOOT)
confirm_return_screen = getCurrentScreen();
strcpy(dgus_sdcard_handler.filenames[0], msg);
dgus_sdcard_handler.filenames[1][0] = '\0';
dgus_sdcard_handler.filenames[2][0] = '\0';
dgus_sdcard_handler.filenames[3][0] = '\0';
strcpy(dgus_sdcard_handler.filenames[4], "[");
strcat(dgus_sdcard_handler.filenames[4], GET_TEXT(MSG_BUTTON_CONFIRM));
strcat(dgus_sdcard_handler.filenames[4], "]");
new_screen = DGUS_ScreenID::FILE1;
#if ALL(DEBUG_OUT, DGUS_SCREEN_PAGE_DEBUG)
DEBUG_ECHOLNPGM("trig confirm: ", msg, ", ret: ", (uint16_t)confirm_return_screen);
#endif
#else
UNUSED(msg);
#endif
}
void DGUSScreenHandler::userConfirmation() {
#if ENABLED(DGUS_USERCONFIRM)
if (confirm_return_screen == DGUS_ScreenID::BOOT) {
DEBUG_ECHOLNPGM("DGUS: User confirmation triggered but no return screen");
return;
}
if (confirm_return_screen >= DGUS_ScreenID::FILE1 && confirm_return_screen <= DGUS_ScreenID::FILE4)
dgus_sdcard_handler.onPageLoad(DGUS_SCREEN_TO_PAGE(confirm_return_screen));
#ifdef DEBUG_DGUSLCD
DEBUG_ECHOLNPGM("trig confirmed, ret:", (uint16_t)confirm_return_screen);
#endif
new_screen = confirm_return_screen;
confirm_return_screen = DGUS_ScreenID::BOOT;
ExtUI::setUserConfirmed();
#endif
}
void DGUSScreenHandler::settingsReset() {
config.initialized = true;
config.volume = DGUS_DEFAULT_VOLUME;
config.brightness = DGUS_DEFAULT_BRIGHTNESS;
config.language = DGUS_Data::Language::Default;
config.jogLength = DGUS_Data::AxisControlCommand::Jog_1mm;
config.plaExtruderTemp = PREHEAT_1_TEMP_HOTEND;
config.plaBedTemp = PREHEAT_1_TEMP_BED;
config.absExtruderTemp = PREHEAT_2_TEMP_HOTEND;
config.absBedTemp = PREHEAT_2_TEMP_BED;
config.levelingEnabled = ExtUI::getLevelingActive();
if (!settings_ready) {
settings_ready = true;
ready();
}
setStatusMessage(GET_TEXT_F(DGUS_MSG_RESET_EEPROM));
}
void DGUSScreenHandler::storeSettings(char *buff) {
static_assert(sizeof(config) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size.");
config.initialized = true;
config.volume = dgus.getVolume();
config.brightness = dgus.getBrightness();
memcpy(buff, &config, sizeof(config));
}
void DGUSScreenHandler::loadSettings(const char *buff) {
static_assert(sizeof(config) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size.");
memcpy(&config, buff, sizeof(config));
if (!config.initialized
|| config.language < DGUS_Data::Language::Chinese_Simplified
|| config.language > DGUS_Data::Language::Turkish
|| config.jogLength < DGUS_Data::AxisControlCommand::Jog_10mm
|| config.jogLength > DGUS_Data::AxisControlCommand::Jog_0_1mm) {
DEBUG_ECHOLNPGM("invalid DGUS settings, resetting");
settingsReset();
}
ExtUI::setLevelingActive(config.levelingEnabled);
dgus.setVolume(config.volume);
dgus.setBrightness(config.brightness);
}
void DGUSScreenHandler::configurationStoreWritten(bool success) {
if (!success)
setStatusMessage(GET_TEXT_F(DGUS_MSG_WRITE_EEPROM_FAILED));
}
void DGUSScreenHandler::configurationStoreRead(bool success) {
if (!success) {
setStatusMessage(GET_TEXT_F(DGUS_MSG_READ_EEPROM_FAILED));
}
else if (!settings_ready) {
settings_ready = true;
ready();
}
}
void DGUSScreenHandler::playTone(const uint16_t frequency, const uint16_t duration/*=0*/) {
if (WITHIN(frequency, 1, 255)) {
if (WITHIN(duration, 1, 255))
dgus.playSound((uint8_t)frequency, (uint8_t)duration);
else
dgus.playSound((uint8_t)frequency);
}
}
void DGUSScreenHandler::angryBeeps(const uint8_t beepCount) {
angry_beeps = beepCount;
}
void DGUSScreenHandler::levelingStart() {
isLeveling = true;
currentMeshPointIndex = 0;
triggerFullUpdate();
}
void DGUSScreenHandler::levelingEnd() {
if (!isLeveling) return;
#if ENABLED(DEBUG_DGUSLCD)
DEBUG_ECHOLNPGM("levelingEnd(), valid=", ExtUI::getLevelingIsValid());
#endif
isLeveling = false;
currentMeshPointIndex = 0;
triggerFullUpdate();
}
void DGUSScreenHandler::meshUpdate(const int8_t xpos, const int8_t ypos) {
if (!isLeveling) return;
currentMeshPointIndex++;
triggerFullUpdate();
}
void DGUSScreenHandler::printTimerStarted() {
TERN_(HAS_FILAMENT_SENSOR, ExtUI::setFilamentRunoutState(false));
triggerScreenChange(DGUS_ScreenID::PAUSE);
}
void DGUSScreenHandler::printTimerPaused() {
dgus.playSound(3);
triggerScreenChange(DGUS_ScreenID::RESUME);
}
void DGUSScreenHandler::printTimerStopped() {
dgus.playSound(3);
triggerScreenChange(DGUS_ScreenID::FINISH);
}
void DGUSScreenHandler::filamentRunout(const ExtUI::extruder_t extruder) {
triggerScreenChange(DGUS_ScreenID::FILAMENTUSEUP);
dgus.playSound(3);
}
ssize_t DGUSScreenHandler::getScrollIndex() {
return currentScrollIndex;
}
void DGUSScreenHandler::addCurrentPageStringLength(size_t stringLength, size_t textControlLength) {
NOLESS(pageMaxStringLen, stringLength);
NOLESS(pageMaxControlLen, textControlLength);
}
#if HAS_MEDIA
void DGUSScreenHandler::sdCardInserted() {}
void DGUSScreenHandler::sdCardRemoved() {
sdPrintFilename = noFileSelected;
if (WITHIN(getCurrentScreen(), DGUS_ScreenID::FILE1, DGUS_ScreenID::FILE4))
triggerTempScreenChange(DGUS_ScreenID::SDCARDCHECK, DGUS_ScreenID::HOME);
}
void DGUSScreenHandler::sdCardError() {}
#endif // HAS_MEDIA
#if ENABLED(POWER_LOSS_RECOVERY)
void DGUSScreenHandler::powerLossResume() {
powerLossRecoveryAvailable = true;
}
#endif
#if HAS_PID_HEATING
void DGUSScreenHandler::pidTuning(const ExtUI::pidresult_t rst) {
dgus.playSound(3);
}
#endif
void DGUSScreenHandler::steppersStatusChanged(bool steppersEnabled) {
refreshVP(DGUS_Addr::AXIS_StepperStatus);
}
void DGUSScreenHandler::homingDone() {
if (isOnTempScreen(DGUS_ScreenID::AUTOHOME))
triggerReturnScreen();
}
void DGUSScreenHandler::startPrintFromSD(const char* const filename) {
triggerScreenChange(DGUS_ScreenID::HOME);
sdPrintFilename = filename;
setStatusMessage(sdPrintFilename, 0);
}
void DGUSScreenHandler::setStatusMessage(FSTR_P msg, const millis_t duration) {
setStatusMessage(FTOP(msg), duration);
}
void DGUSScreenHandler::setStatusMessage(const char* msg, const millis_t duration) {
homeStatusMessage[0] = '\0';
strncat(homeStatusMessage, msg, sizeof(homeStatusMessage) / sizeof(char) - 1);
status_expire = duration ? ExtUI::safe_millis() + duration : 0;
}
DGUS_ScreenID DGUSScreenHandler::getCurrentScreen() { return current_screen; }
void DGUSScreenHandler::homeThenChangeScreen(DGUS_ScreenID screen) {
triggerTempScreenChange(DGUS_ScreenID::AUTOHOME, screen);
ExtUI::injectCommands(F("G28"));
}
void DGUSScreenHandler::triggerScreenChange(DGUS_ScreenID screen) {
if (confirm_return_screen != DGUS_ScreenID::BOOT)
confirm_return_screen = screen;
else
new_screen = screen;
wait_return_screen = DGUS_ScreenID::BOOT; // cancel temp screen
#if ALL(DEBUG_OUT, DGUS_SCREEN_PAGE_DEBUG)
DEBUG_ECHOLNPGM("trig scr: ", (uint16_t)screen);
#endif
}
void DGUSScreenHandler::triggerTempScreenChange(DGUS_ScreenID screen, DGUS_ScreenID returnScreen) {
if (confirm_return_screen != DGUS_ScreenID::BOOT)
confirm_return_screen = screen;
else
new_screen = screen;
wait_return_screen = returnScreen;
#if ALL(DEBUG_OUT, DGUS_SCREEN_PAGE_DEBUG)
DEBUG_ECHOLNPGM("trig tmp: ", (uint16_t)screen, " ret: ", (uint16_t)returnScreen);
#endif
}
void DGUSScreenHandler::triggerReturnScreen() {
new_screen = wait_return_screen;
wait_return_screen = DGUS_ScreenID::BOOT;
#if ALL(DEBUG_OUT, DGUS_SCREEN_PAGE_DEBUG)
DEBUG_ECHOLNPGM("trig ret scr");
#endif
}
bool DGUSScreenHandler::isOnTempScreen(DGUS_ScreenID screen) {
return wait_return_screen != DGUS_ScreenID::BOOT
&& (screen == DGUS_ScreenID::BOOT || current_screen == screen);
}
void DGUSScreenHandler::triggerFullUpdate() {
full_update = true;
}
void DGUSScreenHandler::triggerEEPROMSave() {
eeprom_save = ExtUI::safe_millis() + 500;
}
bool DGUSScreenHandler::isPrinterIdle() {
return (!ExtUI::commandsInQueue() && !ExtUI::isMoving());
}
const DGUS_Addr* DGUSScreenHandler::findScreenAddrList(DGUS_ScreenID screen) {
DGUS_ScreenAddrList list;
const DGUS_ScreenAddrList *map = screen_addr_list_map;
do {
memcpy_P(&list, map, sizeof(*map));
if (!list.addr_list) break;
if (list.screen == screen) return list.addr_list;
} while (++map);
return nullptr;
}
bool DGUSScreenHandler::callScreenSetup(DGUS_ScreenID screen) {
DGUS_ScreenSetup setup;
const DGUS_ScreenSetup *list = screen_setup_list;
do {
memcpy_P(&setup, list, sizeof(*list));
if (!setup.setup_fn) break;
if (setup.screen == screen) return setup.setup_fn();
} while (++list);
return true;
}
void DGUSScreenHandler::moveToScreen(DGUS_ScreenID screen, bool abort_wait) {
current_screen = screen;
if (!callScreenSetup(screen)) return;
if (!sendScreenVPData(screen, true)) return;
dgus.switchScreen(current_screen);
}
bool DGUSScreenHandler::sendScreenVPData(DGUS_ScreenID screen, bool complete_update) {
if (complete_update) full_update = false;
const DGUS_Addr *list = findScreenAddrList(screen);
while (true) {
if (!list) return true; // Nothing left to send
const uint16_t addr = pgm_read_word(list++);
if (!addr) return true; // Nothing left to send
DGUS_VP vp;
if (!DGUS_PopulateVP((DGUS_Addr)addr, &vp)) continue; // Invalid VP
if (!vp.tx_handler) continue; // Nothing to send
if (!complete_update
&& !(vp.flags & VPFLAG_AUTOUPLOAD)
&& TERN1(DGUS_SOFTWARE_AUTOSCROLL, !(vp.flags & VPFLAG_TXSTRING_AUTOSCROLL))
) continue; // Unnecessary VP
uint8_t expected_tx = 6 + vp.size; // 6 bytes header + payload.
const millis_t try_until = ExtUI::safe_millis() + 1000;
while (expected_tx > dgus.getFreeTxBuffer()) {
if (ELAPSED(ExtUI::safe_millis(), try_until)) return false; // Stop trying after 1 second
dgus.flushTx(); // Flush the TX buffer
delay(50);
}
vp.tx_handler(vp);
}
}
bool DGUSScreenHandler::refreshVP(DGUS_Addr vpAddr) {
const DGUS_Addr *list = findScreenAddrList(current_screen);
while (list && (uint16_t)*list) {
if (*list == vpAddr) {
DGUS_VP vp;
if (!DGUS_PopulateVP((DGUS_Addr)vpAddr, &vp) || !vp.tx_handler)
return false;
vp.tx_handler(vp);
return true;
}
list++;
}
return false;
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 15,823
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../../../inc/MarlinConfigPre.h"
#include "config/DGUS_Addr.h"
#include "config/DGUS_Data.h"
#include "config/DGUS_Screen.h"
#include "config/DGUS_Constants.h"
#include "DGUSSDCardHandler.h"
#include "../ui_api.h"
class DGUSScreenHandler {
public:
typedef struct {
bool initialized;
bool levelingEnabled;
uint8_t volume;
uint8_t brightness;
DGUS_Data::Language language;
DGUS_Data::AxisControlCommand jogLength;
uint16_t plaExtruderTemp;
uint16_t plaBedTemp;
uint16_t absExtruderTemp;
uint16_t absBedTemp;
} eeprom_data_t;
public:
static eeprom_data_t config;
static uint16_t currentMeshPointIndex;
static bool isLeveling;
static char homeStatusMessage[128];
private:
static bool settings_ready;
static bool booted;
static DGUS_ScreenID current_screen;
static DGUS_ScreenID new_screen;
static DGUS_ScreenID wait_return_screen;
static DGUS_ScreenID confirm_return_screen;
static bool full_update;
static uint8_t angry_beeps;
#if HAS_MEDIA
static const char* sdPrintFilename;
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
static bool powerLossRecoveryAvailable;
#endif
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
static ssize_t currentScrollIndex;
static size_t pageMaxStringLen;
static size_t pageMaxControlLen;
#endif
static millis_t status_expire;
static millis_t eeprom_save;
public:
DGUSScreenHandler() = default;
static void init();
static void ready();
static void loop();
static void printerKilled(FSTR_P const error, FSTR_P const component);
static bool isOnUserConfirmationScreen() { return confirm_return_screen != DGUS_ScreenID::BOOT; }
static void userConfirmRequired(const char * const msg);
static void userConfirmation();
static void settingsReset();
static void storeSettings(char *buff);
static void loadSettings(const char *buff);
static void configurationStoreWritten(bool success);
static void configurationStoreRead(bool success);
static void playTone(const uint16_t frequency, const uint16_t duration=0);
static void angryBeeps(const uint8_t beepCount);
static void levelingStart();
static void levelingEnd();
static void meshUpdate(const int8_t xpos, const int8_t ypos);
static void printTimerStarted();
static void printTimerPaused();
static void printTimerStopped();
static void filamentRunout(const ExtUI::extruder_t extruder);
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
static ssize_t getScrollIndex();
static void addCurrentPageStringLength(size_t stringLength, size_t textControlLength);
#endif
#if HAS_MEDIA
/// Marlin informed us that a new SD has been inserted.
static void sdCardInserted();
/// Marlin informed us that the SD Card has been removed().
static void sdCardRemoved();
/// Marlin informed us about a bad SD Card.
static void sdCardError();
static const char* getSDCardPrintFilename() { return sdPrintFilename; }
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
static void powerLossResume();
#endif
#if HAS_PID_HEATING
static void pidTuning(const ExtUI::pidresult_t rst);
#endif
static void steppersStatusChanged(bool steppersEnabled);
static void homingDone();
static void startPrintFromSD(const char* const filename);
static void setStatusMessage(FSTR_P msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS);
static void setStatusMessage(const char* msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS);
static DGUS_ScreenID getCurrentScreen();
static void homeThenChangeScreen(DGUS_ScreenID screen);
static void triggerScreenChange(DGUS_ScreenID screen);
static void triggerTempScreenChange(DGUS_ScreenID screen, DGUS_ScreenID returnScreen);
static void triggerReturnScreen();
static bool isOnTempScreen(DGUS_ScreenID screen = DGUS_ScreenID::BOOT);
static void triggerFullUpdate();
static void triggerEEPROMSave();
static bool isPrinterIdle();
private:
static const DGUS_Addr* findScreenAddrList(DGUS_ScreenID screen);
static bool callScreenSetup(DGUS_ScreenID screen);
static void moveToScreen(DGUS_ScreenID screen, bool abort_wait=false);
static bool sendScreenVPData(DGUS_ScreenID screen, bool complete_update);
static bool refreshVP(DGUS_Addr vpAddr);
};
extern DGUSScreenHandler screen;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSScreenHandler.h
|
C++
|
agpl-3.0
| 5,179
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUSSetupHandler.h"
#include "DGUSDisplay.h"
#include "DGUSScreenHandler.h"
typedef void (*controlSet_t)(const DGUS_ScreenID, DGUSDisplay::DGUS_ControlType, DGUS_Control);
bool DGUSSetupHandler::sdCardPrepare() {
bool isConfirm = false;
#if ENABLED(DGUS_USERCONFIRM)
isConfirm = screen.isOnUserConfirmationScreen();
controlSet_t controlSet = isConfirm ? dgus.disableControl : dgus.enableControl;
// Only allow the fifth line used as the confirm button to be clicked
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File1);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File2);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File3);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_File4);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Start);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_End);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Prev);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Next);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Home);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Print);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Ready);
controlSet(DGUS_ScreenID::FILE1, DGUSDisplay::DGUS_ControlType::RETURN_KEY_CODE, DGUS_Control::FILE1_Settings);
#endif
if (!isConfirm) dgus_sdcard_handler.onPageLoad(DGUS_SCREEN_TO_PAGE(screen.getCurrentScreen()));
return true;
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSetupHandler.cpp
|
C++
|
agpl-3.0
| 2,947
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
namespace DGUSSetupHandler {
bool sdCardPrepare();
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSSetupHandler.h
|
C++
|
agpl-3.0
| 931
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUSTxHandler.h"
#include "DGUSScreenHandler.h"
#include "config/DGUS_Data.h"
#include "../../../module/stepper.h" // for axis_enabled
#include "../../../libs/duration_t.h"
void DGUSTxHandler::bootAnimation(DGUS_VP &vp) {
static uint16_t bootIcon = 0;
dgus.write((uint16_t)vp.addr, Endianness::toBE(bootIcon));
if (++bootIcon > 100) {
bootIcon = 0;
screen.triggerScreenChange(DGUS_ScreenID::HOME);
}
}
void DGUSTxHandler::zOffset(DGUS_VP &vp) {
const float position = ExtUI::getZOffset_mm();
const int16_t data = dgus.toFixedPoint<float, int16_t, 2>(position); // Round to 0.01
dgus.write((int16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::elapsedHours(DGUS_VP &vp) {
const duration_t elapsedtime = ExtUI::getProgress_seconds_elapsed();
const int16_t data = elapsedtime.hour();
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::elapsedMinutes(DGUS_VP &vp) {
const duration_t elapsedtime = ExtUI::getProgress_seconds_elapsed();
const int16_t data = elapsedtime.minute() % 60;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::levelingProgress(DGUS_VP &vp) {
const uint16_t data = (100 * screen.currentMeshPointIndex) / GRID_MAX_POINTS;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::fanSpeed(DGUS_VP &vp) {
const int16_t data = (int16_t)ExtUI::getActualFan_percent(ExtUI::FAN0);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::levelingProgressIcon(DGUS_VP &vp) {
const uint16_t data = 1 + (50 * screen.currentMeshPointIndex) / GRID_MAX_POINTS;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
#if HAS_FILAMENT_SENSOR
void DGUSTxHandler::filamentInsertionStatus(DGUS_VP &vp) {
const uint16_t data = ExtUI::getFilamentRunoutState() ? 1 : 0;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
#endif
void DGUSTxHandler::sdCardInsertionStatus(DGUS_VP &vp) {
const uint16_t data = ExtUI::isMediaInserted() ? 1 : 0;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
#if ENABLED(PIDTEMPBED)
void DGUSTxHandler::bed_PID_P(DGUS_VP &vp) {
const int16_t data = dgus.toFixedPoint<float, int16_t, 2>(ExtUI::getBedPID_Kp());
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::bed_PID_I(DGUS_VP &vp) {
const int16_t data = dgus.toFixedPoint<float, int16_t, 2>(ExtUI::getBedPID_Ki());
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::bed_PID_D(DGUS_VP &vp) {
const int16_t data = dgus.toFixedPoint<float, int16_t, 1>(ExtUI::getBedPID_Kd());
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
#endif // PIDTEMPBED
static duration_t _printRemainingDurationEstimate() {
duration_t remainingDuration = 0;
if (ExtUI::isPrinting()) {
const uint8_t progressPercentage = ExtUI::getProgress_percent();
remainingDuration = duration_t(3600);
if (progressPercentage >= 2)
remainingDuration = ExtUI::getProgress_seconds_elapsed() * ((100.0 / (float)progressPercentage) - 1.0);
}
return remainingDuration;
}
void DGUSTxHandler::printRemainingHours(DGUS_VP &vp) {
const int16_t data = _printRemainingDurationEstimate().hour();
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::printRemainingMinutes(DGUS_VP &vp) {
const int16_t data = _printRemainingDurationEstimate().minute() % 60;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::printPercentage(DGUS_VP &vp) {
const int16_t data = ExtUI::getProgress_percent();
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::printSpeedPercentage(DGUS_VP &vp) {
const int16_t data = ExtUI::getFeedrate_percent();
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::extruderTargetTemp(DGUS_VP &vp) {
const int16_t data = ExtUI::getTargetTemp_celsius(ExtUI::H0);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::extruderCurrentTemp(DGUS_VP &vp) {
const int16_t data = ExtUI::getActualTemp_celsius(ExtUI::H0);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::bedTargetTemp(DGUS_VP &vp) {
const int16_t data = ExtUI::getTargetTemp_celsius(ExtUI::BED);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::bedCurrentTemp(DGUS_VP &vp) {
const int16_t data = ExtUI::getActualTemp_celsius(ExtUI::BED);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::axis_X(DGUS_VP &vp) {
const int16_t data = dgus.toFixedPoint<float, int16_t, 1>(ExtUI::getAxisPosition_mm(ExtUI::X));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::axis_Y(DGUS_VP &vp) {
const int16_t data = dgus.toFixedPoint<float, int16_t, 1>(ExtUI::getAxisPosition_mm(ExtUI::Y));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::axis_Z(DGUS_VP &vp) {
const int16_t data = dgus.toFixedPoint<float, int16_t, 1>(ExtUI::getAxisPosition_mm(ExtUI::Z));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::stepperStatus(DGUS_VP &vp) {
const bool areSteppersEnabled = stepper.axis_enabled.bits & (_BV(NUM_AXES) - 1);
const uint16_t data = areSteppersEnabled ? 1 : 0;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::enableIfLanguageMatchesExtra(DGUS_VP &vp) {
const DGUS_Data::Language targetLanguage = (DGUS_Data::Language)reinterpret_cast<uintptr_t>(vp.extra);
const uint16_t data = targetLanguage == screen.config.language ? 1 : 0;
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
void DGUSTxHandler::extraToString(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
if (vp.flags & VPFLAG_TXSTRING_AUTOSCROLL) {
const char* stringStart = (const char*)vp.extra;
const size_t stringLength = strlen(stringStart);
screen.addCurrentPageStringLength(stringLength, vp.size);
if (stringLength <= vp.size || screen.getScrollIndex() <= 0) {
// no scroll needed
}
else if ((ssize_t)stringLength - screen.getScrollIndex() <= vp.size) {
stringStart += (stringLength - vp.size);
}
else
stringStart += screen.getScrollIndex();
dgus.writeString((uint16_t)vp.addr,
stringStart,
vp.size, true, false, false);
return;
}
#endif // DGUS_SOFTWARE_AUTOSCROLL
dgus.writeString((uint16_t)vp.addr, vp.extra, vp.size, true, false, false);
}
void DGUSTxHandler::extraPGMToString(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
dgus.writeStringPGM((uint16_t)vp.addr, vp.extra, vp.size, true, false, false);
}
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.cpp
|
C++
|
agpl-3.0
| 7,729
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "DGUSDisplay.h"
#include "definition/DGUS_VP.h"
#define Swap16(val) (uint16_t((uint16_t(val) >> 8) | (uint16_t(val) << 8)))
namespace DGUSTxHandler {
void bootAnimation(DGUS_VP &);
void zOffset(DGUS_VP &);
void elapsedHours(DGUS_VP &);
void elapsedMinutes(DGUS_VP &);
void levelingProgress(DGUS_VP &vp);
void fanSpeed(DGUS_VP &vp);
void levelingProgressIcon(DGUS_VP &vp);
#if HAS_FILAMENT_SENSOR
void filamentInsertionStatus(DGUS_VP &vp);
#endif
void sdCardInsertionStatus(DGUS_VP &vp);
template <typename T, T axis>
void maxFeedrate(DGUS_VP &vp) {
const uint16_t data = (uint16_t)ExtUI::getAxisMaxFeedrate_mm_s(axis);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
template <typename T, T axis>
void maxAcceleration(DGUS_VP &vp) {
const uint16_t data = (uint16_t)ExtUI::getAxisMaxAcceleration_mm_s2(axis);
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
template <typename T, T axis>
void maxJerk(DGUS_VP &vp) {
const uint16_t data = dgus.toFixedPoint<float, uint16_t, 2>(ExtUI::getAxisMaxJerk_mm_s(axis));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
template <typename T, T axis>
void stepsPerMM(DGUS_VP &vp) {
const uint16_t data = dgus.toFixedPoint<float, uint16_t, 1>(ExtUI::getAxisSteps_per_mm(axis));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
#if ENABLED(PIDTEMP)
template<ExtUI::extruder_t extruder>
void PID_P(DGUS_VP &vp) {
const uint16_t data = dgus.toFixedPoint<float, uint16_t, 2>(ExtUI::getPID_Kp(extruder));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
template<ExtUI::extruder_t extruder>
void PID_I(DGUS_VP &vp) {
const uint16_t data = dgus.toFixedPoint<float, uint16_t, 2>(ExtUI::getPID_Ki(extruder));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
template<ExtUI::extruder_t extruder>
void PID_D(DGUS_VP &vp) {
const uint16_t data = dgus.toFixedPoint<float, uint16_t, 2>(ExtUI::getPID_Kd(extruder));
dgus.write((uint16_t)vp.addr, Endianness::toBE(data));
}
#endif // PIDTEMP
#if ENABLED(PIDTEMPBED)
void bed_PID_P(DGUS_VP &vp);
void bed_PID_I(DGUS_VP &vp);
void bed_PID_D(DGUS_VP &vp);
#endif
void printRemainingHours(DGUS_VP &);
void printRemainingMinutes(DGUS_VP &);
void printPercentage(DGUS_VP &);
void printSpeedPercentage(DGUS_VP &);
void extruderTargetTemp(DGUS_VP &);
void extruderCurrentTemp(DGUS_VP &);
void bedTargetTemp(DGUS_VP &);
void bedCurrentTemp(DGUS_VP &);
void axis_X(DGUS_VP &);
void axis_Y(DGUS_VP &);
void axis_Z(DGUS_VP &);
void stepperStatus(DGUS_VP &);
void enableIfLanguageMatchesExtra(DGUS_VP &);
void extraToString(DGUS_VP &);
void extraPGMToString(DGUS_VP &);
template<typename T>
void extraToInteger(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
switch (vp.size) {
default: return;
case 1: {
const uint8_t data = uint8_t(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), data);
break;
}
case 2: {
const uint16_t data = uint16_t(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), Endianness::toBE(data));
break;
}
case 4: {
const uint32_t data = uint32_t(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), Endianness::toBE(data));
break;
}
}
}
template<typename T, uint8_t decimals>
void extraToFixedPoint(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
switch (vp.size) {
default: return;
case 1: {
const uint8_t data = dgus.toFixedPoint<T, uint8_t, decimals>(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), data);
break;
}
case 2: {
const uint16_t data = dgus.toFixedPoint<T, uint16_t, decimals>(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), Endianness::toBE(data));
break;
}
case 4: {
const uint32_t data = dgus.toFixedPoint<T, uint32_t, decimals>(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), Endianness::toBE(data));
break;
}
}
}
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/DGUSTxHandler.h
|
C++
|
agpl-3.0
| 5,006
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#define DGUS_MAIN_STATUS_LEN 20
#define DGUS_FILENAME_LEN 20
#define DGUS_INFOSTRING_LEN 16 // 20 in the firmware, but really only shows 16 characters
enum class DGUS_Addr : uint16_t {
END = 0,
BOOT_Logo = 0x1000,
CMD_MenuSelect = 0x1002, // r, int, DGUS_Data::MenuSelectCommand
CMD_Adjust = 0x1004, // r, int, DGUS_Data::AdjustCommand
MAIN_PrintSpeedPercentage = 0x1006, // rw, int, 3.0
CMD_CheckKO = 0x1008, // r, int, DGUS_Data::CheckKOCommand
CMD_StopPause = 0x100A, // r, int, DGUS_Data::StopPauseCommand
CMD_CheckOK = 0x100C, // r, int, DGUS_Data::CheckOKCommand
MAIN_Icon_Percentage = 0x100E, // w, icon, 0-100
MAIN_ElapsedHours = 0x1010, // w, int, 3.0
MAIN_ElapsedMinutes = 0x1012, // w, int, 2.0
MAIN_PrintPercentage = 0x1016, // w, int, 3.0
MAIN_ZOffset = 0x1026, // w, int, 2.2
CMD_PresetControl = 0x1030, // r, int, DGUS_Data::PresetControlCommand
CMD_TemperatureControl = 0x1032, // r, int, DGUS_Data::TemperatureControlCommand
MAIN_ExtruderTargetTemp = 0x1034, // rw, int, 3.0
MAIN_ExtruderCurrentTemp = 0x1036, // w, int, 3.0
MAIN_BedTargetTemp = 0x103A, // rw, int, 3.0
MAIN_BedCurrentTemp = 0x103C, // w, int, 3.0
CMD_SettingsMenu = 0x103E, // r, int, DGUS_Data::SettingsMenuCommand
CMD_Leveling = 0x1044, // r, int, DGUS_Data::LevelingCommand
CMD_AxisControl = 0x1046, // r, int, DGUS_Data::AxisControlCommand
AXIS_X = 0x1048, // rw, int, 3.1
AXIS_Y = 0x104A, // rw, int, 3.1
AXIS_Z = 0x104C, // rw, int, 3.1
IO_ExtrudeLength = 0x1052, // r, int, 3.1
IO_RetractLength = 0x1054, // r, int, 3.1
CMD_AxisIO = 0x1056, // r, int, DGUS_Data::FilamentIoCommand
LANGUAGE_SetLanguage = 0x105C, // r, int, 1-9
CMD_PowerLoss = 0x105F, // r, int, DGUS_Data::PowerLossCommand
LEVELING_Progress_Icon = 0x108D, // w, icon, progress 1-50
FILAMENT_Icon_Inserted = 0x108E, // w, icon, on-off 0-1
TEMP_PLA_ExtruderTemp = 0x1090, // rw, int, 3.0
TEMP_PLA_BedTemp = 0x1092, // rw, int, 3.0
TEMP_ABS_ExtruderTemp = 0x1094, // rw, int, 3.0
TEMP_ABS_BedTemp = 0x1096, // rw, int, 3.0
CMD_AdvancedSettings = 0x1098, // r, int, DGUS_Data::AdvancedSettingsCommand
LEVELING_Progress = 0x109C, // w, int, 3.0
MOTION_MaxSpeed_X = 0x109E, // rw, int, 4.0
MOTION_MaxSpeed_Y = 0x10A0, // rw, int, 4.0
MOTION_MaxSpeed_Z = 0x10A2, // rw, int, 4.0
MOTION_MaxSpeed_E = 0x10A4, // rw, int, 4.0
MOTION_Acceleration_X = 0x10A6, // rw, int, 4.0
MOTION_Acceleration_Y = 0x10A8, // rw, int, 4.0
MOTION_Acceleration_Z = 0x10AA, // rw, int, 4.0
MOTION_Acceleration_E = 0x10AC, // rw, int, 4.0
MOTION_MaxJerk_X = 0x10AE, // rw, int, 2.2
MOTION_MaxJerk_Y = 0x10B0, // rw, int, 2.2
MOTION_MaxJerk_Z = 0x10B2, // rw, int, 2.2
MOTION_MaxJerk_E = 0x10B4, // rw, int, 2.2
MOTION_StepsPerMm_X = 0x10B6, // rw, int, 4.1
MOTION_StepsPerMm_Y = 0x10B8, // rw, int, 4.1
MOTION_StepsPerMm_Z = 0x10BA, // rw, int, 4.1
MOTION_StepsPerMm_E = 0x10BC, // rw, int, 4.1
PID_Extruder_P = 0x10BE, // rw, int, 3.2
PID_Extruder_I = 0x10C0, // rw, int, 3.2
PID_Extruder_D = 0x10C2, // rw, int, 3.2
PID_Bed_P = 0x10C4, // rw, int, 3.2
PID_Bed_I = 0x10C6, // rw, int, 3.2
PID_Bed_D = 0x10C8, // rw, int, 4.1
CONTROL_FanSpeed = 0x10CA, // rw, int, 3.0
SDCard_InsertionStatus = 0x1168, // w, icon, on off 0-1
FINISH_Icon_Finished = 0x1170, // w, icon, translated 1-9
MAIN_RemainingHours = 0x1171, // w, int, 3.0
MAIN_RemainingMinutes = 0x1173, // w, int, 2.0
AXIS_StepperStatus = 0x1200, // w, icon, on off 0-1
SDCARD_Selection_File1 = 0x1221, // w, icon, on off 0-1
SDCARD_Selection_File2 = 0x1222, // w, icon, on off 0-1
SDCARD_Selection_File3 = 0x1223, // w, icon, on off 0-1
SDCARD_Selection_File4 = 0x1224, // w, icon, on off 0-1
SDCARD_Selection_File5 = 0x1225, // w, icon, on off 0-1
SDCARD_Selection_File6 = 0x1226, // w, icon, on off 0-1
SDCARD_Selection_File7 = 0x1227, // w, icon, on off 0-1
SDCARD_Selection_File8 = 0x1228, // w, icon, on off 0-1
SDCARD_Selection_File9 = 0x1229, // w, icon, on off 0-1
SDCARD_Selection_File10 = 0x122A, // w, icon, on off 0-1
SDCARD_Selection_File11 = 0x122B, // w, icon, on off 0-1
SDCARD_Selection_File12 = 0x122C, // w, icon, on off 0-1
SDCARD_Selection_File13 = 0x122D, // w, icon, on off 0-1
SDCARD_Selection_File14 = 0x122E, // w, icon, on off 0-1
SDCARD_Selection_File15 = 0x122F, // w, icon, on off 0-1
SDCARD_Selection_File16 = 0x1230, // w, icon, on off 0-1
SDCARD_Selection_File17 = 0x1231, // w, icon, on off 0-1
SDCARD_Selection_File18 = 0x1232, // w, icon, on off 0-1
SDCARD_Selection_File19 = 0x1233, // w, icon, on off 0-1
SDCARD_Selection_File20 = 0x1234, // w, icon, on off 0-1
MENU_Icon_Home_S = 0x1300, // w, icon, translated 1-9
MENU_Icon_Print_S = 0x1301, // w, icon, translated 1-9
MENU_Icon_Ready_S = 0x1302, // w, icon, translated 1-9
MENU_Icon_Settings_S = 0x1303, // w, icon, translated 1-9
MENU_Icon_Home = 0x1304, // w, icon, translated 1-9
MENU_Icon_Print = 0x1305, // w, icon, translated 1-9
MENU_Icon_Ready = 0x1306, // w, icon, translated 1-9
MENU_Icon_Settings = 0x1307, // w, icon, translated 1-9
ADJUST_Icon_Adjust = 0x130D, // w, icon, translated 1-9
ADJUST_Icon_Feedrate = 0x130E, // w, icon, translated 1-9
IO_Icon_ExtruderTemp = 0x130F, // w, icon, translated 1-9
CONTROL_Icon_BedTemp = 0x1310, // w, icon, translated 1-9
ADJUST_Icon_ZOffset = 0x1311, // w, icon, translated 1-9
CONTROL_Icon_FanControl = 0x1312, // w, icon, translated 1-9
ADJUST_Icon_FanControl = 0x1313, // w, icon, translated 1-9
AXIS_Icon_MoveAxis = 0x1314, // w, icon, translated 1-9
AXIS_Icon_IO = 0x1318, // w, icon, translated 1-9
AXIS_Icon_Manual = 0x1319, // w, icon, translated 1-9
CONTROL_Icon_Cooling = 0x131A, // w, icon, translated 1-9
IO_Icon_Extrude = 0x1321, // w, icon, translated 1-9
IO_Icon_Retract = 0x1322, // w, icon, translated 1-9
SETTINGS_Icon_Language = 0x1323, // w, icon, translated 1-9
SETTINGS_Icon_Leveling = 0x1325, // w, icon, translated 1-9
SETTINGS_Icon_Device = 0x1326, // w, icon, translated 1-9
ADV_Icon_ResetSettings = 0x1327, // w, icon, translated 1-9
INFO_Icon_About = 0x1328, // w, icon, translated 1-9
INFO_Icon_Device = 0x1329, // w, icon, translated 1-9
SETTINGS_Icon_Advanced = 0x132A, // w, icon, translated 1-9
SETTINGS_Icon_About = 0x132B, // w, icon, translated 1-9
SETTINGS_Icon_PLA = 0x132D, // w, icon, translated 1-9
SETTINGS_Icon_ABS = 0x132E, // w, icon, translated 1-9
RUNOUT_Icon_Stop = 0x133E, // w, icon, translated 1-9
RUNOUT_Icon_Message = 0x133F, // w, icon, translated 1-9
RESET_Icon_Yes = 0x1340, // w, icon, translated 1-9
RESET_Icon_No = 0x1341, // w, icon, translated 1-9
LOAD_Icon_Message = 0x1342, // w, icon, translated 1-9
LOAD_Icon_Continue = 0x1343, // w, icon, translated 1-9
PAUSE_Icon_Message = 0x1344, // w, icon, translated 1-9
RESUME_Icon_Message = 0x1347, // w, icon, translated 1-9
POWERLOSS_Icon_Message = 0x1348, // w, icon, translated 1-9
AUTOHOME_Icon_WaitMessage = 0x1349, // w, icon, translated 1-9
LEVELING_Icon_Leveling = 0x134B, // w, icon, translated 1-9
RESET_Icon_InfoMessage = 0x134D, // w, icon, translated 1-9
LEVELING_Icon_Start = 0x1356, // w, icon, translated 1-9
LEVELING_Icon_AuxLevel = 0x1357, // w, icon, translated 1-9
LEVELING_Icon_AutoLevel = 0x1358, // w, icon, translated 1-9
LEVELING_Icon_AuxLevel_S = 0x1359, // w, icon, translated 1-9
LEVELING_Icon_AutoLevel_S = 0x135A, // w, icon, translated 1-9
LANGUAGE_Icon_Language = 0x135B, // w, icon, translated 1-9
ADV_Icon_Movement = 0x135C, // w, icon, translated 1-9
ADV_Icon_PID = 0x135D, // w, icon, translated 1-9
ADV_Icon_MotionSettings = 0x135F, // w, icon, translated 1-9
ADV_Icon_MaxFeedrate = 0x1360, // w, icon, translated 1-9
ADV_Icon_Acceleration = 0x1361, // w, icon, translated 1-9
ADV_Icon_Jerk = 0x1362, // w, icon, translated 1-9
ADV_Icon_StepsPerMm = 0x1363, // w, icon, translated 1-9
ADV_Icon_MaxSpeed = 0x1364, // w, icon, translated 1-9
ADV_Icon_MaxSpeed_X = 0x1365, // w, icon, translated 1-9
ADV_Icon_MaxSpeed_Y = 0x1366, // w, icon, translated 1-9
ADV_Icon_MaxSpeed_Z = 0x1367, // w, icon, translated 1-9
ADV_Icon_MaxSpeed_E = 0x1368, // w, icon, translated 1-9
ADV_Icon_AccelerationMenu = 0x1369, // w, icon, translated 1-9
ADV_Icon_Acceleration_X = 0x136A, // w, icon, translated 1-9
ADV_Icon_Acceleration_Y = 0x136B, // w, icon, translated 1-9
ADV_Icon_Acceleration_Z = 0x136C, // w, icon, translated 1-9
ADV_Icon_Acceleration_E = 0x136D, // w, icon, translated 1-9
ADV_Icon_MaxJerkMenu = 0x136E, // w, icon, translated 1-9
ADV_Icon_MaxJerk_X = 0x136F, // w, icon, translated 1-9
ADV_Icon_MaxJerk_Y = 0x1370, // w, icon, translated 1-9
ADV_Icon_MaxJerk_Z = 0x1371, // w, icon, translated 1-9
ADV_Icon_MaxJerk_E = 0x1372, // w, icon, translated 1-9
ADV_Icon_StepsPerMmMenu = 0x1373, // w, icon, translated 1-9
ADV_Icon_StepsPerMm_X = 0x1374, // w, icon, translated 1-9
ADV_Icon_StepsPerMm_Y = 0x1375, // w, icon, translated 1-9
ADV_Icon_StepsPerMm_Z = 0x1376, // w, icon, translated 1-9
ADV_Icon_StepsPerMm_E = 0x1377, // w, icon, translated 1-9
PID_Icon_PIDMenu = 0x1378, // w, icon, translated 1-9
PID_Icon_Extruder_P = 0x1379, // w, icon, translated 1-9
PID_Icon_Extruder_I = 0x137A, // w, icon, translated 1-9
PID_Icon_Extruder_D = 0x137B, // w, icon, translated 1-9
PID_Icon_Bed_P = 0x137C, // w, icon, translated 1-9
PID_Icon_Bed_I = 0x137D, // w, icon, translated 1-9
PID_Icon_Bed_D = 0x137E, // w, icon, translated 1-9
CUTTER_Icon_Message = 0x1381, // w, icon, translated 1-9
FDM_Icon_Message = 0x1382, // w, icon, translated 1-9
ADV_Icon_SwitchToLaser = 0x1388, // w, icon, translated 1-9
PRTMODE_Icon_Message = 0x1389, // w, icon, translated 1-9
PRTMODE_Icon_FDM = 0x138D, // w, icon, translated 1-9
PRTMODE_Icon_Cutter = 0x138E, // w, icon, translated 1-9
INFO_Icon_Model = 0x1400, // w, icon, translated 1-9
INFO_Icon_FW_Version = 0x1401, // w, icon, translated 1-9
INFO_Icon_Screen_Version = 0x1402, // w, icon, translated 1-9
INFO_Icon_HW_Version = 0x1403, // w, icon, translated 1-9
INFO_Icon_Website = 0x1405, // w, icon, translated 1-9
INFO_Icon_Print_Size = 0x1406, // w, icon, translated 1-9
LANGUAGE_Icon_Chinese = 0x1411, // w, icon, on off 0-1
LANGUAGE_Icon_English = 0x1412, // w, icon, on off 0-1
LANGUAGE_Icon_German = 0x1413, // w, icon, on off 0-1
LANGUAGE_Icon_Spanish = 0x1414, // w, icon, on off 0-1
LANGUAGE_Icon_French = 0x1415, // w, icon, on off 0-1
LANGUAGE_Icon_Italian = 0x1416, // w, icon, on off 0-1
LANGUAGE_Icon_Portuguese = 0x1417, // w, icon, on off 0-1
LANGUAGE_Icon_Russian = 0x1418, // w, icon, on off 0-1
LANGUAGE_Icon_Turkish = 0x1419, // w, icon, on off 0-1
INFO_Model = 0x17B0, // w, text, 20
INFO_FW_Version = 0x17C4, // w, text, 20
INFO_Screen_Version = 0x17D8, // w, text, 20
INFO_HW_Version = 0x17EC, // w, text, 20
INFO_Print_Size = 0x1800, // w, text, 20
INFO_Website = 0x1814, // w, text, 20
SDCARD_Filename1 = 0x200A, // w, text, 20
SDCARD_Filename2 = 0x201E, // w, text, 20
SDCARD_Filename3 = 0x2032, // w, text, 20
SDCARD_Filename4 = 0x2046, // w, text, 20
SDCARD_Filename5 = 0x205A, // w, text, 20
SDCARD_Filename6 = 0x206E, // w, text, 20
SDCARD_Filename7 = 0x2082, // w, text, 20
SDCARD_Filename8 = 0x2096, // w, text, 20
SDCARD_Filename9 = 0x20AA, // w, text, 20
SDCARD_Filename10 = 0x20BE, // w, text, 20
SDCARD_Filename11 = 0x20D2, // w, text, 20
SDCARD_Filename12 = 0x20E6, // w, text, 20
SDCARD_Filename13 = 0x20FA, // w, text, 20
SDCARD_Filename14 = 0x210E, // w, text, 20
SDCARD_Filename15 = 0x2122, // w, text, 20
SDCARD_Filename16 = 0x2136, // w, text, 20
SDCARD_Filename17 = 0x214A, // w, text, 20
SDCARD_Filename18 = 0x215E, // w, text, 20
SDCARD_Filename19 = 0x2172, // w, text, 20
SDCARD_Filename20 = 0x2186, // w, text, 20
CMD_FilelistControl = 0x2198, // w, int, DGUS_Data::FilelistControlCommand
SDCARD_FileSelection = 0x2199, // r, int 1-20
MAIN_StatusMessage = 0x219A, // w, text, 20
ABNORMAL_StatusMessage = 0x21D4, // w, text, 30
CMD_LaserControl = 0x2201, // w, int, DGUS_Data::LaserControlCommand
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/config/DGUS_Addr.h
|
C
|
agpl-3.0
| 14,612
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#define DGUS_BED_SIZE_STR STRINGIFY(X_BED_SIZE) "x" STRINGIFY(Y_BED_SIZE) "mm"
#if ENABLED(DGUS_SOFTWARE_AUTOSCROLL)
#ifndef DGUS_AUTOSCROLL_START_CYCLES
// Additional refresh cycles where strings beginnings are shown
#define DGUS_AUTOSCROLL_START_CYCLES 1
#endif
#ifndef DGUS_AUTOSCROLL_END_CYCLES
// Additional refresh cycles where strings endings are shown
#define DGUS_AUTOSCROLL_END_CYCLES 1
#endif
#endif
#ifndef DGUS_DEFAULT_VOLUME
#define DGUS_DEFAULT_VOLUME 50
#endif
#ifndef DGUS_DEFAULT_BRIGHTNESS
#define DGUS_DEFAULT_BRIGHTNESS 100
#endif
#ifndef DGUS_STATUS_EXPIRATION_MS
#define DGUS_STATUS_EXPIRATION_MS 30000
#endif
#ifndef BED_TRAMMING_Z_HOP
#define BED_TRAMMING_Z_HOP 4.0
#endif
#ifndef BED_TRAMMING_HEIGHT
#define BED_TRAMMING_HEIGHT 0.0
#endif
static_assert(BED_TRAMMING_Z_HOP >= 0, "BED_TRAMMING_Z_HOP must be >= 0. Please update your configuration.");
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/config/DGUS_Constants.h
|
C
|
agpl-3.0
| 1,792
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include <inttypes.h>
enum class DGUS_Control : uint8_t {
// FILE1
FILE1_File1 = 4, // RETURN_KEY_CODE
FILE1_File2 = 3, // RETURN_KEY_CODE
FILE1_File3 = 2, // RETURN_KEY_CODE
FILE1_File4 = 1, // RETURN_KEY_CODE
FILE1_File5 = 0, // RETURN_KEY_CODE
FILE1_Start = 8, // RETURN_KEY_CODE
FILE1_End = 7, // RETURN_KEY_CODE
FILE1_Prev = 5, // RETURN_KEY_CODE
FILE1_Next = 6, // RETURN_KEY_CODE
FILE1_Home = 9, // RETURN_KEY_CODE
FILE1_Print = 12, // RETURN_KEY_CODE
FILE1_Ready = 10, // RETURN_KEY_CODE
FILE1_Settings = 11, // RETURN_KEY_CODE
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/config/DGUS_Control.h
|
C
|
agpl-3.0
| 1,498
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include <inttypes.h>
namespace DGUS_Data {
// RX constants
enum class Language : uint16_t {
Chinese_Simplified = 1,
English,
German,
Spanish,
French,
Italian,
Portuguese,
Russian,
Turkish,
// Compatibility with LCD_LANGUAGE
zh_CN = Chinese_Simplified,
en = English,
de = German,
es = Spanish,
fr = French,
fr_na = French,
it = Italian,
pt = Portuguese,
ru = Russian,
tr = Turkish,
Default = LCD_LANGUAGE
};
// 1002
enum class MenuSelectCommand : uint16_t {
Print = 1,
Ready = 2,
Settings = 3,
PrintFinished = 5,
StartAutoLevel = 6,
Main = 8,
PausePrint = 9,
PauseStopPrint = 10
};
// 1004
enum class AdjustCommand : uint16_t {
Show_Adjust = 1,
Show_PrintStatus = 2,
Show_Adjust_ZOffset = 5,
Validate_ZOffset = 7,
};
// 1008
enum class CheckKOCommand : uint16_t {
KO = 2,
SDCard_No = 4, // screen fw 1.0.3
};
// 100A
enum class StopPauseCommand : uint16_t {
Pause_Laser = 1,
Pause = 2,
Stop_Confirm = 3
};
// 100C
enum class CheckOKCommand : uint16_t {
ContinueStop_Continue = 1,
FilamentRunout_Yes = 2,
FilamentLoad_Yes = 3,
SDCardCheck_Yes = 4,
};
// 1030
enum class PresetControlCommand : uint16_t {
Show_Settings_PLA_Settings = 3,
Show_Settings_ABS_Settings = 4,
Apply_PLA_Settings = 5,
Apply_ABS_Settings = 6,
Show_Ready_Manual = 8,
};
// 1032
enum class TemperatureControlCommand : uint16_t {
Cooldown = 1,
Exit_Temperature_Preset_And_Discard_Temperature = 2
};
// 103E
enum class SettingsMenuCommand : uint16_t {
Show_Settings_Device_Language = 1,
Show_Settings_Advanced = 2,
Show_Ready_Jog = 3,
Show_Settings_About = 5,
DisableStepperMotors = 6,
Reset_All_Settings = 7,
Show_Settings_Device_and_Save_Temperatures = 8,
FactoryReset_Validate = 11,
FactoryReset_Cancel = 14,
Exit_Settings_Tramming = 15,
Exit_Settings_Leveling = 16,
Show_Settings_Device_and_Discard_Temperatures = 17
};
// 1044
enum class LevelingCommand : uint16_t {
Show_Settings_Leveling = 1,
Show_AuxLeveling = 4,
Goto_Center = 5,
Goto_LF = 6,
Goto_RF = 7,
Goto_RB = 8,
Goto_LB = 9,
Show_AutoLeveling = 10,
};
// 1046
enum class AxisControlCommand : uint16_t {
Jog_10mm = 1,
Jog_1mm = 2,
Jog_0_1mm = 3,
Home_XY = 4,
Home_Z = 5,
};
// 1056
enum class FilamentIoCommand : uint16_t {
FilamentCheck_Yes = 1,
FilamentCheck_No = 2,
Show_Ready_IO = 3
};
// 105F
enum class PowerLossCommand : uint16_t {
PowerLoss_Continue = 1,
PowerLoss_No = 2
};
// 1098
enum class AdvancedSettingsCommand : uint16_t {
Show_AdvSettings_Movement = 4,
Show_AdvSettings_PID = 5,
Show_AdvSettings_Movement_StepsPerMm = 7,
Show_AdvSettings_Movement_Acceleration = 8,
Show_AdvSettings_Movement_Jerk = 9,
Show_AdvSettings_Movement_MaxFeedrate = 10,
Exit_AdvSettings_Movement_Submenu = 12,
Show_AdvSettings = 13,
};
// 2198
enum class FilelistControlCommand : uint16_t {
Start_Print = 1,
F1_Down = 2,
F1_Up = 3,
F2_Down = 4,
F2_Up = F1_Up,
F3_Down = 6,
F3_Up = 5,
F4_Down = 8,
F4_Up = 7,
Begin = 9,
End = 10
};
// 2198
enum class LaserControlCommand : uint16_t {
Mode_FDM = 1,
Mode_Cutter = 2,
Mode_FDM_Confirm = 3,
Mode_FDM_Cancel = 4,
Mode_Cutter_Confirm = 5,
Mode_Cutter_Cancel = 6,
Mode_Change = 0xB
};
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/config/DGUS_Data.h
|
C++
|
agpl-3.0
| 4,471
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
enum class DGUS_ScreenID : uint8_t {
START = 0,
MAIN,
FILE1,
FILE2,
FILE3,
FILE4,
FILE5,
FILAMENTUSEUP,
FILAMENTLOAD,
FINISH,
PAUSE,
PAUSE_STOP,
RESUME,
CONTINUE_STOP,
ADJUST,
PREPARE,
MOVEAXIS_10,
MOVEAXIS_1,
MOVEAXIS_01,
FEEDRETURN,
CONTROL,
TEMP,
PLA_TEMP,
ABS_TEMP,
INFORMATION,
LEVELINGMODE,
LEVELING,
POWERCONTINUE,
LANGUAGE,
KEYBOARD,
KEYBOARD_CONFIRM,
THERMAL_RUNAWAY,
LEVEL_OFFSET,
CONTROL_DEVICE,
MOTION,
MAX_FEEDRATE,
ACCELERATION,
JERK,
STEPSMM,
PIDCONTROL,
AUTOHOME,
ABNORMAL,
WIFI_CONFIRM,
FACTORYRESET_CONFIRM,
SHUTDOWN,
SMOKE_ALARM,
FILAMENTCHECK,
SDCARDCHECK,
LASER_FDM,
MAIN_LASER,
_52_FILE1,
_53_FILE2,
_54_FILE3,
_55_FILE4,
SW_LASER_TIPS,
SW_FDM_TIPS,
STOP_CONFIRM,
PAUSE_LASER,
FINISH_LASER,
RESUME_LASER,
PAUSE_CONFIRM,
FOCUS,
DEVICE_LASER,
LANGE,
LASER_INFORMATION,
ACCEL_LASER,
JERK_SPEED_LASER,
MAX_SPEED_LASER,
AXIS_MOVE_10,
AXIS_MOVE_1,
AXIS_MOVE_01,
ADJUST_LASER,
ENGRAVE_TIPS,
RATIO,
SW_FOCUS,
AXIS_ADJUST_10,
AXIS_ADJUST_1,
AXIS_ADJUST_01,
BOOT = START,
HOME = MAIN
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/config/DGUS_Screen.h
|
C
|
agpl-3.0
| 2,080
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUS_ScreenAddrList.h"
#include "../../ui_api.h"
constexpr DGUS_Addr LIST_BOOT[] PROGMEM = {
DGUS_Addr::BOOT_Logo,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_HOME[] PROGMEM = {
DGUS_Addr::MAIN_PrintSpeedPercentage,
DGUS_Addr::MAIN_Icon_Percentage,
DGUS_Addr::MAIN_ElapsedHours,
DGUS_Addr::MAIN_ElapsedMinutes,
DGUS_Addr::MAIN_PrintPercentage,
DGUS_Addr::MAIN_ZOffset,
DGUS_Addr::MAIN_ExtruderTargetTemp,
DGUS_Addr::MAIN_ExtruderCurrentTemp,
DGUS_Addr::MAIN_BedTargetTemp,
DGUS_Addr::MAIN_BedCurrentTemp,
DGUS_Addr::MAIN_RemainingHours,
DGUS_Addr::MAIN_RemainingMinutes,
DGUS_Addr::MAIN_StatusMessage,
DGUS_Addr::MENU_Icon_Home_S,
DGUS_Addr::MENU_Icon_Print,
DGUS_Addr::MENU_Icon_Ready,
DGUS_Addr::MENU_Icon_Settings,
DGUS_Addr::FINISH_Icon_Finished,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PRINTING[] PROGMEM = {
DGUS_Addr::MAIN_PrintSpeedPercentage,
DGUS_Addr::MAIN_Icon_Percentage,
DGUS_Addr::MAIN_ElapsedHours,
DGUS_Addr::MAIN_ElapsedMinutes,
DGUS_Addr::MAIN_PrintPercentage,
DGUS_Addr::MAIN_ZOffset,
DGUS_Addr::MAIN_ExtruderTargetTemp,
DGUS_Addr::MAIN_ExtruderCurrentTemp,
DGUS_Addr::MAIN_BedTargetTemp,
DGUS_Addr::MAIN_BedCurrentTemp,
DGUS_Addr::MAIN_RemainingHours,
DGUS_Addr::MAIN_RemainingMinutes,
DGUS_Addr::MAIN_StatusMessage,
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready,
DGUS_Addr::MENU_Icon_Settings,
DGUS_Addr::FINISH_Icon_Finished,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_RUNOUT[] PROGMEM = {
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RUNOUT_Icon_Stop,
DGUS_Addr::RUNOUT_Icon_Message,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_FILAMENTLOAD[] PROGMEM = {
DGUS_Addr::LOAD_Icon_Continue,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::LOAD_Icon_Message,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PAUSE_STOP[] PROGMEM = {
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::PAUSE_Icon_Message,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_CONTINUE_STOP[] PROGMEM = {
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::RESUME_Icon_Message,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_MOVEAXIS[] PROGMEM = {
DGUS_Addr::AXIS_StepperStatus,
DGUS_Addr::AXIS_X,
DGUS_Addr::AXIS_Y,
DGUS_Addr::AXIS_Z,
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready_S,
DGUS_Addr::MENU_Icon_Settings,
DGUS_Addr::AXIS_Icon_MoveAxis,
DGUS_Addr::AXIS_Icon_IO,
DGUS_Addr::AXIS_Icon_Manual,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_IO[] PROGMEM = {
DGUS_Addr::AXIS_Icon_MoveAxis,
DGUS_Addr::AXIS_Icon_IO,
DGUS_Addr::AXIS_Icon_Manual,
DGUS_Addr::MAIN_ExtruderTargetTemp,
DGUS_Addr::MAIN_ExtruderCurrentTemp,
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready_S,
DGUS_Addr::MENU_Icon_Settings,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_CONTROL[] PROGMEM = {
DGUS_Addr::AXIS_Icon_MoveAxis,
DGUS_Addr::AXIS_Icon_IO,
DGUS_Addr::AXIS_Icon_Manual,
DGUS_Addr::MAIN_ExtruderTargetTemp,
DGUS_Addr::MAIN_BedTargetTemp,
DGUS_Addr::IO_Icon_ExtruderTemp,
DGUS_Addr::CONTROL_Icon_BedTemp,
DGUS_Addr::AXIS_Icon_IO, // bogus, it's for "PLA temp" icon
DGUS_Addr::AXIS_Icon_Manual, // bogus, it's for "ABS temp" icon
DGUS_Addr::CONTROL_FanSpeed,
DGUS_Addr::ADJUST_Icon_FanControl,
DGUS_Addr::CONTROL_Icon_Cooling,
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready_S,
DGUS_Addr::MENU_Icon_Settings,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_ADJUST[] PROGMEM = {
DGUS_Addr::ADJUST_Icon_Adjust,
DGUS_Addr::IO_Icon_ExtruderTemp,
DGUS_Addr::CONTROL_Icon_BedTemp,
DGUS_Addr::ADJUST_Icon_Feedrate,
DGUS_Addr::ADJUST_Icon_FanControl,
DGUS_Addr::ADJUST_Icon_ZOffset,
DGUS_Addr::MAIN_ExtruderTargetTemp,
DGUS_Addr::MAIN_BedTargetTemp,
DGUS_Addr::MAIN_PrintSpeedPercentage,
DGUS_Addr::CONTROL_FanSpeed,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_ADJUST_ZOFFSET[] PROGMEM = {
DGUS_Addr::MAIN_ZOffset,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_AUTOHOME[] PROGMEM = {
DGUS_Addr::AUTOHOME_Icon_WaitMessage,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_ABNORMAL[] PROGMEM = {
DGUS_Addr::ABNORMAL_StatusMessage,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_SETTINGS[] PROGMEM = {
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready_S,
DGUS_Addr::MENU_Icon_Settings_S,
DGUS_Addr::SETTINGS_Icon_Language,
DGUS_Addr::SETTINGS_Icon_Leveling,
DGUS_Addr::SETTINGS_Icon_Device,
DGUS_Addr::SETTINGS_Icon_Advanced,
DGUS_Addr::SETTINGS_Icon_About,
DGUS_Addr::SETTINGS_Icon_PLA,
DGUS_Addr::SETTINGS_Icon_ABS,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_TEMPERATURE_PRESETS[] PROGMEM = {
DGUS_Addr::SETTINGS_Icon_PLA,
DGUS_Addr::SETTINGS_Icon_ABS,
DGUS_Addr::IO_Icon_ExtruderTemp,
DGUS_Addr::CONTROL_Icon_BedTemp,
DGUS_Addr::TEMP_PLA_ExtruderTemp,
DGUS_Addr::TEMP_PLA_BedTemp,
DGUS_Addr::TEMP_ABS_ExtruderTemp,
DGUS_Addr::TEMP_ABS_BedTemp,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_TRAMMING[] PROGMEM = {
DGUS_Addr::LEVELING_Icon_Leveling,
DGUS_Addr::LEVELING_Icon_AutoLevel,
DGUS_Addr::LEVELING_Icon_AuxLevel_S,
DGUS_Addr::MAIN_ZOffset,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_AUTOLEVEL[] PROGMEM = {
DGUS_Addr::LEVELING_Icon_Start,
DGUS_Addr::LEVELING_Icon_Leveling,
DGUS_Addr::LEVELING_Icon_AutoLevel_S,
DGUS_Addr::LEVELING_Icon_AuxLevel,
DGUS_Addr::LEVELING_Progress_Icon,
DGUS_Addr::LEVELING_Progress,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_POWERLOSS[] PROGMEM = {
DGUS_Addr::POWERLOSS_Icon_Message,
DGUS_Addr::LOAD_Icon_Continue,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_LANGUAGE[] PROGMEM = {
DGUS_Addr::LANGUAGE_Icon_Language,
DGUS_Addr::LANGUAGE_Icon_Chinese,
DGUS_Addr::LANGUAGE_Icon_English,
DGUS_Addr::LANGUAGE_Icon_German,
DGUS_Addr::LANGUAGE_Icon_Spanish,
DGUS_Addr::LANGUAGE_Icon_French,
DGUS_Addr::LANGUAGE_Icon_Italian,
DGUS_Addr::LANGUAGE_Icon_Portuguese,
DGUS_Addr::LANGUAGE_Icon_Russian,
DGUS_Addr::LANGUAGE_Icon_Turkish,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_INFO[] PROGMEM = {
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready_S,
DGUS_Addr::MENU_Icon_Settings_S,
DGUS_Addr::INFO_Icon_Device,
DGUS_Addr::SETTINGS_Icon_Advanced,
DGUS_Addr::INFO_Icon_About,
DGUS_Addr::INFO_Icon_Model,
DGUS_Addr::INFO_Icon_FW_Version,
DGUS_Addr::INFO_Icon_Screen_Version,
DGUS_Addr::INFO_Icon_HW_Version,
DGUS_Addr::INFO_Icon_Print_Size,
DGUS_Addr::INFO_Icon_Website,
DGUS_Addr::INFO_Model,
DGUS_Addr::INFO_FW_Version,
DGUS_Addr::INFO_Screen_Version,
DGUS_Addr::INFO_HW_Version,
DGUS_Addr::INFO_Print_Size,
DGUS_Addr::INFO_Website,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_ADV_SETTINGS[] PROGMEM = {
DGUS_Addr::MENU_Icon_Home,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready_S,
DGUS_Addr::MENU_Icon_Settings_S,
DGUS_Addr::SETTINGS_Icon_Device,
DGUS_Addr::SETTINGS_Icon_Advanced,
DGUS_Addr::INFO_Icon_About,
DGUS_Addr::ADV_Icon_Movement,
DGUS_Addr::ADV_Icon_ResetSettings,
DGUS_Addr::ADV_Icon_PID,
DGUS_Addr::ADV_Icon_SwitchToLaser,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_MOTION[] PROGMEM = {
DGUS_Addr::ADV_Icon_MotionSettings,
DGUS_Addr::ADV_Icon_MaxFeedrate,
DGUS_Addr::ADV_Icon_Acceleration,
DGUS_Addr::ADV_Icon_Jerk,
DGUS_Addr::ADV_Icon_StepsPerMm,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_MAX_FEEDRATE[] PROGMEM = {
DGUS_Addr::ADV_Icon_MaxSpeed,
DGUS_Addr::ADV_Icon_MaxSpeed_X,
DGUS_Addr::ADV_Icon_MaxSpeed_Y,
DGUS_Addr::ADV_Icon_MaxSpeed_Z,
DGUS_Addr::ADV_Icon_MaxSpeed_E,
DGUS_Addr::MOTION_MaxSpeed_X,
DGUS_Addr::MOTION_MaxSpeed_Y,
DGUS_Addr::MOTION_MaxSpeed_Z,
DGUS_Addr::MOTION_MaxSpeed_E,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_ACCELERATION[] PROGMEM = {
DGUS_Addr::ADV_Icon_AccelerationMenu,
DGUS_Addr::ADV_Icon_Acceleration_X,
DGUS_Addr::ADV_Icon_Acceleration_Y,
DGUS_Addr::ADV_Icon_Acceleration_Z,
DGUS_Addr::ADV_Icon_Acceleration_E,
DGUS_Addr::MOTION_Acceleration_X,
DGUS_Addr::MOTION_Acceleration_Y,
DGUS_Addr::MOTION_Acceleration_Z,
DGUS_Addr::MOTION_Acceleration_E,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_JERK[] PROGMEM = {
DGUS_Addr::ADV_Icon_MaxJerkMenu,
DGUS_Addr::ADV_Icon_MaxJerk_X,
DGUS_Addr::ADV_Icon_MaxJerk_Y,
DGUS_Addr::ADV_Icon_MaxJerk_Z,
DGUS_Addr::ADV_Icon_MaxJerk_E,
DGUS_Addr::MOTION_MaxJerk_X,
DGUS_Addr::MOTION_MaxJerk_Y,
DGUS_Addr::MOTION_MaxJerk_Z,
DGUS_Addr::MOTION_MaxJerk_E,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_STEPSMM[] PROGMEM = {
DGUS_Addr::ADV_Icon_StepsPerMmMenu,
DGUS_Addr::ADV_Icon_StepsPerMm_X,
DGUS_Addr::ADV_Icon_StepsPerMm_Y,
DGUS_Addr::ADV_Icon_StepsPerMm_Z,
DGUS_Addr::ADV_Icon_StepsPerMm_E,
DGUS_Addr::MOTION_StepsPerMm_X,
DGUS_Addr::MOTION_StepsPerMm_Y,
DGUS_Addr::MOTION_StepsPerMm_Z,
DGUS_Addr::MOTION_StepsPerMm_E,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PIDCONTROL[] PROGMEM = {
DGUS_Addr::PID_Icon_PIDMenu,
DGUS_Addr::PID_Icon_Extruder_P,
DGUS_Addr::PID_Icon_Extruder_I,
DGUS_Addr::PID_Icon_Extruder_D,
DGUS_Addr::PID_Icon_Bed_P,
DGUS_Addr::PID_Icon_Bed_I,
DGUS_Addr::PID_Icon_Bed_D,
DGUS_Addr::PID_Extruder_P,
DGUS_Addr::PID_Extruder_I,
DGUS_Addr::PID_Extruder_D,
DGUS_Addr::PID_Bed_P,
DGUS_Addr::PID_Bed_I,
DGUS_Addr::PID_Bed_D,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_RESET_CONFIRM[] PROGMEM = {
DGUS_Addr::RESET_Icon_InfoMessage,
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_FILAMENTCHECK[] PROGMEM = {
DGUS_Addr::FILAMENT_Icon_Inserted,
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_SDCARDCHECK[] PROGMEM = {
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::SDCard_InsertionStatus,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PRINTMODE[] PROGMEM = {
DGUS_Addr::PRTMODE_Icon_Message,
DGUS_Addr::PRTMODE_Icon_FDM,
DGUS_Addr::PRTMODE_Icon_Cutter,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PRINTMODE_CONFIRM[] PROGMEM = {
DGUS_Addr::CUTTER_Icon_Message,
DGUS_Addr::FDM_Icon_Message,
DGUS_Addr::RESET_Icon_Yes,
DGUS_Addr::RESET_Icon_No,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_SDCARD[] PROGMEM = {
DGUS_Addr::MENU_Icon_Home_S,
DGUS_Addr::MENU_Icon_Print_S,
DGUS_Addr::MENU_Icon_Ready,
DGUS_Addr::MENU_Icon_Settings,
DGUS_Addr::SDCARD_Filename1,
DGUS_Addr::SDCARD_Filename2,
DGUS_Addr::SDCARD_Filename3,
DGUS_Addr::SDCARD_Filename4,
DGUS_Addr::SDCARD_Filename5,
DGUS_Addr::SDCARD_Filename6,
DGUS_Addr::SDCARD_Filename7,
DGUS_Addr::SDCARD_Filename8,
DGUS_Addr::SDCARD_Filename9,
DGUS_Addr::SDCARD_Filename10,
DGUS_Addr::SDCARD_Filename11,
DGUS_Addr::SDCARD_Filename12,
DGUS_Addr::SDCARD_Filename13,
DGUS_Addr::SDCARD_Filename14,
DGUS_Addr::SDCARD_Filename15,
DGUS_Addr::SDCARD_Filename16,
DGUS_Addr::SDCARD_Filename17,
DGUS_Addr::SDCARD_Filename18,
DGUS_Addr::SDCARD_Filename19,
DGUS_Addr::SDCARD_Filename20,
DGUS_Addr::SDCARD_Selection_File1,
DGUS_Addr::SDCARD_Selection_File2,
DGUS_Addr::SDCARD_Selection_File3,
DGUS_Addr::SDCARD_Selection_File4,
DGUS_Addr::SDCARD_Selection_File5,
DGUS_Addr::SDCARD_Selection_File6,
DGUS_Addr::SDCARD_Selection_File7,
DGUS_Addr::SDCARD_Selection_File8,
DGUS_Addr::SDCARD_Selection_File9,
DGUS_Addr::SDCARD_Selection_File10,
DGUS_Addr::SDCARD_Selection_File11,
DGUS_Addr::SDCARD_Selection_File12,
DGUS_Addr::SDCARD_Selection_File13,
DGUS_Addr::SDCARD_Selection_File14,
DGUS_Addr::SDCARD_Selection_File15,
DGUS_Addr::SDCARD_Selection_File16,
DGUS_Addr::SDCARD_Selection_File17,
DGUS_Addr::SDCARD_Selection_File18,
DGUS_Addr::SDCARD_Selection_File19,
DGUS_Addr::SDCARD_Selection_File20,
DGUS_Addr::END
};
#define MAP_HELPER(SCREEN, LIST) \
{ .screen = SCREEN, \
.addr_list = LIST }
const struct DGUS_ScreenAddrList screen_addr_list_map[] PROGMEM = {
MAP_HELPER(DGUS_ScreenID::BOOT, LIST_BOOT),
MAP_HELPER(DGUS_ScreenID::HOME, LIST_HOME),
MAP_HELPER(DGUS_ScreenID::FILE1, LIST_SDCARD),
MAP_HELPER(DGUS_ScreenID::FILE2, LIST_SDCARD),
MAP_HELPER(DGUS_ScreenID::FILE3, LIST_SDCARD),
MAP_HELPER(DGUS_ScreenID::FILE4, LIST_SDCARD),
MAP_HELPER(DGUS_ScreenID::FILAMENTUSEUP, LIST_RUNOUT),
MAP_HELPER(DGUS_ScreenID::FILAMENTLOAD, LIST_FILAMENTLOAD),
MAP_HELPER(DGUS_ScreenID::FINISH, LIST_PRINTING),
MAP_HELPER(DGUS_ScreenID::PAUSE, LIST_PRINTING),
MAP_HELPER(DGUS_ScreenID::PAUSE_STOP, LIST_PAUSE_STOP),
MAP_HELPER(DGUS_ScreenID::RESUME, LIST_PRINTING),
MAP_HELPER(DGUS_ScreenID::CONTINUE_STOP, LIST_CONTINUE_STOP),
MAP_HELPER(DGUS_ScreenID::ADJUST, LIST_ADJUST),
MAP_HELPER(DGUS_ScreenID::PREPARE, LIST_ADJUST_ZOFFSET),
MAP_HELPER(DGUS_ScreenID::MOVEAXIS_01, LIST_MOVEAXIS),
MAP_HELPER(DGUS_ScreenID::MOVEAXIS_1, LIST_MOVEAXIS),
MAP_HELPER(DGUS_ScreenID::MOVEAXIS_10, LIST_MOVEAXIS),
MAP_HELPER(DGUS_ScreenID::FEEDRETURN, LIST_IO),
MAP_HELPER(DGUS_ScreenID::CONTROL, LIST_CONTROL),
MAP_HELPER(DGUS_ScreenID::TEMP, LIST_SETTINGS),
MAP_HELPER(DGUS_ScreenID::PLA_TEMP, LIST_TEMPERATURE_PRESETS),
MAP_HELPER(DGUS_ScreenID::ABS_TEMP, LIST_TEMPERATURE_PRESETS),
MAP_HELPER(DGUS_ScreenID::AUTOHOME, LIST_AUTOHOME),
MAP_HELPER(DGUS_ScreenID::ABNORMAL, LIST_ABNORMAL),
MAP_HELPER(DGUS_ScreenID::LEVELINGMODE, LIST_TRAMMING),
MAP_HELPER(DGUS_ScreenID::LEVELING, LIST_AUTOLEVEL),
MAP_HELPER(DGUS_ScreenID::POWERCONTINUE, LIST_POWERLOSS),
MAP_HELPER(DGUS_ScreenID::LANGUAGE, LIST_LANGUAGE),
MAP_HELPER(DGUS_ScreenID::INFORMATION, LIST_INFO),
MAP_HELPER(DGUS_ScreenID::CONTROL_DEVICE, LIST_ADV_SETTINGS),
MAP_HELPER(DGUS_ScreenID::MOTION, LIST_MOTION),
MAP_HELPER(DGUS_ScreenID::MAX_FEEDRATE, LIST_MAX_FEEDRATE),
MAP_HELPER(DGUS_ScreenID::ACCELERATION, LIST_ACCELERATION),
MAP_HELPER(DGUS_ScreenID::JERK, LIST_JERK),
MAP_HELPER(DGUS_ScreenID::STEPSMM, LIST_STEPSMM),
MAP_HELPER(DGUS_ScreenID::PIDCONTROL, LIST_PIDCONTROL),
MAP_HELPER(DGUS_ScreenID::FACTORYRESET_CONFIRM, LIST_RESET_CONFIRM),
MAP_HELPER(DGUS_ScreenID::FILAMENTCHECK, LIST_FILAMENTCHECK),
MAP_HELPER(DGUS_ScreenID::SDCARDCHECK, LIST_SDCARDCHECK),
MAP_HELPER(DGUS_ScreenID::LASER_FDM, LIST_PRINTMODE),
MAP_HELPER(DGUS_ScreenID::SW_LASER_TIPS, LIST_PRINTMODE_CONFIRM),
MAP_HELPER(DGUS_ScreenID::SW_FDM_TIPS, LIST_PRINTMODE_CONFIRM),
MAP_HELPER((DGUS_ScreenID)0, nullptr)
};
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_ScreenAddrList.cpp
|
C++
|
agpl-3.0
| 15,991
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../config/DGUS_Screen.h"
#include "../config/DGUS_Addr.h"
struct DGUS_ScreenAddrList {
DGUS_ScreenID screen;
const DGUS_Addr *addr_list;
};
extern const struct DGUS_ScreenAddrList screen_addr_list_map[];
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_ScreenAddrList.h
|
C
|
agpl-3.0
| 1,102
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUS_ScreenSetup.h"
#include "../DGUSSetupHandler.h"
#include "../../ui_api.h"
#define SETUP_HELPER(SCREEN, SETUP) \
{ .screen = SCREEN, \
.setup_fn = SETUP }
const struct DGUS_ScreenSetup screen_setup_list[] PROGMEM = {
SETUP_HELPER(DGUS_ScreenID::FILE1, &DGUSSetupHandler::sdCardPrepare),
SETUP_HELPER(DGUS_ScreenID::FILE2, &DGUSSetupHandler::sdCardPrepare),
SETUP_HELPER(DGUS_ScreenID::FILE3, &DGUSSetupHandler::sdCardPrepare),
SETUP_HELPER(DGUS_ScreenID::FILE4, &DGUSSetupHandler::sdCardPrepare),
SETUP_HELPER((DGUS_ScreenID)0, nullptr)
};
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_ScreenSetup.cpp
|
C++
|
agpl-3.0
| 1,545
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../config/DGUS_Screen.h"
struct DGUS_ScreenSetup {
DGUS_ScreenID screen;
bool (*setup_fn)(void);
};
extern const struct DGUS_ScreenSetup screen_setup_list[];
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_ScreenSetup.h
|
C
|
agpl-3.0
| 1,050
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../config/DGUS_Addr.h"
#define VPFLAG_NONE 0
#define VPFLAG_AUTOUPLOAD (1U << 0) // Upload on every DGUS update
#define VPFLAG_RXSTRING (1U << 1) // Treat the received data as a string (terminated with 0xFFFF)
#define VPFLAG_TXSTRING_AUTOSCROLL (1U << 2)
#define VP_U16_FROM_EXTRA(N) (*(uint16_t*)N)
struct DGUS_VP {
DGUS_Addr addr;
uint8_t size;
uint8_t flags;
void *extra;
// Callback that will be called if the display modified the value.
// nullptr makes it readonly for the display.
void (*rx_handler)(DGUS_VP &, void *);
void (*tx_handler)(DGUS_VP &);
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VP.h
|
C
|
agpl-3.0
| 1,515
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "DGUS_VPList.h"
#include "../config/DGUS_Addr.h"
#include "../DGUSScreenHandler.h"
#include "../DGUSReturnKeyCodeHandler.h"
#include "../DGUSRxHandler.h"
#include "../DGUSTxHandler.h"
#include "../../ui_api.h"
const char DGUS_MACHINENAME[] PROGMEM = MACHINE_NAME;
const char DGUS_MARLINVERSION[] PROGMEM = SHORT_BUILD_VERSION;
const char DGUS_BOARD[] PROGMEM = BOARD_INFO_NAME;
const char DGUS_BEDSIZE[] PROGMEM = DGUS_BED_SIZE_STR;
const char DGUS_WEBSITE[] PROGMEM = "http://marlinfw.org";
const uint16_t DGUS_ZERO = 0;
#define VP_HELPER(ADDR, SIZE, FLAGS, EXTRA, RXHANDLER, TXHANDLER) \
{ .addr = ADDR, \
.size = SIZE, \
.flags = FLAGS, \
.extra = EXTRA, \
.rx_handler = RXHANDLER, \
.tx_handler = TXHANDLER }
#define VP_HELPER_WORD(ADDR, FLAGS, EXTRA, RXHANDLER, TXHANDLER) \
VP_HELPER(ADDR, 2, FLAGS, EXTRA, RXHANDLER, TXHANDLER)
#define VP_HELPER_DWORD(ADDR, FLAGS, EXTRA, RXHANDLER, TXHANDLER) \
VP_HELPER(ADDR, 4, FLAGS, EXTRA, RXHANDLER, TXHANDLER)
#define VP_HELPER_RX(ADDR, RXHANDLER) \
VP_HELPER_WORD(ADDR, VPFLAG_NONE, nullptr, RXHANDLER, nullptr)
#define VP_HELPER_RX_EXTRA(ADDR, EXTRA, RXHANDLER) \
VP_HELPER_WORD(ADDR, VPFLAG_NONE, EXTRA, RXHANDLER, nullptr)
#define VP_HELPER_RX_NODATA(ADDR, RXHANDLER) \
VP_HELPER(ADDR, 0, VPFLAG_NONE, nullptr, RXHANDLER, nullptr)
#define VP_HELPER_TX(ADDR, TXHANDLER) \
VP_HELPER_WORD(ADDR, VPFLAG_NONE, nullptr, nullptr, TXHANDLER)
#define VP_HELPER_TX_SIZE(ADDR, SIZE, TXHANDLER) \
VP_HELPER(ADDR, SIZE, VPFLAG_NONE, nullptr, nullptr, TXHANDLER)
#define VP_HELPER_TX_EXTRA(ADDR, EXTRA, TXHANDLER) \
VP_HELPER_WORD(ADDR, VPFLAG_NONE, EXTRA, nullptr, TXHANDLER)
#define VP_HELPER_TX_AUTO(ADDR, EXTRA, TXHANDLER) \
VP_HELPER_WORD(ADDR, VPFLAG_AUTOUPLOAD, EXTRA, nullptr, TXHANDLER)
#define VP_HELPER_LANG_ICON(ADDR) \
VP_HELPER_TX_EXTRA(ADDR, &screen.config.language, (&DGUSTxHandler::extraToInteger<uint16_t>))
#define VP_HELPER_FILENAME(ADDR, filenameIndex) \
VP_HELPER(ADDR, DGUS_FILENAME_LEN, VPFLAG_TXSTRING_AUTOSCROLL, \
VP_EXTRA_TO_STR(DGUS_SDCardHandler::filenames[filenameIndex]), \
nullptr, DGUSTxHandler::extraToString)
const struct DGUS_VP vp_list[] PROGMEM = {
VP_HELPER_TX_AUTO( DGUS_Addr::BOOT_Logo,
nullptr,
&DGUSTxHandler::bootAnimation),
VP_HELPER_RX( DGUS_Addr::CMD_MenuSelect,
&DGUSReturnKeyCodeHandler::Command_MenuSelect),
VP_HELPER_RX( DGUS_Addr::CMD_Adjust,
&DGUSReturnKeyCodeHandler::Command_Adjust),
VP_HELPER_WORD( DGUS_Addr::MAIN_PrintSpeedPercentage,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::printSpeedPercentage,
&DGUSTxHandler::printSpeedPercentage),
VP_HELPER_RX( DGUS_Addr::CMD_CheckKO,
&DGUSReturnKeyCodeHandler::Command_CheckKO),
VP_HELPER_RX( DGUS_Addr::CMD_StopPause,
&DGUSReturnKeyCodeHandler::Command_StopPause),
VP_HELPER_RX( DGUS_Addr::CMD_CheckOK,
&DGUSReturnKeyCodeHandler::Command_CheckOK),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_Icon_Percentage, nullptr,
&DGUSTxHandler::printPercentage),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_ElapsedHours,
nullptr,
&DGUSTxHandler::elapsedHours),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_ElapsedMinutes,
nullptr,
&DGUSTxHandler::elapsedMinutes),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_PrintPercentage,
nullptr,
&DGUSTxHandler::printPercentage),
VP_HELPER_WORD( DGUS_Addr::MAIN_ZOffset,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::zOffset,
&DGUSTxHandler::zOffset),
VP_HELPER_RX( DGUS_Addr::CMD_PresetControl,
&DGUSReturnKeyCodeHandler::Command_PresetControl),
VP_HELPER_RX( DGUS_Addr::CMD_TemperatureControl,
&DGUSReturnKeyCodeHandler::Control_TemperatureCommand),
VP_HELPER_WORD( DGUS_Addr::MAIN_ExtruderTargetTemp,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::extruderTargetTemp,
&DGUSTxHandler::extruderTargetTemp),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_ExtruderCurrentTemp,
nullptr,
&DGUSTxHandler::extruderCurrentTemp),
VP_HELPER_WORD( DGUS_Addr::MAIN_BedTargetTemp,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::bedTargetTemp,
&DGUSTxHandler::bedTargetTemp),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_BedCurrentTemp,
nullptr,
&DGUSTxHandler::bedCurrentTemp),
VP_HELPER_RX( DGUS_Addr::CMD_SettingsMenu,
&DGUSReturnKeyCodeHandler::Command_SettingsMenu),
VP_HELPER_RX( DGUS_Addr::CMD_Leveling,
&DGUSReturnKeyCodeHandler::Command_Leveling),
VP_HELPER_RX( DGUS_Addr::CMD_AxisControl,
&DGUSReturnKeyCodeHandler::Command_AxisControl),
VP_HELPER_WORD( DGUS_Addr::AXIS_X,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::axis_X,
&DGUSTxHandler::axis_X),
VP_HELPER_WORD( DGUS_Addr::AXIS_Y,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::axis_Y,
&DGUSTxHandler::axis_Y),
VP_HELPER_WORD( DGUS_Addr::AXIS_Z,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::axis_Z,
&DGUSTxHandler::axis_Z),
VP_HELPER_RX( DGUS_Addr::IO_ExtrudeLength,
&DGUSRxHandler::extrudeLength),
VP_HELPER_RX( DGUS_Addr::IO_RetractLength,
&DGUSRxHandler::retractLength),
VP_HELPER_RX( DGUS_Addr::CMD_AxisIO,
&DGUSReturnKeyCodeHandler::Command_FilamentIO),
VP_HELPER_RX( DGUS_Addr::LANGUAGE_SetLanguage,
&DGUSRxHandler::setLanguage),
VP_HELPER_RX( DGUS_Addr::CMD_PowerLoss,
&DGUSReturnKeyCodeHandler::Command_PowerLoss),
VP_HELPER_TX( DGUS_Addr::LEVELING_Progress_Icon,
&DGUSTxHandler::levelingProgressIcon),
#if HAS_FILAMENT_SENSOR
VP_HELPER_TX_AUTO( DGUS_Addr::FILAMENT_Icon_Inserted,
nullptr,
&DGUSTxHandler::filamentInsertionStatus),
#endif
VP_HELPER_WORD( DGUS_Addr::TEMP_PLA_ExtruderTemp,
VPFLAG_NONE,
&screen.config.plaExtruderTemp,
&DGUSRxHandler::integerToExtra<uint16_t>,
&DGUSTxHandler::extraToInteger<uint16_t>),
VP_HELPER_WORD( DGUS_Addr::TEMP_PLA_BedTemp,
VPFLAG_NONE,
&screen.config.plaBedTemp,
&DGUSRxHandler::integerToExtra<uint16_t>,
&DGUSTxHandler::extraToInteger<uint16_t>),
VP_HELPER_WORD( DGUS_Addr::TEMP_ABS_ExtruderTemp,
VPFLAG_NONE,
&screen.config.absExtruderTemp,
&DGUSRxHandler::integerToExtra<uint16_t>,
&DGUSTxHandler::extraToInteger<uint16_t>),
VP_HELPER_WORD( DGUS_Addr::TEMP_ABS_BedTemp,
VPFLAG_NONE,
&screen.config.absBedTemp,
&DGUSRxHandler::integerToExtra<uint16_t>,
&DGUSTxHandler::extraToInteger<uint16_t>),
VP_HELPER_RX( DGUS_Addr::CMD_AdvancedSettings,
&DGUSReturnKeyCodeHandler::Command_AdvancedSettings),
VP_HELPER_TX( DGUS_Addr::LEVELING_Progress,
&DGUSTxHandler::levelingProgress),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxSpeed_X,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxFeedrate<ExtUI::axis_t, ExtUI::X>),
(&DGUSTxHandler::maxFeedrate<ExtUI::axis_t, ExtUI::X>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxSpeed_Y,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxFeedrate<ExtUI::axis_t, ExtUI::Y>),
(&DGUSTxHandler::maxFeedrate<ExtUI::axis_t, ExtUI::Y>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxSpeed_Z,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxFeedrate<ExtUI::axis_t, ExtUI::Z>),
(&DGUSTxHandler::maxFeedrate<ExtUI::axis_t, ExtUI::Z>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxSpeed_E,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxFeedrate<ExtUI::extruder_t, ExtUI::E0>),
(&DGUSTxHandler::maxFeedrate<ExtUI::extruder_t, ExtUI::E0>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_Acceleration_X,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxAcceleration<ExtUI::axis_t, ExtUI::X>),
(&DGUSTxHandler::maxAcceleration<ExtUI::axis_t, ExtUI::X>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_Acceleration_Y,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxAcceleration<ExtUI::axis_t, ExtUI::Y>),
(&DGUSTxHandler::maxAcceleration<ExtUI::axis_t, ExtUI::Y>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_Acceleration_Z,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxAcceleration<ExtUI::axis_t, ExtUI::Z>),
(&DGUSTxHandler::maxAcceleration<ExtUI::axis_t, ExtUI::Z>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_Acceleration_E,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxAcceleration<ExtUI::extruder_t, ExtUI::E0>),
(&DGUSTxHandler::maxAcceleration<ExtUI::extruder_t, ExtUI::E0>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxJerk_X,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxJerk<ExtUI::axis_t, ExtUI::X>),
(&DGUSTxHandler::maxJerk<ExtUI::axis_t, ExtUI::X>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxJerk_Y,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxJerk<ExtUI::axis_t, ExtUI::Y>),
(&DGUSTxHandler::maxJerk<ExtUI::axis_t, ExtUI::Y>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxJerk_Z,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxJerk<ExtUI::axis_t, ExtUI::Z>),
(&DGUSTxHandler::maxJerk<ExtUI::axis_t, ExtUI::Z>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_MaxJerk_E,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::maxJerk<ExtUI::extruder_t, ExtUI::E0>),
(&DGUSTxHandler::maxJerk<ExtUI::extruder_t, ExtUI::E0>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_StepsPerMm_X,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::stepsPerMM<ExtUI::axis_t, ExtUI::X>),
(&DGUSTxHandler::stepsPerMM<ExtUI::axis_t, ExtUI::X>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_StepsPerMm_Y,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::stepsPerMM<ExtUI::axis_t, ExtUI::Y>),
(&DGUSTxHandler::stepsPerMM<ExtUI::axis_t, ExtUI::Y>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_StepsPerMm_Z,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::stepsPerMM<ExtUI::axis_t, ExtUI::Z>),
(&DGUSTxHandler::stepsPerMM<ExtUI::axis_t, ExtUI::Z>)),
VP_HELPER_WORD( DGUS_Addr::MOTION_StepsPerMm_E,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::stepsPerMM<ExtUI::extruder_t, ExtUI::E0>),
(&DGUSTxHandler::stepsPerMM<ExtUI::extruder_t, ExtUI::E0>)),
#if ENABLED(PIDTEMP)
VP_HELPER_WORD( DGUS_Addr::PID_Extruder_P,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::PID_P<ExtUI::E0>),
(&DGUSTxHandler::PID_P<ExtUI::E0>)),
VP_HELPER_WORD( DGUS_Addr::PID_Extruder_I,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::PID_I<ExtUI::E0>),
(&DGUSTxHandler::PID_I<ExtUI::E0>)),
VP_HELPER_WORD( DGUS_Addr::PID_Extruder_D,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::PID_D<ExtUI::E0>),
(&DGUSTxHandler::PID_D<ExtUI::E0>)),
#else
VP_HELPER_WORD( DGUS_Addr::PID_Extruder_P,
VPFLAG_AUTOUPLOAD,
const_cast<uint16_t*>(&DGUS_ZERO),
DGUSRxHandler::disabled,
(DGUSTxHandler::extraToFixedPoint<uint16_t, 2>)),
VP_HELPER_WORD( DGUS_Addr::PID_Extruder_I,
VPFLAG_AUTOUPLOAD,
const_cast<uint16_t*>(&DGUS_ZERO),
DGUSRxHandler::disabled,
(DGUSTxHandler::extraToFixedPoint<uint16_t, 2>)),
VP_HELPER_WORD( DGUS_Addr::PID_Extruder_D,
VPFLAG_AUTOUPLOAD,
const_cast<uint16_t*>(&DGUS_ZERO),
DGUSRxHandler::disabled,
(DGUSTxHandler::extraToFixedPoint<uint16_t, 2>)),
#endif // PIDTEMP
#if ENABLED(PIDTEMPBED)
VP_HELPER_WORD( DGUS_Addr::PID_Bed_P,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::bed_PID_P),
(&DGUSTxHandler::bed_PID_P)),
VP_HELPER_WORD( DGUS_Addr::PID_Bed_I,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::bed_PID_I),
(&DGUSTxHandler::bed_PID_I)),
VP_HELPER_WORD( DGUS_Addr::PID_Bed_D,
VPFLAG_AUTOUPLOAD,
nullptr,
(&DGUSRxHandler::bed_PID_D),
(&DGUSTxHandler::bed_PID_D)),
#else
VP_HELPER_WORD( DGUS_Addr::PID_Bed_P,
VPFLAG_AUTOUPLOAD,
const_cast<uint16_t*>(&DGUS_ZERO),
DGUSRxHandler::disabled,
(DGUSTxHandler::extraToFixedPoint<uint16_t, 2>)),
VP_HELPER_WORD( DGUS_Addr::PID_Bed_I,
VPFLAG_AUTOUPLOAD,
const_cast<uint16_t*>(&DGUS_ZERO),
DGUSRxHandler::disabled,
(DGUSTxHandler::extraToFixedPoint<uint16_t, 2>)),
VP_HELPER_WORD( DGUS_Addr::PID_Bed_D,
VPFLAG_AUTOUPLOAD,
const_cast<uint16_t*>(&DGUS_ZERO),
DGUSRxHandler::disabled,
(DGUSTxHandler::extraToFixedPoint<uint16_t, 2>)),
#endif // PIDTEMPBED
VP_HELPER_WORD( DGUS_Addr::CONTROL_FanSpeed,
VPFLAG_AUTOUPLOAD,
nullptr,
&DGUSRxHandler::fanSpeed,
&DGUSTxHandler::fanSpeed),
VP_HELPER_TX( DGUS_Addr::SDCard_InsertionStatus,
DGUSTxHandler::sdCardInsertionStatus),
VP_HELPER_LANG_ICON(DGUS_Addr::FINISH_Icon_Finished),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_RemainingHours,
nullptr,
&DGUSTxHandler::printRemainingHours),
VP_HELPER_TX_AUTO( DGUS_Addr::MAIN_RemainingMinutes,
nullptr,
&DGUSTxHandler::printRemainingMinutes),
VP_HELPER_TX_AUTO( DGUS_Addr::AXIS_StepperStatus,
nullptr,
&DGUSTxHandler::stepperStatus),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Home_S),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Print_S),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Ready_S),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Settings_S),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Home),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Print),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Ready),
VP_HELPER_LANG_ICON(DGUS_Addr::MENU_Icon_Settings),
VP_HELPER_LANG_ICON(DGUS_Addr::ADJUST_Icon_Adjust),
VP_HELPER_LANG_ICON(DGUS_Addr::ADJUST_Icon_Feedrate),
VP_HELPER_LANG_ICON(DGUS_Addr::IO_Icon_ExtruderTemp),
VP_HELPER_LANG_ICON(DGUS_Addr::CONTROL_Icon_BedTemp),
VP_HELPER_LANG_ICON(DGUS_Addr::ADJUST_Icon_ZOffset),
VP_HELPER_LANG_ICON(DGUS_Addr::CONTROL_Icon_FanControl),
VP_HELPER_LANG_ICON(DGUS_Addr::ADJUST_Icon_FanControl),
VP_HELPER_LANG_ICON(DGUS_Addr::AXIS_Icon_MoveAxis),
VP_HELPER_LANG_ICON(DGUS_Addr::AXIS_Icon_IO),
VP_HELPER_LANG_ICON(DGUS_Addr::AXIS_Icon_Manual),
VP_HELPER_LANG_ICON(DGUS_Addr::CONTROL_Icon_Cooling),
VP_HELPER_LANG_ICON(DGUS_Addr::IO_Icon_Extrude),
VP_HELPER_LANG_ICON(DGUS_Addr::IO_Icon_Retract),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_Language),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_Leveling),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_Device),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_ResetSettings),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_About),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_Device),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_Advanced),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_About),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_PLA),
VP_HELPER_LANG_ICON(DGUS_Addr::SETTINGS_Icon_ABS),
VP_HELPER_LANG_ICON(DGUS_Addr::RUNOUT_Icon_Stop),
VP_HELPER_LANG_ICON(DGUS_Addr::RUNOUT_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::RESET_Icon_Yes),
VP_HELPER_LANG_ICON(DGUS_Addr::RESET_Icon_No),
VP_HELPER_LANG_ICON(DGUS_Addr::LOAD_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::LOAD_Icon_Continue),
VP_HELPER_LANG_ICON(DGUS_Addr::PAUSE_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::RESUME_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::POWERLOSS_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::AUTOHOME_Icon_WaitMessage),
VP_HELPER_LANG_ICON(DGUS_Addr::LEVELING_Icon_Leveling),
VP_HELPER_LANG_ICON(DGUS_Addr::LEVELING_Icon_Start),
VP_HELPER_LANG_ICON(DGUS_Addr::LEVELING_Icon_AuxLevel),
VP_HELPER_LANG_ICON(DGUS_Addr::LEVELING_Icon_AutoLevel),
VP_HELPER_LANG_ICON(DGUS_Addr::LEVELING_Icon_AuxLevel_S),
VP_HELPER_LANG_ICON(DGUS_Addr::LEVELING_Icon_AutoLevel_S),
VP_HELPER_LANG_ICON(DGUS_Addr::LANGUAGE_Icon_Language),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Movement),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_PID),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MotionSettings),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxFeedrate),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Acceleration),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Jerk),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_StepsPerMm),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxSpeed),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxSpeed_X),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxSpeed_Y),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxSpeed_Z),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxSpeed_E),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_AccelerationMenu),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Acceleration_X),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Acceleration_Y),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Acceleration_Z),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_Acceleration_E),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxJerkMenu),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxJerk_X),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxJerk_Y),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxJerk_Z),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_MaxJerk_E),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_StepsPerMmMenu),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_StepsPerMm_X),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_StepsPerMm_Y),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_StepsPerMm_Z),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_StepsPerMm_E),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_PIDMenu),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_Extruder_P),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_Extruder_I),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_Extruder_D),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_Bed_P),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_Bed_I),
VP_HELPER_LANG_ICON(DGUS_Addr::PID_Icon_Bed_D),
VP_HELPER_LANG_ICON(DGUS_Addr::CUTTER_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::FDM_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::ADV_Icon_SwitchToLaser),
VP_HELPER_LANG_ICON(DGUS_Addr::PRTMODE_Icon_Message),
VP_HELPER_LANG_ICON(DGUS_Addr::PRTMODE_Icon_FDM),
VP_HELPER_LANG_ICON(DGUS_Addr::PRTMODE_Icon_Cutter),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_Model),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_FW_Version),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_Screen_Version),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_HW_Version),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_Website),
VP_HELPER_LANG_ICON(DGUS_Addr::INFO_Icon_Print_Size),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_Chinese,
(void*)DGUS_Data::Language::Chinese_Simplified,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_English,
(void*)DGUS_Data::Language::English,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_German,
(void*)DGUS_Data::Language::German,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_Spanish,
(void*)DGUS_Data::Language::Spanish,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_French,
(void*)DGUS_Data::Language::French,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_Italian,
(void*)DGUS_Data::Language::Italian,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_Portuguese,
(void*)DGUS_Data::Language::Portuguese,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_Russian,
(void*)DGUS_Data::Language::Russian,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER_TX_AUTO( DGUS_Addr::LANGUAGE_Icon_Turkish,
(void*)DGUS_Data::Language::Turkish,
&DGUSTxHandler::enableIfLanguageMatchesExtra),
VP_HELPER( DGUS_Addr::INFO_Model,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(DGUS_MACHINENAME),
nullptr,
DGUSTxHandler::extraToString),
VP_HELPER( DGUS_Addr::INFO_FW_Version,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(DGUS_MARLINVERSION),
nullptr,
DGUSTxHandler::extraToString),
//already set in the screen memory:
/*
VP_HELPER(DGUS_Addr::INFO_Screen_Version,
DGUS_INFOSTRING_LEN,
VPFLAG_NONE,
(void*)"",
nullptr,
DGUSTxHandler::extraToString),
*/
VP_HELPER( DGUS_Addr::INFO_HW_Version,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(DGUS_BOARD),
nullptr,
DGUSTxHandler::extraToString),
VP_HELPER( DGUS_Addr::INFO_Print_Size,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(DGUS_BEDSIZE),
nullptr,
DGUSTxHandler::extraToString),
VP_HELPER( DGUS_Addr::INFO_Website,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(DGUS_WEBSITE),
nullptr,
DGUSTxHandler::extraToString),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename1,
0),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename2,
1),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename3,
2),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename4,
3),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename5,
4),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename6,
0),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename7,
1),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename8,
2),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename9,
3),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename10,
4),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename11,
0),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename12,
1),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename13,
2),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename14,
3),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename15,
4),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename16,
0),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename17,
1),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename18,
2),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename19,
3),
VP_HELPER_FILENAME( DGUS_Addr::SDCARD_Filename20,
4),
VP_HELPER_RX( DGUS_Addr::CMD_FilelistControl,
&DGUSReturnKeyCodeHandler::Command_FilelistControl),
VP_HELPER_RX( DGUS_Addr::SDCARD_FileSelection,
&DGUSRxHandler::sdCardFileSection),
VP_HELPER( DGUS_Addr::MAIN_StatusMessage,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(screen.homeStatusMessage),
nullptr,
DGUSTxHandler::extraToString),
VP_HELPER( DGUS_Addr::ABNORMAL_StatusMessage,
DGUS_INFOSTRING_LEN,
VPFLAG_TXSTRING_AUTOSCROLL,
VP_EXTRA_TO_STR(screen.homeStatusMessage),
nullptr,
DGUSTxHandler::extraToString),
VP_HELPER_RX( DGUS_Addr::CMD_LaserControl,
&DGUSReturnKeyCodeHandler::Command_LaserControl),
VP_HELPER((DGUS_Addr)0, 0, VPFLAG_NONE, nullptr, nullptr, nullptr)
};
#endif // DGUS_LCD_UI_E3S1PRO
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VPList.cpp
|
C++
|
agpl-3.0
| 29,268
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "DGUS_VP.h"
#define VP_EXTRA_TO_U16(N) (void*)(uint16_t)(N)
#define VP_U16_FROM_EXTRA(N) (*(uint16_t*)N)
#define VP_EXTRA_TO_STR(N) (void*)(N)
extern const struct DGUS_VP vp_list[];
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/definition/DGUS_VPList.h
|
C
|
agpl-3.0
| 1,070
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2023 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 <https://www.gnu.org/licenses/>.
*
*/
/**
* lcd/extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp
*/
#include "../../../inc/MarlinConfigPre.h"
#if ENABLED(DGUS_LCD_UI_E3S1PRO)
#include "../ui_api.h"
#include "DGUSScreenHandler.h"
#define DEBUG_OUT 1
#include "../../../core/debug_out.h"
namespace ExtUI {
void onStartup() {
screen.init();
}
void onIdle() {
static bool processing = false;
// Prevent recursion
if (!processing) {
processing = true;
screen.loop();
processing = false;
}
}
void onPrinterKilled(FSTR_P const error, FSTR_P const component) {
screen.printerKilled(error, component);
}
void onMediaInserted() { TERN_(HAS_MEDIA, screen.sdCardInserted()); }
void onMediaError() { TERN_(HAS_MEDIA, screen.sdCardError()); }
void onMediaRemoved() { TERN_(HAS_MEDIA, screen.sdCardRemoved()); }
void onHeatingError(const heater_id_t header_id) {}
void onMinTempError(const heater_id_t header_id) {}
void onMaxTempError(const heater_id_t header_id) {}
void onPlayTone(const uint16_t frequency, const uint16_t duration/*=0*/) {
screen.playTone(frequency, duration);
}
void onPrintTimerStarted() {
screen.printTimerStarted();
}
void onPrintTimerPaused() {
screen.printTimerPaused();
}
void onPrintTimerStopped() {
screen.printTimerStopped();
}
void onFilamentRunout(const extruder_t extruder) {
screen.filamentRunout(extruder);
}
void onUserConfirmRequired(const char * const msg) {
screen.userConfirmRequired(msg);
}
// For fancy LCDs include an icon ID, message, and translated button title
void onUserConfirmRequired(const int icon, const char * const cstr, FSTR_P const fBtn) {
onUserConfirmRequired(cstr);
UNUSED(icon); UNUSED(fBtn);
}
void onUserConfirmRequired(const int icon, FSTR_P const fstr, FSTR_P const fBtn) {
onUserConfirmRequired(fstr);
UNUSED(icon); UNUSED(fBtn);
}
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void onPauseMode(
const PauseMessage message,
const PauseMode mode/*=PAUSE_MODE_SAME*/,
const uint8_t extruder/*=active_extruder*/
) {
stdOnPauseMode(message, mode, extruder);
}
#endif
void onStatusChanged(const char * const msg) {
screen.setStatusMessage(msg);
}
void onHomingStart() {}
void onHomingDone() {
screen.homingDone();
}
void onPrintDone() {}
void onFactoryReset() {
screen.settingsReset();
}
void onStoreSettings(char *buff) {
screen.storeSettings(buff);
}
void onLoadSettings(const char *buff) {
screen.loadSettings(buff);
}
void onPostprocessSettings() {}
void onSettingsStored(const bool success) {
screen.configurationStoreWritten(success);
}
void onSettingsLoaded(const bool success) {
screen.configurationStoreRead(success);
}
#if HAS_LEVELING
void onLevelingStart() { screen.levelingStart(); }
void onLevelingDone() { screen.levelingEnd(); }
#if ENABLED(PREHEAT_BEFORE_LEVELING)
celsius_t getLevelingBedTemp() { return LEVELING_BED_TEMP; }
#endif
#endif
#if HAS_MESH
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const_float_t zval) {
screen.meshUpdate(xpos, ypos);
}
void onMeshUpdate(const int8_t xpos, const int8_t ypos, const probe_state_t state) { }
#endif
#if ENABLED(PREVENT_COLD_EXTRUSION)
void onSetMinExtrusionTemp(const celsius_t) {}
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
void onSetPowerLoss(const bool onoff) {
// Called when power-loss is enabled/disabled
}
void onPowerLoss() {
// Called when power-loss state is detected
}
void onPowerLossResume() {
// Called on resume from power-loss
screen.powerLossResume();
}
#endif
#if HAS_PID_HEATING
void onPIDTuning(const pidresult_t rst) {
// Called for temperature PID tuning result
screen.pidTuning(rst);
}
void onStartM303(const int count, const heater_id_t hid, const celsius_t temp) {
// Called by M303 to update the UI
}
#endif
#if ENABLED(MPC_AUTOTUNE)
void onMPCTuning(const mpcresult_t rst) {
// Called for temperature PID tuning result
}
#endif
#if ENABLED(PLATFORM_M997_SUPPORT)
void onFirmwareFlash() {}
#endif
void onSteppersDisabled() {
screen.steppersStatusChanged(false);
}
void onSteppersEnabled() {
screen.steppersStatusChanged(true);
}
void onAxisDisabled(const axis_t) {}
void onAxisEnabled(const axis_t) {}
}
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_e3s1pro/dgus_e3s1pro_extui.cpp
|
C++
|
agpl-3.0
| 5,367
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
/* DGUS implementation written by coldtobi in 2019 for Marlin */
#include "../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUSDisplay.h"
#include "config/DGUS_Addr.h"
#include "config/DGUS_Constants.h"
#include "definition/DGUS_VPList.h"
#include "../ui_api.h"
#include "../../../gcode/gcode.h"
long map_precise(float x, long in_min, long in_max, long out_min, long out_max) {
return LROUND((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min);
}
uint8_t DGUSDisplay::gui_version = 0;
uint8_t DGUSDisplay::os_version = 0;
uint8_t DGUSDisplay::volume = 255;
uint8_t DGUSDisplay::brightness = 100;
DGUSDisplay::rx_datagram_state_t DGUSDisplay::rx_datagram_state = DGUS_IDLE;
uint8_t DGUSDisplay::rx_datagram_len = 0;
bool DGUSDisplay::initialized = false;
void DGUSDisplay::loop() {
processRx();
}
void DGUSDisplay::init() {
LCD_SERIAL.begin(LCD_BAUDRATE);
readVersions();
}
void DGUSDisplay::read(uint16_t addr, uint8_t size) {
writeHeader(addr, DGUS_READVAR, size);
LCD_SERIAL.write(size);
}
void DGUSDisplay::write(uint16_t addr, const void* data_ptr, uint8_t size) {
if (!data_ptr) return;
writeHeader(addr, DGUS_WRITEVAR, size);
const char* data = static_cast<const char*>(data_ptr);
while (size--) {
LCD_SERIAL.write(*data++);
}
}
void DGUSDisplay::writeString(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) {
if (!data_ptr) return;
writeHeader(addr, DGUS_WRITEVAR, size);
const char* data = static_cast<const char*>(data_ptr);
size_t len = strlen(data);
uint8_t left_spaces = 0;
uint8_t right_spaces = 0;
if (len < size) {
if (!len) {
right_spaces = size;
}
else if ((left && right) || (!left && !right)) {
left_spaces = (size - len) / 2;
right_spaces = size - len - left_spaces;
}
else if (left) {
right_spaces = size - len;
}
else {
left_spaces = size - len;
}
}
else {
len = size;
}
while (left_spaces--) {
LCD_SERIAL.write(' ');
}
while (len--) {
LCD_SERIAL.write(*data++);
}
while (right_spaces--) {
LCD_SERIAL.write(use_space ? ' ' : '\0');
}
}
void DGUSDisplay::writeStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left, bool right, bool use_space) {
if (!data_ptr) return;
writeHeader(addr, DGUS_WRITEVAR, size);
const char* data = static_cast<const char*>(data_ptr);
size_t len = strlen_P(data);
uint8_t left_spaces = 0, right_spaces = 0;
if (len < size) {
if (!len) {
right_spaces = size;
}
else if ((left && right) || (!left && !right)) {
left_spaces = (size - len) / 2;
right_spaces = size - len - left_spaces;
}
else if (left) {
right_spaces = size - len;
}
else {
left_spaces = size - len;
}
}
else {
len = size;
}
while (left_spaces--) LCD_SERIAL.write(' ');
while (len--) LCD_SERIAL.write(pgm_read_byte(data++));
while (right_spaces--) LCD_SERIAL.write(use_space ? ' ' : '\0');
}
void DGUSDisplay::readVersions() {
if (gui_version != 0 && os_version != 0) return;
read(DGUS_VERSION, 1);
}
void DGUSDisplay::switchScreen(const DGUS_ScreenID screenID) {
const uint8_t command[] = { 0x5A, 0x01, 0x00, (uint8_t)screenID };
write(0x84, command, sizeof(command));
}
void DGUSDisplay::playSound(uint8_t start, uint8_t len, uint8_t volume) {
if (volume == 0) volume = DGUSDisplay::volume;
if (volume == 0) return;
const uint8_t command[] = { start, len, volume, 0x00 };
write(0xA0, command, sizeof(command));
}
void DGUSDisplay::enableControl(const DGUS_ScreenID screenID, DGUS_ControlType type, DGUS_Control control) {
const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screenID, (uint8_t)control, type, 0x00, 0x01 };
write(0xB0, command, sizeof(command));
flushTx();
delay(50);
}
void DGUSDisplay::disableControl(const DGUS_ScreenID screenID, DGUS_ControlType type, DGUS_Control control) {
const uint8_t command[] = { 0x5A, 0xA5, 0x00, (uint8_t)screenID, (uint8_t)control, type, 0x00, 0x00 };
write(0xB0, command, sizeof(command));
flushTx();
delay(50);
}
uint8_t DGUSDisplay::getBrightness() {
return brightness;
}
uint8_t DGUSDisplay::getVolume() {
return map_precise(volume, 0, 255, 0, 100);
}
void DGUSDisplay::setBrightness(uint8_t new_brightness) {
brightness = constrain(new_brightness, 0, 100);
new_brightness = map_precise(brightness, 0, 100, 5, 100);
const uint8_t command[] = { new_brightness, new_brightness };
write(0x82, command, sizeof(command));
}
void DGUSDisplay::setVolume(uint8_t new_volume) {
volume = map_precise(constrain(new_volume, 0, 100), 0, 100, 0, 255);
const uint8_t command[] = { volume, 0x00 };
write(0xA1, command, sizeof(command));
}
void DGUSDisplay::processRx() {
#if ENABLED(LCD_SERIAL_STATS_RX_BUFFER_OVERRUNS)
if (!LCD_SERIAL.available() && LCD_SERIAL.buffer_overruns()) {
// Overrun, but reset the flag only when the buffer is empty
// We want to extract as many as valid datagrams possible...
rx_datagram_state = DGUS_IDLE;
//LCD_SERIAL.reset_rx_overun();
LCD_SERIAL.flush();
}
#endif
uint8_t receivedbyte;
while (LCD_SERIAL.available()) {
switch (rx_datagram_state) {
case DGUS_IDLE: // Waiting for the first header byte
receivedbyte = LCD_SERIAL.read();
if (DGUS_HEADER1 == receivedbyte) rx_datagram_state = DGUS_HEADER1_SEEN;
break;
case DGUS_HEADER1_SEEN: // Waiting for the second header byte
receivedbyte = LCD_SERIAL.read();
rx_datagram_state = (DGUS_HEADER2 == receivedbyte) ? DGUS_HEADER2_SEEN : DGUS_IDLE;
break;
case DGUS_HEADER2_SEEN: // Waiting for the length byte
rx_datagram_len = LCD_SERIAL.read();
// Telegram min len is 3 (command and one word of payload)
rx_datagram_state = WITHIN(rx_datagram_len, 3, DGUS_RX_BUFFER_SIZE) ? DGUS_WAIT_TELEGRAM : DGUS_IDLE;
break;
case DGUS_WAIT_TELEGRAM: // wait for complete datagram to arrive.
if (LCD_SERIAL.available() < rx_datagram_len) return;
initialized = true; // We've talked to it, so we defined it as initialized.
uint8_t command = LCD_SERIAL.read();
uint8_t readlen = rx_datagram_len - 1; // command is part of len.
unsigned char tmp[rx_datagram_len - 1];
unsigned char *ptmp = tmp;
while (readlen--) {
receivedbyte = LCD_SERIAL.read();
*ptmp++ = receivedbyte;
}
// mostly we'll get this: 5A A5 03 82 4F 4B -- ACK on 0x82, so discard it.
if (command == DGUS_WRITEVAR && 'O' == tmp[0] && 'K' == tmp[1]) {
rx_datagram_state = DGUS_IDLE;
break;
}
/* AutoUpload, (and answer to) Command 0x83 :
| tmp[0 1 2 3 4 ... ]
| Example 5A A5 06 83 20 01 01 78 01 ……
| / / | | \ / | \ \
| Header | | | | \_____\_ DATA (Words!)
| DatagramLen / VPAdr |
| Command DataLen (in Words) */
if (command == DGUS_READVAR) {
const uint16_t addr = tmp[0] << 8 | tmp[1];
const uint8_t dlen = tmp[2] << 1; // Convert to Bytes. (Display works with words)
if (addr == DGUS_VERSION && dlen == 2) {
gui_version = tmp[3];
os_version = tmp[4];
rx_datagram_state = DGUS_IDLE;
break;
}
DGUS_VP vp;
if (!populateVP((DGUS_Addr)addr, &vp)) {
rx_datagram_state = DGUS_IDLE;
break;
}
if (!vp.rx_handler) {
rx_datagram_state = DGUS_IDLE;
break;
}
gcode.reset_stepper_timeout();
if (!vp.size) {
DEBUG_EOL();
vp.rx_handler(vp, nullptr);
rx_datagram_state = DGUS_IDLE;
break;
}
if (vp.flags & VPFLAG_RXSTRING) {
unsigned char buffer[vp.size];
memset(buffer, 0, vp.size);
for (uint8_t i = 0; i < dlen; i++) {
if (i >= vp.size) break;
if (i + 1 < dlen && tmp[i + 3] == 0xFF && tmp[i + 4] == 0xFF)
break;
buffer[i] = tmp[i + 3];
}
DEBUG_EOL();
vp.rx_handler(vp, buffer);
rx_datagram_state = DGUS_IDLE;
break;
}
if (dlen != vp.size) {
rx_datagram_state = DGUS_IDLE;
break;
}
DEBUG_EOL();
vp.rx_handler(vp, &tmp[3]);
rx_datagram_state = DGUS_IDLE;
break;
}
rx_datagram_state = DGUS_IDLE;
break;
}
}
}
size_t DGUSDisplay::getFreeTxBuffer() {
return (
#ifdef LCD_SERIAL_GET_TX_BUFFER_FREE
LCD_SERIAL_GET_TX_BUFFER_FREE()
#else
SIZE_MAX
#endif
);
}
void DGUSDisplay::flushTx() {
#ifdef ARDUINO_ARCH_STM32
LCD_SERIAL.flush();
#else
LCD_SERIAL.flushTX();
#endif
}
void DGUSDisplay::writeHeader(uint16_t addr, uint8_t command, uint8_t len) {
LCD_SERIAL.write(DGUS_HEADER1);
LCD_SERIAL.write(DGUS_HEADER2);
LCD_SERIAL.write(len + 3);
LCD_SERIAL.write(command);
LCD_SERIAL.write(addr >> 8);
LCD_SERIAL.write(addr & 0xFF);
}
bool populateVP(const DGUS_Addr addr, DGUS_VP * const buffer) {
const DGUS_VP *ret = vp_list;
do {
const uint16_t *paddr = (uint16_t *)(&ret->addr);
const uint16_t addrcheck = pgm_read_word(paddr);
if (addrcheck == 0) break;
if ((DGUS_Addr)addrcheck == addr) {
memcpy_P(buffer, ret, sizeof(*ret));
return true;
}
} while (++ret);
return false;
}
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.cpp
|
C++
|
agpl-3.0
| 10,641
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
/**
* DGUS implementation written by coldtobi in 2019.
* Updated for STM32G0B1RE by Protomosh in 2022.
*/
#include "config/DGUS_ScreenID.h"
#include "config/DGUS_Control.h"
#include "definition/DGUS_VP.h"
#include "../../../inc/MarlinConfigPre.h"
#include "../../../MarlinCore.h"
//#define DEBUG_DGUSLCD // Uncomment for debug messages
#define DEBUG_OUT ENABLED(DEBUG_DGUSLCD)
#include "../../../core/debug_out.h"
// New endianness swap for 32bit mcu (tested with STM32G0B1RE)
#define BE16_P(V) ( ((uint8_t*)(V))[0] << 8U | ((uint8_t*)(V))[1] )
#define BE32_P(V) ( ((uint8_t*)(V))[0] << 24U | ((uint8_t*)(V))[1] << 16U | ((uint8_t*)(V))[2] << 8U | ((uint8_t*)(V))[3] )
// Low-Level access to the display.
class DGUSDisplay {
public:
enum DGUS_ControlType : uint8_t {
VARIABLE_DATA_INPUT = 0x00,
POPUP_WINDOW = 0x01,
INCREMENTAL_ADJUST = 0x02,
SLIDER_ADJUST = 0x03,
RTC_SETTINGS = 0x04,
RETURN_KEY_CODE = 0x05,
TEXT_INPUT = 0x06,
FIRMWARE_SETTINGS = 0x07
};
DGUSDisplay() = default;
static void init();
static void read(uint16_t addr, uint8_t size);
static void write(uint16_t addr, const void* data_ptr, uint8_t size);
static void writeString(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true);
static void writeStringPGM(uint16_t addr, const void* data_ptr, uint8_t size, bool left=true, bool right=false, bool use_space=true);
static void writeString(uint16_t addr, FSTR_P const fstr, uint8_t size, bool left=true, bool right=false, bool use_space=true) {
writeStringPGM(addr, FTOP(fstr), size, left, right, use_space);
}
template<typename T>
static void write(uint16_t addr, T data) {
write(addr, static_cast<const void*>(&data), sizeof(T));
}
// Until now I did not need to actively read from the display. That's why there is no readVariable
// (I extensively use the auto upload of the display)
// Read GUI and OS version from screen
static void readVersions();
// Force display into another screen.
static void switchScreen(const DGUS_ScreenID screenID);
// Play sounds using the display speaker.
// start: position at which the sound was stored on the display.
// len: how many sounds to play. Sounds will play consecutively from start to start+len-1.
// volume: playback volume. 0 keeps the current volume.
static void playSound(uint8_t start, uint8_t len=1, uint8_t volume=0);
// Enable/disable a specific touch control.
// type: control type.
// control: index of the control on the page (set during screen development).
static void enableControl(const DGUS_ScreenID screenID, DGUS_ControlType type, DGUS_Control control);
static void disableControl(const DGUS_ScreenID screenID, DGUS_ControlType type, DGUS_Control control);
static uint8_t getBrightness();
static uint8_t getVolume();
// Set the display brightness/volume, ranging 0 - 100
static void setBrightness(uint8_t brightness);
static void setVolume(uint8_t volume);
// Periodic tasks, eg. Rx-Queue handling.
static void loop();
// Helper for users of this class to estimate if an interaction would be blocking.
static size_t getFreeTxBuffer();
static void flushTx();
// Checks two things: Can we confirm the presence of the display and has we initialized it.
// (both boils down that the display answered to our chatting)
static bool isInitialized() {
return initialized;
}
static uint8_t gui_version;
static uint8_t os_version;
template<typename T>
static T swapBytes(const T value) {
union {
T val;
char byte[sizeof(T)];
} src, dst;
src.val = value;
for (uint8_t i = 0; i < sizeof(T); ++i) dst.byte[i] = src.byte[sizeof(T) - i - 1];
return dst.val;
}
template<typename T_in, typename T_out, uint8_t decimals>
T_out fromFixedPoint(const T_in value) {
return (T_out)((float)value / POW(10, decimals));
}
template<typename T_in, typename T_out, uint8_t decimals>
T_out toFixedPoint(const T_in value) {
return (T_out)LROUND((float)value * POW(10, decimals));
}
private:
enum dgus_header : uint8_t {
DGUS_HEADER1 = 0x5A,
DGUS_HEADER2 = 0xA5
};
enum dgus_command : uint8_t {
DGUS_WRITEVAR = 0x82,
DGUS_READVAR = 0x83
};
enum rx_datagram_state_t : uint8_t {
DGUS_IDLE, //< waiting for DGUS_HEADER1.
DGUS_HEADER1_SEEN, //< DGUS_HEADER1 received
DGUS_HEADER2_SEEN, //< DGUS_HEADER2 received
DGUS_WAIT_TELEGRAM, //< LEN received, Waiting for to receive all bytes.
};
enum dgus_system_addr : uint16_t {
DGUS_VERSION = 0x000F // OS/GUI version
};
static void writeHeader(uint16_t addr, uint8_t command, uint8_t len);
static void processRx();
static uint8_t volume;
static uint8_t brightness;
static rx_datagram_state_t rx_datagram_state;
static uint8_t rx_datagram_len;
static bool initialized;
};
template<> inline uint16_t DGUSDisplay::swapBytes(const uint16_t value) {
return ((value << 8) | (value >> 8));
}
extern DGUSDisplay dgus;
/// Helper to populate a DGUS_VP for a given VP. Return false if not found.
extern bool populateVP(const DGUS_Addr addr, DGUS_VP * const buffer);
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSDisplay.h
|
C++
|
agpl-3.0
| 6,133
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUSRxHandler.h"
#include "DGUSScreenHandler.h"
#include "config/DGUS_ScreenID.h"
#include "../ui_api.h"
#include "../../../core/language.h"
#include "../../../module/temperature.h"
#include "../../../module/printcounter.h"
#include "../../../module/stepper.h"
#include "../../../gcode/queue.h"
#if ENABLED(ADVANCED_PAUSE_FEATURE)
#include "../../../feature/pause.h"
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
#include "../../../feature/powerloss.h"
#endif
void DGUSRxHandler::screenChange(DGUS_VP &vp, void *data_ptr) {
const DGUS_ScreenID screenID = (DGUS_ScreenID)((uint8_t*)data_ptr)[1];
if (vp.addr == DGUS_Addr::SCREENCHANGE_SD) {
#if HAS_MEDIA
IF_DISABLED(HAS_SD_DETECT, card.mount());
if (!ExtUI::isMediaInserted()) {
screen.setStatusMessage(GET_TEXT_F(MSG_NO_MEDIA));
return;
}
card.cdroot();
#else
screen.setStatusMessage(GET_TEXT_F(MSG_NO_MEDIA));
return;
#endif
}
if (vp.addr == DGUS_Addr::SCREENCHANGE_Idle
&& (ExtUI::isPrinting() || ExtUI::isPrintingPaused())) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_NOT_WHILE_PRINTING));
return;
}
if (vp.addr == DGUS_Addr::SCREENCHANGE_Printing
&& (!ExtUI::isPrinting() && !ExtUI::isPrintingPaused())) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_NOT_WHILE_IDLE));
return;
}
screen.triggerScreenChange(screenID);
}
#if HAS_MEDIA
void DGUSRxHandler::scroll(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Scroll scroll = (DGUS_Data::Scroll)((uint8_t*)data_ptr)[1];
switch (scroll) {
case DGUS_Data::Scroll::GO_BACK:
if (screen.filelist.isAtRootDir()) {
return;
}
screen.filelist_offset = 0;
screen.filelist_selected = -1;
screen.filelist.upDir();
break;
case DGUS_Data::Scroll::UP:
if (screen.filelist_offset < 1) {
return;
}
--screen.filelist_offset;
break;
case DGUS_Data::Scroll::DOWN:
if (screen.filelist_offset + 1 + DGUS_FILE_COUNT > screen.filelist.count()) {
return;
}
++screen.filelist_offset;
break;
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::selectFile(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const uint8_t index = ((uint8_t*)data_ptr)[1];
if (!screen.filelist.seek(screen.filelist_offset + index)) {
return;
}
if (screen.filelist.isDir()) {
screen.filelist_offset = 0;
screen.filelist_selected = -1;
screen.filelist.changeDir(screen.filelist.filename());
}
else {
screen.filelist_selected = screen.filelist_offset + index;
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::printFile(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
if (screen.filelist_selected < 0) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_NO_FILE_SELECTED));
return;
}
if (!screen.filelist.seek(screen.filelist_selected)
|| screen.filelist.isDir()) {
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
ExtUI::printFile(screen.filelist.shortFilename());
screen.triggerScreenChange(DGUS_ScreenID::PRINT_STATUS);
}
#endif // HAS_MEDIA
void DGUSRxHandler::printAbort(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) {
return;
}
if (!ExtUI::isPrinting() && !ExtUI::isPrintingPaused()) {
screen.triggerFullUpdate();
return;
}
ExtUI::stopPrint();
}
void DGUSRxHandler::printPause(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) {
return;
}
if (!ExtUI::isPrinting()) {
screen.triggerFullUpdate();
return;
}
ExtUI::pausePrint();
}
void DGUSRxHandler::printResume(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) {
return;
}
if (!ExtUI::isPrintingPaused()) {
screen.triggerFullUpdate();
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
ExtUI::resumePrint();
}
void DGUSRxHandler::feedrate(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const int16_t feedrate = BE16_P(data_ptr);
ExtUI::setFeedrate_percent(feedrate);
screen.triggerFullUpdate();
}
void DGUSRxHandler::flowrate(DGUS_VP &vp, void *data_ptr) {
const int16_t flowrate = BE16_P(data_ptr);
switch (vp.addr) {
default: return;
case DGUS_Addr::ADJUST_SetFlowrate_CUR:
ExtUI::setFlow_percent(flowrate, TERN(HAS_MULTI_EXTRUDER, ExtUI::getActiveTool(), ExtUI::E0));
break;
#if HAS_MULTI_EXTRUDER
case DGUS_Addr::ADJUST_SetFlowrate_E0:
ExtUI::setFlow_percent(flowrate, ExtUI::E0);
break;
case DGUS_Addr::ADJUST_SetFlowrate_E1:
ExtUI::setFlow_percent(flowrate, ExtUI::E1);
break;
#endif
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::babystepSet(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const int16_t data = BE16_P(data_ptr);
const float offset = dgus.fromFixedPoint<int16_t, float, 2>(data);
const int16_t steps = ExtUI::mmToWholeSteps(offset - ExtUI::getZOffset_mm(), ExtUI::Z);
ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true);
screen.triggerEEPROMSave();
screen.triggerFullUpdate();
}
void DGUSRxHandler::babystep(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Adjust adjust = (DGUS_Data::Adjust)((uint8_t*)data_ptr)[1];
int16_t steps;
switch (adjust) {
default: return;
case DGUS_Data::Adjust::INCREMENT:
steps = ExtUI::mmToWholeSteps(DGUS_PRINT_BABYSTEP, ExtUI::Z);
break;
case DGUS_Data::Adjust::DECREMENT:
steps = ExtUI::mmToWholeSteps(-DGUS_PRINT_BABYSTEP, ExtUI::Z);
break;
}
ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true);
screen.triggerEEPROMSave();
screen.triggerFullUpdate();
}
void DGUSRxHandler::tempPreset(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::TempPreset preset = (DGUS_Data::TempPreset)((uint8_t*)data_ptr)[1];
switch (preset) {
case DGUS_Data::TempPreset::PLA:
#if HOTENDS < 2
ExtUI::setTargetTemp_celsius(DGUS_PLA_TEMP_HOTEND, ExtUI::H0);
#else
ExtUI::setTargetTemp_celsius(DGUS_PLA_TEMP_HOTEND, ExtUI::getActiveTool());
#endif
ExtUI::setTargetTemp_celsius(DGUS_PLA_TEMP_BED, ExtUI::BED);
break;
case DGUS_Data::TempPreset::ABS:
#if HOTENDS < 2
ExtUI::setTargetTemp_celsius(DGUS_ABS_TEMP_HOTEND, ExtUI::H0);
#else
ExtUI::setTargetTemp_celsius(DGUS_ABS_TEMP_HOTEND, ExtUI::getActiveTool());
#endif
ExtUI::setTargetTemp_celsius(DGUS_ABS_TEMP_BED, ExtUI::BED);
break;
case DGUS_Data::TempPreset::PETG:
#if HOTENDS < 2
ExtUI::setTargetTemp_celsius(DGUS_PETG_TEMP_HOTEND, ExtUI::H0);
#else
ExtUI::setTargetTemp_celsius(DGUS_PETG_TEMP_HOTEND, ExtUI::getActiveTool());
#endif
ExtUI::setTargetTemp_celsius(DGUS_PETG_TEMP_BED, ExtUI::BED);
break;
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::tempTarget(DGUS_VP &vp, void *data_ptr) {
const int16_t temp = BE16_P(data_ptr);
switch (vp.addr) {
default: return;
case DGUS_Addr::TEMP_SetTarget_Bed:
ExtUI::setTargetTemp_celsius(temp, ExtUI::BED);
break;
case DGUS_Addr::TEMP_SetTarget_H0:
ExtUI::setTargetTemp_celsius(temp, ExtUI::H0);
break;
#if HAS_MULTI_HOTEND
case DGUS_Addr::TEMP_SetTarget_H1:
ExtUI::setTargetTemp_celsius(temp, ExtUI::H1);
break;
#endif
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::tempCool(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Heater heater = (DGUS_Data::Heater)BE16_P(data_ptr);
switch (heater) {
default: return;
case DGUS_Data::Heater::ALL:
ExtUI::setTargetTemp_celsius(0, ExtUI::BED);
ExtUI::setTargetTemp_celsius(0, ExtUI::H0);
#if HAS_MULTI_HOTEND
ExtUI::setTargetTemp_celsius(0, ExtUI::H1);
#endif
break;
case DGUS_Data::Heater::BED:
ExtUI::setTargetTemp_celsius(0, ExtUI::BED);
break;
case DGUS_Data::Heater::H0:
ExtUI::setTargetTemp_celsius(0, ExtUI::H0);
break;
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
ExtUI::setTargetTemp_celsius(0, ExtUI::H1);
break;
#endif
}
screen.setStatusMessage(GET_TEXT_F(MSG_COOLING));
screen.triggerFullUpdate();
}
void DGUSRxHandler::steppers(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Control control = (DGUS_Data::Control)((uint8_t*)data_ptr)[1];
switch (control) {
case DGUS_Data::Control::ENABLE:
stepper.enable_all_steppers();
break;
case DGUS_Data::Control::DISABLE:
stepper.disable_all_steppers();
break;
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::zOffset(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
if (TERN0(NO_MOTION_BEFORE_HOMING, !ExtUI::isAxisPositionKnown(ExtUI::Z))) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_HOMING_REQUIRED));
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
const int16_t data = BE16_P(data_ptr);
const float offset = dgus.fromFixedPoint<int16_t, float, 2>(data);
const int16_t steps = ExtUI::mmToWholeSteps(offset - ExtUI::getZOffset_mm(), ExtUI::Z);
ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true);
screen.triggerEEPROMSave();
screen.triggerFullUpdate();
}
void DGUSRxHandler::zOffsetStep(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
if (TERN0(NO_MOTION_BEFORE_HOMING, !ExtUI::isAxisPositionKnown(ExtUI::Z))) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_HOMING_REQUIRED));
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
const DGUS_Data::Adjust adjust = (DGUS_Data::Adjust)((uint8_t*)data_ptr)[1];
int16_t steps;
switch (screen.offset_steps) {
default: return;
case DGUS_Data::StepSize::MMP1:
steps = ExtUI::mmToWholeSteps((adjust == DGUS_Data::Adjust::INCREMENT ? 0.1f : -0.1f), ExtUI::Z);
break;
case DGUS_Data::StepSize::MMP01:
steps = ExtUI::mmToWholeSteps((adjust == DGUS_Data::Adjust::INCREMENT ? 0.01f : -0.01f), ExtUI::Z);
break;
}
ExtUI::smartAdjustAxis_steps(steps, ExtUI::Z, true);
screen.triggerEEPROMSave();
screen.triggerFullUpdate();
}
void DGUSRxHandler::zOffsetSetStep(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::StepSize size = (DGUS_Data::StepSize)((uint8_t*)data_ptr)[1];
screen.offset_steps = size;
screen.triggerFullUpdate();
}
void DGUSRxHandler::moveToPoint(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
if (!ExtUI::isPositionKnown()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_HOMING_REQUIRED));
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
const uint8_t point = ((uint8_t*)data_ptr)[1];
constexpr float lfrb[4] = BED_TRAMMING_INSET_LFRB;
float x, y;
switch (point) {
default: return;
case 1:
x = DGUS_LEVEL_CENTER_X;
y = DGUS_LEVEL_CENTER_Y;
break;
case 2:
x = X_MIN_POS + lfrb[0];
y = Y_MIN_POS + lfrb[1];
break;
case 3:
x = X_MAX_POS - lfrb[2];
y = Y_MIN_POS + lfrb[1];
break;
case 4:
x = X_MAX_POS - lfrb[2];
y = Y_MAX_POS - lfrb[3];
break;
case 5:
x = X_MIN_POS + lfrb[0];
y = Y_MAX_POS - lfrb[3];
break;
}
if (ExtUI::getAxisPosition_mm(ExtUI::Z) < Z_MIN_POS + BED_TRAMMING_Z_HOP) {
ExtUI::setAxisPosition_mm(Z_MIN_POS + BED_TRAMMING_Z_HOP, ExtUI::Z);
}
ExtUI::setAxisPosition_mm(x, ExtUI::X);
ExtUI::setAxisPosition_mm(y, ExtUI::Y);
ExtUI::setAxisPosition_mm(Z_MIN_POS + BED_TRAMMING_HEIGHT, ExtUI::Z);
}
void DGUSRxHandler::probe(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
#if ENABLED(MESH_BED_LEVELING)
screen.setStatusMessage(FPSTR(DGUS_MSG_ABL_REQUIRED));
return;
#endif
if (!ExtUI::isPositionKnown()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_HOMING_REQUIRED));
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
screen.triggerScreenChange(DGUS_ScreenID::LEVELING_PROBING);
#if ENABLED(AUTO_BED_LEVELING_UBL)
queue.enqueue_now(F("G29P1\nG29P3\nG29P5C"));
#else
queue.enqueue_now(F("G29"));
#endif
queue.enqueue_now(F("M500"));
}
void DGUSRxHandler::disableABL(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
ExtUI::setLevelingActive(false);
screen.triggerEEPROMSave();
screen.triggerFullUpdate();
}
void DGUSRxHandler::filamentSelect(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Extruder extruder = (DGUS_Data::Extruder)BE16_P(data_ptr);
switch (extruder) {
default: return;
case DGUS_Data::Extruder::CURRENT:
case DGUS_Data::Extruder::E0:
E_TERN_(case DGUS_Data::Extruder::E1:)
screen.filament_extruder = extruder;
break;
}
screen.triggerFullUpdate();
}
void DGUSRxHandler::filamentLength(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const uint16_t length = BE16_P(data_ptr);
screen.filament_length = constrain(length, 0, EXTRUDE_MAXLENGTH);
screen.triggerFullUpdate();
}
void DGUSRxHandler::filamentMove(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
ExtUI::extruder_t extruder;
switch (screen.filament_extruder) {
default: return;
case DGUS_Data::Extruder::CURRENT:
#if HAS_MULTI_EXTRUDER
extruder = ExtUI::getActiveTool();
break;
#endif
case DGUS_Data::Extruder::E0:
extruder = ExtUI::E0;
break;
#if HAS_MULTI_EXTRUDER
case DGUS_Data::Extruder::E1:
extruder = ExtUI::E1;
break;
#endif
}
if (ExtUI::getActualTemp_celsius(extruder) < (float)EXTRUDE_MINTEMP) {
screen.setStatusMessage(GET_TEXT_F(MSG_TEMP_TOO_LOW));
return;
}
const DGUS_Data::FilamentMove move = (DGUS_Data::FilamentMove)((uint8_t*)data_ptr)[1];
switch (move) {
case DGUS_Data::FilamentMove::RETRACT:
UI_DECREMENT_BY(AxisPosition_mm, (float)screen.filament_length, extruder);
break;
case DGUS_Data::FilamentMove::EXTRUDE:
UI_INCREMENT_BY(AxisPosition_mm, (float)screen.filament_length, extruder);
break;
}
}
void DGUSRxHandler::home(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
DGUS_Data::Axis axis = (DGUS_Data::Axis)((uint8_t*)data_ptr)[1];
screen.showWaitScreen(GET_TEXT_F(DGUS_MSG_HOMING), screen.getCurrentScreen());
switch (axis) {
case DGUS_Data::Axis::X_Y_Z:
queue.enqueue_now(F("G28XYZ"));
break;
case DGUS_Data::Axis::X_Y:
queue.enqueue_now(F("G28XY"));
break;
case DGUS_Data::Axis::Z:
queue.enqueue_now(F("G28Z"));
break;
}
}
void DGUSRxHandler::move(DGUS_VP &vp, void *data_ptr) {
const int16_t data = BE16_P(data_ptr);
const float position = dgus.fromFixedPoint<int16_t, float, 1>(data);
ExtUI::axis_t axis;
switch (vp.addr) {
default: return;
case DGUS_Addr::MOVE_SetX: axis = ExtUI::X; break;
case DGUS_Addr::MOVE_SetY: axis = ExtUI::Y; break;
case DGUS_Addr::MOVE_SetZ: axis = ExtUI::Z; break;
}
if (TERN0(NO_MOTION_BEFORE_HOMING, !ExtUI::isAxisPositionKnown(axis))) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_HOMING_REQUIRED));
return;
}
ExtUI::setAxisPosition_mm(position, axis);
screen.triggerFullUpdate();
}
void DGUSRxHandler::moveStep(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
float offset;
switch (screen.move_steps) {
default: return;
case DGUS_Data::StepSize::MM10: offset = 10.0f; break;
case DGUS_Data::StepSize::MM1: offset = 1.0f; break;
case DGUS_Data::StepSize::MMP1: offset = 0.1f; break;
}
const DGUS_Data::MoveDirection direction = (DGUS_Data::MoveDirection)((uint8_t*)data_ptr)[1];
ExtUI::axis_t axis;
switch (direction) {
default: return;
case DGUS_Data::MoveDirection::XM: offset = -offset;
case DGUS_Data::MoveDirection::XP: axis = ExtUI::X; break;
case DGUS_Data::MoveDirection::YM: offset = -offset;
case DGUS_Data::MoveDirection::YP: axis = ExtUI::Y; break;
case DGUS_Data::MoveDirection::ZM: offset = -offset;
case DGUS_Data::MoveDirection::ZP: axis = ExtUI::Z; break;
}
if (TERN0(NO_MOTION_BEFORE_HOMING, !ExtUI::isAxisPositionKnown(axis))) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_HOMING_REQUIRED));
return;
}
UI_INCREMENT_BY(AxisPosition_mm, offset, axis);
screen.triggerFullUpdate();
}
void DGUSRxHandler::moveSetStep(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::StepSize size = (DGUS_Data::StepSize)((uint8_t*)data_ptr)[1];
screen.move_steps = size;
screen.triggerFullUpdate();
}
void DGUSRxHandler::gcodeClear(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
ZERO(screen.gcode);
screen.triggerFullUpdate();
}
void DGUSRxHandler::gcodeExecute(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
if (!strlen(screen.gcode)) return;
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
screen.showWaitScreen(GET_TEXT_F(DGUS_MSG_EXECUTING_COMMAND), DGUS_ScreenID::GCODE);
queue.enqueue_one_now(screen.gcode);
}
void DGUSRxHandler::resetEEPROM(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) return;
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
queue.enqueue_now(F("M502"));
queue.enqueue_now(F("M500"));
}
void DGUSRxHandler::settingsExtra(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Extra extra = (DGUS_Data::Extra)((uint8_t*)data_ptr)[1];
switch (extra) {
default: return;
case DGUS_Data::Extra::BUTTON1:
#if ENABLED(BLTOUCH)
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
queue.enqueue_now(F(DGUS_RESET_BLTOUCH));
#else
screen.triggerScreenChange(DGUS_ScreenID::INFOS);
#endif
break;
#if ENABLED(BLTOUCH)
case DGUS_Data::Extra::BUTTON2:
screen.triggerScreenChange(DGUS_ScreenID::INFOS);
break;
#endif
}
}
void DGUSRxHandler::pidSelect(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Heater heater = (DGUS_Data::Heater)BE16_P(data_ptr);
switch (heater) {
default: return;
case DGUS_Data::Heater::BED:
screen.pid_temp = DGUS_PLA_TEMP_BED;
screen.pid_heater = heater;
break;
case DGUS_Data::Heater::H0:
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
#endif
screen.pid_temp = DGUS_PLA_TEMP_HOTEND;
screen.pid_heater = heater;
break;
}
screen.pid_cycles = 5;
screen.triggerFullUpdate();
}
void DGUSRxHandler::pidSetTemp(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
uint16_t temp = BE16_P(data_ptr);
switch (screen.pid_heater) {
default: return;
#if HAS_HEATED_BED
case DGUS_Data::Heater::BED:
LIMIT(temp, BED_MINTEMP, BED_MAX_TARGET);
break;
#endif
#if HAS_HOTEND
case DGUS_Data::Heater::H0:
LIMIT(temp, celsius_t(HEATER_0_MINTEMP), thermalManager.hotend_max_target(0));
break;
#endif
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
LIMIT(temp, celsius_t(HEATER_1_MINTEMP), thermalManager.hotend_max_target(0));
break;
#endif
}
screen.pid_temp = temp;
screen.triggerFullUpdate();
}
void DGUSRxHandler::pidRun(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
heater_id_t heater;
uint8_t cycles = constrain(screen.pid_cycles, 3, 10);
switch (screen.pid_heater) {
default: return;
case DGUS_Data::Heater::BED:
#if ENABLED(PIDTEMPBED)
heater = H_BED;
break;
#else
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BED_PID_DISABLED));
return;
#endif
case DGUS_Data::Heater::H0:
#if ENABLED(PIDTEMP)
heater = H_E0;
break;
#else
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_PID_DISABLED));
return;
#endif
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
#if ENABLED(PIDTEMP)
heater = H_E1;
break;
#else
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_PID_DISABLED));
return;
#endif
#endif
}
char buffer[24];
snprintf_P(buffer, sizeof(buffer), PSTR("M303C%dE%dS%dU1"), cycles, heater, screen.pid_temp);
screen.showWaitScreen(GET_TEXT_F(DGUS_MSG_PID_AUTOTUNING), DGUS_ScreenID::PID);
queue.enqueue_one_now(buffer);
queue.enqueue_now(F("M500"));
}
#if ENABLED(POWER_LOSS_RECOVERY)
void DGUSRxHandler::powerLossAbort(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) {
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
screen.triggerScreenChange(DGUS_ScreenID::HOME);
queue.enqueue_now(F("M1000C"));
}
void DGUSRxHandler::powerLossResume(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) {
return;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return;
}
if (!recovery.valid()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_INVALID_RECOVERY_DATA));
return;
}
screen.triggerScreenChange(DGUS_ScreenID::PRINT_STATUS);
queue.enqueue_now(F("M1000"));
}
#endif // POWER_LOSS_RECOVERY
void DGUSRxHandler::waitAbort(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
const DGUS_Data::Popup result = (DGUS_Data::Popup)((uint8_t*)data_ptr)[1];
if (result != DGUS_Data::Popup::CONFIRMED) {
return;
}
if (!ExtUI::isPrintingPaused()) {
screen.triggerFullUpdate();
return;
}
ExtUI::stopPrint();
screen.triggerFullUpdate();
}
void DGUSRxHandler::waitContinue(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
ExtUI::setUserConfirmed();
screen.triggerFullUpdate();
}
void DGUSRxHandler::fanSpeed(DGUS_VP &vp, void *data_ptr) {
uint8_t speed = ((uint8_t*)data_ptr)[1];
switch (vp.addr) {
default: return;
case DGUS_Addr::FAN0_Speed:
ExtUI::setTargetFan_percent(speed, ExtUI::FAN0);
break;
}
}
void DGUSRxHandler::volume(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
uint8_t volume = ((uint8_t*)data_ptr)[1];
dgus.setVolume(volume);
screen.triggerEEPROMSave();
}
void DGUSRxHandler::brightness(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
uint8_t brightness = ((uint8_t*)data_ptr)[1];
dgus.setBrightness(brightness);
screen.triggerEEPROMSave();
}
void DGUSRxHandler::debug(DGUS_VP &vp, void *data_ptr) {
UNUSED(vp);
UNUSED(data_ptr);
++screen.debug_count;
if (screen.debug_count >= 10) {
screen.triggerScreenChange(DGUS_ScreenID::DEBUG);
}
}
void DGUSRxHandler::stringToExtra(DGUS_VP &vp, void *data_ptr) {
if (!vp.size || !vp.extra) return;
memcpy(vp.extra, data_ptr, vp.size);
}
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp
|
C++
|
agpl-3.0
| 25,362
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "DGUSDisplay.h"
#include "definition/DGUS_VP.h"
namespace DGUSRxHandler {
void screenChange(DGUS_VP &, void *);
#if HAS_MEDIA
void scroll(DGUS_VP &, void *);
void selectFile(DGUS_VP &, void *);
void printFile(DGUS_VP &, void *);
#endif
void printAbort(DGUS_VP &, void *);
void printPause(DGUS_VP &, void *);
void printResume(DGUS_VP &, void *);
void feedrate(DGUS_VP &, void *);
void flowrate(DGUS_VP &, void *);
void babystepSet(DGUS_VP &, void *);
void babystep(DGUS_VP &, void *);
void tempPreset(DGUS_VP &, void *);
void tempTarget(DGUS_VP &, void *);
void tempCool(DGUS_VP &, void *);
void steppers(DGUS_VP &, void *);
void zOffset(DGUS_VP &, void *);
void zOffsetStep(DGUS_VP &, void *);
void zOffsetSetStep(DGUS_VP &, void *);
void moveToPoint(DGUS_VP &, void *);
void probe(DGUS_VP &, void *);
void disableABL(DGUS_VP &, void *);
void filamentSelect(DGUS_VP &, void *);
void filamentLength(DGUS_VP &, void *);
void filamentMove(DGUS_VP &, void *);
void home(DGUS_VP &, void *);
void move(DGUS_VP &, void *);
void moveStep(DGUS_VP &, void *);
void moveSetStep(DGUS_VP &, void *);
void gcodeClear(DGUS_VP &, void *);
void gcodeExecute(DGUS_VP &, void *);
void resetEEPROM(DGUS_VP &, void *);
void settingsExtra(DGUS_VP &, void *);
void pidSelect(DGUS_VP &, void *);
void pidSetTemp(DGUS_VP &, void *);
void pidRun(DGUS_VP &, void *);
#if ENABLED(POWER_LOSS_RECOVERY)
void powerLossAbort(DGUS_VP &, void *);
void powerLossResume(DGUS_VP &, void *);
#endif
void waitAbort(DGUS_VP &, void *);
void waitContinue(DGUS_VP &, void *);
void fanSpeed(DGUS_VP &, void *);
void volume(DGUS_VP &, void *);
void brightness(DGUS_VP &, void *);
void debug(DGUS_VP &, void *);
void stringToExtra(DGUS_VP &, void *);
template<typename T>
void integerToExtra(DGUS_VP &vp, void *data_ptr) {
if (!vp.size || !vp.extra) return;
switch (vp.size) {
default: return;
case 1: {
const uint8_t data = *(uint8_t*)data_ptr;
*(T*)vp.extra = (T)data;
break;
}
case 2: {
const uint16_t data = BE16_P(data_ptr);
*(T*)vp.extra = (T)data;
break;
}
case 4: {
const uint32_t data = dgus.swapBytes(*(uint32_t*)data_ptr);
*(T*)vp.extra = (T)data;
break;
}
}
}
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.h
|
C++
|
agpl-3.0
| 3,277
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUSScreenHandler.h"
#include "DGUSDisplay.h"
#include "definition/DGUS_ScreenAddrList.h"
#include "definition/DGUS_ScreenSetup.h"
#include "../../../gcode/queue.h"
uint8_t DGUSScreenHandler::debug_count = 0;
#if HAS_MEDIA
ExtUI::FileList DGUSScreenHandler::filelist;
uint16_t DGUSScreenHandler::filelist_offset = 0;
int16_t DGUSScreenHandler::filelist_selected = -1;
#endif
DGUS_Data::StepSize DGUSScreenHandler::offset_steps = DGUS_Data::StepSize::MMP1;
DGUS_Data::StepSize DGUSScreenHandler::move_steps = DGUS_Data::StepSize::MM10;
uint16_t DGUSScreenHandler::probing_icons[] = { 0, 0 };
DGUS_Data::Extruder DGUSScreenHandler::filament_extruder = DGUS_Data::Extruder::CURRENT;
uint16_t DGUSScreenHandler::filament_length = DGUS_DEFAULT_FILAMENT_LEN;
char DGUSScreenHandler::gcode[] = "";
DGUS_Data::Heater DGUSScreenHandler::pid_heater = DGUS_Data::Heater::H0;
celsius_t DGUSScreenHandler::pid_temp = DGUS_PLA_TEMP_HOTEND;
uint8_t DGUSScreenHandler::pid_cycles = 5;
bool DGUSScreenHandler::settings_ready = false;
bool DGUSScreenHandler::booted = false;
DGUS_ScreenID DGUSScreenHandler::current_screenID = DGUS_ScreenID::BOOT;
DGUS_ScreenID DGUSScreenHandler::new_screenID = DGUS_ScreenID::BOOT;
bool DGUSScreenHandler::full_update = false;
DGUS_ScreenID DGUSScreenHandler::wait_return_screenID = DGUS_ScreenID::HOME;
bool DGUSScreenHandler::wait_continue = false;
bool DGUSScreenHandler::leveling_active = false;
millis_t DGUSScreenHandler::status_expire = 0;
millis_t DGUSScreenHandler::eeprom_save = 0;
void DGUSScreenHandler::init() {
dgus.init();
moveToScreen(DGUS_ScreenID::BOOT, true);
}
void DGUSScreenHandler::ready() {
dgus.playSound(1);
}
void DGUSScreenHandler::loop() {
if (!settings_ready || current_screenID == DGUS_ScreenID::KILL)
return;
const millis_t ms = ExtUI::safe_millis();
static millis_t next_event_ms = 0;
if (new_screenID != DGUS_ScreenID::BOOT) {
const DGUS_ScreenID screenID = new_screenID;
new_screenID = DGUS_ScreenID::BOOT;
if (current_screenID == screenID)
triggerFullUpdate();
else
moveToScreen(screenID);
return;
}
if (!booted && ELAPSED(ms, 3000)) {
booted = true;
dgus.readVersions();
if (current_screenID == DGUS_ScreenID::BOOT)
moveToScreen(DGUS_ScreenID::HOME);
return;
}
if (ELAPSED(ms, next_event_ms) || full_update) {
next_event_ms = ms + DGUS_UPDATE_INTERVAL_MS;
if (!sendScreenVPData(current_screenID, full_update))
DEBUG_ECHOLNPGM("sendScreenVPData failed");
return;
}
if (current_screenID == DGUS_ScreenID::WAIT
&& ((wait_continue && !wait_for_user) || (!wait_continue && isPrinterIdle()))
) {
moveToScreen(wait_return_screenID, true);
return;
}
if (current_screenID == DGUS_ScreenID::LEVELING_PROBING && isPrinterIdle()) {
dgus.playSound(3);
setStatusMessage(ExtUI::getLevelingIsValid() ? GET_TEXT_F(DGUS_MSG_PROBING_SUCCESS) : GET_TEXT_F(DGUS_MSG_PROBING_FAILED));
moveToScreen(DGUS_ScreenID::LEVELING_AUTOMATIC);
return;
}
if (status_expire > 0 && ELAPSED(ms, status_expire)) {
setStatusMessage(FPSTR(NUL_STR), 0);
return;
}
if (eeprom_save > 0 && ELAPSED(ms, eeprom_save) && isPrinterIdle()) {
eeprom_save = 0;
queue.enqueue_now(F("M500"));
return;
}
dgus.loop();
}
void DGUSScreenHandler::printerKilled(FSTR_P const error, FSTR_P const component) {
setMessageLine(error, 1);
setMessageLine(component, 2);
setMessageLinePGM(NUL_STR, 3);
setMessageLine(GET_TEXT_F(MSG_PLEASE_RESET), 4);
dgus.playSound(3, 1, 200);
moveToScreen(DGUS_ScreenID::KILL, true);
}
void DGUSScreenHandler::userConfirmRequired(const char * const msg) {
setMessageLinePGM(NUL_STR, 1);
setMessageLine(msg, 2);
setMessageLinePGM(NUL_STR, 3);
setMessageLinePGM(NUL_STR, 4);
dgus.playSound(3);
showWaitScreen(current_screenID, true);
}
void DGUSScreenHandler::settingsReset() {
dgus.setVolume(DGUS_DEFAULT_VOLUME);
dgus.setBrightness(DGUS_DEFAULT_BRIGHTNESS);
if (!settings_ready) {
settings_ready = true;
ready();
}
setStatusMessage(GET_TEXT_F(DGUS_MSG_RESET_EEPROM));
}
void DGUSScreenHandler::storeSettings(char *buff) {
eeprom_data_t data;
static_assert(sizeof(data) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size.");
data.initialized = true;
data.volume = dgus.getVolume();
data.brightness = dgus.getBrightness();
data.abl_okay = (ExtUI::getLevelingActive() && ExtUI::getLevelingIsValid());
memcpy(buff, &data, sizeof(data));
}
void DGUSScreenHandler::loadSettings(const char *buff) {
eeprom_data_t data;
static_assert(sizeof(data) <= ExtUI::eeprom_data_size, "sizeof(eeprom_data_t) > eeprom_data_size.");
memcpy(&data, buff, sizeof(data));
dgus.setVolume(data.initialized ? data.volume : DGUS_DEFAULT_VOLUME);
dgus.setBrightness(data.initialized ? data.brightness : DGUS_DEFAULT_BRIGHTNESS);
if (data.initialized) {
leveling_active = (data.abl_okay && ExtUI::getLevelingIsValid());
ExtUI::setLevelingActive(leveling_active);
}
}
void DGUSScreenHandler::configurationStoreWritten(bool success) {
if (!success)
setStatusMessage(GET_TEXT_F(DGUS_MSG_WRITE_EEPROM_FAILED));
}
void DGUSScreenHandler::configurationStoreRead(bool success) {
if (!success) {
setStatusMessage(GET_TEXT_F(DGUS_MSG_READ_EEPROM_FAILED));
}
else if (!settings_ready) {
settings_ready = true;
ready();
}
}
void DGUSScreenHandler::playTone(const uint16_t frequency, const uint16_t duration/*=0*/) {
if (WITHIN(frequency, 1, 255)) {
if (WITHIN(duration, 1, 255))
dgus.playSound((uint8_t)frequency, (uint8_t)duration);
else
dgus.playSound((uint8_t)frequency);
}
}
void DGUSScreenHandler::meshUpdate(const int8_t xpos, const int8_t ypos) {
if (current_screenID != DGUS_ScreenID::LEVELING_PROBING) {
if (current_screenID == DGUS_ScreenID::LEVELING_AUTOMATIC)
triggerFullUpdate();
return;
}
uint8_t point = ypos * GRID_MAX_POINTS_X + xpos;
probing_icons[point < 16 ? 0 : 1] |= (1U << (point % 16));
if (xpos >= GRID_MAX_POINTS_X - 1 && ypos >= GRID_MAX_POINTS_Y - 1 && !ExtUI::getLevelingIsValid())
probing_icons[0] = probing_icons[1] = 0;
triggerFullUpdate();
}
void DGUSScreenHandler::printTimerStarted() {
triggerScreenChange(DGUS_ScreenID::PRINT_STATUS);
}
void DGUSScreenHandler::printTimerPaused() {
dgus.playSound(3);
triggerFullUpdate();
}
void DGUSScreenHandler::printTimerStopped() {
if (current_screenID != DGUS_ScreenID::PRINT_STATUS && current_screenID != DGUS_ScreenID::PRINT_ADJUST)
return;
dgus.playSound(3);
triggerScreenChange(DGUS_ScreenID::PRINT_FINISHED);
}
void DGUSScreenHandler::filamentRunout(const ExtUI::extruder_t extruder) {
char buffer[21];
snprintf_P(buffer, sizeof(buffer), GET_TEXT(DGUS_MSG_FILAMENT_RUNOUT), extruder);
setStatusMessage(buffer);
dgus.playSound(3);
}
#if HAS_MEDIA
void DGUSScreenHandler::sdCardInserted() {
if (current_screenID == DGUS_ScreenID::HOME)
triggerScreenChange(DGUS_ScreenID::PRINT);
}
void DGUSScreenHandler::sdCardRemoved() {
if (current_screenID == DGUS_ScreenID::PRINT)
triggerScreenChange(DGUS_ScreenID::HOME);
}
void DGUSScreenHandler::sdCardError() {
setStatusMessage(GET_TEXT_F(MSG_MEDIA_READ_ERROR));
if (current_screenID == DGUS_ScreenID::PRINT)
triggerScreenChange(DGUS_ScreenID::HOME);
}
#endif // HAS_MEDIA
#if ENABLED(POWER_LOSS_RECOVERY)
void DGUSScreenHandler::powerLossResume() {
moveToScreen(DGUS_ScreenID::POWERLOSS, true);
}
#endif
#if HAS_PID_HEATING
void DGUSScreenHandler::pidTuning(const ExtUI::pidresult_t rst) {
switch (rst) {
case ExtUI::PID_STARTED:
case ExtUI::PID_BED_STARTED:
case ExtUI::PID_CHAMBER_STARTED:
setStatusMessage(GET_TEXT_F(MSG_PID_AUTOTUNE));
break;
case ExtUI::PID_BAD_HEATER_ID:
setStatusMessage(GET_TEXT_F(MSG_PID_BAD_HEATER_ID));
break;
case ExtUI::PID_TEMP_TOO_HIGH:
setStatusMessage(GET_TEXT_F(MSG_PID_TEMP_TOO_HIGH));
break;
case ExtUI::PID_TUNING_TIMEOUT:
setStatusMessage(GET_TEXT_F(MSG_PID_TIMEOUT));
break;
case ExtUI::PID_DONE:
setStatusMessage(GET_TEXT_F(MSG_PID_AUTOTUNE_DONE));
break;
default:
return;
}
dgus.playSound(3);
}
#endif // HAS_PID_HEATING
void DGUSScreenHandler::setMessageLine(const char * const msg, const uint8_t line) {
switch (line) {
default: return;
case 1:
dgus.writeString((uint16_t)DGUS_Addr::MESSAGE_Line1, msg, DGUS_LINE_LEN, true, true);
break;
case 2:
dgus.writeString((uint16_t)DGUS_Addr::MESSAGE_Line2, msg, DGUS_LINE_LEN, true, true);
break;
case 3:
dgus.writeString((uint16_t)DGUS_Addr::MESSAGE_Line3, msg, DGUS_LINE_LEN, true, true);
break;
case 4:
dgus.writeString((uint16_t)DGUS_Addr::MESSAGE_Line4, msg, DGUS_LINE_LEN, true, true);
break;
}
}
void DGUSScreenHandler::setMessageLinePGM(PGM_P const msg, const uint8_t line) {
switch (line) {
default: return;
case 1:
dgus.writeStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line1, msg, DGUS_LINE_LEN, true, true);
break;
case 2:
dgus.writeStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line2, msg, DGUS_LINE_LEN, true, true);
break;
case 3:
dgus.writeStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line3, msg, DGUS_LINE_LEN, true, true);
break;
case 4:
dgus.writeStringPGM((uint16_t)DGUS_Addr::MESSAGE_Line4, msg, DGUS_LINE_LEN, true, true);
break;
}
}
void DGUSScreenHandler::setStatusMessage(const char* msg, const millis_t duration) {
dgus.writeString((uint16_t)DGUS_Addr::MESSAGE_Status, msg, DGUS_STATUS_LEN, false, true);
status_expire = (duration > 0 ? ExtUI::safe_millis() + duration : 0);
}
void DGUSScreenHandler::setStatusMessage(FSTR_P const fmsg, const millis_t duration) {
dgus.writeString((uint16_t)DGUS_Addr::MESSAGE_Status, fmsg, DGUS_STATUS_LEN, false, true);
status_expire = (duration > 0 ? ExtUI::safe_millis() + duration : 0);
}
void DGUSScreenHandler::showWaitScreen(const DGUS_ScreenID return_screenID, const bool has_continue/*=false*/) {
if (return_screenID != DGUS_ScreenID::WAIT)
wait_return_screenID = return_screenID;
wait_continue = has_continue;
triggerScreenChange(DGUS_ScreenID::WAIT);
}
void DGUSScreenHandler::showWaitScreen(FSTR_P const msg, const DGUS_ScreenID return_screenID, const bool has_continue/*=false*/) {
setMessageLinePGM(NUL_STR, 1);
setMessageLine(msg, 2);
setMessageLinePGM(NUL_STR, 3);
setMessageLinePGM(NUL_STR, 4);
showWaitScreen(return_screenID, has_continue);
}
DGUS_ScreenID DGUSScreenHandler::getCurrentScreen() {
return current_screenID;
}
void DGUSScreenHandler::triggerScreenChange(const DGUS_ScreenID screenID) {
new_screenID = screenID;
}
void DGUSScreenHandler::triggerFullUpdate() {
full_update = true;
}
void DGUSScreenHandler::triggerEEPROMSave() {
eeprom_save = ExtUI::safe_millis() + 500;
}
bool DGUSScreenHandler::isPrinterIdle() {
return (!ExtUI::commandsInQueue() && !ExtUI::isMoving());
}
const DGUS_Addr* DGUSScreenHandler::findScreenAddrList(const DGUS_ScreenID screenID) {
DGUS_ScreenAddrList list;
const DGUS_ScreenAddrList *map = screen_addr_list_map;
do {
memcpy_P(&list, map, sizeof(*map));
if (!list.addr_list) break;
if (list.screenID == screenID) return list.addr_list;
} while (++map);
return nullptr;
}
bool DGUSScreenHandler::callScreenSetup(const DGUS_ScreenID screenID) {
DGUS_ScreenSetup setup;
const DGUS_ScreenSetup *list = screen_setup_list;
do {
memcpy_P(&setup, list, sizeof(*list));
if (!setup.setup_fn) break;
if (setup.screenID == screenID) {
return setup.setup_fn();
}
} while (++list);
return true;
}
void DGUSScreenHandler::moveToScreen(const DGUS_ScreenID screenID, bool abort_wait) {
if (current_screenID == DGUS_ScreenID::KILL) return;
if (current_screenID == DGUS_ScreenID::WAIT) {
if (screenID != DGUS_ScreenID::WAIT)
wait_return_screenID = screenID;
if (!abort_wait) return;
if (wait_continue && wait_for_user)
ExtUI::setUserConfirmed();
}
if (!callScreenSetup(screenID)) return;
if (!sendScreenVPData(screenID, true)) return;
current_screenID = screenID;
dgus.switchScreen(current_screenID);
}
bool DGUSScreenHandler::sendScreenVPData(const DGUS_ScreenID screenID, bool complete_update) {
if (complete_update) full_update = false;
const DGUS_Addr *list = findScreenAddrList(screenID);
while (true) {
if (!list) return true; // Nothing left to send
const uint16_t addr = pgm_read_word(list++);
if (!addr) return true; // Nothing left to send
DGUS_VP vp;
if (!populateVP((DGUS_Addr)addr, &vp)) continue; // Invalid VP
if (!vp.tx_handler) continue; // Nothing to send
if (!complete_update && !(vp.flags & VPFLAG_AUTOUPLOAD)) continue; // Unnecessary VP
uint8_t expected_tx = 6 + vp.size; // 6 bytes header + payload.
const millis_t try_until = ExtUI::safe_millis() + 1000;
while (expected_tx > dgus.getFreeTxBuffer()) {
if (ELAPSED(ExtUI::safe_millis(), try_until)) return false; // Stop trying after 1 second
dgus.flushTx(); // Flush the TX buffer
delay(50);
}
vp.tx_handler(vp);
}
}
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.cpp
|
C++
|
agpl-3.0
| 14,381
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "config/DGUS_Addr.h"
#include "config/DGUS_Data.h"
#include "config/DGUS_ScreenID.h"
#include "config/DGUS_Constants.h"
#include "../ui_api.h"
#include "../../../inc/MarlinConfigPre.h"
class DGUSScreenHandler {
public:
DGUSScreenHandler() = default;
static void init();
static void ready();
static void loop();
static void printerKilled(FSTR_P const error, FSTR_P const component);
static void userConfirmRequired(const char * const msg);
static void settingsReset();
static void storeSettings(char *buff);
static void loadSettings(const char *buff);
static void configurationStoreWritten(bool success);
static void configurationStoreRead(bool success);
static void playTone(const uint16_t frequency, const uint16_t duration=0);
static void meshUpdate(const int8_t xpos, const int8_t ypos);
static void printTimerStarted();
static void printTimerPaused();
static void printTimerStopped();
static void filamentRunout(const ExtUI::extruder_t extruder);
#if HAS_MEDIA
/// Marlin informed us that a new SD has been inserted.
static void sdCardInserted();
/// Marlin informed us that the SD Card has been removed().
static void sdCardRemoved();
/// Marlin informed us about a bad SD Card.
static void sdCardError();
#endif
#if ENABLED(POWER_LOSS_RECOVERY)
static void powerLossResume();
#endif
#if HAS_PID_HEATING
static void pidTuning(const ExtUI::pidresult_t rst);
#endif
static void setMessageLine(const char * const msg, const uint8_t line);
static void setMessageLinePGM(PGM_P const msg, const uint8_t line);
static void setMessageLine(FSTR_P const msg, const uint8_t line) { setMessageLinePGM(FTOP(msg), line); }
static void setStatusMessage(const char* msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS);
static void setStatusMessage(FSTR_P const msg, const millis_t duration=DGUS_STATUS_EXPIRATION_MS);
static void showWaitScreen(const DGUS_ScreenID return_screenID, const bool has_continue=false);
static void showWaitScreen(FSTR_P const msg, const DGUS_ScreenID return_screenID, const bool has_continue=false);
static DGUS_ScreenID getCurrentScreen();
static void triggerScreenChange(const DGUS_ScreenID screenID);
static void triggerFullUpdate();
static void triggerEEPROMSave();
static bool isPrinterIdle();
static uint8_t debug_count;
#if HAS_MEDIA
static ExtUI::FileList filelist;
static uint16_t filelist_offset;
static int16_t filelist_selected;
#endif
static DGUS_Data::StepSize offset_steps;
static DGUS_Data::StepSize move_steps;
static uint16_t probing_icons[2];
static DGUS_Data::Extruder filament_extruder;
static uint16_t filament_length;
static char gcode[DGUS_GCODE_LEN + 1];
static DGUS_Data::Heater pid_heater;
static celsius_t pid_temp;
static uint8_t pid_cycles;
static bool wait_continue;
static bool leveling_active;
private:
static const DGUS_Addr* findScreenAddrList(const DGUS_ScreenID screenID);
static bool callScreenSetup(const DGUS_ScreenID screenID);
static void moveToScreen(const DGUS_ScreenID screenID, bool abort_wait=false);
static bool sendScreenVPData(const DGUS_ScreenID screenID, bool complete_update);
static bool settings_ready;
static bool booted;
static DGUS_ScreenID current_screenID;
static DGUS_ScreenID new_screenID;
static bool full_update;
static DGUS_ScreenID wait_return_screenID;
static millis_t status_expire;
static millis_t eeprom_save;
typedef struct {
bool initialized;
uint8_t volume;
uint8_t brightness;
bool abl_okay;
} eeprom_data_t;
};
extern DGUSScreenHandler screen;
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSScreenHandler.h
|
C++
|
agpl-3.0
| 4,542
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUSSetupHandler.h"
#include "DGUSDisplay.h"
#include "DGUSScreenHandler.h"
#include "../../../gcode/queue.h"
#if HAS_MEDIA
bool DGUSSetupHandler::print() {
screen.filelist.refresh();
while (!screen.filelist.isAtRootDir()) {
screen.filelist.upDir();
}
screen.filelist_offset = 0;
screen.filelist_selected = -1;
return true;
}
#endif
bool DGUSSetupHandler::printStatus() {
if (ExtUI::isPrinting() || ExtUI::isPrintingPaused()) {
return true;
}
screen.triggerScreenChange(DGUS_ScreenID::PRINT_FINISHED);
return false;
}
bool DGUSSetupHandler::printAdjust() {
if (ExtUI::isPrinting() || ExtUI::isPrintingPaused()) {
return true;
}
screen.triggerScreenChange(DGUS_ScreenID::PRINT_FINISHED);
return false;
}
bool DGUSSetupHandler::levelingMenu() {
ExtUI::setLevelingActive(screen.leveling_active);
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return false;
}
if (ExtUI::isPositionKnown()) {
if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 10.0f) {
queue.enqueue_now(F("G0Z10"));
}
return true;
}
screen.showWaitScreen(GET_TEXT_F(DGUS_MSG_HOMING), DGUS_ScreenID::LEVELING_MENU);
queue.enqueue_now(F("G28"));
return false;
}
bool DGUSSetupHandler::levelingManual() {
ExtUI::setLevelingActive(false);
if (ExtUI::isPositionKnown()) {
return true;
}
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return false;
}
screen.showWaitScreen(GET_TEXT_F(DGUS_MSG_HOMING), DGUS_ScreenID::LEVELING_MANUAL);
queue.enqueue_now(F("G28"));
return false;
}
bool DGUSSetupHandler::levelingOffset() {
screen.offset_steps = DGUS_Data::StepSize::MMP1;
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return false;
}
if (ExtUI::isPositionKnown()) {
if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 4.0f) {
queue.enqueue_now(F("G0Z4"));
}
char buffer[20];
snprintf_P(buffer, sizeof(buffer), PSTR("G0X%dY%d"), DGUS_LEVEL_CENTER_X, DGUS_LEVEL_CENTER_Y);
queue.enqueue_one_now(buffer);
queue.enqueue_now(F("G0Z0"));
return true;
}
screen.showWaitScreen(GET_TEXT_F(DGUS_MSG_HOMING), DGUS_ScreenID::LEVELING_OFFSET);
queue.enqueue_now(F("G28"));
return false;
}
bool DGUSSetupHandler::levelingAutomatic() {
if (ExtUI::getLevelingIsValid()) {
screen.leveling_active = true;
ExtUI::setLevelingActive(true);
}
return true;
}
bool DGUSSetupHandler::levelingProbing() {
screen.probing_icons[0] = 0;
screen.probing_icons[1] = 0;
return true;
}
bool DGUSSetupHandler::filament() {
screen.filament_extruder = DGUS_Data::Extruder::CURRENT;
screen.filament_length = DGUS_DEFAULT_FILAMENT_LEN;
return true;
}
bool DGUSSetupHandler::move() {
screen.move_steps = DGUS_Data::StepSize::MM10;
if (!screen.isPrinterIdle()) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_BUSY));
return false;
}
return true;
}
bool DGUSSetupHandler::gcode() {
ZERO(screen.gcode);
if (dgus.gui_version < 0x30 || dgus.os_version < 0x21) {
screen.setStatusMessage(GET_TEXT_F(DGUS_MSG_FW_OUTDATED));
return false;
}
return true;
}
bool DGUSSetupHandler::pid() {
screen.pid_heater = DGUS_Data::Heater::H0;
screen.pid_temp = DGUS_PLA_TEMP_HOTEND;
return true;
}
bool DGUSSetupHandler::infos() {
screen.debug_count = 0;
return true;
}
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.cpp
|
C++
|
agpl-3.0
| 4,429
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
namespace DGUSSetupHandler {
#if HAS_MEDIA
bool print();
#endif
bool printStatus();
bool printAdjust();
bool levelingMenu();
bool levelingOffset();
bool levelingManual();
bool levelingAutomatic();
bool levelingProbing();
bool filament();
bool move();
bool gcode();
bool pid();
bool infos();
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.h
|
C++
|
agpl-3.0
| 1,203
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUSTxHandler.h"
#include "DGUSScreenHandler.h"
#include "config/DGUS_Data.h"
#include "../ui_api.h"
#include "../../../module/stepper.h"
#include "../../../module/temperature.h"
#include "../../../module/printcounter.h"
#if ENABLED(ADVANCED_PAUSE_FEATURE)
#include "../../../feature/pause.h"
#endif
#if HAS_MEDIA
void DGUSTxHandler::setFileControlState(int16_t file, bool state) {
DGUS_Control control;
switch (file) {
default: return;
case 0:
control = DGUS_Control::FILE0;
break;
case 1:
control = DGUS_Control::FILE1;
break;
case 2:
control = DGUS_Control::FILE2;
break;
case 3:
control = DGUS_Control::FILE3;
break;
case 4:
control = DGUS_Control::FILE4;
break;
}
if (state) {
dgus.enableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
control);
}
else {
dgus.disableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
control);
}
}
void DGUSTxHandler::fileType(DGUS_VP &vp) {
// Batch send
uint16_t data[DGUS_FILE_COUNT];
for (int16_t i = 0; i < DGUS_FILE_COUNT; i++) {
if (!screen.filelist.seek(screen.filelist_offset + i)) {
data[i] = Swap16(DGUS_Data::SDType::NONE);
setFileControlState(i, false);
continue;
}
data[i] = screen.filelist.isDir() ?
Swap16(DGUS_Data::SDType::DIRECTORY)
: Swap16(DGUS_Data::SDType::FILE);
setFileControlState(i, true);
}
dgus.write((uint16_t)vp.addr, data, sizeof(*data) * DGUS_FILE_COUNT);
}
void DGUSTxHandler::fileName(DGUS_VP &vp) {
uint8_t offset;
switch (vp.addr) {
default: return;
case DGUS_Addr::SD_FileName0:
offset = 0;
break;
case DGUS_Addr::SD_FileName1:
offset = 1;
break;
case DGUS_Addr::SD_FileName2:
offset = 2;
break;
case DGUS_Addr::SD_FileName3:
offset = 3;
break;
case DGUS_Addr::SD_FileName4:
offset = 4;
break;
}
if (screen.filelist.seek(screen.filelist_offset + offset)) {
dgus.writeString((uint16_t)vp.addr, screen.filelist.filename(), vp.size);
}
else {
dgus.writeStringPGM((uint16_t)vp.addr, NUL_STR, vp.size);
}
}
void DGUSTxHandler::scrollIcons(DGUS_VP &vp) {
uint16_t icons = 0;
if (!screen.filelist.isAtRootDir()) {
icons |= (uint16_t)DGUS_Data::ScrollIcon::GO_BACK;
dgus.enableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::GO_BACK);
}
else {
dgus.disableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::GO_BACK);
}
if (screen.filelist_offset > 0) {
icons |= (uint16_t)DGUS_Data::ScrollIcon::UP;
dgus.enableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::SCROLL_UP);
}
else {
dgus.disableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::SCROLL_UP);
}
if (screen.filelist_offset + DGUS_FILE_COUNT < screen.filelist.count()) {
icons |= (uint16_t)DGUS_Data::ScrollIcon::DOWN;
dgus.enableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::SCROLL_DOWN);
}
else {
dgus.disableControl(DGUS_ScreenID::PRINT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::SCROLL_DOWN);
}
dgus.write((uint16_t)vp.addr, Swap16(icons));
}
void DGUSTxHandler::selectedFileName(DGUS_VP &vp) {
if (screen.filelist_selected < 0
|| !screen.filelist.seek(screen.filelist_selected)) {
dgus.writeStringPGM((uint16_t)vp.addr, NUL_STR, vp.size);
return;
}
dgus.writeString((uint16_t)vp.addr, screen.filelist.filename(), vp.size);
}
#endif // HAS_MEDIA
void DGUSTxHandler::zPosition(DGUS_VP &vp) {
const float position = ExtUI::isAxisPositionKnown(ExtUI::Z) ? planner.get_axis_position_mm(Z_AXIS) : 0;
const int32_t data = dgus.toFixedPoint<float, int32_t, 2>(int32_t(position * 50.0f) / 50.0f); // Round to 0.02
dgus.write((uint16_t)vp.addr, dgus.swapBytes(data));
}
void DGUSTxHandler::elapsed(DGUS_VP &vp) {
char buffer[21];
duration_t(print_job_timer.duration()).toString(buffer);
dgus.writeString((uint16_t)vp.addr, buffer, vp.size);
}
void DGUSTxHandler::percent(DGUS_VP &vp) {
uint16_t progress;
switch (vp.addr) {
default: return;
case DGUS_Addr::STATUS_Percent:
progress = constrain(ExtUI::getProgress_percent(), 0, 100);
break;
case DGUS_Addr::STATUS_Percent_Complete:
progress = 100;
break;
}
dgus.write((uint16_t)DGUS_Addr::STATUS_Percent, Swap16(progress));
}
void DGUSTxHandler::statusIcons(DGUS_VP &vp) {
uint16_t icons = 0;
if (ExtUI::isPrinting()) {
icons |= (uint16_t)DGUS_Data::StatusIcon::PAUSE;
dgus.enableControl(DGUS_ScreenID::PRINT_STATUS,
DGUSDisplay::POPUP_WINDOW,
DGUS_Control::PAUSE);
}
else {
dgus.disableControl(DGUS_ScreenID::PRINT_STATUS,
DGUSDisplay::POPUP_WINDOW,
DGUS_Control::PAUSE);
}
if (ExtUI::isPrintingPaused()) {
icons |= (uint16_t)DGUS_Data::StatusIcon::RESUME;
dgus.enableControl(DGUS_ScreenID::PRINT_STATUS,
DGUSDisplay::POPUP_WINDOW,
DGUS_Control::RESUME);
}
else {
dgus.disableControl(DGUS_ScreenID::PRINT_STATUS,
DGUSDisplay::POPUP_WINDOW,
DGUS_Control::RESUME);
}
dgus.write((uint16_t)vp.addr, Swap16(icons));
}
void DGUSTxHandler::flowrate(DGUS_VP &vp) {
int16_t flowrate;
switch (vp.addr) {
default: return;
case DGUS_Addr::ADJUST_Flowrate_CUR:
flowrate = ExtUI::getFlow_percent(TERN(HAS_MULTI_EXTRUDER, ExtUI::getActiveTool(), ExtUI::E0));
break;
#if HAS_MULTI_EXTRUDER
case DGUS_Addr::ADJUST_Flowrate_E0:
flowrate = ExtUI::getFlow_percent(ExtUI::E0);
break;
case DGUS_Addr::ADJUST_Flowrate_E1:
flowrate = ExtUI::getFlow_percent(ExtUI::E1);
break;
#endif
}
dgus.write((uint16_t)vp.addr, Swap16(flowrate));
}
void DGUSTxHandler::tempMax(DGUS_VP &vp) {
uint16_t temp;
switch (vp.addr) {
default: return;
#if HAS_HEATED_BED
case DGUS_Addr::TEMP_Max_Bed:
temp = BED_MAX_TARGET;
break;
#endif
#if HAS_HOTEND
case DGUS_Addr::TEMP_Max_H0:
temp = thermalManager.hotend_max_target(0);
break;
#endif
#if HAS_MULTI_HOTEND
case DGUS_Addr::TEMP_Max_H1:
temp = thermalManager.hotend_max_target(1);
break;
#endif
}
dgus.write((uint16_t)vp.addr, Swap16(temp));
}
void DGUSTxHandler::stepperStatus(DGUS_VP &vp) {
const bool motor_on = stepper.axis_enabled.bits & (_BV(NUM_AXES) - 1);
dgus.write((uint16_t)vp.addr, Swap16(motor_on ? DGUS_Data::Status::ENABLED : DGUS_Data::Status::DISABLED));
}
void DGUSTxHandler::stepIcons(DGUS_VP &vp) {
if (!vp.extra) return;
uint16_t icons = 0;
DGUS_Data::StepSize size = *(DGUS_Data::StepSize*)vp.extra;
switch (size) {
case DGUS_Data::StepSize::MM10:
icons |= (uint16_t)DGUS_Data::StepIcon::MM10;
break;
case DGUS_Data::StepSize::MM1:
icons |= (uint16_t)DGUS_Data::StepIcon::MM1;
break;
case DGUS_Data::StepSize::MMP1:
icons |= (uint16_t)DGUS_Data::StepIcon::MMP1;
break;
case DGUS_Data::StepSize::MMP01:
icons |= (uint16_t)DGUS_Data::StepIcon::MMP01;
break;
}
dgus.write((uint16_t)vp.addr, Swap16(icons));
}
void DGUSTxHandler::ablDisableIcon(DGUS_VP &vp) {
uint16_t data;
if (ExtUI::getLevelingActive()) {
data = (uint16_t)DGUS_Data::Status::ENABLED;
dgus.enableControl(DGUS_ScreenID::LEVELING_AUTOMATIC,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::DISABLE);
}
else {
data = (uint16_t)DGUS_Data::Status::DISABLED;
dgus.disableControl(DGUS_ScreenID::LEVELING_AUTOMATIC,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::DISABLE);
}
dgus.write((uint16_t)vp.addr, Swap16(data));
}
void DGUSTxHandler::ablGrid(DGUS_VP &vp) {
// Batch send
int16_t data[DGUS_LEVEL_GRID_SIZE];
xy_uint8_t point;
int16_t fixed;
for (int16_t i = 0; i < DGUS_LEVEL_GRID_SIZE; i++) {
point.x = i % (GRID_MAX_POINTS_X);
point.y = i / (GRID_MAX_POINTS_X);
fixed = dgus.toFixedPoint<float, int16_t, 3>(ExtUI::getMeshPoint(point));
data[i] = Swap16(fixed);
}
dgus.write((uint16_t)vp.addr, data, sizeof(*data) * DGUS_LEVEL_GRID_SIZE);
}
void DGUSTxHandler::filamentIcons(DGUS_VP &vp) {
uint16_t icons = 0;
switch (screen.filament_extruder) {
default: return;
case DGUS_Data::Extruder::CURRENT:
#if HAS_MULTI_EXTRUDER
switch (ExtUI::getActiveTool()) {
default: break;
case ExtUI::E0:
icons |= (uint16_t)DGUS_Data::ExtruderIcon::E0;
break;
case ExtUI::E1:
icons |= (uint16_t)DGUS_Data::ExtruderIcon::E1;
break;
}
break;
#endif
case DGUS_Data::Extruder::E0:
icons |= (uint16_t)DGUS_Data::ExtruderIcon::E0;
break;
case DGUS_Data::Extruder::E1:
icons |= (uint16_t)DGUS_Data::ExtruderIcon::E1;
break;
}
dgus.write((uint16_t)vp.addr, Swap16(icons));
}
void DGUSTxHandler::blTouch(DGUS_VP &vp) {
#if ENABLED(BLTOUCH)
dgus.enableControl(DGUS_ScreenID::SETTINGS_MENU2,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::EXTRA2);
dgus.write((uint16_t)vp.addr, Swap16(DGUS_Data::Status::ENABLED));
#else
dgus.disableControl(DGUS_ScreenID::SETTINGS_MENU2,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::EXTRA2);
dgus.write((uint16_t)vp.addr, Swap16(DGUS_Data::Status::DISABLED));
#endif
}
void DGUSTxHandler::pidIcons(DGUS_VP &vp) {
uint16_t icons = 0;
switch (screen.pid_heater) {
default: return;
case DGUS_Data::Heater::BED:
icons |= (uint16_t)DGUS_Data::HeaterIcon::BED;
break;
case DGUS_Data::Heater::H0:
icons |= (uint16_t)DGUS_Data::HeaterIcon::H0;
break;
case DGUS_Data::Heater::H1:
icons |= (uint16_t)DGUS_Data::HeaterIcon::H1;
break;
}
dgus.write((uint16_t)vp.addr, Swap16(icons));
}
void DGUSTxHandler::pidKp(DGUS_VP &vp) {
float value;
switch (screen.pid_heater) {
default: return;
#if ENABLED(PIDTEMPBED)
case DGUS_Data::Heater::BED:
value = ExtUI::getBedPID_Kp();
break;
#endif
#if ENABLED(PIDTEMP)
case DGUS_Data::Heater::H0:
value = ExtUI::getPID_Kp(ExtUI::E0);
break;
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
value = ExtUI::getPID_Kp(ExtUI::E1);
break;
#endif
#endif
}
const int32_t data = dgus.toFixedPoint<float, int32_t, 2>(value);
dgus.write((uint16_t)vp.addr, dgus.swapBytes(data));
}
void DGUSTxHandler::pidKi(DGUS_VP &vp) {
float value;
switch (screen.pid_heater) {
default: return;
#if ENABLED(PIDTEMPBED)
case DGUS_Data::Heater::BED:
value = ExtUI::getBedPID_Ki();
break;
#endif
#if ENABLED(PIDTEMP)
case DGUS_Data::Heater::H0:
value = ExtUI::getPID_Ki(ExtUI::E0);
break;
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
value = ExtUI::getPID_Ki(ExtUI::E1);
break;
#endif
#endif
}
const int32_t data = dgus.toFixedPoint<float, int32_t, 2>(value);
dgus.write((uint16_t)vp.addr, dgus.swapBytes(data));
}
void DGUSTxHandler::pidKd(DGUS_VP &vp) {
float value;
switch (screen.pid_heater) {
default: return;
#if ENABLED(PIDTEMPBED)
case DGUS_Data::Heater::BED:
value = ExtUI::getBedPID_Kd();
break;
#endif
#if ENABLED(PIDTEMP)
case DGUS_Data::Heater::H0:
value = ExtUI::getPID_Kd(ExtUI::E0);
break;
#if HAS_MULTI_HOTEND
case DGUS_Data::Heater::H1:
value = ExtUI::getPID_Kd(ExtUI::E1);
break;
#endif
#endif
}
const int32_t data = dgus.toFixedPoint<float, int32_t, 2>(value);
dgus.write((uint16_t)vp.addr, dgus.swapBytes(data));
}
void DGUSTxHandler::buildVolume(DGUS_VP &vp) {
char buffer[vp.size];
snprintf_P(buffer, vp.size, PSTR("%dx%dx%d"), X_BED_SIZE, Y_BED_SIZE, (Z_MAX_POS - Z_MIN_POS));
dgus.writeString((uint16_t)vp.addr, buffer, vp.size);
}
void DGUSTxHandler::totalPrints(DGUS_VP &vp) {
#if ENABLED(PRINTCOUNTER)
dgus.write((uint16_t)vp.addr, dgus.swapBytes(print_job_timer.getStats().totalPrints));
#else
UNUSED(vp);
#endif
}
void DGUSTxHandler::finishedPrints(DGUS_VP &vp) {
#if ENABLED(PRINTCOUNTER)
dgus.write((uint16_t)vp.addr, dgus.swapBytes(print_job_timer.getStats().finishedPrints));
#else
UNUSED(vp);
#endif
}
void DGUSTxHandler::printTime(DGUS_VP &vp) {
#if ENABLED(PRINTCOUNTER)
char buffer[21];
ExtUI::getTotalPrintTime_str(buffer);
dgus.writeString((uint16_t)vp.addr, buffer, vp.size);
#else
dgus.writeString((uint16_t)vp.addr, F("-"), vp.size);
#endif
}
void DGUSTxHandler::longestPrint(DGUS_VP &vp) {
#if ENABLED(PRINTCOUNTER)
char buffer[21];
ExtUI::getLongestPrint_str(buffer);
dgus.writeString((uint16_t)vp.addr, buffer, vp.size);
#else
dgus.writeString((uint16_t)vp.addr, F("-"), vp.size);
#endif
}
void DGUSTxHandler::filamentUsed(DGUS_VP &vp) {
#if ENABLED(PRINTCOUNTER)
char buffer[21];
ExtUI::getFilamentUsed_str(buffer);
dgus.writeString((uint16_t)vp.addr, buffer, vp.size);
#else
dgus.writeString((uint16_t)vp.addr, F("-"), vp.size);
#endif
}
void DGUSTxHandler::waitIcons(DGUS_VP &vp) {
uint16_t icons = 0;
if (ExtUI::isPrintingPaused()) {
icons |= (uint16_t)DGUS_Data::WaitIcon::ABORT;
dgus.enableControl(DGUS_ScreenID::WAIT,
DGUSDisplay::POPUP_WINDOW,
DGUS_Control::ABORT);
}
else {
dgus.disableControl(DGUS_ScreenID::WAIT,
DGUSDisplay::POPUP_WINDOW,
DGUS_Control::ABORT);
}
if (screen.wait_continue) {
icons |= (uint16_t)DGUS_Data::WaitIcon::CONTINUE;
dgus.enableControl(DGUS_ScreenID::WAIT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::CONTINUE);
}
else {
dgus.disableControl(DGUS_ScreenID::WAIT,
DGUSDisplay::RETURN_KEY_CODE,
DGUS_Control::CONTINUE);
}
dgus.write((uint16_t)vp.addr, Swap16(icons));
}
void DGUSTxHandler::fanSpeed(DGUS_VP &vp) {
uint16_t fan_speed;
switch (vp.addr) {
default: return;
case DGUS_Addr::FAN0_Speed: fan_speed = ExtUI::getTargetFan_percent(ExtUI::FAN0); break;
}
dgus.write((uint16_t)vp.addr, Swap16(fan_speed));
}
void DGUSTxHandler::volume(DGUS_VP &vp) {
const uint16_t volume = dgus.getVolume();
dgus.write((uint16_t)vp.addr, Swap16(volume));
}
void DGUSTxHandler::brightness(DGUS_VP &vp) {
const uint16_t brightness = dgus.getBrightness();
dgus.write((uint16_t)vp.addr, Swap16(brightness));
}
void DGUSTxHandler::extraToString(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
dgus.writeString((uint16_t)vp.addr, vp.extra, vp.size, true, false, false);
}
void DGUSTxHandler::extraPGMToString(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
dgus.writeStringPGM((uint16_t)vp.addr, vp.extra, vp.size, true, false, false);
}
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.cpp
|
C++
|
agpl-3.0
| 17,340
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "DGUSDisplay.h"
#include "definition/DGUS_VP.h"
#define Swap16(val) (uint16_t((uint16_t(val) >> 8) | (uint16_t(val) << 8)))
namespace DGUSTxHandler {
#if HAS_MEDIA
void setFileControlState(int16_t, bool);
void fileType(DGUS_VP &);
void fileName(DGUS_VP &);
void scrollIcons(DGUS_VP &);
void selectedFileName(DGUS_VP &);
#endif
void zPosition(DGUS_VP &);
void elapsed(DGUS_VP &);
void percent(DGUS_VP &);
void statusIcons(DGUS_VP &);
void flowrate(DGUS_VP &);
void tempMax(DGUS_VP &);
void stepperStatus(DGUS_VP &);
void stepIcons(DGUS_VP &);
void ablDisableIcon(DGUS_VP &);
void ablGrid(DGUS_VP &);
void filamentIcons(DGUS_VP &);
void blTouch(DGUS_VP &);
void pidIcons(DGUS_VP &);
void pidKp(DGUS_VP &);
void pidKi(DGUS_VP &);
void pidKd(DGUS_VP &);
void buildVolume(DGUS_VP &);
void totalPrints(DGUS_VP &);
void finishedPrints(DGUS_VP &);
void printTime(DGUS_VP &);
void longestPrint(DGUS_VP &);
void filamentUsed(DGUS_VP &);
void waitIcons(DGUS_VP &);
void fanSpeed(DGUS_VP &);
void volume(DGUS_VP &);
void brightness(DGUS_VP &);
void extraToString(DGUS_VP &);
void extraPGMToString(DGUS_VP &);
template<typename T>
void extraToInteger(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
switch (vp.size) {
default: return;
case 1: {
const uint8_t data = uint8_t(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), data);
break;
}
case 2: {
const uint16_t data = uint16_t(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), Swap16(data));
break;
}
case 4: {
const uint32_t data = uint32_t(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), dgus.swapBytes(data));
break;
}
}
}
template<typename T, uint8_t decimals>
void extraToFixedPoint(DGUS_VP &vp) {
if (!vp.size || !vp.extra) return;
switch (vp.size) {
default: return;
case 1: {
const uint8_t data = dgus.toFixedPoint<T, uint8_t, decimals>(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), data);
break;
}
case 2: {
const uint16_t data = dgus.toFixedPoint<T, uint16_t, decimals>(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), Swap16(data));
break;
}
case 4: {
const uint32_t data = dgus.toFixedPoint<T, uint32_t, decimals>(*(T*)vp.extra);
dgus.write(uint16_t(vp.addr), dgus.swapBytes(data));
break;
}
}
}
}
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/DGUSTxHandler.h
|
C++
|
agpl-3.0
| 3,390
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#define DGUS_LINE_LEN 32
#define DGUS_STATUS_LEN 32
#define DGUS_FILE_COUNT 5
#define DGUS_FILENAME_LEN 32
#define DGUS_ELAPSED_LEN 15
#define DGUS_LEVEL_GRID_SIZE 25
#define DGUS_MACHINE_LEN 24
#define DGUS_BUILDVOLUME_LEN 24
#define DGUS_VERSION_LEN 16
#define DGUS_PRINTTIME_LEN 24
#define DGUS_LONGESTPRINT_LEN 24
#define DGUS_FILAMENTUSED_LEN 24
#define DGUS_GCODE_LEN 32
enum class DGUS_Addr : uint16_t {
END = 0,
MESSAGE_Line1 = 0x1100, // 0x1100 - 0x111F
MESSAGE_Line2 = 0x1120, // 0x1120 - 0x113F
MESSAGE_Line3 = 0x1140, // 0x1140 - 0x115F
MESSAGE_Line4 = 0x1160, // 0x1160 - 0x117F
// READ-ONLY VARIABLES
SCREENCHANGE = 0x2000, // Screen change request. Data contains target screen in low byte.
SCREENCHANGE_SD = 0x2001, // Only change if SD card present.
SCREENCHANGE_Idle = 0x2002, // Only change if not printing.
SCREENCHANGE_Printing = 0x2003, // Only change if printing.
SD_SelectFile = 0x2004, // Data: file index (0-4)
SD_Scroll = 0x2005, // Data: DGUS_Data::Scroll
SD_Print = 0x2006,
STATUS_Abort = 0x2007, // Popup / Data: DGUS_Data::Popup
STATUS_Pause = 0x2008, // Popup / Data: DGUS_Data::Popup
STATUS_Resume = 0x2009, // Popup / Data: DGUS_Data::Popup
ADJUST_SetFeedrate = 0x200A, // Type: Integer (16 bits signed)
ADJUST_SetFlowrate_CUR = 0x200B, // Type: Integer (16 bits signed)
#if HAS_MULTI_EXTRUDER
ADJUST_SetFlowrate_E0 = 0x200C, // Type: Integer (16 bits signed)
ADJUST_SetFlowrate_E1 = 0x200D, // Type: Integer (16 bits signed)
#endif
ADJUST_SetBabystep = 0x200E, // Type: Fixed point, 2 decimals (16 bits signed)
ADJUST_Babystep = 0x200F, // Data: DGUS_Data::Adjust
TEMP_Preset = 0x2010, // Popup / Data: DGUS_Data::TempPreset
TEMP_SetTarget_Bed = 0x2011, // Type: Integer (16 bits signed)
TEMP_SetTarget_H0 = 0x2012, // Type: Integer (16 bits signed)
#if HAS_MULTI_HOTEND
TEMP_SetTarget_H1 = 0x2013, // Type: Integer (16 bits signed)
#endif
TEMP_Cool = 0x2014, // Data: DGUS_Data::Heater
STEPPER_Control = 0x2015, // Popup / Data: DGUS_Data::Control
LEVEL_OFFSET_Set = 0x2016, // Type: Fixed point, 2 decimals (16 bits signed)
LEVEL_OFFSET_Step = 0x2017, // Data: DGUS_Data::Adjust
LEVEL_OFFSET_SetStep = 0x2018, // Data: DGUS_Data::StepSize
LEVEL_MANUAL_Point = 0x2019, // Data: point index (1-5)
LEVEL_AUTO_Probe = 0x201A,
LEVEL_AUTO_Disable = 0x201B,
FILAMENT_Select = 0x201C, // Data: DGUS_Data::Extruder
FILAMENT_SetLength = 0x201D, // Type: Integer (16 bits unsigned)
FILAMENT_Move = 0x201E, // Data: DGUS_Data::FilamentMove
MOVE_Home = 0x201F, // Data: DGUS_Data::Axis
MOVE_SetX = 0x2020, // Type: Fixed point, 1 decimal (16 bits signed)
MOVE_SetY = 0x2021, // Type: Fixed point, 1 decimal (16 bits signed)
MOVE_SetZ = 0x2022, // Type: Fixed point, 1 decimal (16 bits signed)
MOVE_Step = 0x2023, // Data: DGUS_Data::MoveDirection
MOVE_SetStep = 0x2024, // Data: DGUS_Data::StepSize
GCODE_Clear = 0x2025,
GCODE_Execute = 0x2026,
EEPROM_Reset = 0x2027, // Popup / Data: DGUS_Data::Popup
SETTINGS2_Extra = 0x2028, // Data: DGUS_Data::Extra
PID_Select = 0x2029, // Data: DGUS_Data::Heater
PID_SetTemp = 0x202A, // Type: Integer (16 bits unsigned)
PID_Run = 0x202B,
POWERLOSS_Abort = 0x202C, // Popup / Data: DGUS_Data::Popup
POWERLOSS_Resume = 0x202D, // Popup / Data: DGUS_Data::Popup
WAIT_Abort = 0x202E, // Popup / Data: DGUS_Data::Popup
WAIT_Continue = 0x202F,
// WRITE-ONLY VARIABLES
MESSAGE_Status = 0x3000, // 0x3000 - 0x301F
SD_Type = 0x3020, // 0x3020 - 0x3024 / Data: DGUS_Data::SDType
SD_FileName0 = 0x3025, // 0x3025 - 0x3044
SD_FileName1 = 0x3045, // 0x3045 - 0x3064
SD_FileName2 = 0x3065, // 0x3065 - 0x3084
SD_FileName3 = 0x3085, // 0x3085 - 0x30A4
SD_FileName4 = 0x30A5, // 0x30A5 - 0x30C4
SD_ScrollIcons = 0x30C5, // Bits: DGUS_Data::ScrollIcon
SD_SelectedFileName = 0x30C6, // 0x30C6 - 0x30E5
STATUS_PositionZ = 0x30E6, // Type: Fixed point, 2 decimal (32 bits signed)
STATUS_Elapsed = 0x30E8, // 0x30E8 - 0x30F6
STATUS_Percent = 0x30F7, // Type: Integer (16 bits unsigned)
ADJUST_Feedrate = 0x30F8, // Type: Integer (16 bits signed)
ADJUST_Flowrate_CUR = 0x30F9, // Type: Integer (16 bits signed)
#if HAS_MULTI_EXTRUDER
ADJUST_Flowrate_E0 = 0x30FA, // Type: Integer (16 bits signed)
ADJUST_Flowrate_E1 = 0x30FB, // Type: Integer (16 bits signed)
#endif
TEMP_Current_Bed = 0x30FC, // Type: Integer (16 bits signed)
TEMP_Target_Bed = 0x30FD, // Type: Integer (16 bits signed)
TEMP_Max_Bed = 0x30FE, // Type: Integer (16 bits unsigned)
TEMP_Current_H0 = 0x30FF, // Type: Fixed point, 1 decimal (16 bits signed)
TEMP_Target_H0 = 0x3100, // Type: Integer (16 bits signed)
TEMP_Max_H0 = 0x3101, // Type: Integer (16 bits unsigned)
#if HAS_MULTI_HOTEND
TEMP_Current_H1 = 0x3102, // Type: Fixed point, 1 decimal (16 bits signed)
TEMP_Target_H1 = 0x3103, // Type: Integer (16 bits signed)
TEMP_Max_H1 = 0x3104, // Type: Integer (16 bits unsigned)
#endif
STEPPER_Status = 0x3105, // Data: DGUS_Data::Status
LEVEL_OFFSET_Current = 0x3106, // Type: Fixed point, 2 decimals (16 bits signed)
LEVEL_OFFSET_StepIcons = 0x3107, // Bits: DGUS_Data::StepIcon
LEVEL_AUTO_DisableIcon = 0x3108, // Data: DGUS_Data::Status
LEVEL_AUTO_Grid = 0x3109, // 0x3109 - 0x3121 / Type: Fixed point, 3 decimals (16 bits signed)
LEVEL_PROBING_Icons1 = 0x3122, // Type: Integer (16 bits unsigned) / Each bit represents a grid point
LEVEL_PROBING_Icons2 = 0x3123, // Type: Integer (16 bits unsigned) / Each bit represents a grid point
FILAMENT_ExtruderIcons = 0x3124, // Data: DGUS_Data::ExtruderIcon
FILAMENT_Length = 0x3125, // Type: Integer (16 bits unsigned)
MOVE_CurrentX = 0x3126, // Type: Fixed point, 1 decimal (16 bits signed)
MOVE_CurrentY = 0x3127, // Type: Fixed point, 1 decimal (16 bits signed)
MOVE_CurrentZ = 0x3128, // Type: Fixed point, 1 decimal (16 bits signed)
MOVE_StepIcons = 0x3129, // Bits: DGUS_Data::StepIcon
SETTINGS2_BLTouch = 0x312A, // Data: DGUS_Data::Status
PID_HeaterIcons = 0x312B, // Data: DGUS_Data::HeaterIcon
PID_Temp = 0x312C, // Type: Integer (16 bits unsigned)
PID_Kp = 0x312D, // Type: Fixed point, 2 decimals (32 bits signed)
PID_Ki = 0x312F, // Type: Fixed point, 2 decimals (32 bits signed)
PID_Kd = 0x3131, // Type: Fixed point, 2 decimals (32 bits signed)
INFOS_Machine = 0x3133, // 0x3133 - 0x314A
INFOS_BuildVolume = 0x314B, // 0x314B - 0x3162
INFOS_Version = 0x3163, // 0x3163 - 0x3172
INFOS_TotalPrints = 0x3173, // Type: Integer (16 bits unsigned)
INFOS_FinishedPrints = 0x3174, // Type: Integer (16 bits unsigned)
INFOS_PrintTime = 0x3175, // 0x3175 - 0x318C
INFOS_LongestPrint = 0x318D, // 0x318D - 0x31A4
INFOS_FilamentUsed = 0x31A5, // 0x31A5 - 0x31BC
WAIT_Icons = 0x31BD, // Bits: DGUS_Data::WaitIcon
STATUS_Icons = 0x31BE, // Bits: DGUS_Data::StatusIcon
// READ-WRITE VARIABLES
FAN0_Speed = 0x4000, // Type: Integer (16 bits unsigned) / Data: fan speed as percent (0-100)
GCODE_Data = 0x4001, // 0x4001 - 0x4020
PID_Cycles = 0x4021, // Type: Integer (16 bits unsigned)
VOLUME_Level = 0x4022, // Type: Integer (16 bits unsigned) / Data: volume as percent (0-100)
BRIGHTNESS_Level = 0x4023, // Type: Integer (16 bits unsigned) / Data: brightness as percent (0-100)
// SPECIAL CASES
STATUS_Percent_Complete = 0x5000, // Same as STATUS_Percent, but always 100%
INFOS_Debug = 0x5001,
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Addr.h
|
C
|
agpl-3.0
| 9,363
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../../../../inc/MarlinConfigPre.h"
#include "DGUS_Addr.h"
#if DGUS_LEVEL_GRID_SIZE != GRID_MAX_POINTS
#error "DGUS_LEVEL_GRID_SIZE is incompatible with current mesh."
#endif
#ifndef DGUS_DEFAULT_VOLUME
#define DGUS_DEFAULT_VOLUME 50
#endif
#ifndef DGUS_DEFAULT_BRIGHTNESS
#define DGUS_DEFAULT_BRIGHTNESS 100
#endif
#ifndef DGUS_STATUS_EXPIRATION_MS
#define DGUS_STATUS_EXPIRATION_MS 30000
#endif
#ifndef DGUS_PRINT_BABYSTEP
#define DGUS_PRINT_BABYSTEP 0.01f
#endif
#ifndef DGUS_PLA_TEMP_HOTEND
#define DGUS_PLA_TEMP_HOTEND 200
#endif
#ifndef DGUS_PLA_TEMP_BED
#define DGUS_PLA_TEMP_BED 60
#endif
#ifndef DGUS_ABS_TEMP_HOTEND
#define DGUS_ABS_TEMP_HOTEND 240
#endif
#ifndef DGUS_ABS_TEMP_BED
#define DGUS_ABS_TEMP_BED 80
#endif
#ifndef DGUS_PETG_TEMP_HOTEND
#define DGUS_PETG_TEMP_HOTEND 240
#endif
#ifndef DGUS_PETG_TEMP_BED
#define DGUS_PETG_TEMP_BED 60
#endif
#ifndef DGUS_DEFAULT_FILAMENT_LEN
#define DGUS_DEFAULT_FILAMENT_LEN 10
#endif
#ifndef BED_TRAMMING_Z_HOP
#define BED_TRAMMING_Z_HOP 4.0
#endif
#ifndef BED_TRAMMING_HEIGHT
#define BED_TRAMMING_HEIGHT 0.0
#endif
static_assert(BED_TRAMMING_Z_HOP >= 0, "BED_TRAMMING_Z_HOP must be >= 0. Please update your configuration.");
#ifndef DGUS_LEVEL_CENTER_X
#define DGUS_LEVEL_CENTER_X ((X_BED_SIZE) / 2)
#endif
#ifndef DGUS_LEVEL_CENTER_Y
#define DGUS_LEVEL_CENTER_Y ((Y_BED_SIZE) / 2)
#endif
#if ENABLED(BLTOUCH)
#ifndef DGUS_RESET_BLTOUCH
#define DGUS_RESET_BLTOUCH "M999\nM280P0S160"
#endif
#endif
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Constants.h
|
C
|
agpl-3.0
| 2,399
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
enum class DGUS_Control : uint8_t {
// PRINT
FILE0 = 1, // RETURN_KEY_CODE
FILE1 = 2, // RETURN_KEY_CODE
FILE2 = 3, // RETURN_KEY_CODE
FILE3 = 4, // RETURN_KEY_CODE
FILE4 = 5, // RETURN_KEY_CODE
GO_BACK = 6, // RETURN_KEY_CODE
SCROLL_UP = 7, // RETURN_KEY_CODE
SCROLL_DOWN = 8, // RETURN_KEY_CODE
// PRINT_STATUS
PAUSE = 1, // POPUP_WINDOW
RESUME = 2, // POPUP_WINDOW
// LEVELING_AUTOMATIC
DISABLE = 5, // RETURN_KEY_CODE
// SETTINGS_MENU2
EXTRA2 = 6, // RETURN_KEY_CODE
// WAIT
ABORT = 1, // POPUP_WINDOW
CONTINUE = 2 // RETURN_KEY_CODE
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Control.h
|
C
|
agpl-3.0
| 1,527
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include <inttypes.h>
namespace DGUS_Data {
// RX constants
enum class Scroll : uint8_t {
GO_BACK = 0,
UP = 1,
DOWN = 2
};
enum class Popup : uint8_t {
CONFIRMED = 1
};
enum class Adjust : uint8_t {
INCREMENT = 0,
DECREMENT = 1
};
enum class TempPreset : uint8_t {
PLA = 1,
ABS = 2,
PETG = 3
};
enum class Extruder : int8_t {
CURRENT = -1,
E0 = 0,
E1 = 1
};
enum class Heater : int8_t {
ALL = -2,
BED = -1,
H0 = 0,
H1 = 1
};
enum class Control : uint8_t {
ENABLE = 1,
DISABLE = 2
};
enum class StepSize : uint8_t {
MM10 = 0, // 10mm
MM1 = 1, // 1mm
MMP1 = 2, // 0.1mm
MMP01 = 3 // 0.01mm
};
enum class FilamentMove : uint8_t {
RETRACT = 0,
EXTRUDE = 1
};
enum class Axis : uint8_t {
X_Y_Z = 0,
X_Y = 1,
Z = 2
};
enum class MoveDirection : uint8_t {
XP = 0, // X+
XM = 1, // X-
YP = 2, // Y+
YM = 3, // Y-
ZP = 4, // Z+
ZM = 5 // Z-
};
enum class Extra : uint8_t {
BUTTON1 = 0,
BUTTON2 = 1
};
// TX constants
enum class SDType : uint16_t {
NONE = 0,
FILE = 1,
DIRECTORY = 2
};
enum class ScrollIcon : uint16_t {
GO_BACK = 1U << 0,
UP = 1U << 1,
DOWN = 1U << 2
};
enum class StatusIcon : uint16_t {
PAUSE = 1U << 0,
RESUME = 1U << 1
};
enum class Status : uint16_t {
DISABLED = 0,
ENABLED = 1
};
enum class StepIcon : uint16_t {
MM10 = 1U << 0, // 10mm
MM1 = 1U << 1, // 1mm
MMP1 = 1U << 2, // 0.1mm
MMP01 = 1U << 3 // 0.01mm
};
enum class ExtruderIcon : uint16_t {
E0 = 1U << 0,
E1 = 1U << 1
};
enum class HeaterIcon : uint16_t {
BED = 1U << 0,
H0 = 1U << 1,
H1 = 1U << 2
};
enum class WaitIcon : uint16_t {
ABORT = 1U << 0,
CONTINUE = 1U << 1
};
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_Data.h
|
C++
|
agpl-3.0
| 2,824
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
enum class DGUS_ScreenID : uint8_t {
BOOT = 0,
HOME = 1,
PRINT = 2,
PRINT_STATUS = 3,
PRINT_ADJUST = 4,
PRINT_FINISHED = 5,
TEMP_MENU = 6,
TEMP_MANUAL = 7,
FAN = 8,
SETTINGS_MENU = 9,
LEVELING_MENU = 10,
LEVELING_OFFSET = 11,
LEVELING_MANUAL = 12,
LEVELING_AUTOMATIC = 13,
LEVELING_PROBING = 14,
FILAMENT = 15,
MOVE = 16,
GCODE = 17,
SETTINGS_MENU2 = 18,
PID = 19,
VOLUME = 20,
BRIGHTNESS = 21,
INFOS = 22,
DEBUG = 240,
POWERLOSS = 248,
WAIT = 249,
KILL = 250
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/config/DGUS_ScreenID.h
|
C
|
agpl-3.0
| 1,665
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUS_ScreenAddrList.h"
#include "../../ui_api.h"
constexpr DGUS_Addr LIST_HOME[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::END
};
#if HAS_MEDIA
constexpr DGUS_Addr LIST_PRINT[] PROGMEM = {
DGUS_Addr::SD_Type,
DGUS_Addr::SD_FileName0,
DGUS_Addr::SD_FileName1,
DGUS_Addr::SD_FileName2,
DGUS_Addr::SD_FileName3,
DGUS_Addr::SD_FileName4,
DGUS_Addr::SD_ScrollIcons,
DGUS_Addr::SD_SelectedFileName,
DGUS_Addr::END
};
#endif
constexpr DGUS_Addr LIST_PRINT_STATUS[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::STATUS_PositionZ,
DGUS_Addr::STATUS_Elapsed,
DGUS_Addr::STATUS_Percent,
DGUS_Addr::STATUS_Icons,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PRINT_ADJUST[] PROGMEM = {
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::FAN0_Speed,
DGUS_Addr::ADJUST_Feedrate,
DGUS_Addr::ADJUST_Flowrate_CUR,
DGUS_Addr::LEVEL_OFFSET_Current,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PRINT_FINISHED[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::STATUS_PositionZ,
DGUS_Addr::STATUS_Elapsed,
DGUS_Addr::STATUS_Percent_Complete,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_TEMP_MENU[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_TEMP_MANUAL[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Max_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::TEMP_Max_Bed,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_FAN[] PROGMEM = {
DGUS_Addr::FAN0_Speed,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_SETTINGS_MENU[] PROGMEM = {
DGUS_Addr::STEPPER_Status,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_LEVELING_OFFSET[] PROGMEM = {
DGUS_Addr::LEVEL_OFFSET_Current,
DGUS_Addr::LEVEL_OFFSET_StepIcons,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_LEVELING_MANUAL[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_LEVELING_AUTOMATIC[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::TEMP_Current_Bed,
DGUS_Addr::TEMP_Target_Bed,
DGUS_Addr::LEVEL_AUTO_DisableIcon,
DGUS_Addr::LEVEL_AUTO_Grid,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_LEVELING_PROBING[] PROGMEM = {
DGUS_Addr::LEVEL_PROBING_Icons1,
DGUS_Addr::LEVEL_PROBING_Icons2,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_FILAMENT[] PROGMEM = {
DGUS_Addr::TEMP_Current_H0,
DGUS_Addr::TEMP_Target_H0,
DGUS_Addr::FILAMENT_ExtruderIcons,
DGUS_Addr::FILAMENT_Length,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_MOVE[] PROGMEM = {
DGUS_Addr::MOVE_CurrentX,
DGUS_Addr::MOVE_CurrentY,
DGUS_Addr::MOVE_CurrentZ,
DGUS_Addr::MOVE_StepIcons,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_GCODE[] PROGMEM = {
DGUS_Addr::GCODE_Data,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_SETTINGS_MENU2[] PROGMEM = {
DGUS_Addr::SETTINGS2_BLTouch,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_PID[] PROGMEM = {
DGUS_Addr::PID_HeaterIcons,
DGUS_Addr::PID_Temp,
DGUS_Addr::PID_Cycles,
DGUS_Addr::PID_Kp,
DGUS_Addr::PID_Ki,
DGUS_Addr::PID_Kd,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_VOLUME[] PROGMEM = {
DGUS_Addr::VOLUME_Level,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_BRIGHTNESS[] PROGMEM = {
DGUS_Addr::BRIGHTNESS_Level,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_INFOS[] PROGMEM = {
DGUS_Addr::INFOS_Machine,
DGUS_Addr::INFOS_BuildVolume,
DGUS_Addr::INFOS_Version,
DGUS_Addr::INFOS_TotalPrints,
DGUS_Addr::INFOS_FinishedPrints,
DGUS_Addr::INFOS_PrintTime,
DGUS_Addr::INFOS_LongestPrint,
DGUS_Addr::INFOS_FilamentUsed,
DGUS_Addr::END
};
constexpr DGUS_Addr LIST_WAIT[] PROGMEM = {
DGUS_Addr::WAIT_Icons,
DGUS_Addr::END
};
#define MAP_HELPER(SCREEN, LIST) { .screenID = SCREEN, .addr_list = LIST }
const struct DGUS_ScreenAddrList screen_addr_list_map[] PROGMEM = {
MAP_HELPER(DGUS_ScreenID::HOME, LIST_HOME),
#if HAS_MEDIA
MAP_HELPER(DGUS_ScreenID::PRINT, LIST_PRINT),
#endif
MAP_HELPER(DGUS_ScreenID::PRINT_STATUS, LIST_PRINT_STATUS),
MAP_HELPER(DGUS_ScreenID::PRINT_ADJUST, LIST_PRINT_ADJUST),
MAP_HELPER(DGUS_ScreenID::PRINT_FINISHED, LIST_PRINT_FINISHED),
MAP_HELPER(DGUS_ScreenID::TEMP_MENU, LIST_TEMP_MENU),
MAP_HELPER(DGUS_ScreenID::TEMP_MANUAL, LIST_TEMP_MANUAL),
MAP_HELPER(DGUS_ScreenID::FAN, LIST_FAN),
MAP_HELPER(DGUS_ScreenID::SETTINGS_MENU, LIST_SETTINGS_MENU),
MAP_HELPER(DGUS_ScreenID::LEVELING_OFFSET, LIST_LEVELING_OFFSET),
MAP_HELPER(DGUS_ScreenID::LEVELING_MANUAL, LIST_LEVELING_MANUAL),
MAP_HELPER(DGUS_ScreenID::LEVELING_AUTOMATIC, LIST_LEVELING_AUTOMATIC),
MAP_HELPER(DGUS_ScreenID::LEVELING_PROBING, LIST_LEVELING_PROBING),
MAP_HELPER(DGUS_ScreenID::FILAMENT, LIST_FILAMENT),
MAP_HELPER(DGUS_ScreenID::MOVE, LIST_MOVE),
MAP_HELPER(DGUS_ScreenID::GCODE, LIST_GCODE),
MAP_HELPER(DGUS_ScreenID::SETTINGS_MENU2, LIST_SETTINGS_MENU2),
MAP_HELPER(DGUS_ScreenID::PID, LIST_PID),
MAP_HELPER(DGUS_ScreenID::VOLUME, LIST_VOLUME),
MAP_HELPER(DGUS_ScreenID::BRIGHTNESS, LIST_BRIGHTNESS),
MAP_HELPER(DGUS_ScreenID::INFOS, LIST_INFOS),
MAP_HELPER(DGUS_ScreenID::WAIT, LIST_WAIT),
MAP_HELPER((DGUS_ScreenID)0, nullptr)
};
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.cpp
|
C++
|
agpl-3.0
| 6,814
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../config/DGUS_ScreenID.h"
#include "../config/DGUS_Addr.h"
struct DGUS_ScreenAddrList {
DGUS_ScreenID screenID;
const DGUS_Addr *addr_list;
};
extern const struct DGUS_ScreenAddrList screen_addr_list_map[];
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenAddrList.h
|
C
|
agpl-3.0
| 1,102
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#include "../../../../inc/MarlinConfigPre.h"
#if DGUS_LCD_UI_RELOADED
#include "DGUS_ScreenSetup.h"
#include "../DGUSSetupHandler.h"
#include "../../ui_api.h"
#define SETUP_HELPER(SCREEN, SETUP) { .screenID = SCREEN, .setup_fn = SETUP }
const struct DGUS_ScreenSetup screen_setup_list[] PROGMEM = {
#if HAS_MEDIA
SETUP_HELPER(DGUS_ScreenID::PRINT, &DGUSSetupHandler::print),
#endif
SETUP_HELPER(DGUS_ScreenID::PRINT_STATUS, &DGUSSetupHandler::printStatus),
SETUP_HELPER(DGUS_ScreenID::PRINT_ADJUST, &DGUSSetupHandler::printAdjust),
SETUP_HELPER(DGUS_ScreenID::LEVELING_MENU, &DGUSSetupHandler::levelingMenu),
SETUP_HELPER(DGUS_ScreenID::LEVELING_OFFSET, &DGUSSetupHandler::levelingOffset),
SETUP_HELPER(DGUS_ScreenID::LEVELING_MANUAL, &DGUSSetupHandler::levelingManual),
SETUP_HELPER(DGUS_ScreenID::LEVELING_AUTOMATIC, &DGUSSetupHandler::levelingAutomatic),
SETUP_HELPER(DGUS_ScreenID::LEVELING_PROBING, &DGUSSetupHandler::levelingProbing),
SETUP_HELPER(DGUS_ScreenID::FILAMENT, &DGUSSetupHandler::filament),
SETUP_HELPER(DGUS_ScreenID::MOVE, &DGUSSetupHandler::move),
SETUP_HELPER(DGUS_ScreenID::GCODE, &DGUSSetupHandler::gcode),
SETUP_HELPER(DGUS_ScreenID::PID, &DGUSSetupHandler::pid),
SETUP_HELPER(DGUS_ScreenID::INFOS, &DGUSSetupHandler::infos),
SETUP_HELPER((DGUS_ScreenID)0, nullptr)
};
#endif // DGUS_LCD_UI_RELOADED
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.cpp
|
C++
|
agpl-3.0
| 2,331
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../config/DGUS_ScreenID.h"
struct DGUS_ScreenSetup {
DGUS_ScreenID screenID;
bool (*setup_fn)(void);
};
extern const struct DGUS_ScreenSetup screen_setup_list[];
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_ScreenSetup.h
|
C
|
agpl-3.0
| 1,063
|
/**
* Marlin 3D Printer Firmware
* Copyright (c) 2021 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 <https://www.gnu.org/licenses/>.
*
*/
#pragma once
#include "../config/DGUS_Addr.h"
#define VPFLAG_NONE 0
#define VPFLAG_AUTOUPLOAD (1U << 0) // Upload on every DGUS update
#define VPFLAG_RXSTRING (1U << 1) // Treat the received data as a string (terminated with 0xFFFF)
struct DGUS_VP {
DGUS_Addr addr;
uint8_t size;
uint8_t flags;
void *extra;
// Callback that will be called if the display modified the value.
// nullptr makes it readonly for the display.
void (*rx_handler)(DGUS_VP &, void *);
void (*tx_handler)(DGUS_VP &);
};
|
2301_81045437/Marlin
|
Marlin/src/lcd/extui/dgus_reloaded/definition/DGUS_VP.h
|
C
|
agpl-3.0
| 1,396
|