thomas
/
marlin
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Y-center GLCD status logo, reorganize (#19954) 

Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
Alexander D. Kanevskiy 4 years ago
parent
12e8861a1c
commit
83097657d5
No account linked to committer's email address
7 changed files with 1365 additions and 1208 deletions
Split View Show Diff Stats
  1. 28
    1208
      Marlin/src/lcd/dogm/dogm_Statusscreen.h
  2. 110
    0
      Marlin/src/lcd/dogm/status/bed.h
  3. 89
    0
      Marlin/src/lcd/dogm/status/chamber.h
  4. 236
    0
      Marlin/src/lcd/dogm/status/combined.h
  5. 123
    0
      Marlin/src/lcd/dogm/status/cutter.h
  6. 443
    0
      Marlin/src/lcd/dogm/status/fan.h
  7. 336
    0
      Marlin/src/lcd/dogm/status/hotend.h

+ 28
- 1208
Marlin/src/lcd/dogm/dogm_Statusscreen.h
File diff suppressed because it is too large
View File


+ 110
- 0
Marlin/src/lcd/dogm/status/bed.h View File 

@@ -0,0 +1,110 @@
1 
+/**
2 
+ * Marlin 3D Printer Firmware
3 
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
4 
+ *
5 
+ * Based on Sprinter and grbl.
6 
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
7 
+ *
8 
+ * This program is free software: you can redistribute it and/or modify
9 
+ * it under the terms of the GNU General Public License as published by
10 
+ * the Free Software Foundation, either version 3 of the License, or
11 
+ * (at your option) any later version.
12 
+ *
13 
+ * This program is distributed in the hope that it will be useful,
14 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
+ * GNU General Public License for more details.
17 
+ *
18 
+ * You should have received a copy of the GNU General Public License
19 
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
20 
+ *
21 
+ */
22 
+#pragma once
23 
+
24 
+//
25 
+// lcd/dogm/status/bed.h - Status Screen Bed bitmaps
26 
+//
27 
+
28 
+#if ENABLED(STATUS_ALT_BED_BITMAP)
29 
+
30 
+  #define STATUS_BED_ANIM
31 
+  #define STATUS_BED_WIDTH  24
32 
+  #ifndef STATUS_BED_X
33 
+    #define STATUS_BED_X   (LCD_PIXEL_WIDTH - (STATUS_BED_BYTEWIDTH + STATUS_CHAMBER_BYTEWIDTH + STATUS_FAN_BYTEWIDTH) * 8)
34 
+  #endif
35 
+  #define STATUS_BED_TEXT_X (STATUS_BED_X + 11)
36 
+
37 
+  const unsigned char status_bed_bmp[] PROGMEM = {
38 
+    B11111111,B11111111,B11000000,
39 
+    B01000000,B00000000,B00100000,
40 
+    B00100000,B00000000,B00010000,
41 
+    B00010000,B00000000,B00001000,
42 
+    B00001000,B00000000,B00000100,
43 
+    B00000100,B00000000,B00000010,
44 
+    B00000011,B11111111,B11111111
45 
+  };
46 
+
47 
+  const unsigned char status_bed_on_bmp[] PROGMEM = {
48 
+    B00000010,B00100010,B00000000,
49 
+    B00000100,B01000100,B00000000,
50 
+    B00000100,B01000100,B00000000,
51 
+    B00000010,B00100010,B00000000,
52 
+    B00000001,B00010001,B00000000,
53 
+    B11111111,B11111111,B11000000,
54 
+    B01000000,B10001000,B10100000,
55 
+    B00100001,B00010001,B00010000,
56 
+    B00010010,B00100010,B00001000,
57 
+    B00001000,B00000000,B00000100,
58 
+    B00000100,B00000000,B00000010,
59 
+    B00000011,B11111111,B11111111
60 
+  };
61 
+
62 
+#else
63 
+
64 
+  #define STATUS_BED_WIDTH  21
65 
+  #ifndef STATUS_BED_X
66 
+    #define STATUS_BED_X   (LCD_PIXEL_WIDTH - (STATUS_BED_BYTEWIDTH + STATUS_CHAMBER_BYTEWIDTH + STATUS_FAN_BYTEWIDTH) * 8)
67 
+  #endif
68 
+
69 
+  #ifdef STATUS_BED_ANIM
70 
+
71 
+    const unsigned char status_bed_bmp[] PROGMEM = {
72 
+      B00011111,B11111111,B11111000,
73 
+      B00011111,B11111111,B11111000
74 
+    };
75 
+
76 
+    const unsigned char status_bed_on_bmp[] PROGMEM = {
77 
+      B00000100,B00010000,B01000000,
78 
+      B00000010,B00001000,B00100000,
79 
+      B00000010,B00001000,B00100000,
80 
+      B00000100,B00010000,B01000000,
81 
+      B00001000,B00100000,B10000000,
82 
+      B00010000,B01000001,B00000000,
83 
+      B00010000,B01000001,B00000000,
84 
+      B00001000,B00100000,B10000000,
85 
+      B00000100,B00010000,B01000000,
86 
+      B00000000,B00000000,B00000000,
87 
+      B00011111,B11111111,B11111000,
88 
+      B00011111,B11111111,B11111000
89 
+    };
90 
+
91 
+  #else
92 
+
93 
+    const unsigned char status_bed_bmp[] PROGMEM = {
94 
+      B00000100,B00010000,B01000000,
95 
+      B00000010,B00001000,B00100000,
96 
+      B00000010,B00001000,B00100000,
97 
+      B00000100,B00010000,B01000000,
98 
+      B00001000,B00100000,B10000000,
99 
+      B00010000,B01000001,B00000000,
100 
+      B00010000,B01000001,B00000000,
101 
+      B00001000,B00100000,B10000000,
102 
+      B00000100,B00010000,B01000000,
103 
+      B00000000,B00000000,B00000000,
104 
+      B00011111,B11111111,B11111000,
105 
+      B00011111,B11111111,B11111000
106 
+    };
107 
+
108 
+  #endif
109 
+
110 
+#endif

+ 89
- 0
Marlin/src/lcd/dogm/status/chamber.h View File 

@@ -0,0 +1,89 @@
1 
+/**
2 
+ * Marlin 3D Printer Firmware
3 
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
4 
+ *
5 
+ * Based on Sprinter and grbl.
6 
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
7 
+ *
8 
+ * This program is free software: you can redistribute it and/or modify
9 
+ * it under the terms of the GNU General Public License as published by
10 
+ * the Free Software Foundation, either version 3 of the License, or
11 
+ * (at your option) any later version.
12 
+ *
13 
+ * This program is distributed in the hope that it will be useful,
14 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
+ * GNU General Public License for more details.
17 
+ *
18 
+ * You should have received a copy of the GNU General Public License
19 
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
20 
+ *
21 
+ */
22 
+#pragma once
23 
+
24 
+//
25 
+// lcd/dogm/status/chamber.h - Status Screen Chamber bitmaps
26 
+//
27 
+
28 
+#define STATUS_CHAMBER_WIDTH 21
29 
+#if STATUS_HEATERS_WIDTH
30 
+  #if ENABLED(STATUS_COMBINE_HEATERS)
31 
+    #define STATUS_CHAMBER_X (LCD_PIXEL_WIDTH - 2 - (STATUS_CHAMBER_BYTEWIDTH) * 8)
32 
+  #elif HAS_FAN0 && HAS_HEATED_BED && HOTENDS <= 2
33 
+    #define STATUS_CHAMBER_X (LCD_PIXEL_WIDTH - 2 - (STATUS_HEATERS_BYTEWIDTH - STATUS_CHAMBER_BYTEWIDTH) * 8)
34 
+  #elif HAS_FAN0 && !HAS_HEATED_BED
35 
+    #define STATUS_CHAMBER_X (LCD_PIXEL_WIDTH - (STATUS_CHAMBER_BYTEWIDTH + STATUS_FAN_BYTEWIDTH) * 8)
36 
+  #else
37 
+    #define STATUS_CHAMBER_X (LCD_PIXEL_WIDTH - (STATUS_CHAMBER_BYTEWIDTH) * 8)
38 
+  #endif
39 
+#endif
40 
+
41 
+#ifdef STATUS_CHAMBER_ANIM
42 
+
43 
+  const unsigned char status_chamber_bmp[] PROGMEM = {
44 
+    B00011111,B11111111,B11111000,
45 
+    B00010000,B00000000,B00001000,
46 
+    B00010000,B00000000,B00001000,
47 
+    B00010000,B00000000,B00001000,
48 
+    B00010000,B00000000,B00001000,
49 
+    B00010000,B00000000,B00001000,
50 
+    B00010000,B00000000,B00001000,
51 
+    B00010000,B00000000,B00001000,
52 
+    B00010000,B00000000,B00001000,
53 
+    B00010000,B00000000,B00001000,
54 
+    B00011111,B11111111,B11111000,
55 
+    B00011111,B11111111,B11111000
56 
+  };
57 
+  const unsigned char status_chamber_on_bmp[] PROGMEM = {
58 
+    B00011111,B11111111,B11111000,
59 
+    B00010000,B00000000,B00001000,
60 
+    B00010000,B10000100,B00001000,
61 
+    B00010000,B01000010,B00001000,
62 
+    B00010000,B01000010,B00001000,
63 
+    B00010000,B10000100,B00001000,
64 
+    B00010001,B00001000,B00001000,
65 
+    B00010001,B00001000,B00001000,
66 
+    B00010000,B10000100,B00001000,
67 
+    B00010000,B00000000,B00001000,
68 
+    B00011111,B11111111,B11111000,
69 
+    B00011111,B11111111,B11111000
70 
+  };
71 
+
72 
+#else
73 
+
74 
+  const unsigned char status_chamber_bmp[] PROGMEM = {
75 
+    B00011111,B11111111,B11111000,
76 
+    B00010000,B00000000,B00001000,
77 
+    B00010000,B10000100,B00001000,
78 
+    B00010000,B01000010,B00001000,
79 
+    B00010000,B01000010,B00001000,
80 
+    B00010000,B10000100,B00001000,
81 
+    B00010001,B00001000,B00001000,
82 
+    B00010001,B00001000,B00001000,
83 
+    B00010000,B10000100,B00001000,
84 
+    B00010000,B00000000,B00001000,
85 
+    B00011111,B11111111,B11111000,
86 
+    B00011111,B11111111,B11111000
87 
+  };
88 
+
89 
+#endif

+ 236
- 0
Marlin/src/lcd/dogm/status/combined.h View File 

@@ -0,0 +1,236 @@
1 
+/**
2 
+ * Marlin 3D Printer Firmware
3 
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
4 
+ *
5 
+ * Based on Sprinter and grbl.
6 
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
7 
+ *
8 
+ * This program is free software: you can redistribute it and/or modify
9 
+ * it under the terms of the GNU General Public License as published by
10 
+ * the Free Software Foundation, either version 3 of the License, or
11 
+ * (at your option) any later version.
12 
+ *
13 
+ * This program is distributed in the hope that it will be useful,
14 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
+ * GNU General Public License for more details.
17 
+ *
18 
+ * You should have received a copy of the GNU General Public License
19 
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
20 
+ *
21 
+ */
22 
+#pragma once
23 
+
24 
+//
25 
+// lcd/dogm/status/combined.h - Status Screen Combined Heater bitmaps
26 
+//
27 
+
28 
+#undef STATUS_HOTEND_ANIM
29 
+#undef STATUS_BED_ANIM
30 
+#define STATUS_HEATERS_XSPACE 24
31 
+
32 
+#if HAS_HEATED_BED && HOTENDS <= 4
33 
+
34 
+  #if HOTENDS == 0
35 
+
36 
+    #define STATUS_HEATERS_WIDTH 96
37 
+
38 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
39 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
40 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000010,B00001000,B00100000,
41 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000010,B00001000,B00100000,
42 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
43 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001000,B00100000,B10000000,
44 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00010000,B01000001,B00000000,
45 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00010000,B01000001,B00000000,
46 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001000,B00100000,B10000000,
47 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
48 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
49 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111000,
50 
+      B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111000
51 
+    };
52 
+
53 
+  #elif HOTENDS == 1
54 
+
55 
+    #define STATUS_HEATERS_WIDTH 96
56 
+
57 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
58 
+      B00011111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
59 
+      B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000010,B00001000,B00100000,
60 
+      B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000010,B00001000,B00100000,
61 
+      B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
62 
+      B00011111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001000,B00100000,B10000000,
63 
+      B00011111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00010000,B01000001,B00000000,
64 
+      B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00010000,B01000001,B00000000,
65 
+      B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00001000,B00100000,B10000000,
66 
+      B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
67 
+      B00001111,B11000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
68 
+      B00000111,B10000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111000,
69 
+      B00000011,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111000
70 
+    };
71 
+
72 
+  #elif HOTENDS == 2
73 
+
74 
+    #define STATUS_HEATERS_WIDTH 96
75 
+
76 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
77 
+      B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
78 
+      B00111110,B11110000,B00000000,B00111100,B11110000,B00000000,B00000000,B00000000,B00000000,B00000010,B00001000,B00100000,
79 
+      B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00000000,B00000000,B00000000,B00000010,B00001000,B00100000,
80 
+      B00111010,B11110000,B00000000,B00111111,B01110000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
81 
+      B00011110,B11100000,B00000000,B00011110,B11100000,B00000000,B00000000,B00000000,B00000000,B00001000,B00100000,B10000000,
82 
+      B00011110,B11100000,B00000000,B00011101,B11100000,B00000000,B00000000,B00000000,B00000000,B00010000,B01000001,B00000000,
83 
+      B00111110,B11110000,B00000000,B00111011,B11110000,B00000000,B00000000,B00000000,B00000000,B00010000,B01000001,B00000000,
84 
+      B00111110,B11110000,B00000000,B00111000,B01110000,B00000000,B00000000,B00000000,B00000000,B00001000,B00100000,B10000000,
85 
+      B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00000000,B00000000,B00000000,B00000100,B00010000,B01000000,
86 
+      B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,
87 
+      B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111000,
88 
+      B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000000,B00000000,B00000000,B00011111,B11111111,B11111000
89 
+    };
90 
+
91 
+  #elif HOTENDS == 3
92 
+
93 
+    #define STATUS_HEATERS_WIDTH 96
94 
+
95 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
96 
+      B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00000100,B00010000,B01000000,
97 
+      B00111110,B11110000,B00000000,B00111100,B11110000,B00000000,B00111100,B11110000,B00000000,B00000010,B00001000,B00100000,
98 
+      B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,B00000000,B00000010,B00001000,B00100000,
99 
+      B00111010,B11110000,B00000000,B00111111,B01110000,B00000000,B00111111,B01110000,B00000000,B00000100,B00010000,B01000000,
100 
+      B00011110,B11100000,B00000000,B00011110,B11100000,B00000000,B00011100,B11100000,B00000000,B00001000,B00100000,B10000000,
101 
+      B00011110,B11100000,B00000000,B00011101,B11100000,B00000000,B00011111,B01100000,B00000000,B00010000,B01000001,B00000000,
102 
+      B00111110,B11110000,B00000000,B00111011,B11110000,B00000000,B00111011,B01110000,B00000000,B00010000,B01000001,B00000000,
103 
+      B00111110,B11110000,B00000000,B00111000,B01110000,B00000000,B00111100,B11110000,B00000000,B00001000,B00100000,B10000000,
104 
+      B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00000100,B00010000,B01000000,
105 
+      B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00000000,B00000000,B00000000,
106 
+      B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00011111,B11111111,B11111000,
107 
+      B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00011111,B11111111,B11111000
108 
+    };
109 
+
110 
+  #else // HOTENDS > 3
111 
+
112 
+    #define STATUS_HEATERS_WIDTH 120
113 
+
114 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
115 
+      B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00000100,B00010000,B01000000,
116 
+      B00111110,B11110000,B00000000,B00111100,B11110000,B00000000,B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00000010,B00001000,B00100000,
117 
+      B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,B00000000,B00000010,B00001000,B00100000,
118 
+      B00111010,B11110000,B00000000,B00111111,B01110000,B00000000,B00111111,B01110000,B00000000,B00111011,B01110000,B00000000,B00000100,B00010000,B01000000,
119 
+      B00011110,B11100000,B00000000,B00011110,B11100000,B00000000,B00011100,B11100000,B00000000,B00011011,B01100000,B00000000,B00001000,B00100000,B10000000,
120 
+      B00011110,B11100000,B00000000,B00011101,B11100000,B00000000,B00011111,B01100000,B00000000,B00011000,B00100000,B00000000,B00010000,B01000001,B00000000,
121 
+      B00111110,B11110000,B00000000,B00111011,B11110000,B00000000,B00111011,B01110000,B00000000,B00111111,B01110000,B00000000,B00010000,B01000001,B00000000,
122 
+      B00111110,B11110000,B00000000,B00111000,B01110000,B00000000,B00111100,B11110000,B00000000,B00111111,B01110000,B00000000,B00001000,B00100000,B10000000,
123 
+      B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00000100,B00010000,B01000000,
124 
+      B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00000000,B00000000,B00000000,
125 
+      B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00011111,B11111111,B11111000,
126 
+      B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00011111,B11111111,B11111000
127 
+    };
128 
+
129 
+  #endif // HOTENDS
130 
+
131 
+  #define STATUS_BED_TEXT_X (STATUS_HEATERS_WIDTH - 10)
132 
+
133 
+#else // !HAS_HEATED_BED || HOTENDS > 3
134 
+
135 
+  #if HOTENDS == 0
136 
+
137 
+    #define STATUS_HEATERS_WIDTH  0
138 
+
139 
+  #elif HOTENDS == 1
140 
+
141 
+    #define STATUS_HEATERS_WIDTH  12
142 
+
143 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
144 
+      B00011111,B11100000,
145 
+      B00111111,B11110000,
146 
+      B00111111,B11110000,
147 
+      B00111111,B11110000,
148 
+      B00011111,B11100000,
149 
+      B00011111,B11100000,
150 
+      B00111111,B11110000,
151 
+      B00111111,B11110000,
152 
+      B00111111,B11110000,
153 
+      B00001111,B11000000,
154 
+      B00000111,B10000000,
155 
+      B00000011,B00000000
156 
+    };
157 
+
158 
+  #elif HOTENDS == 2
159 
+
160 
+    #define STATUS_HEATERS_WIDTH  36
161 
+
162 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
163 
+      B00011111,B11100000,B00000000,B00011111,B11100000,
164 
+      B00111110,B11110000,B00000000,B00111100,B11110000,
165 
+      B00111100,B11110000,B00000000,B00111011,B01110000,
166 
+      B00111010,B11110000,B00000000,B00111111,B01110000,
167 
+      B00011110,B11100000,B00000000,B00011110,B11100000,
168 
+      B00011110,B11100000,B00000000,B00011101,B11100000,
169 
+      B00111110,B11110000,B00000000,B00111011,B11110000,
170 
+      B00111110,B11110000,B00000000,B00111000,B01110000,
171 
+      B00111111,B11110000,B00000000,B00111111,B11110000,
172 
+      B00001111,B11000000,B00000000,B00001111,B11000000,
173 
+      B00000111,B10000000,B00000000,B00000111,B10000000,
174 
+      B00000011,B00000000,B00000000,B00000011,B00000000
175 
+    };
176 
+
177 
+  #elif HOTENDS == 3
178 
+
179 
+    #define STATUS_HEATERS_WIDTH  60
180 
+
181 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
182 
+      B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,
183 
+      B00111110,B11110000,B00000000,B00111100,B11110000,B00000000,B00111100,B11110000,
184 
+      B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,
185 
+      B00111010,B11110000,B00000000,B00111111,B01110000,B00000000,B00111111,B01110000,
186 
+      B00011110,B11100000,B00000000,B00011110,B11100000,B00000000,B00011100,B11100000,
187 
+      B00011110,B11100000,B00000000,B00011101,B11100000,B00000000,B00011111,B01100000,
188 
+      B00111110,B11110000,B00000000,B00111011,B11110000,B00000000,B00111011,B01110000,
189 
+      B00111110,B11110000,B00000000,B00111000,B01110000,B00000000,B00111100,B11110000,
190 
+      B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,
191 
+      B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,
192 
+      B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,
193 
+      B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000
194 
+    };
195 
+
196 
+  #elif HOTENDS == 4
197 
+
198 
+    #define STATUS_HEATERS_WIDTH  84
199 
+
200 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
201 
+      B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,
202 
+      B00111110,B11110000,B00000000,B00111100,B11110000,B00000000,B00111100,B11110000,B00000000,B00111011,B01110000,
203 
+      B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,
204 
+      B00111010,B11110000,B00000000,B00111111,B01110000,B00000000,B00111111,B01110000,B00000000,B00111011,B01110000,
205 
+      B00011110,B11100000,B00000000,B00011110,B11100000,B00000000,B00011100,B11100000,B00000000,B00011011,B01100000,
206 
+      B00011110,B11100000,B00000000,B00011101,B11100000,B00000000,B00011111,B01100000,B00000000,B00011000,B00100000,
207 
+      B00111110,B11110000,B00000000,B00111011,B11110000,B00000000,B00111011,B01110000,B00000000,B00111111,B01110000,
208 
+      B00111110,B11110000,B00000000,B00111000,B01110000,B00000000,B00111100,B11110000,B00000000,B00111111,B01110000,
209 
+      B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,
210 
+      B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,
211 
+      B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,
212 
+      B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000
213 
+    };
214 
+
215 
+  #else // HOTENDS > 4
216 
+
217 
+    #define STATUS_HEATERS_WIDTH  108
218 
+
219 
+    const unsigned char status_heaters_bmp[] PROGMEM = {
220 
+      B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,B00000000,B00011111,B11100000,
221 
+      B00111110,B11110000,B00000000,B00111100,B11110000,B00000000,B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00111000,B01110000,
222 
+      B00111100,B11110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,B00000000,B00111011,B01110000,B00000000,B00111011,B11110000,
223 
+      B00111010,B11110000,B00000000,B00111111,B01110000,B00000000,B00111111,B01110000,B00000000,B00111011,B01110000,B00000000,B00111000,B11110000,
224 
+      B00011110,B11100000,B00000000,B00011110,B11100000,B00000000,B00011100,B11100000,B00000000,B00011011,B01100000,B00000000,B00011111,B01100000,
225 
+      B00011110,B11100000,B00000000,B00011101,B11100000,B00000000,B00011111,B01100000,B00000000,B00011000,B00100000,B00000000,B00011111,B01100000,
226 
+      B00111110,B11110000,B00000000,B00111011,B11110000,B00000000,B00111011,B01110000,B00000000,B00111111,B01110000,B00000000,B00111011,B01110000,
227 
+      B00111110,B11110000,B00000000,B00111000,B01110000,B00000000,B00111100,B11110000,B00000000,B00111111,B01110000,B00000000,B00111100,B11110000,
228 
+      B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,B00000000,B00111111,B11110000,
229 
+      B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,B00000000,B00001111,B11000000,
230 
+      B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,B00000000,B00000111,B10000000,
231 
+      B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000,B00000000,B00000011,B00000000
232 
+    };
233 
+
234 
+  #endif // HOTENDS
235 
+
236 
+#endif // !HAS_HEATED_BED || HOTENDS > 3

