bissen21/Marlin_Firmware
1
0
Fork 0
Code Issues Pull Requests Projects Releases 4 Wiki Activity

Laser Coolant Flow Meter / Safety Shutdown (#21431)

Browse Source 
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
This commit is contained in:
Mike La Spina
2021-03-29 01:41:56 -05:00
committed by GitHub
parent 8f509b0ae0
commit ccdbffbf3f
20 changed files with 512 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
Marlin/src/lcd/HD44780/marlinui_HD44780.cpp
View File

@ -46,6 +46,10 @@
#include "../../gcode/parser.h"
#endif
#if HAS_COOLER || HAS_FLOWMETER
#include "../../feature/cooler.h"
#endif
#if ENABLED(AUTO_BED_LEVELING_UBL)
#include "../../feature/bedlevel/bedlevel.h"
#endif
@ -517,6 +521,7 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
lcd_put_u8str(value);
}
FORCE_INLINE void _draw_heater_status(const heater_id_t heater_id, const char prefix, const bool blink) {
#if HAS_HEATED_BED
const bool isBed = TERN(HAS_HEATED_CHAMBER, heater_id == H_BED, heater_id < 0);
@ -550,6 +555,43 @@ FORCE_INLINE void _draw_heater_status(const heater_id_t heater_id, const char pr
}
}
#if HAS_COOLER
FORCE_INLINE void _draw_cooler_status(const char prefix, const bool blink) {
const float t1 = thermalManager.degCooler(), t2 = thermalManager.degTargetCooler();
if (prefix >= 0) lcd_put_wchar(prefix);
lcd_put_u8str(i16tostr3rj(t1 + 0.5));
lcd_put_wchar('/');
#if !HEATER_IDLE_HANDLER
UNUSED(blink);
#else
if (!blink && thermalManager.heater_idle[thermalManager.idle_index_for_id(heater_id)].timed_out) {
lcd_put_wchar(' ');
if (t2 >= 10) lcd_put_wchar(' ');
if (t2 >= 100) lcd_put_wchar(' ');
}
else
#endif
lcd_put_u8str(i16tostr3left(t2 + 0.5));
if (prefix >= 0) {
lcd_put_wchar(LCD_STR_DEGREE[0]);
lcd_put_wchar(' ');
if (t2 < 10) lcd_put_wchar(' ');
}
}
#endif
#if HAS_FLOWMETER
FORCE_INLINE void _draw_flowmeter_status() {
lcd_put_u8str("~ ");
lcd_put_u8str(ftostr11ns(cooler.flowrate));
lcd_put_wchar('L');
}
#endif
FORCE_INLINE void _draw_bed_status(const bool blink) {
_draw_heater_status(H_BED, TERN0(HAS_LEVELING, blink && planner.leveling_active) ? '_' : LCD_STR_BEDTEMP[0], blink);
}
@ -747,17 +789,19 @@ void MarlinUI::draw_status_screen() {
//
// Hotend 0 Temperature
//
_draw_heater_status(H_E0, -1, blink);
#if HAS_HOTEND
_draw_heater_status(H_E0, -1, blink);
//
// Hotend 1 or Bed Temperature
//
#if HAS_MULTI_HOTEND
lcd_moveto(8, 0);
_draw_heater_status(H_E1, LCD_STR_THERMOMETER[0], blink);
#elif HAS_HEATED_BED
lcd_moveto(8, 0);
_draw_bed_status(blink);
//
// Hotend 1 or Bed Temperature
//
#if HAS_MULTI_HOTEND
lcd_moveto(8, 0);
_draw_heater_status(H_E1, LCD_STR_THERMOMETER[0], blink);
#elif HAS_HEATED_BED
lcd_moveto(8, 0);
_draw_bed_status(blink);
#endif
#endif
#else // LCD_WIDTH >= 20
@ -765,17 +809,26 @@ void MarlinUI::draw_status_screen() {
//
// Hotend 0 Temperature
//
_draw_heater_status(H_E0, LCD_STR_THERMOMETER[0], blink);
#if HAS_HOTEND
_draw_heater_status(H_E0, LCD_STR_THERMOMETER[0], blink);
//
// Hotend 1 or Bed Temperature
//
#if HAS_MULTI_HOTEND
lcd_moveto(10, 0);
_draw_heater_status(H_E1, LCD_STR_THERMOMETER[0], blink);
#elif HAS_HEATED_BED
lcd_moveto(10, 0);
_draw_bed_status(blink);
//
// Hotend 1 or Bed Temperature
//
#if HAS_MULTI_HOTEND
lcd_moveto(10, 0);
_draw_heater_status(H_E1, LCD_STR_THERMOMETER[0], blink);
#elif HAS_HEATED_BED
lcd_moveto(10, 0);
_draw_bed_status(blink);
#endif
#endif
#if HAS_COOLER
_draw_cooler_status('*', blink);
#endif
#if HAS_FLOWMETER
_draw_flowmeter_status();
#endif
#endif // LCD_WIDTH >= 20

182
Marlin/src/lcd/dogm/dogm_Statusscreen.h
View File

@ -77,9 +77,12 @@
#ifndef STATUS_CUTTER_WIDTH
#define STATUS_CUTTER_WIDTH 0
#endif
#ifndef STATUS_CUTTER_BYTEWIDTH
#define STATUS_CUTTER_BYTEWIDTH BW(STATUS_CUTTER_WIDTH)
#endif
//
// Laser Cooler
// Laser cooler
//
#if !STATUS_COOLER_WIDTH && HAS_COOLER
#include "status/cooler.h"
@ -87,6 +90,24 @@
#ifndef STATUS_COOLER_WIDTH
#define STATUS_COOLER_WIDTH 0
#endif
#ifndef STATUS_COOLER_BYTEWIDTH
#define STATUS_COOLER_BYTEWIDTH BW(STATUS_COOLER_WIDTH)
#endif
//
// Laser Flowmeter
//
#if !STATUS_FLOWMETER_WIDTH && HAS_FLOWMETER
#include "status/cooler.h"
#endif
#ifndef STATUS_FLOWMETER_WIDTH
#define STATUS_FLOWMETER_WIDTH 0
#endif
#ifndef STATUS_FLOWMETER_BYTEWIDTH
#define STATUS_FLOWMETER_BYTEWIDTH BW(STATUS_FLOWMETER_WIDTH)
#endif
//
// Bed
@ -425,46 +446,45 @@
//
// Cutter Bitmap Properties
//
#ifndef STATUS_CUTTER_BYTEWIDTH
#define STATUS_CUTTER_BYTEWIDTH BW(STATUS_CUTTER_WIDTH)
#endif
#if STATUS_CUTTER_WIDTH
#if HAS_CUTTER
#if STATUS_CUTTER_WIDTH
#ifndef STATUS_CUTTER_X
#define STATUS_CUTTER_X (LCD_PIXEL_WIDTH - (STATUS_CUTTER_BYTEWIDTH + STATUS_CUTTER_BYTEWIDTH) * 8)
#endif
#ifndef STATUS_CUTTER_HEIGHT
#ifdef STATUS_CUTTER_ANIM
#define STATUS_CUTTER_HEIGHT(S) ((S) ? sizeof(status_cutter_on_bmp) / (STATUS_CUTTER_BYTEWIDTH) : sizeof(status_cutter_bmp) / (STATUS_CUTTER_BYTEWIDTH))
#else
#define STATUS_CUTTER_HEIGHT(S) (sizeof(status_cutter_bmp) / (STATUS_CUTTER_BYTEWIDTH))
#ifndef STATUS_CUTTER_X
#define STATUS_CUTTER_X (LCD_PIXEL_WIDTH - (STATUS_CUTTER_BYTEWIDTH + STATUS_CUTTER_BYTEWIDTH) * 8)
#endif
#endif
#ifndef STATUS_CUTTER_Y
#define STATUS_CUTTER_Y(S) 4
#endif
#ifndef STATUS_CUTTER_HEIGHT
#ifdef STATUS_CUTTER_ANIM
#define STATUS_CUTTER_HEIGHT(S) ((S) ? sizeof(status_cutter_on_bmp) / (STATUS_CUTTER_BYTEWIDTH) : sizeof(status_cutter_bmp) / (STATUS_CUTTER_BYTEWIDTH))
#else
#define STATUS_CUTTER_HEIGHT(S) (sizeof(status_cutter_bmp) / (STATUS_CUTTER_BYTEWIDTH))
#endif
#endif
#ifndef STATUS_CUTTER_TEXT_X
#define STATUS_CUTTER_TEXT_X (STATUS_CUTTER_X -1)
#endif
#ifndef STATUS_CUTTER_Y
#define STATUS_CUTTER_Y(S) 4
#endif
#ifndef STATUS_CUTTER_TEXT_Y
#define STATUS_CUTTER_TEXT_Y 28
#endif
#ifndef STATUS_CUTTER_TEXT_X
#define STATUS_CUTTER_TEXT_X (STATUS_CUTTER_X -1)
#endif
#ifndef STATUS_CUTTER_TEXT_Y
#define STATUS_CUTTER_TEXT_Y 28
#endif
static_assert(
sizeof(status_cutter_bmp) == (STATUS_CUTTER_BYTEWIDTH) * (STATUS_CUTTER_HEIGHT(0)),
"Status cutter bitmap (status_cutter_bmp) dimensions don't match data."
);
#ifdef STATUS_CUTTER_ANIM
static_assert(
sizeof(status_cutter_on_bmp) == (STATUS_CUTTER_BYTEWIDTH) * (STATUS_CUTTER_HEIGHT(1)),
"Status cutter bitmap (status_cutter_on_bmp) dimensions don't match data."
sizeof(status_cutter_bmp) == (STATUS_CUTTER_BYTEWIDTH) * (STATUS_CUTTER_HEIGHT(0)),
"Status cutter bitmap (status_cutter_bmp) dimensions don't match data."
);
#endif
#ifdef STATUS_CUTTER_ANIM
static_assert(
sizeof(status_cutter_on_bmp) == (STATUS_CUTTER_BYTEWIDTH) * (STATUS_CUTTER_HEIGHT(1)),
"Status cutter bitmap (status_cutter_on_bmp) dimensions don't match data."
);
#endif
#endif
#endif
//
@ -511,42 +531,72 @@
//
// Cooler Bitmap Properties
//
#ifndef STATUS_COOLER_BYTEWIDTH
#define STATUS_COOLER_BYTEWIDTH BW(STATUS_COOLER_WIDTH)
#endif
#if STATUS_COOLER_WIDTH
#if HAS_COOLER
#if STATUS_COOLER_WIDTH
#ifndef STATUS_COOLER_X
#define STATUS_COOLER_X (LCD_PIXEL_WIDTH - (STATUS_COOLER_BYTEWIDTH + STATUS_FAN_BYTEWIDTH + STATUS_CUTTER_BYTEWIDTH) * 8)
#endif
#ifndef STATUS_COOLER_X
#define STATUS_COOLER_X (LCD_PIXEL_WIDTH - (STATUS_COOLER_BYTEWIDTH + STATUS_FAN_BYTEWIDTH + STATUS_CUTTER_BYTEWIDTH) * 8)
#endif
#ifndef STATUS_COOLER_HEIGHT
#ifndef STATUS_COOLER_HEIGHT
#define STATUS_COOLER_HEIGHT(S) (sizeof(status_cooler_bmp1) / (STATUS_COOLER_BYTEWIDTH))
#endif
#ifndef STATUS_COOLER_Y
#define STATUS_COOLER_Y(S) (18 - STATUS_COOLER_HEIGHT(S))
#endif
#ifndef STATUS_COOLER_TEXT_X
#define STATUS_COOLER_TEXT_X (STATUS_COOLER_X + 8)
#endif
static_assert(
sizeof(status_cooler_bmp1) == (STATUS_COOLER_BYTEWIDTH) * (STATUS_COOLER_HEIGHT(0)),
"Status cooler bitmap (status_cooler_bmp1) dimensions don't match data."
);
#ifdef STATUS_COOLER_ANIM
#define STATUS_COOLER_HEIGHT(S) ((S) ? sizeof(status_cooler_on_bmp) / (STATUS_COOLER_BYTEWIDTH) : sizeof(status_cooler_bmp) / (STATUS_COOLER_BYTEWIDTH))
#else
#define STATUS_COOLER_HEIGHT(S) (sizeof(status_cooler_bmp) / (STATUS_COOLER_BYTEWIDTH))
static_assert(
sizeof(status_cooler_bmp2) == (STATUS_COOLER_BYTEWIDTH) * (STATUS_COOLER_HEIGHT(1)),
"Status cooler bitmap (status_cooler_bmp2) dimensions don't match data."
);
#endif
#endif
#endif
//
// Flowmeter Bitmap Properties
//
#if HAS_FLOWMETER
#if STATUS_FLOWMETER_WIDTH
#ifndef STATUS_FLOWMETER_X
#define STATUS_FLOWMETER_X (LCD_PIXEL_WIDTH - (STATUS_FLOWMETER_BYTEWIDTH + STATUS_FAN_BYTEWIDTH + STATUS_CUTTER_BYTEWIDTH + STATUS_COOLER_BYTEWIDTH) * 8)
#endif
#ifndef STATUS_FLOWMETER_HEIGHT
#define STATUS_FLOWMETER_HEIGHT(S) (sizeof(status_flowmeter_bmp1) / (STATUS_FLOWMETER_BYTEWIDTH))
#endif
#ifndef STATUS_FLOWMETER_Y
#define STATUS_FLOWMETER_Y(S) (20 - STATUS_FLOWMETER_HEIGHT(S))
#endif
#ifndef STATUS_FLOWMETER_TEXT_X
#define STATUS_FLOWMETER_TEXT_X (STATUS_FLOWMETER_X + 8)
#endif
static_assert(
sizeof(status_flowmeter_bmp1) == (STATUS_FLOWMETER_BYTEWIDTH) * STATUS_FLOWMETER_HEIGHT(0),
"Status flowmeter bitmap (status_flowmeter_bmp1) dimensions don't match data."
);
#ifdef STATUS_COOLER_ANIM
static_assert(
sizeof(status_flowmeter_bmp2) == (STATUS_FLOWMETER_BYTEWIDTH) * STATUS_FLOWMETER_HEIGHT(1),
"Status flowmeter bitmap (status_flowmeter_bmp2) dimensions don't match data."
);
#endif
#endif
#ifndef STATUS_COOLER_Y
#define STATUS_COOLER_Y(S) (18 - STATUS_COOLER_HEIGHT(S))
#endif
#ifndef STATUS_COOLER_TEXT_X
#define STATUS_COOLER_TEXT_X (STATUS_COOLER_X + 8)
#endif
static_assert(
sizeof(status_cooler_bmp) == (STATUS_COOLER_BYTEWIDTH) * (STATUS_COOLER_HEIGHT(0)),
"Status cooler bitmap (status_cooler_bmp) dimensions don't match data."
);
#ifdef STATUS_COOLER_ANIM
static_assert(
sizeof(status_cooler_on_bmp) == (STATUS_COOLER_BYTEWIDTH) * (STATUS_COOLER_HEIGHT(1)),
"Status cooler bitmap (status_cooler_on_bmp) dimensions don't match data."
);
#endif
#endif
//
@ -639,6 +689,9 @@
#if HAS_COOLER
#define DO_DRAW_COOLER 1
#endif
#if HAS_FLOWMETER
#define DO_DRAW_FLOWMETER 1
#endif
#if HAS_TEMP_CHAMBER && STATUS_CHAMBER_WIDTH && HOTENDS <= 4
#define DO_DRAW_CHAMBER 1
@ -661,6 +714,9 @@
#if BOTH(DO_DRAW_COOLER, STATUS_COOLER_ANIM)
#define ANIM_COOLER 1
#endif
#if BOTH(DO_DRAW_FLOWMETER, STATUS_FLOWMETER_ANIM)
#define ANIM_FLOWMETER 1
#endif
#if ANIM_HOTEND || ANIM_BED || ANIM_CHAMBER || ANIM_CUTTER
#define ANIM_HBCC 1
#endif

94
Marlin/src/lcd/dogm/status/cooler.h
View File

@ -24,12 +24,9 @@
//
// lcd/dogm/status/cooler.h - Status Screen Laser Cooler bitmaps
//
#define STATUS_COOLER_WIDTH 16
#ifdef STATUS_COOLER_ANIM
const unsigned char status_cooler_on_bmp[] PROGMEM = {
#if HAS_COOLER
#define STATUS_COOLER_WIDTH 16
const unsigned char status_cooler_bmp2[] PROGMEM = {
B00010000,B00001000,
B00010010,B01001001,
B01010100,B00101010,
@ -47,24 +44,71 @@
B00000010,B10100000,
B00000100,B10010000
};
const unsigned char status_cooler_bmp1[] PROGMEM = {
B00010000,B00001000,
B00010010,B01001001,
B01010100,B00101010,
B00101000,B00010100,
B11000111,B01100011,
B00101000,B00010100,
B01010100,B00101010,
B10010000,B10001001,
B00010000,B10000000,
B00000100,B10010000,
B00000010,B10100000,
B00000001,B01000000,
B00011110,B00111100,
B00000001,B01000000,
B00000010,B10100000,
B00000100,B10010000
};
#endif
#if HAS_FLOWMETER
#define STATUS_FLOWMETER_WIDTH 24
const unsigned char status_flowmeter_bmp2[] PROGMEM = {
B00000001,B11111000,B00000000,
B00000110,B00000110,B00000000,
B00001000,B01100001,B00000000,
B00010000,B01100000,B10000000,
B00100000,B01100000,B01000000,
B00100000,B01100000,B01000000,
B01000000,B01100000,B00100000,
B01000000,B01100000,B00100000,
B01011111,B11111111,B10100000,
B01011111,B11111111,B10100000,
B01000000,B01100000,B00100000,
B01000000,B01100000,B00100000,
B00100000,B01100000,B01000000,
B00100000,B01100000,B01000000,
B00010000,B01100000,B10000000,
B00001000,B01100001,B00000000,
B00000110,B00000110,B00000000,
B00000001,B11111000,B00000000,
B00000000,B01100000,B00000000,
B00011111,B11111111,B10000000
};
const unsigned char status_flowmeter_bmp1[] PROGMEM = {
B00000001,B11111000,B00000000,
B00000110,B00000110,B00000000,
B00001000,B00000001,B00000000,
B00010100,B00000010,B10000000,
B00101110,B00000111,B01000000,
B00100111,B00001110,B01000000,
B01000011,B10011100,B00100000,
B01000001,B11111000,B00100000,
B01000000,B11110000,B00100000,
B01000000,B11110000,B00100000,
B01000001,B11111000,B00100000,
B01000011,B10011100,B00100000,
B00100111,B00001110,B01000000,
B00101110,B00000111,B01000000,
B00010100,B00000010,B10000000,
B00001000,B00000001,B00000000,
B00000110,B00000110,B00000000,
B00000001,B11111000,B00000000,
B00000000,B01100000,B00000000,
B00011111,B11111111,B10000000
};
#endif
const unsigned char status_cooler_bmp[] PROGMEM = {
B00010000,B00001000,
B00010010,B01001001,
B01010100,B00101010,
B00101000,B00010100,
B11000111,B01100011,
B00101000,B00010100,
B01010100,B00101010,
B10010000,B10001001,
B00010000,B10000000,
B00000100,B10010000,
B00000010,B10100000,
B00000001,B01000000,
B00011110,B00111100,
B00000001,B01000000,
B00000010,B10100000,
B00000100,B10010000
};

80
Marlin/src/lcd/dogm/status_screen_DOGM.cpp
View File

@ -53,6 +53,10 @@
#include "../../feature/spindle_laser.h"
#endif
#if HAS_COOLER || HAS_FLOWMETER
#include "../../feature/cooler.h"
#endif
#if HAS_POWER_MONITOR
#include "../../feature/power_monitor.h"
#endif
@ -83,40 +87,34 @@
#if ANIM_HBCC
enum HeatBits : uint8_t {
HEATBIT_HOTEND,
HEATBIT_BED = HOTENDS,
HEATBIT_CHAMBER,
HEATBIT_COOLER,
HEATBIT_CUTTER
DRAWBIT_HOTEND,
DRAWBIT_BED = HOTENDS,
DRAWBIT_CHAMBER,
DRAWBIT_CUTTER
};
IF<(HEATBIT_CUTTER > 7), uint16_t, uint8_t>::type heat_bits;
IF<(DRAWBIT_CUTTER > 7), uint16_t, uint8_t>::type draw_bits;
#endif
#if ANIM_HOTEND
#define HOTEND_ALT(N) TEST(heat_bits, HEATBIT_HOTEND + N)
#define HOTEND_ALT(N) TEST(draw_bits, DRAWBIT_HOTEND + N)
#else
#define HOTEND_ALT(N) false
#endif
#if ANIM_BED
#define BED_ALT() TEST(heat_bits, HEATBIT_BED)
#define BED_ALT() TEST(draw_bits, DRAWBIT_BED)
#else
#define BED_ALT() false
#endif
#if ANIM_CHAMBER
#define CHAMBER_ALT() TEST(heat_bits, HEATBIT_CHAMBER)
#define CHAMBER_ALT() TEST(draw_bits, DRAWBIT_CHAMBER)
#else
#define CHAMBER_ALT() false
#endif
#if ANIM_CUTTER
#define CUTTER_ALT(N) TEST(heat_bits, HEATBIT_CUTTER)
#define CUTTER_ALT(N) TEST(draw_bits, DRAWBIT_CUTTER)
#else
#define CUTTER_ALT() false
#endif
#if ANIM_COOLER
#define COOLER_ALT(N) TEST(heat_bits, HEATBIT_COOLER)
#else
#define COOLER_ALT() false
#endif
#if DO_DRAW_HOTENDS
#define MAX_HOTEND_DRAW _MIN(HOTENDS, ((LCD_PIXEL_WIDTH - (STATUS_LOGO_BYTEWIDTH + STATUS_FAN_BYTEWIDTH) * 8) / (STATUS_HEATERS_XSPACE)))
@ -194,6 +192,15 @@ FORCE_INLINE void _draw_centered_temp(const celsius_t temp, const uint8_t tx, co
lcd_put_wchar(LCD_STR_DEGREE[0]);
}
#if DO_DRAW_FLOWMETER
FORCE_INLINE void _draw_centered_flowrate(const float flow, const uint8_t tx, const uint8_t ty) {
const char *str = ftostr11ns(flow);
const uint8_t len = str[0] != ' ' ? 3 : str[1] != ' ' ? 2 : 1;
lcd_put_u8str(tx - len * (INFO_FONT_WIDTH) / 2 + 1, ty, &str[3-len]);
lcd_put_u8str("L");
}
#endif
#if DO_DRAW_HOTENDS
// Draw hotend bitmap with current and target temperatures
@ -384,6 +391,13 @@ FORCE_INLINE void _draw_centered_temp(const celsius_t temp, const uint8_t tx, co
}
#endif
#if DO_DRAW_FLOWMETER
FORCE_INLINE void _draw_flowmeter_status() {
if (PAGE_CONTAINS(28 - INFO_FONT_ASCENT, 28 - 1))
_draw_centered_flowrate(cooler.flowrate, STATUS_FLOWMETER_TEXT_X, 28);
}
#endif
//
// Before homing, blink '123' <-> '???'.
// Homed but unknown... '123' <-> ' '.
@ -451,17 +465,14 @@ void MarlinUI::draw_status_screen() {
#if ANIM_HBCC
uint8_t new_bits = 0;
#if ANIM_HOTEND
HOTEND_LOOP() if (thermalManager.isHeatingHotend(e)) SBI(new_bits, HEATBIT_HOTEND + e);
HOTEND_LOOP() if (thermalManager.isHeatingHotend(e)) SBI(new_bits, DRAWBIT_HOTEND + e);
#endif
if (TERN0(ANIM_BED, thermalManager.isHeatingBed())) SBI(new_bits, HEATBIT_BED);
if (TERN0(ANIM_BED, thermalManager.isHeatingBed())) SBI(new_bits, DRAWBIT_BED);
#if DO_DRAW_CHAMBER && HAS_HEATED_CHAMBER
if (thermalManager.isHeatingChamber()) SBI(new_bits, HEATBIT_CHAMBER);
if (thermalManager.isHeatingChamber()) SBI(new_bits, DRAWBIT_CHAMBER);
#endif
#if DO_DRAW_COOLER && HAS_COOLER
if (thermalManager.isLaserCooling()) SBI(new_bits, HEATBIT_COOLER);
#endif
if (TERN0(ANIM_CUTTER, cutter.enabled())) SBI(new_bits, HEATBIT_CUTTER);
heat_bits = new_bits;
if (TERN0(ANIM_CUTTER, cutter.enabled())) SBI(new_bits, DRAWBIT_CUTTER);
draw_bits = new_bits;
#endif
const xyz_pos_t lpos = current_position.asLogical();
@ -646,17 +657,21 @@ void MarlinUI::draw_status_screen() {
// Laser Cooler
#if DO_DRAW_COOLER
#if ANIM_COOLER
#define COOLER_BITMAP(S) ((S) ? status_cooler_bmp : status_cooler_on_bmp)
#else
#define COOLER_BITMAP(S) status_cooler_bmp
#endif
const uint8_t coolery = STATUS_COOLER_Y(COOLER_ALT()),
coolerh = STATUS_COOLER_HEIGHT(COOLER_ALT());
const uint8_t coolery = STATUS_COOLER_Y(status_cooler_bmp1),
coolerh = STATUS_COOLER_HEIGHT(status_cooler_bmp1);
if (PAGE_CONTAINS(coolery, coolery + coolerh - 1))
u8g.drawBitmapP(STATUS_COOLER_X, coolery, STATUS_COOLER_BYTEWIDTH, coolerh, COOLER_BITMAP(COOLER_ALT()));
u8g.drawBitmapP(STATUS_COOLER_X, coolery, STATUS_COOLER_BYTEWIDTH, coolerh, blink && cooler.enabled ? status_cooler_bmp2 : status_cooler_bmp1);
#endif
// Laser Cooler Flow Meter
#if DO_DRAW_FLOWMETER
const uint8_t flowmetery = STATUS_FLOWMETER_Y(status_flowmeter_bmp1),
flowmeterh = STATUS_FLOWMETER_HEIGHT(status_flowmeter_bmp1);
if (PAGE_CONTAINS(flowmetery, flowmetery + flowmeterh - 1))
u8g.drawBitmapP(STATUS_FLOWMETER_X, flowmetery, STATUS_FLOWMETER_BYTEWIDTH, flowmeterh, blink && cooler.flowpulses ? status_flowmeter_bmp2 : status_flowmeter_bmp1);
#endif
// Heated Bed
TERN_(DO_DRAW_BED, _draw_bed_status(blink));
@ -666,6 +681,9 @@ void MarlinUI::draw_status_screen() {
// Cooler
TERN_(DO_DRAW_COOLER, _draw_cooler_status());
// Flowmeter
TERN_(DO_DRAW_FLOWMETER, _draw_flowmeter_status());
// Fan, if a bitmap was provided
#if DO_DRAW_FAN
if (PAGE_CONTAINS(STATUS_FAN_TEXT_Y - INFO_FONT_ASCENT, STATUS_FAN_TEXT_Y - 1)) {

3
Marlin/src/lcd/language/language_en.h
View File

@ -116,10 +116,10 @@ namespace Language_en {
PROGMEM Language_Str MSG_LASER_TOGGLE = _UxGT("Toggle Laser");
PROGMEM Language_Str MSG_LASER_PULSE_MS = _UxGT("Test Pulse ms");
PROGMEM Language_Str MSG_LASER_FIRE_PULSE = _UxGT("Fire Pulse");
PROGMEM Language_Str MSG_FLOWMETER_FAULT = _UxGT("Coolant Flow Fault");
PROGMEM Language_Str MSG_SPINDLE_TOGGLE = _UxGT("Toggle Spindle");
PROGMEM Language_Str MSG_SPINDLE_FORWARD = _UxGT("Spindle Forward");
PROGMEM Language_Str MSG_SPINDLE_REVERSE = _UxGT("Spindle Reverse");
PROGMEM Language_Str MSG_SWITCH_PS_ON = _UxGT("Switch Power On");
PROGMEM Language_Str MSG_SWITCH_PS_OFF = _UxGT("Switch Power Off");
PROGMEM Language_Str MSG_EXTRUDE = _UxGT("Extrude");
@ -278,6 +278,7 @@ namespace Language_en {
PROGMEM Language_Str MSG_CHAMBER = _UxGT("Enclosure");
PROGMEM Language_Str MSG_COOLER = _UxGT("Laser Coolant");
PROGMEM Language_Str MSG_COOLER_TOGGLE = _UxGT("Toggle Cooler");
PROGMEM Language_Str MSG_FLOWMETER_SAFETY = _UxGT("Flow Safety");
PROGMEM Language_Str MSG_LASER = _UxGT("Laser");
PROGMEM Language_Str MSG_FAN_SPEED = _UxGT("Fan Speed");
PROGMEM Language_Str MSG_FAN_SPEED_N = _UxGT("Fan Speed ~");

6
Marlin/src/lcd/marlinui.cpp
View File

@ -1513,6 +1513,12 @@ void MarlinUI::update() {
TERN_(HAS_LCD_MENU, return_to_status());
}
void MarlinUI::flow_fault() {
LCD_ALERTMESSAGEPGM(MSG_FLOWMETER_FAULT);
TERN_(HAS_BUZZER, buzz(1000, 440));
TERN_(HAS_LCD_MENU, return_to_status());
}
#if ANY(PARK_HEAD_ON_PAUSE, SDSUPPORT)
#include "../gcode/queue.h"
#endif

5
Marlin/src/lcd/marlinui.h
View File

@ -43,6 +43,10 @@
#define HAS_ENCODER_ACTION 1
#endif
#if HAS_STATUS_MESSAGE
#define START_OF_UTF8_CHAR(C) (((C) & 0xC0u) != 0x80U)
#endif
#if E_MANUAL > 1
#define MULTI_MANUAL 1
#endif
@ -311,6 +315,7 @@ public:
static void abort_print();
static void pause_print();
static void resume_print();
static void flow_fault();
#if HAS_WIRED_LCD

14
Marlin/src/lcd/menu/menu_temperature.cpp
View File

@ -35,7 +35,7 @@
#include "../../module/motion.h"
#endif
#if HAS_COOLER
#if HAS_COOLER || HAS_FLOWMETER
#include "../../feature/cooler.h"
#endif
@ -192,11 +192,19 @@ void menu_temperature() {
// Cooler:
//
#if HAS_COOLER
editable.state = cooler.is_enabled();
EDIT_ITEM(bool, MSG_COOLER(TOGGLE), &cooler.state, []{ if (editable.state) cooler.disable(); else cooler.enable(); });
bool cstate = cooler.enabled;
EDIT_ITEM(bool, MSG_COOLER_TOGGLE, &cstate, cooler.toggle);
EDIT_ITEM_FAST(int3, MSG_COOLER, &thermalManager.temp_cooler.target, COOLER_MIN_TARGET, COOLER_MAX_TARGET, thermalManager.start_watching_cooler);
#endif
//
// Flow Meter Safety Shutdown:
//
#if ENABLED(FLOWMETER_SAFETY)
bool fstate = cooler.flowsafety_enabled;
EDIT_ITEM(bool, MSG_FLOWMETER_SAFETY, &fstate, cooler.flowsafety_toggle);
#endif
//
// Fan Speed:
//