+ 123
- 0
Marlin/src/lcd/dogm/status/cutter.h View File 

@@ -0,0 +1,123 @@
1 
+/**
2 
+ * Marlin 3D Printer Firmware
3 
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
4 
+ *
5 
+ * Based on Sprinter and grbl.
6 
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
7 
+ *
8 
+ * This program is free software: you can redistribute it and/or modify
9 
+ * it under the terms of the GNU General Public License as published by
10 
+ * the Free Software Foundation, either version 3 of the License, or
11 
+ * (at your option) any later version.
12 
+ *
13 
+ * This program is distributed in the hope that it will be useful,
14 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
+ * GNU General Public License for more details.
17 
+ *
18 
+ * You should have received a copy of the GNU General Public License
19 
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
20 
+ *
21 
+ */
22 
+#pragma once
23 
+
24 
+//
25 
+// lcd/dogm/status/cutter.h - Status Screen Laser / Spindle bitmaps
26 
+//
27 
+
28 
+#define STATUS_CUTTER_WIDTH 24
29 
+#define STATUS_CUTTER_X     80
30 
+
31 
+#if ENABLED(LASER_FEATURE)
32 
+  #ifdef STATUS_CUTTER_ANIM
33 
+    const unsigned char status_cutter_on_bmp[] PROGMEM = {
34 
+      B00000000,B00100100,B00000000,
35 
+      B00000000,B01100110,B00000000,
36 
+      B00000000,B11000011,B00000000,
37 
+      B00000001,B10011001,B10000000,
38 
+      B00000011,B00100100,B11000000,
39 
+      B00000000,B01000010,B00000000,
40 
+      B00000000,B01000010,B00000000,
41 
+      B00000011,B00100100,B11000000,
42 
+      B00000001,B10011001,B10000000,
43 
+      B00000000,B11000011,B00000000,
44 
+      B00000000,B01100110,B00000000,
45 
+      B00000000,B00100100,B00000000
46 
+    };
47 
+    const unsigned char status_cutter_bmp[] PROGMEM = {
48 
+      B00000000,B00100100,B00000000,
49 
+      B00000000,B01100110,B00000000,
50 
+      B00000000,B00000000,B00000000,
51 
+      B00000001,B00000000,B10000000,
52 
+      B00000011,B00000000,B11000000,
53 
+      B00000000,B00011000,B00000000,
54 
+      B00000000,B00011000,B00000000,
55 
+      B00000011,B00000000,B11000000,
56 
+      B00000001,B00000000,B10000000,
57 
+      B00000000,B00000000,B00000000,
58 
+      B00000000,B01100110,B00000000,
59 
+      B00000000,B00100100,B00000000
60 
+    };
61 
+  #else
62 
+    const unsigned char status_cutter_bmp[] PROGMEM = {
63 
+      B00000000,B00100100,B00000000,
64 
+      B00000000,B01100110,B00000000,
65 
+      B00000000,B11000011,B00000000,
66 
+      B00000001,B10000001,B10000000,
67 
+      B00000011,B00000000,B11000000,
68 
+      B00000000,B00000000,B00000000,
69 
+      B00000000,B00000000,B00000000,
70 
+      B00000011,B00000000,B11000000,
71 
+      B00000001,B10000001,B10000000,
72 
+      B00000000,B11000011,B00000000,
73 
+      B00000000,B01100110,B00000000,
74 
+      B00000000,B00100100,B00000000
75 
+    };
76 
+  #endif
77 
+#else
78 
+  #ifdef STATUS_CUTTER_ANIM
79 
+    const unsigned char status_cutter_on_bmp[] PROGMEM = {
80 
+      B00000001,B11111110,B10000000,
81 
+      B00000000,B11000000,B00000000,
82 
+      B00000001,B10000000,B10000000,
83 
+      B00000001,B00000000,B10000000,
84 
+      B00000001,B11111100,B10000000,
85 
+      B00000000,B11100000,B00000000,
86 
+      B00000001,B11000000,B10000000,
87 
+      B00000000,B10000001,B00000000,
88 
+      B00000000,B01111010,B00000000,
89 
+      B00000000,B00110100,B00000000,
90 
+      B00000000,B00011000,B00000000,
91 
+      B00000000,B00000000,B00000000
92 
+    };
93 
+    const unsigned char status_cutter_bmp[] PROGMEM = {
94 
+      B00000001,B11111110,B10000000,
95 
+      B00000000,B11000000,B00000000,
96 
+      B00000001,B10000000,B10000000,
97 
+      B00000001,B00000000,B10000000,
98 
+      B00000001,B11111100,B10000000,
99 
+      B00000000,B11100000,B00000000,
100 
+      B00000001,B11000000,B10000000,
101 
+      B00000000,B10000001,B00000000,
102 
+      B00000000,B01111010,B00000000,
103 
+      B00000000,B00110100,B00000000,
104 
+      B00000000,B00011000,B00000000,
105 
+      B00000000,B00000000,B00000000
106 
+    };
107 
+  #else
108 
+    const unsigned char status_cutter_bmp[] PROGMEM = {
109 
+      B00000001,B11000010,B10000000,
110 
+      B00000001,B00011100,B10000000,
111 
+      B00000000,B11100001,B00000000,
112 
+      B00000001,B00001110,B10000000,
113 
+      B00000001,B01110000,B10000000,
114 
+      B00000000,B10000111,B10000000,
115 
+      B00000001,B00111111,B10000000,
116 
+      B00000000,B11111111,B00000000,
117 
+      B00000000,B01111110,B00000000,
118 
+      B00000000,B00111100,B00000000,
119 
+      B00000000,B00011000,B00000000,
120 
+      B00000000,B00000000,B00000000
121 
+    };
122 
+  #endif
123 
+#endif

+ 443
- 0
Marlin/src/lcd/dogm/status/fan.h View File 

@@ -0,0 +1,443 @@
1 
+/**
2 
+ * Marlin 3D Printer Firmware
3 
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
4 
+ *
5 
+ * Based on Sprinter and grbl.
6 
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
7 
+ *
8 
+ * This program is free software: you can redistribute it and/or modify
9 
+ * it under the terms of the GNU General Public License as published by
10 
+ * the Free Software Foundation, either version 3 of the License, or
11 
+ * (at your option) any later version.
12 
+ *
13 
+ * This program is distributed in the hope that it will be useful,
14 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
+ * GNU General Public License for more details.
17 
+ *
18 
+ * You should have received a copy of the GNU General Public License
19 
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
20 
+ *
21 
+ */
22 
+#pragma once
23 
+
24 
+//
25 
+// lcd/dogm/status/fan.h - Status Screen Fan bitmaps
26 
+//
27 
+
28 
+#undef STATUS_FAN_WIDTH
29 
+#define STATUS_FAN_WIDTH 20
30 
+
31 
+#if STATUS_FAN_FRAMES <= 2
32 
+
33 
+  #define STATUS_FAN_Y 2
34 
+
35 
+  #if ENABLED(STATUS_ALT_FAN_BITMAP)
36 
+
37 
+    const unsigned char status_fan0_bmp[] PROGMEM = {
38 
+      B00000001,B11111110,B00000000,
39 
+      B00000110,B00000001,B10000000,
40 
+      B00001000,B11111100,B01000000,
41 
+      B00010000,B11111100,B00100000,
42 
+      B00010000,B01111000,B00100000,
43 
+      B00100000,B00110000,B00010000,
44 
+      B00101100,B00000000,B11010000,
45 
+      B00101110,B00110001,B11010000,
46 
+      B00101111,B01111011,B11010000,
47 
+      B00101111,B01111011,B11010000,
48 
+      B00101110,B00110001,B11010000,
49 
+      B00101100,B00000000,B11010000,
50 
+      B00100000,B00110000,B00010000,
51 
+      B00010000,B01111000,B00100000,
52 
+      B00010000,B11111100,B00100000,
53 
+      B00001000,B11111100,B01000000,
54 
+      B00000110,B00000001,B10000000,
55 
+      B00000001,B11111110,B00000000
56 
+    };
57 
+
58 
+    #if STATUS_FAN_FRAMES == 2
59 
+      const unsigned char status_fan1_bmp[] PROGMEM = {
60 
+        B00000001,B11111110,B00000000,
61 
+        B00000110,B00000001,B10000000,
62 
+        B00001001,B10000110,B01000000,
63 
+        B00010011,B10000111,B00100000,
64 
+        B00010111,B10000111,B10100000,
65 
+        B00101111,B10000111,B11010000,
66 
+        B00101111,B00000011,B11010000,
67 
+        B00100000,B00110000,B00010000,
68 
+        B00100000,B01111000,B00010000,
69 
+        B00100000,B01111000,B00010000,
70 
+        B00100000,B00110000,B00010000,
71 
+        B00101111,B00000011,B11010000,
72 
+        B00101111,B10000111,B11010000,
73 
+        B00010111,B10000111,B10100000,
74 
+        B00010011,B10000111,B00100000,
75 
+        B00001001,B10000110,B01000000,
76 
+        B00000110,B00000001,B10000000,
77 
+        B00000001,B11111110,B00000000
78 
+      };
79 
+    #endif
80 
+
81 
+  #else // !STATUS_ALT_FAN_BITMAP
82 
+
83 
+    const unsigned char status_fan0_bmp[] PROGMEM = {
84 
+      B00111111,B11111111,B11110000,
85 
+      B00111000,B00000000,B01110000,
86 
+      B00110000,B11111100,B00110000,
87 
+      B00100000,B11111100,B00010000,
88 
+      B00100000,B01111000,B00010000,
89 
+      B00100000,B00110000,B00010000,
90 
+      B00101100,B00000000,B11010000,
91 
+      B00101110,B00110001,B11010000,
92 
+      B00101111,B01111011,B11010000,
93 
+      B00101111,B01111011,B11010000,
94 
+      B00101110,B00110001,B11010000,
95 
+      B00101100,B00000000,B11010000,
96 
+      B00100000,B00110000,B00010000,
97 
+      B00100000,B01111000,B00010000,
98 
+      B00100000,B11111100,B00010000,
99 
+      B00110000,B11111100,B00110000,
100 
+      B00111000,B00000000,B01110000,
101 
+      B00111111,B11111111,B11110000
102 
+    };
103 
+
104 
+    #if STATUS_FAN_FRAMES == 2
105 
+      const unsigned char status_fan1_bmp[] PROGMEM = {
106 
+        B00111111,B11111111,B11110000,
107 
+        B00111000,B00000000,B01110000,
108 
+        B00110001,B10000110,B00110000,
109 
+        B00100011,B10000111,B00010000,
110 
+        B00100111,B10000111,B10010000,
111 
+        B00101111,B10000111,B11010000,
112 
+        B00101111,B00000011,B11010000,
113 
+        B00100000,B00110000,B00010000,
114 
+        B00100000,B01111000,B00010000,
115 
+        B00100000,B01111000,B00010000,
116 
+        B00100000,B00110000,B00010000,
117 
+        B00101111,B00000011,B11010000,
118 
+        B00101111,B10000111,B11010000,
119 
+        B00100111,B10000111,B10010000,
120 
+        B00100011,B10000111,B00010000,
121 
+        B00110001,B10000110,B00110000,
122 
+        B00111000,B00000000,B01110000,
123 
+        B00111111,B11111111,B11110000
124 
+      };
125 
+    #endif
126 
+
127 
+  #endif // !STATUS_ALT_FAN_BITMAP
128 
+
129 
+#elif STATUS_FAN_FRAMES == 3
130 
+
131 
+  #if ENABLED(STATUS_ALT_FAN_BITMAP)
132 
+
133 
+    const unsigned char status_fan0_bmp[] PROGMEM = {
134 
+      B00000001,B11111111,B00000000,
135 
+      B00000110,B00000000,B11000000,
136 
+      B00001001,B00000001,B00100000,
137 
+      B00010111,B10000011,B11010000,
138 
+      B00010111,B10000011,B11010000,
139 
+      B00101111,B11000111,B11101000,
140 
+      B00100111,B11000111,B11001000,
141 
+      B00100001,B11111111,B00001000,
142 
+      B00100000,B01111100,B00001000,
143 
+      B00100000,B01111100,B00001000,
144 
+      B00100000,B01111100,B00001000,
145 
+      B00100001,B11111111,B00001000,
146 
+      B00100111,B11000111,B11001000,
147 
+      B00101111,B11000111,B11101000,
148 
+      B00010111,B10000011,B11010000,
149 
+      B00010111,B10000011,B11010000,
150 
+      B00001001,B00000001,B00100000,
151 
+      B00000110,B00000000,B11000000,
152 
+      B00000001,B11111111,B00000000
153 
+    };
154 
+    const unsigned char status_fan1_bmp[] PROGMEM = {
155 
+      B00000001,B11111111,B00000000,
156 
+      B00000110,B00110000,B11000000,
157 
+      B00001001,B11110000,B00100000,
158 
+      B00010001,B11110000,B00010000,
159 
+      B00010000,B11110000,B00010000,
160 
+      B00100000,B11110000,B01101000,
161 
+      B00100000,B00110001,B11101000,
162 
+      B00100000,B00111001,B11101000,
163 
+      B00100000,B01111111,B11111000,
164 
+      B00111111,B11111111,B11111000,
165 
+      B00111111,B11111100,B00001000,
166 
+      B00101111,B00111000,B00001000,
167 
+      B00101110,B00011000,B00001000,
168 
+      B00101100,B00011110,B00001000,
169 
+      B00010000,B00011110,B00010000,
170 
+      B00010000,B00011111,B00010000,
171 
+      B00001000,B00011111,B00100000,
172 
+      B00000110,B00011000,B11000000,
173 
+      B00000001,B11111111,B00000000
174 
+    };
175 
+    const unsigned char status_fan2_bmp[] PROGMEM = {
176 
+      B00000001,B11111111,B00000000,
177 
+      B00000110,B00011000,B11000000,
178 
+      B00001000,B00011111,B00100000,
179 
+      B00010000,B00011111,B10010000,
180 
+      B00010100,B00011111,B00010000,
181 
+      B00101110,B00011110,B00001000,
182 
+      B00101111,B00011100,B00001000,
183 
+      B00101111,B10111000,B00001000,
184 
+      B00111111,B11111100,B00001000,
185 
+      B00111111,B11111111,B11111000,
186 
+      B00100000,B01111111,B11111000,
187 
+      B00100000,B00111011,B11101000,
188 
+      B00100000,B01110001,B11101000,
189 
+      B00100000,B11110000,B11101000,
190 
+      B00010001,B11110000,B01010000,
191 
+      B00010011,B11110000,B00010000,
192 
+      B00001001,B11110000,B00100000,
193 
+      B00000110,B00110000,B11000000,
194 
+      B00000001,B11111111,B00000000
195 
+    };
196 
+
197 
+  #else // !STATUS_ALT_FAN_BITMAP
198 
+
199 
+    const unsigned char status_fan0_bmp[] PROGMEM = {
200 
+      B00111111,B11111111,B11111000,
201 
+      B00111110,B00000000,B11111000,
202 
+      B00111001,B00000001,B00111000,
203 
+      B00110111,B10000011,B11011000,
204 
+      B00110111,B10000011,B11011000,
205 
+      B00101111,B11000111,B11101000,
206 
+      B00100111,B11000111,B11001000,
207 
+      B00100001,B11111111,B00001000,
208 
+      B00100000,B01111100,B00001000,
209 
+      B00100000,B01111100,B00001000,
210 
+      B00100000,B01111100,B00001000,
211 
+      B00100001,B11111111,B00001000,
212 
+      B00100111,B11000111,B11001000,
213 
+      B00101111,B11000111,B11101000,
214 
+      B00110111,B10000011,B11011000,
215 
+      B00110111,B10000011,B11011000,
216 
+      B00111001,B00000001,B00111000,
217 
+      B00111110,B00000000,B11111000,
218 
+      B00111111,B11111111,B11111000
219 
+    };
220 
+    const unsigned char status_fan1_bmp[] PROGMEM = {
221 
+      B00111111,B11111111,B11111000,
222 
+      B00111110,B00110000,B11111000,
223 
+      B00111001,B11110000,B00111000,
224 
+      B00110001,B11110000,B00011000,
225 
+      B00110000,B11110000,B00011000,
226 
+      B00100000,B11110000,B01101000,
227 
+      B00100000,B00110001,B11101000,
228 
+      B00100000,B00111001,B11101000,
229 
+      B00100000,B01111111,B11111000,
230 
+      B00111111,B11111111,B11111000,
231 
+      B00111111,B11111100,B00001000,
232 
+      B00101111,B00111000,B00001000,
233 
+      B00101110,B00011000,B00001000,
234 
+      B00101100,B00011110,B00001000,
235 
+      B00110000,B00011110,B00011000,
236 
+      B00110000,B00011111,B00011000,
237 
+      B00111000,B00011111,B00111000,
238 
+      B00111110,B00011000,B11111000,
239 
+      B00111111,B11111111,B11111000
240 
+    };
241 
+    const unsigned char status_fan2_bmp[] PROGMEM = {
242 
+      B00111111,B11111111,B11111000,
243 
+      B00111110,B00011000,B11111000,
244 
+      B00111000,B00011111,B00111000,
245 
+      B00110000,B00011111,B10011000,
246 
+      B00110100,B00011111,B00011000,
247 
+      B00101110,B00011110,B00001000,
248 
+      B00101111,B00011100,B00001000,
249 
+      B00101111,B10111000,B00001000,
250 
+      B00111111,B11111100,B00001000,
251 
+      B00111111,B11111111,B11111000,
252 
+      B00100000,B01111111,B11111000,
253 
+      B00100000,B00111011,B11101000,
254 
+      B00100000,B01110001,B11101000,
255 
+      B00100000,B11110000,B11101000,
256 
+      B00110001,B11110000,B01011000,
257 
+      B00110011,B11110000,B00011000,
258 
+      B00111001,B11110000,B00111000,
259 
+      B00111110,B00110000,B11111000,
260 
+      B00111111,B11111111,B11111000
261 
+    };
262 
+
263 
+  #endif // !STATUS_ALT_FAN_BITMAP
264 
+
265 
+#elif STATUS_FAN_FRAMES == 4
266 
+
267 
+  #if ENABLED(STATUS_ALT_FAN_BITMAP)
268 
+
269 
+    const unsigned char status_fan0_bmp[] PROGMEM = {
270 
+      B00000001,B11111111,B00000000,
271 
+      B00000110,B00000000,B11000000,
272 
+      B00001000,B00111111,B00100000,
273 
+      B00010000,B01111110,B00010000,
274 
+      B00010000,B01111100,B00010000,
275 
+      B00101000,B01111100,B00001000,
276 
+      B00101100,B00111000,B00001000,
277 
+      B00101111,B00111001,B11001000,
278 
+      B00101111,B11111111,B11101000,
279 
+      B00101111,B11000111,B11101000,
280 
+      B00101111,B11111111,B11101000,
281 
+      B00100111,B00111001,B11101000,
282 
+      B00100000,B00111000,B01101000,
283 
+      B00100000,B01111100,B00101000,
284 
+      B00010000,B01111100,B00010000,
285 
+      B00010000,B11111100,B00010000,
286 
+      B00001001,B11111000,B00100000,
287 
+      B00000110,B00000000,B11000000,
288 
+      B00000001,B11111111,B00000000
289 
+    };
290 
+    const unsigned char status_fan1_bmp[] PROGMEM = {
291 
+      B00000001,B11111111,B00000000,
292 
+      B00000110,B00000000,B11000000,
293 
+      B00001000,B00001111,B00100000,
294 
+      B00010100,B00011111,B11010000,
295 
+      B00010110,B00011111,B10010000,
296 
+      B00101111,B00011111,B00001000,
297 
+      B00101111,B10011110,B00001000,
298 
+      B00101111,B11111100,B00001000,
299 
+      B00101111,B11011100,B00001000,
300 
+      B00100111,B11101111,B11001000,
301 
+      B00100000,B01110111,B11101000,
302 
+      B00100000,B01111111,B11101000,
303 
+      B00100000,B11110011,B11101000,
304 
+      B00100001,B11110001,B11101000,
305 
+      B00010011,B11110000,B11010000,
306 
+      B00010111,B11110000,B01010000,
307 
+      B00001001,B11100000,B00100000,
308 
+      B00000110,B00000000,B11000000,
309 
+      B00000001,B11111111,B00000000
310 
+    };
311 
+    const unsigned char status_fan2_bmp[] PROGMEM = {
312 
+      B00000001,B11111111,B00000000,
313 
+      B00000110,B10000000,B11000000,
314 
+      B00001001,B10000000,B00100000,
315 
+      B00010111,B10000001,B11010000,
316 
+      B00010111,B11000011,B11010000,
317 
+      B00100111,B11000111,B11101000,
318 
+      B00100011,B11000111,B11111000,
319 
+      B00100001,B11111111,B10001000,
320 
+      B00100000,B01101100,B00001000,
321 
+      B00100000,B01101100,B00001000,
322 
+      B00100000,B01101100,B00001000,
323 
+      B00100011,B11111111,B00001000,
324 
+      B00111111,B11000111,B10001000,
325 
+      B00101111,B11000111,B11001000,
326 
+      B00010111,B10000111,B11010000,
327 
+      B00010111,B00000011,B11010000,
328 
+      B00001000,B00000011,B00100000,
329 
+      B00000110,B00000010,B11000000,
330 
+      B00000001,B11111111,B00000000
331 
+    };
332 
+    const unsigned char status_fan3_bmp[] PROGMEM = {
333 
+      B00000001,B11111111,B00000000,
334 
+      B00000110,B00000000,B11000000,
335 
+      B00001001,B11110000,B00100000,
336 
+      B00010001,B11100000,B00010000,
337 
+      B00010001,B11100000,B00010000,
338 
+      B00100001,B11100001,B11101000,
339 
+      B00100000,B11110011,B11101000,
340 
+      B00100000,B01111111,B11101000,
341 
+      B00100000,B01110111,B11101000,
342 
+      B00101000,B11101110,B00101000,
343 
+      B00101111,B11011100,B00001000,
344 
+      B00101111,B11111100,B00001000,
345 
+      B00101111,B10011110,B00001000,
346 
+      B00101111,B00001111,B00001000,
347 
+      B00010000,B00001111,B00010000,
348 
+      B00010000,B00001111,B00010000,
349 
+      B00001000,B00011111,B00100000,
350 
+      B00000110,B00000000,B11000000,
351 
+      B00000001,B11111111,B00000000
352 
+    };
353 
+
354 
+  #else // !STATUS_ALT_FAN_BITMAP
355 
+
356 
+    const unsigned char status_fan0_bmp[] PROGMEM = {
357 
+      B00111111,B11111111,B11111000,
358 
+      B00111110,B00000000,B11111000,
359 
+      B00111000,B00111111,B00111000,
360 
+      B00110000,B01111110,B00011000,
361 
+      B00110000,B01111100,B00011000,
362 
+      B00101000,B01111100,B00001000,
363 
+      B00101100,B00111000,B00001000,
364 
+      B00101111,B00111001,B11001000,
365 
+      B00101111,B11111111,B11101000,
366 
+      B00101111,B11000111,B11101000,
367 
+      B00101111,B11111111,B11101000,
368 
+      B00100111,B00111001,B11101000,
369 
+      B00100000,B00111000,B01101000,
370 
+      B00100000,B01111100,B00101000,
371 
+      B00110000,B01111100,B00011000,
372 
+      B00110000,B11111100,B00011000,
373 
+      B00111001,B11111000,B00111000,
374 
+      B00111110,B00000000,B11111000,
375 
+      B00111111,B11111111,B11111000
376 
+    };
377 
+    const unsigned char status_fan1_bmp[] PROGMEM = {
378 
+      B00111111,B11111111,B11111000,
379 
+      B00111110,B00000000,B11111000,
380 
+      B00111000,B00001111,B00111000,
381 
+      B00110100,B00011111,B11011000,
382 
+      B00110110,B00011111,B10011000,
383 
+      B00101111,B00011111,B00001000,
384 
+      B00101111,B10011110,B00001000,
385 
+      B00101111,B11111100,B00001000,
386 
+      B00101111,B11011100,B00001000,
387 
+      B00100111,B11101111,B11001000,
388 
+      B00100000,B01110111,B11101000,
389 
+      B00100000,B01111111,B11101000,
390 
+      B00100000,B11110011,B11101000,
391 
+      B00100001,B11110001,B11101000,
392 
+      B00110011,B11110000,B11011000,
393 
+      B00110111,B11110000,B01011000,
394 
+      B00111001,B11100000,B00111000,
395 
+      B00111110,B00000000,B11111000,
396 
+      B00111111,B11111111,B11111000
397 
+    };
398 
+    const unsigned char status_fan2_bmp[] PROGMEM = {
399 
+      B00111111,B11111111,B11111000,
400 
+      B00111110,B10000000,B11111000,
401 
+      B00111001,B10000000,B00111000,
402 
+      B00110111,B10000001,B11011000,
403 
+      B00110111,B11000011,B11011000,
404 
+      B00100111,B11000111,B11101000,
405 
+      B00100011,B11000111,B11111000,
406 
+      B00100001,B11111111,B10001000,
407 
+      B00100000,B01101100,B00001000,
408 
+      B00100000,B01101100,B00001000,
409 
+      B00100000,B01101100,B00001000,
410 
+      B00100011,B11111111,B00001000,
411 
+      B00111111,B11000111,B10001000,
412 
+      B00101111,B11000111,B11001000,
413 
+      B00110111,B10000111,B11011000,
414 
+      B00110111,B00000011,B11011000,
415 
+      B00111000,B00000011,B00111000,
416 
+      B00111110,B00000010,B11111000,
417 
+      B00111111,B11111111,B11111000
418 
+    };
419 
+    const unsigned char status_fan3_bmp[] PROGMEM = {
420 
+      B00111111,B11111111,B11111000,
421 
+      B00111110,B00000000,B11111000,
422 
+      B00111001,B11110000,B00111000,
423 
+      B00110001,B11100000,B00011000,
424 
+      B00110001,B11100000,B00011000,
425 
+      B00100001,B11100001,B11101000,
426 
+      B00100000,B11110011,B11101000,
427 
+      B00100000,B01111111,B11101000,
428 
+      B00100000,B01110111,B11101000,
429 
+      B00101000,B11101110,B00101000,
430 
+      B00101111,B11011100,B00001000,
431 
+      B00101111,B11111100,B00001000,
432 
+      B00101111,B10011110,B00001000,
433 
+      B00101111,B00001111,B00001000,
434 
+      B00110000,B00001111,B00011000,
435 
+      B00110000,B00001111,B00011000,
436 
+      B00111000,B00011111,B00111000,
437 
+      B00111110,B00000000,B11111000,
438 
+      B00111111,B11111111,B11111000
439 
+    };
440 
+
441 
+  #endif // !STATUS_ALT_FAN_BITMAP
442 
+
443 
+#endif

+ 336
- 0
Marlin/src/lcd/dogm/status/hotend.h View File 

@@ -0,0 +1,336 @@
1 
+/**
2 
+ * Marlin 3D Printer Firmware
3 
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
4 
+ *
5 
+ * Based on Sprinter and grbl.
6 
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
7 
+ *
8 
+ * This program is free software: you can redistribute it and/or modify
9 
+ * it under the terms of the GNU General Public License as published by
10 
+ * the Free Software Foundation, either version 3 of the License, or
11 
+ * (at your option) any later version.
12 
+ *
13 
+ * This program is distributed in the hope that it will be useful,
14 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
+ * GNU General Public License for more details.
17 
+ *
18 
+ * You should have received a copy of the GNU General Public License
19 
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
20 
+ *
21 
+ */
22 
+#pragma once
23 
+
24 
+//
25 
+// lcd/dogm/status/hotend.h - Status Screen Hotends bitmaps
26 
+//
27 
+
28 
+#define STATUS_HOTEND1_WIDTH  16
29 
+
30 
+#define MAX_HOTEND_BITMAPS     5
31 
+#if HOTENDS > MAX_HOTEND_BITMAPS
32 
+  #define STATUS_HOTEND_BITMAPS MAX_HOTEND_BITMAPS
33 
+#else
34 
+  #define STATUS_HOTEND_BITMAPS HOTENDS
35 
+#endif
36 
+
37 
+#if HOTENDS == 1 || ENABLED(STATUS_HOTEND_NUMBERLESS)
38 
+
39 
+  const unsigned char status_hotend_a_bmp[] PROGMEM = {
40 
+    B00011111,B11100000,
41 
+    B00111111,B11110000,
42 
+    B00111111,B11110000,
43 
+    B00111111,B11110000,
44 
+    B00011111,B11100000,
45 
+    B00011111,B11100000,
46 
+    B00111111,B11110000,
47 
+    B00111111,B11110000,
48 
+    B00111111,B11110000,
49 
+    B00001111,B11000000,
50 
+    B00000111,B10000000,
51 
+    B00000011,B00000000
52 
+  };
53 
+
54 
+  #ifdef STATUS_HOTEND_ANIM
55 
+
56 
+    const unsigned char status_hotend_b_bmp[] PROGMEM = {
57 
+      B00011111,B11100000,
58 
+      B00100000,B00010000,
59 
+      B00100000,B00010000,
60 
+      B00100000,B00010000,
61 
+      B00010000,B00100000,
62 
+      B00010000,B00100000,
63 
+      B00100000,B00010000,
64 
+      B00100000,B00010000,
65 
+      B00110000,B00110000,
66 
+      B00001000,B01000000,
67 
+      B00000100,B10000000,
68 
+      B00000011,B00000000
69 
+    };
70 
+
71 
+  #endif
72 
+
73 
+#elif HOTENDS >= 2
74 
+
75 
+  #ifdef STATUS_HOTEND_ANIM
76 
+
77 
+    const unsigned char status_hotend1_a_bmp[] PROGMEM = {
78 
+      B00011111,B11100000,
79 
+      B00111111,B11110000,
80 
+      B00111110,B11110000,
81 
+      B00111100,B11110000,
82 
+      B00011010,B11100000,
83 
+      B00011110,B11100000,
84 
+      B00111110,B11110000,
85 
+      B00111110,B11110000,
86 
+      B00111110,B11110000,
87 
+      B00001111,B11000000,
88 
+      B00000111,B10000000,
89 
+      B00000011,B00000000
90 
+    };
91 
+
92 
+    const unsigned char status_hotend1_b_bmp[] PROGMEM = {
93 
+      B00011111,B11100000,
94 
+      B00100000,B00010000,
95 
+      B00100001,B00010000,
96 
+      B00100011,B00010000,
97 
+      B00010101,B00100000,
98 
+      B00010001,B00100000,
99 
+      B00100001,B00010000,
100 
+      B00100001,B00010000,
101 
+      B00110001,B00110000,
102 
+      B00001000,B01000000,
103 
+      B00000100,B10000000,
104 
+      B00000011,B00000000
105 
+    };
106 
+
107 
+    const unsigned char status_hotend2_a_bmp[] PROGMEM = {
108 
+      B00011111,B11100000,
109 
+      B00111111,B11110000,
110 
+      B00111100,B11110000,
111 
+      B00111011,B01110000,
112 
+      B00011111,B01100000,
113 
+      B00011110,B11100000,
114 
+      B00111101,B11110000,
115 
+      B00111011,B11110000,
116 
+      B00111000,B01110000,
117 
+      B00001111,B11000000,
118 
+      B00000111,B10000000,
119 
+      B00000011,B00000000
120 
+    };
121 
+
122 
+    const unsigned char status_hotend2_b_bmp[] PROGMEM = {
123 
+      B00011111,B11100000,
124 
+      B00100000,B00010000,
125 
+      B00100011,B00010000,
126 
+      B00100100,B10010000,
127 
+      B00010000,B10100000,
128 
+      B00010001,B00100000,
129 
+      B00100010,B00010000,
130 
+      B00100100,B00010000,
131 
+      B00110111,B10110000,
132 
+      B00001000,B01000000,
133 
+      B00000100,B10000000,
134 
+      B00000011,B00000000
135 
+    };
136 
+
137 
+  #else
138 
+
139 
+    const unsigned char status_hotend1_a_bmp[] PROGMEM = {
140 
+      B00011111,B11100000,
141 
+      B00111110,B11110000,
142 
+      B00111100,B11110000,
143 
+      B00111010,B11110000,
144 
+      B00011110,B11100000,
145 
+      B00011110,B11100000,
146 
+      B00111110,B11110000,
147 
+      B00111110,B11110000,
148 
+      B00111111,B11110000,
149 
+      B00001111,B11000000,
150 
+      B00000111,B10000000,
151 
+      B00000011,B00000000
152 
+    };
153 
+
154 
+    const unsigned char status_hotend2_a_bmp[] PROGMEM = {
155 
+      B00011111,B11100000,
156 
+      B00111100,B11110000,
157 
+      B00111011,B01110000,
158 
+      B00111111,B01110000,
159 
+      B00011110,B11100000,
160 
+      B00011101,B11100000,
161 
+      B00111011,B11110000,
162 
+      B00111000,B01110000,
163 
+      B00111111,B11110000,
164 
+      B00001111,B11000000,
165 
+      B00000111,B10000000,
166 
+      B00000011,B00000000
167 
+    };
168 
+
169 
+  #endif
170 
+
171 
+  #if STATUS_HOTEND_BITMAPS >= 3
172 
+
173 
+    #ifdef STATUS_HOTEND_ANIM
174 
+
175 
+      const unsigned char status_hotend3_a_bmp[] PROGMEM = {
176 
+        B00011111,B11100000,
177 
+        B00111111,B11110000,
178 
+        B00111100,B11110000,
179 
+        B00111011,B01110000,
180 
+        B00011111,B01100000,
181 
+        B00011100,B11100000,
182 
+        B00111111,B01110000,
183 
+        B00111011,B01110000,
184 
+        B00111100,B11110000,
185 
+        B00001111,B11000000,
186 
+        B00000111,B10000000,
187 
+        B00000011,B00000000
188 
+      };
189 
+
190 
+      const unsigned char status_hotend3_b_bmp[] PROGMEM = {
191 
+        B00011111,B11100000,
192 
+        B00100000,B00010000,
193 
+        B00100011,B00010000,
194 
+        B00100100,B10010000,
195 
+        B00010000,B10100000,
196 
+        B00010011,B00100000,
197 
+        B00100000,B10010000,
198 
+        B00100100,B10010000,
199 
+        B00110011,B00110000,
200 
+        B00001000,B01000000,
201 
+        B00000100,B10000000,
202 
+        B00000011,B00000000
203 
+      };
204 
+
205 
+    #else
206 
+
207 
+      const unsigned char status_hotend3_a_bmp[] PROGMEM = {
208 
+        B00011111,B11100000,
209 
+        B00111100,B11110000,
210 
+        B00111011,B01110000,
211 
+        B00111111,B01110000,
212 
+        B00011100,B11100000,
213 
+        B00011111,B01100000,
214 
+        B00111011,B01110000,
215 
+        B00111100,B11110000,
216 
+        B00111111,B11110000,
217 
+        B00001111,B11000000,
218 
+        B00000111,B10000000,
219 
+        B00000011,B00000000
220 
+      };
221 
+
222 
+    #endif
223 
+
224 
+  #endif
225 
+
226 
+  #if STATUS_HOTEND_BITMAPS >= 4
227 
+
228 
+    #ifdef STATUS_HOTEND_ANIM
229 
+
230 
+      const unsigned char status_hotend4_a_bmp[] PROGMEM = {
231 
+        B00011111,B11100000,
232 
+        B00111111,B11110000,
233 
+        B00111011,B01110000,
234 
+        B00111011,B01110000,
235 
+        B00011011,B01100000,
236 
+        B00011011,B01100000,
237 
+        B00111000,B00110000,
238 
+        B00111111,B01110000,
239 
+        B00111111,B01110000,
240 
+        B00001111,B11000000,
241 
+        B00000111,B10000000,
242 
+        B00000011,B00000000
243 
+      };
244 
+
245 
+      const unsigned char status_hotend4_b_bmp[] PROGMEM = {
246 
+        B00011111,B11100000,
247 
+        B00100000,B00010000,
248 
+        B00100100,B10010000,
249 
+        B00100100,B10010000,
250 
+        B00010100,B10100000,
251 
+        B00010100,B10100000,
252 
+        B00100111,B11010000,
253 
+        B00100000,B10010000,
254 
+        B00110000,B10110000,
255 
+        B00001000,B01000000,
256 
+        B00000100,B10000000,
257 
+        B00000011,B00000000
258 
+      };
259 
+
260 
+    #else
261 
+
262 
+      const unsigned char status_hotend4_a_bmp[] PROGMEM = {
263 
+        B00011111,B11100000,
264 
+        B00111011,B01110000,
265 
+        B00111011,B01110000,
266 
+        B00111011,B01110000,
267 
+        B00011011,B01100000,
268 
+        B00011000,B00100000,
269 
+        B00111111,B01110000,
270 
+        B00111111,B01110000,
271 
+        B00111111,B11110000,
272 
+        B00001111,B11000000,
273 
+        B00000111,B10000000,
274 
+        B00000011,B00000000
275 
+      };
276 
+
277 
+    #endif
278 
+
279 
+  #endif
280 
+
281 
+  #if STATUS_HOTEND_BITMAPS >= 5
282 
+
283 
+    #ifdef STATUS_HOTEND_ANIM
284 
+
285 
+      const unsigned char status_hotend5_a_bmp[] PROGMEM = {
286 
+        B00011111,B11100000,
287 
+        B00111111,B11110000,
288 
+        B00111000,B01110000,
289 
+        B00111011,B11110000,
290 
+        B00011000,B11100000,
291 
+        B00011111,B01100000,
292 
+        B00111111,B01110000,
293 
+        B00111011,B01110000,
294 
+        B00111100,B11110000,
295 
+        B00001111,B11000000,
296 
+        B00000111,B10000000,
297 
+        B00000011,B00000000
298 
+      };
299 
+
300 
+      const unsigned char status_hotend5_b_bmp[] PROGMEM = {
301 
+        B00011111,B11100000,
302 
+        B00100000,B00010000,
303 
+        B00100111,B10010000,
304 
+        B00100100,B00010000,
305 
+        B00010111,B00100000,
306 
+        B00010000,B10100000,
307 
+        B00100000,B10010000,
308 
+        B00100100,B10010000,
309 
+        B00110011,B00110000,
310 
+        B00001000,B01000000,
311 
+        B00000100,B10000000,
312 
+        B00000011,B00000000
313 
+      };
314 
+
315 
+    #else
316 
+
317 
+      const unsigned char status_hotend5_a_bmp[] PROGMEM = {
318 
+        B00011111,B11100000,
319 
+        B00111000,B01110000,
320 
+        B00111011,B11110000,
321 
+        B00111000,B11110000,
322 
+        B00011111,B01100000,
323 
+        B00011111,B01100000,
324 
+        B00111011,B01110000,
325 
+        B00111100,B11110000,
326 
+        B00111111,B11110000,
327 
+        B00001111,B11000000,
328 
+        B00000111,B10000000,
329 
+        B00000011,B00000000
330 
+      };
331 
+
332 
+    #endif
333 
+
334 
+  #endif
335 
+
336 
+#endif

Write Preview
Loading…
Cancel
Save