aboutsummaryrefslogtreecommitdiff
path: root/Marlin/src/lcd/HD44780
diff options
context:
space:
mode:
authorGeorgiy Bondarenko <69736697+nehilo@users.noreply.github.com>2021-03-04 20:54:23 +0300
committerGeorgiy Bondarenko <69736697+nehilo@users.noreply.github.com>2021-03-04 20:54:23 +0300
commite8701195e66f2d27ffe17fb514eae8173795aaf7 (patch)
tree9f519c4abf6556b9ae7190a6210d87ead1dfadde /Marlin/src/lcd/HD44780
downloadkp3s-lgvl-e8701195e66f2d27ffe17fb514eae8173795aaf7.tar.xz
kp3s-lgvl-e8701195e66f2d27ffe17fb514eae8173795aaf7.zip
Initial commit
Diffstat (limited to 'Marlin/src/lcd/HD44780')
-rw-r--r--Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp1122
-rw-r--r--Marlin/src/lcd/HD44780/marlinui_HD44780.cpp1518
-rw-r--r--Marlin/src/lcd/HD44780/marlinui_HD44780.h102
3 files changed, 2742 insertions, 0 deletions
diff --git a/Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp b/Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp
new file mode 100644
index 0000000..8aca19b
--- /dev/null
+++ b/Marlin/src/lcd/HD44780/lcdprint_hd44780.cpp
@@ -0,0 +1,1122 @@
+/**
+ * @file lcdprint_hd44780.cpp
+ * @brief LCD print api for HD44780
+ * @author Yunhui Fu (yhfudev@gmail.com)
+ * @version 1.0
+ * @date 2016-08-19
+ * @copyright GPL/BSD
+ */
+
+/**
+ * Due to the limitation of the HD44780 hardware, the current available LCD modules can only support
+ * Western(English), Cyrillic(Russian), Kana(Japanese) charsets.
+ */
+
+#include "../../inc/MarlinConfigPre.h"
+
+#if HAS_MARLINUI_HD44780
+
+#include "../marlinui.h"
+#include "../../MarlinCore.h"
+
+#include "marlinui_HD44780.h"
+
+#include <string.h>
+
+extern LCD_CLASS lcd;
+
+int lcd_glyph_height() { return 1; }
+
+typedef struct _hd44780_charmap_t {
+ wchar_t uchar; // the unicode char
+ uint8_t idx; // the glyph of the char in the ROM
+ uint8_t idx2; // the char used to be combined with the idx to simulate a single char
+} hd44780_charmap_t;
+
+#ifdef __AVR__
+ #define IV(a) U##a
+#else
+ #define IV(a) L##a
+#endif
+
+static const hd44780_charmap_t g_hd44780_charmap_device[] PROGMEM = {
+ // sorted by uchar:
+ #if DISPLAY_CHARSET_HD44780 == JAPANESE
+
+ {IV('¢'), 0xEC, 0}, // A2
+ {IV('°'), 0xDF, 0}, // B0, Marlin special: '°' LCD_STR_DEGREE (0x09)
+ {IV('ä'), 0xE1, 0}, // E4
+ {IV('ö'), 0xEF, 0}, // F6
+ {IV('÷'), 0xFD, 0}, // 00F7
+ {IV('ü'), 0xF5, 0}, // 00FC
+ {IV('ˣ'), 0xEB, 0}, // 02E3
+
+ {IV('·'), 0xA5, 0}, // 0387
+ {IV('Ώ'), 0xF4, 0}, // 038F
+ {IV('Θ'), 0xF2, 0}, // 0398, Theta
+ {IV('Ξ'), 0xE3, 0}, // 039E, Xi
+ {IV('Σ'), 0xF6, 0}, // 03A3, Sigma
+ {IV('Ω'), 0xF4, 0}, // 03A9, Omega
+ {IV('ά'), 0xE0, 0}, // 03AC
+ {IV('έ'), 0xE3, 0}, // 03AD
+ {IV('α'), 0xE0, 0}, // 03B1, alpha
+ {IV('β'), 0xE2, 0}, // 03B2, beta
+ {IV('ε'), 0xE3, 0}, // 03B5, epsilon
+ {IV('θ'), 0xF2, 0}, // 03B8, theta
+ {IV('μ'), 0xE4, 0}, // 03BC, mu
+ {IV('ξ'), 0xE3, 0}, // 03BE, xi
+ {IV('π'), 0xF7, 0}, // 03C0, pi
+ {IV('ρ'), 0xE6, 0}, // 03C1, rho
+ {IV('σ'), 0xE5, 0}, // 03C3, sigma
+
+ {IV('←'), 0x7F, 0}, // 2190
+ {IV('→'), 0x7E, 0}, // 2192, Marlin special: '⮈⮉⮊⮋➤→' LCD_STR_ARROW_RIGHT (0x03)
+ {IV('√'), 0xE8, 0}, // 221A
+ {IV('∞'), 0xF3, 0}, // 221E
+ {IV('█'), 0xFF, 0}, // 2588
+
+ //{IV(''), 0xA0, 0},
+ {IV('。'), 0xA1, 0},
+ {IV('「'), 0xA2, 0},
+ {IV('」'), 0xA3, 0},
+ {IV('゛'), 0xDE, 0}, // ‶
+ {IV('゜'), 0xDF, 0}, // '〫'
+ {IV('゠'), '=', 0},
+ {IV('ァ'), 0xA7, 0},
+ {IV('ア'), 0xB1, 0},
+ {IV('ィ'), 0xA8, 0},
+ {IV('イ'), 0xB2, 0},
+ {IV('ゥ'), 0xA9, 0},
+ {IV('ウ'), 0xB3, 0},
+ {IV('ェ'), 0xAA, 0},
+ {IV('エ'), 0xB4, 0},
+ {IV('ォ'), 0xAB, 0},
+
+ {IV('オ'), 0xB5, 0},
+ {IV('カ'), 0xB6, 0},
+ {IV('ガ'), 0xB6, 0xDE},
+ {IV('キ'), 0xB7, 0},
+ {IV('ギ'), 0xB7, 0xDE},
+ {IV('ク'), 0xB8, 0},
+ {IV('グ'), 0xB8, 0xDE},
+ {IV('ケ'), 0xB9, 0},
+ {IV('ゲ'), 0xB9, 0xDE},
+ {IV('コ'), 0xBA, 0},
+ {IV('ゴ'), 0xBA, 0xDE},
+ {IV('サ'), 0xBB, 0},
+ {IV('ザ'), 0xBB, 0xDE},
+ {IV('シ'), 0xBC, 0},
+ {IV('ジ'), 0xBC, 0xDE},
+ {IV('ス'), 0xBD, 0},
+ {IV('ズ'), 0xBD, 0xDE},
+ {IV('セ'), 0xBE, 0},
+ {IV('ゼ'), 0xBE, 0xDE},
+ {IV('ソ'), 0xBF, 0},
+ {IV('ゾ'), 0xBF, 0xDE},
+
+ {IV('タ'), 0xC0, 0},
+ {IV('ダ'), 0xC0, 0xDE},
+ {IV('チ'), 0xC1, 0},
+ {IV('ヂ'), 0xC1, 0xDE},
+ {IV('ッ'), 0xAF, 0},
+ {IV('ツ'), 0xC2, 0},
+ {IV('ヅ'), 0xC2, 0xDE},
+ {IV('テ'), 0xC3, 0},
+ {IV('デ'), 0xC3, 0xDE},
+ {IV('ト'), 0xC4, 0},
+ {IV('ド'), 0xC4, 0xDE},
+ {IV('ナ'), 0xC5, 0},
+ {IV('ニ'), 0xC6, 0},
+ {IV('ヌ'), 0xC7, 0},
+ {IV('ネ'), 0xC8, 0},
+ {IV('ノ'), 0xC9, 0},
+ {IV('ハ'), 0xCA, 0},
+ {IV('バ'), 0xCA, 0xDE},
+ {IV('パ'), 0xCA, 0xDF},
+ {IV('ヒ'), 0xCB, 0},
+ {IV('ビ'), 0xCB, 0xDE},
+ {IV('ピ'), 0xCB, 0xDF},
+ {IV('フ'), 0xCC, 0},
+ {IV('ブ'), 0xCC, 0xDE},
+ {IV('プ'), 0xCC, 0xDF},
+ {IV('ヘ'), 0xCD, 0},
+ {IV('ベ'), 0xCD, 0xDE},
+ {IV('ペ'), 0xCD, 0xDF},
+ {IV('ホ'), 0xCE, 0},
+ {IV('ボ'), 0xCE, 0xDE},
+ {IV('ポ'), 0xCE, 0xDF},
+ {IV('マ'), 0xCF, 0},
+
+ {IV('ミ'), 0xD0, 0},
+ {IV('ム'), 0xD1, 0},
+ {IV('メ'), 0xD2, 0},
+ {IV('モ'), 0xD3, 0},
+ {IV('ャ'), 0xAC, 0},
+ {IV('ヤ'), 0xD4, 0},
+ {IV('ュ'), 0xAD, 0},
+ {IV('ユ'), 0xD5, 0},
+ {IV('ョ'), 0xAE, 0},
+ {IV('ヨ'), 0xD6, 0},
+ {IV('ラ'), 0xD7, 0},
+ {IV('リ'), 0xD8, 0},
+ {IV('ル'), 0xD9, 0},
+ {IV('レ'), 0xDA, 0},
+ {IV('ロ'), 0xDB, 0},
+ {IV('ワ'), 0xDC, 0},
+ {IV('ヲ'), 0xA6, 0},
+ {IV('ン'), 0xDD, 0},
+ {IV('ヴ'), 0xB3, 0xDE},
+ {IV('ヷ'), 0xDC, 0xDE},
+ {IV('ヺ'), 0xA6, 0xDE},
+ {IV('・'), 0xA5, 0},
+ {IV('ー'), 0xB0, 0},
+ {IV('ヽ'), 0xA4, 0},
+
+ //{IV('g'), 0xE7, 0}, // error
+ //{IV(''), 0xE9, 0},
+ //{IV('j'), 0xEA, 0}, // error
+ //{IV(''), 0xED, 0},
+ //{IV(''), 0xEE, 0},
+
+ //{IV('p'), 0xF0, 0}, // error
+ //{IV('q'), 0xF1, 0}, // error
+ //{IV(''), 0xF8, 0},
+ //{IV('y'), 0xF9, 0}, // error
+ {IV('万'), 0xFB, 0},
+ {IV('円'), 0xFC, 0},
+ {IV('千'), 0xFA, 0},
+ //{IV(''), 0xFE, 0},
+
+ //､･ｦｧｨｩｪｫｬｭｮｯｰ
+ {IV('､'), 0xA4, 0}, //ヽ
+ {IV('･'), 0xA5, 0}, //・
+ {IV('ｦ'), 0xA6, 0}, //ヲ
+ {IV('ｧ'), 0xA7, 0}, //ァ
+ {IV('ｨ'), 0xA8, 0}, //ィ
+ {IV('ｩ'), 0xA9, 0}, //ゥ
+ {IV('ｪ'), 0xAA, 0}, //ェ
+ {IV('ｫ'), 0xAB, 0}, //ォ
+ {IV('ｬ'), 0xAC, 0}, //ャ
+ {IV('ｭ'), 0xAD, 0}, //ュ
+ {IV('ｮ'), 0xAE, 0}, //ョ
+ {IV('ｯ'), 0xAF, 0}, //ッ
+ {IV('ｰ'), 0xB0, 0}, //ー
+
+ //ｱｲｳｴｵｶｷｸｹｺｻｼｽｾ
+ {IV('ｱ'), 0xB1, 0}, //ア
+ {IV('ｲ'), 0xB2, 0}, //イ
+ {IV('ｳ'), 0xB3, 0}, //ウ
+ {IV('ｴ'), 0xB4, 0}, //エ
+ {IV('ｵ'), 0xB5, 0}, //オ
+ {IV('ｶ'), 0xB6, 0}, //カ
+ {IV('ｷ'), 0xB7, 0}, //キ
+ {IV('ｸ'), 0xB8, 0}, //ク
+ {IV('ｹ'), 0xB9, 0}, //ケ
+ {IV('ｺ'), 0xBA, 0}, //コ
+ {IV('ｻ'), 0xBB, 0}, //サ
+ {IV('ｼ'), 0xBC, 0}, //シ
+ {IV('ｽ'), 0xBD, 0}, //ス
+ {IV('ｾ'), 0xBE, 0}, //セ
+
+ //ｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌ
+ {IV('ｿ'), 0xBF, 0}, //ソ
+ {IV('ﾀ'), 0xC0, 0}, //タ
+ {IV('ﾁ'), 0xC1, 0}, //チ
+ {IV('ﾂ'), 0xC2, 0}, //ツ
+ {IV('ﾃ'), 0xC3, 0}, //テ
+ {IV('ﾄ'), 0xC4, 0}, //ト
+ {IV('ﾅ'), 0xC5, 0}, //ナ
+ {IV('ﾆ'), 0xC6, 0}, //ニ
+ {IV('ﾇ'), 0xC7, 0}, //ヌ
+ {IV('ﾈ'), 0xC8, 0}, //ネ
+ {IV('ﾉ'), 0xC9, 0}, //ノ
+ {IV('ﾊ'), 0xCA, 0}, //ハ
+ {IV('ﾋ'), 0xCB, 0}, //ヒ
+ {IV('ﾌ'), 0xCC, 0}, //フ
+
+ //ﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝﾞﾟ
+ {IV('ﾍ'), 0xCD, 0}, //ヘ
+ {IV('ﾎ'), 0xCE, 0}, //ホ
+ {IV('ﾏ'), 0xCF, 0}, //マ
+ {IV('ﾐ'), 0xD0, 0}, //ミ
+ {IV('ﾑ'), 0xD1, 0}, //ム
+ {IV('ﾒ'), 0xD2, 0}, //メ
+ {IV('ﾓ'), 0xD3, 0}, //モ
+ {IV('ﾔ'), 0xD4, 0}, //ヤ
+ {IV('ﾕ'), 0xD5, 0}, //ユ
+ {IV('ﾖ'), 0xD6, 0}, //ヨ
+ {IV('ﾗ'), 0xD7, 0}, //ラ
+ {IV('ﾘ'), 0xD8, 0}, //リ
+ {IV('ﾙ'), 0xD9, 0}, //ル
+ {IV('ﾚ'), 0xDA, 0}, //レ
+ {IV('ﾛ'), 0xDB, 0}, //ロ
+ {IV('ﾜ'), 0xDC, 0}, //ワ
+ {IV('ﾝ'), 0xDD, 0}, //ン
+ {IV('ﾞ'), 0xDE, 0}, // ゛
+ {IV('ﾟ'), 0xDF, 0}, // ゜
+
+ {IV('￥'), 0x5C, 0},
+
+ #elif DISPLAY_CHARSET_HD44780 == WESTERN
+ // 0x10 -- 0x1F (except 0x1C)
+ // 0x80 -- 0xFF (except 0xA7,0xB0,0xB1,0xB3,0xB4,0xBF,0xD1,0xF8,0xFA,0xFC-0xFF)
+
+ {IV('¡'), 0xA9, 0},
+ {IV('¢'), 0xA4, 0},
+ {IV('£'), 0xA5, 0},
+ {IV('¥'), 0xA6, 0},
+ {IV('§'), 0xD2, 0}, // section sign
+ {IV('©'), 0xCF, 0},
+
+ {IV('ª'), 0x9D, 0},
+ {IV('«'), 0xBB, 0},
+ {IV('®'), 0xCE, 0},
+
+ {IV('°'), 0xB2, 0}, // Marlin special: '°' LCD_STR_DEGREE (0x09)
+ //{IV(''), 0xD1, 0},
+ {IV('±'), 0x10, 0}, //∓±
+ //{'='), 0x1C, 0}, // error
+ {IV('²'), 0x1E, 0},
+ {IV('³'), 0x1F, 0},
+ {IV('¶'), 0xD3, 0}, // pilcrow sign
+ {IV('º'), 0x9E, 0},
+ {IV('»'), 0xBC, 0}, // 00BB
+ //{IV(''), 0xB3, 0}, // error
+ //{IV(''), 0xB4, 0}, // error
+ {IV('¼'), 0xB6, 0}, // 00BC
+ {IV('½'), 0xB5, 0}, // 00BD
+ //{IV('¾'), '3', 0}, // 00BE
+ {IV('¿'), 0x9F, 0}, // 00BF
+
+ {IV('Â'), 0x8F, 0},
+ {IV('Ã'), 0xAA, 0},
+ {IV('Ä'), 0x8E, 0},
+ {IV('Æ'), 0x92, 0},
+ {IV('Ç'), 0x80, 0},
+ {IV('É'), 0x90, 0},
+ {IV('Ñ'), 0x9C, 0},
+ {IV('Õ'), 0xAC, 0},
+ {IV('Ö'), 0x99, 0},
+ {IV('×'), 0xB7, 0},
+ {IV('Ø'), 0xAE, 0},
+ {IV('Ü'), 0x9A, 0},
+ {IV('à'), 0x85, 0},
+ {IV('á'), 0xA0, 0},
+ {IV('â'), 0x83, 0},
+ {IV('ã'), 0xAB, 0},
+ {IV('ä'), 0x84, 0},
+ {IV('å'), 0x86, 0},
+ {IV('æ'), 0x91, 0},
+ {IV('ç'), 0x87, 0},
+ {IV('è'), 0x8A, 0},
+ {IV('é'), 0x82, 0},
+ {IV('ê'), 0x88, 0},
+ {IV('ë'), 0x89, 0},
+ {IV('ì'), 0x8D, 0},
+ {IV('í'), 0xA1, 0},
+ {IV('î'), 0x8C, 0},
+ {IV('ï'), 0x8B, 0},
+
+ {IV('ñ'), 0x9B, 0},
+ {IV('ò'), 0x95, 0},
+ {IV('ó'), 0xA2, 0},
+ {IV('ô'), 0x93, 0},
+ {IV('õ'), 0xAD, 0},
+ {IV('ö'), 0x94, 0},
+ {IV('÷'), 0xB8, 0},
+ {IV('ø'), 0xAF, 0},
+ {IV('ù'), 0x97, 0},
+ {IV('ú'), 0xA3, 0},
+ {IV('û'), 0x96, 0},
+ {IV('ü'), 0x81, 0},
+ {IV('ÿ'), 0x98, 0},
+
+ //{IV(''), 0xB0, 0}, // error
+ //{IV(''), 0xB1, 0}, // error
+ {IV('ƒ'), 0xA8, 0}, // 0192
+
+ {IV('Ύ'), 0xDB, 0}, // 038E
+ {IV('Ώ'), 0xDE, 0}, // 038F
+ {IV('ΐ'), 0xE7, 0}, // 0390
+
+ {IV('Γ'), 0xD4, 0}, // 0393, Gamma
+ {IV('Δ'), 0xD5, 0}, // 0394, Delta, ◿
+ {IV('Θ'), 0xD6, 0}, // 0398, Theta
+ {IV('Λ'), 0xD7, 0}, // 039B, Lambda
+ {IV('Ξ'), 0xD8, 0}, // 039E, Xi
+ {IV('Π'), 0xD9, 0}, // Pi
+ {IV('Σ'), 0xDA, 0}, // Sigma
+ {IV('Υ'), 0xDB, 0}, // Upsilon
+ {IV('Φ'), 0xDC, 0}, // Phi
+ {IV('Ψ'), 0xDD, 0}, // Psi
+ {IV('Ω'), 0xDE, 0}, // Omega
+
+ {IV('ά'), 0xDF, 0}, // 03AC
+ {IV('έ'), 0xE3, 0}, // 03AD
+ {IV('ή'), 0xE5, 0}, // 03AE
+ {IV('ί'), 0xE7, 0}, // 03AF
+ {IV('ΰ'), 0xF1, 0}, // 03B0
+
+ {IV('α'), 0xDF, 0}, // alpha
+ {IV('β'), 0xE0, 0}, // beta
+ {IV('γ'), 0xE1, 0}, // gamma
+ {IV('δ'), 0xE2, 0}, // delta
+ {IV('ε'), 0xE3, 0}, // epsilon
+ {IV('ζ'), 0xE4, 0}, // zeta
+ {IV('η'), 0xE5, 0}, // eta
+ {IV('θ'), 0xE6, 0}, // theta
+ {IV('ι'), 0xE7, 0}, // lota
+ {IV('κ'), 0xE8, 0}, // kappa
+ {IV('λ'), 0xE9, 0}, // lambda
+ {IV('μ'), 0xEA, 0}, // mu
+ {IV('ν'), 0xEB, 0}, // nu
+ {IV('ξ'), 0xEC, 0}, // xi
+ {IV('π'), 0xED, 0}, // pi
+ {IV('ρ'), 0xEE, 0}, // rho
+ {IV('σ'), 0xEF, 0}, // sigma
+
+ {IV('τ'), 0xF0, 0}, // tau
+ {IV('υ'), 0xF1, 0}, // upsilon
+ {IV('χ'), 0xF2, 0}, // chi
+ {IV('ψ'), 0xF3, 0}, // psi
+ {IV('ω'), 0xF4, 0}, // 03C9, omega
+ {IV('ϊ'), 0xE7, 0}, // 03CA
+ {IV('ϋ'), 0xF1, 0}, // 03CB
+ {IV('ύ'), 0xF1, 0}, // 03CD
+ {IV('ώ'), 0xF4, 0}, // 03CE
+
+ {IV('•'), 0xCD, 0}, // ·
+ {IV('℞'), 0xA7, 0}, // ℞ Pt ASCII 158
+ {IV('™'), 0xD0, 0},
+ {IV('↤'), 0xF9, 0}, // ⟻
+ {IV('↵'), 0xC4, 0},
+ {IV('↻'), 0x04, 0}, // Marlin special: '↻↺⟳⟲' LCD_STR_REFRESH (0x01)
+ {IV('⇥'), 0xFB, 0},
+ {IV('√'), 0xBE, 0}, // √
+ {IV('∞'), 0xC2, 0}, // infinity
+ {IV('∫'), 0x1B, 0},
+ {IV('∼'), 0x1D, 0},
+ {IV('≈'), 0x1A, 0},
+ {IV('≠'), 0xBD, 0},
+ {IV('≡'), 0x11, 0},
+ {IV('≤'), 0xB9, 0},// ≤≥ ⩽⩾
+ {IV('≥'), 0xBA, 0},
+ //{IV(''), 0xBF, 0}, // error
+
+ {IV('⌠'), 0xC0, 0},
+ {IV('⌡'), 0xC1, 0},
+
+ {IV('⎧'), 0x14, 0},
+ {IV('⎩'), 0x15, 0},
+ {IV('⎫'), 0x16, 0},
+ {IV('⎭'), 0x17, 0},
+ {IV('⎰'), 0x18, 0},
+ {IV('⎱'), 0x19, 0},
+
+ {IV('⎲'), 0x12, 0},
+ {IV('⎳'), 0x13, 0},
+
+ {IV('⏱'), 0x07, 0}, // Marlin special: '🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚🕛🕜🕝🕞🕟🕠🕡🕢🕣🕤🕥🕦🕧 ⌚⌛⏰⏱⏳⧖⧗' LCD_STR_CLOCK (0x05)
+ {IV('┌'), 0xC9, 0},
+ {IV('┐'), 0xCA, 0},
+ {IV('└'), 0xCB, 0},
+ {IV('┘'), 0xCC, 0},
+ {IV('◸'), 0xC3, 0}, // ◿
+ {IV('⭠'), 0xC8, 0},
+ {IV('⭡'), 0xC5, 0},
+ {IV('⭢'), 0xC7, 0},
+ {IV('⭣'), 0xC6, 0},
+
+
+ {IV('⯆'), 0xF5, 0},
+ {IV('⯇'), 0xF7, 0}, // ⯅
+ {IV('⯈'), 0xF6, 0},
+ //{IV(''), 0xF8, 0}, // error
+ //{IV(''), 0xFA, 0}, // error
+ //{IV(''), 0xFC, 0}, // error
+ //{IV(''), 0xFD, 0}, // error
+ //{IV(''), 0xFE, 0}, // error
+ //{IV(''), 0xFF, 0}, // error
+
+ #elif DISPLAY_CHARSET_HD44780 == CYRILLIC
+
+ {IV('¢'), 0x5C, 0}, // 00A2
+ {IV('£'), 0xCF, 0}, // 00A3
+ {IV('°'), 0x01, 0}, // 00B0, Marlin special: '°' LCD_STR_DEGREE (0x09)
+
+ //{IV(''), 0x80, 0},
+ //{IV(''), 0x81, 0},
+ //{IV(''), 0x82, 0},
+ //{IV(''), 0x83, 0},
+ //{IV(''), 0x84, 0},
+ //{IV(''), 0x85, 0},
+ //{IV(''), 0x86, 0},
+ //{IV(''), 0x87, 0},
+ //{IV(''), 0x88, 0},
+ //{IV(''), 0x89, 0},
+ //{IV(''), 0x8A, 0},
+ //{IV(''), 0x8B, 0},
+ //{IV(''), 0x8C, 0},
+ //{IV(''), 0x8D, 0},
+ //{IV(''), 0x8E, 0},
+ //{IV(''), 0x8F, 0},
+
+ //{IV(''), 0x90, 0},
+ //{IV(''), 0x91, 0},
+ //{IV(''), 0x92, 0},
+ //{IV(''), 0x93, 0},
+ //{IV(''), 0x94, 0},
+ //{IV(''), 0x95, 0},
+ //{IV(''), 0x96, 0},
+ //{IV(''), 0x97, 0},
+ //{IV(''), 0x98, 0},
+ //{IV(''), 0x99, 0},
+ //{IV(''), 0x9A, 0},
+ //{IV(''), 0x9B, 0},
+ //{IV(''), 0x9C, 0},
+ //{IV(''), 0x9D, 0},
+ //{IV(''), 0x9E, 0},
+ //{IV(''), 0x9F, 0},
+
+
+ {IV('¼'), 0xF0, 0}, // 00BC
+ {IV('⅓'), 0xF1, 0},
+ {IV('½'), 0xF2, 0}, // 00BD
+ {IV('¾'), 0xF3, 0}, // 00BE
+ {IV('¿'), 0xCD, 0}, // 00BF
+
+ #if ENABLED(DISPLAY_CHARSET_ISO10646_5)
+
+ // Map Cyrillic to HD44780 extended CYRILLIC where possible
+ {IV('Ё'), 0xA2, 0}, // 0401
+ {IV('А'), 'A', 0}, // 0410
+ {IV('Б'), 0xA0, 0},
+ {IV('В'), 'B', 0},
+ {IV('Г'), 0xA1, 0},
+ {IV('Д'), 0xE0, 0},
+ {IV('Е'), 'E', 0},
+ {IV('Ж'), 0xA3, 0},
+ {IV('З'), 0xA4, 0},
+ {IV('И'), 0xA5, 0},
+ {IV('Й'), 0xA6, 0},
+ {IV('К'), 'K', 0},
+ {IV('Л'), 0xA7, 0},
+ {IV('М'), 'M', 0},
+ {IV('Н'), 'H', 0},
+ {IV('О'), 'O', 0},
+ {IV('П'), 0xA8, 0},
+ {IV('Р'), 'P', 0},
+ {IV('С'), 'C', 0},
+ {IV('Т'), 'T', 0},
+ {IV('У'), 0xA9, 0},
+ {IV('Ф'), 0xAA, 0},
+ {IV('Х'), 'X', 0},
+ {IV('Ц'), 0xE1, 0},
+ {IV('Ч'), 0xAB, 0},
+ {IV('Ш'), 0xAC, 0},
+ {IV('Щ'), 0xE2, 0},
+ {IV('Ъ'), 0xAD, 0},
+ {IV('Ы'), 0xAE, 0},
+ {IV('Ь'), 'b', 0},
+ {IV('Э'), 0xAF, 0},
+ {IV('Ю'), 0xB0, 0},
+ {IV('Я'), 0xB1, 0},
+ {IV('а'), 'a', 0},
+
+ {IV('б'), 0xB2, 0},
+ {IV('в'), 0xB3, 0},
+ {IV('г'), 0xB4, 0},
+ {IV('д'), 0xE3, 0},
+ {IV('е'), 'e', 0},
+ {IV('ж'), 0xB6, 0},
+ {IV('з'), 0xB7, 0},
+ {IV('и'), 0xB8, 0},
+ {IV('й'), 0xB9, 0},
+ {IV('к'), 0xBA, 0}, //клмноп
+ {IV('л'), 0xBB, 0},
+ {IV('м'), 0xBC, 0},
+ {IV('н'), 0xBD, 0},
+ {IV('о'), 'o', 0},
+ {IV('п'), 0xBE, 0},
+ {IV('р'), 'p', 0},
+ {IV('с'), 'c', 0},
+ {IV('т'), 0xBF, 0},
+
+ {IV('у'), 'y', 0},
+ {IV('ф'), 0xE4, 0},
+ {IV('х'), 'x', 0},
+ {IV('ц'), 0xE5, 0},
+ {IV('ч'), 0xC0, 0},
+ {IV('ш'), 0xC1, 0},
+ {IV('щ'), 0xE6, 0},
+ {IV('ъ'), 0xC2, 0},
+ {IV('ы'), 0xC3, 0},
+ {IV('ь'), 0xC4, 0},
+ {IV('э'), 0xC5, 0},
+ {IV('ю'), 0xC6, 0},
+ {IV('я'), 0xC7, 0}, // 044F
+ {IV('ё'), 0xB5, 0}, // 0451
+ //{IV(''), 0xC8, 0},
+ //{IV(''), 0xC9, 0},
+ //{IV(''), 0xCA, 0},
+ //{IV(''), 0xCB, 0},
+ //{IV(''), 0xCC, 0},
+ //{IV(''), 0xCD, 0},
+ //{IV(''), 0xCE, 0},
+
+ //{IV(''), 0xD0, 0},
+ //{IV(''), 0xD1, 0},
+ //{IV(''), 0xD2, 0},
+ //{IV(''), 0xD3, 0},
+ //{IV(''), 0xD4, 0},
+ //{IV(''), 0xD5, 0},
+ //{IV(''), 0xD6, 0},
+ //{IV(''), 0xD7, 0},
+ //{IV(''), 0xD8, 0},
+ //{IV(''), 0xDB, 0},
+ //{IV(''), 0xDC, 0},
+ //{IV(''), 0xDD, 0},
+ //{IV(''), 0xDE, 0},
+ //{IV(''), 0xDF, 0},
+
+ //{IV(''), 0xE7, 0},
+ //{IV(''), 0xE8, 0},
+ //{IV(''), 0xE9, 0},
+ //{IV(''), 0xEA, 0},
+ //{IV(''), 0xEB, 0},
+ //{IV(''), 0xEC, 0},
+ //{IV(''), 0xED, 0},
+ //{IV(''), 0xEE, 0},
+ //{IV(''), 0xEF, 0},
+
+ //{IV(''), 0xF4, 0},
+ //{IV(''), 0xF5, 0},
+ //{IV(''), 0xF6, 0},
+ //{IV(''), 0xF7, 0},
+ //{IV(''), 0xF8, 0},
+ //{IV(''), 0xF9, 0},
+ //{IV(''), 0xFA, 0},
+ //{IV(''), 0xFB, 0},
+ //{IV(''), 0xFC, 0},
+ //{IV(''), 0xFD, 0},
+ //{IV(''), 0xFE, 0},
+ //{IV(''), 0xFF, 0},
+
+ #endif
+
+ {IV('↑'), 0xD9, 0}, // 2191 ←↑→↓
+ {IV('↓'), 0xDA, 0}, // 2193
+ #endif
+};
+
+// the plain ASCII replacement for various char
+static const hd44780_charmap_t g_hd44780_charmap_common[] PROGMEM = {
+ {IV('¡'), 'i', 0}, // A1
+ {IV('¢'), 'c', 0}, // A2
+ {IV('°'), 0x09, 0}, // B0 Marlin special: '°' LCD_STR_DEGREE (0x09)
+
+ // Map WESTERN code to plain ASCII
+ {IV('Á'), 'A', 0}, // C1
+ {IV('Â'), 'A', 0}, // C2
+ {IV('Ã'), 'A', 0}, // C3
+ {IV('Ä'), 'A', 0}, // C4
+ {IV('Å'), 'A', 0}, // C5
+ {IV('Æ'), 'A', 'E'}, // C6
+ {IV('Ç'), 'C', 0}, // C7
+ {IV('È'), 'E', 0}, // C8
+ {IV('É'), 'E', 0}, // C9
+ {IV('Í'), 'I', 0}, // CD
+ {IV('Ñ'), 'N', 0}, // D1
+ {IV('Õ'), 'O', 0}, // D5
+ {IV('Ö'), 'O', 0}, // D6
+ {IV('×'), 'x', 0}, // D7
+ {IV('Ü'), 'U', 0}, // DC
+ {IV('Ý'), 'Y', 0}, // DD
+ {IV('à'), 'a', 0}, // E0
+ {IV('á'), 'a', 0},
+ {IV('â'), 'a', 0},
+ {IV('ã'), 'a', 0},
+ {IV('ä'), 'a', 0},
+ {IV('å'), 'a', 0},
+ {IV('æ'), 'a', 'e'},
+ {IV('ç'), 'c', 0},
+ {IV('è'), 'e', 0}, // 00E8
+ {IV('é'), 'e', 0},
+ {IV('ê'), 'e', 0},
+ {IV('ë'), 'e', 0},
+ {IV('ì'), 'i', 0}, // 00EC
+ {IV('í'), 'i', 0},
+ {IV('î'), 'i', 0},
+ {IV('ï'), 'i', 0}, // 00EF
+
+ {IV('ñ'), 'n', 0}, // 00F1
+ {IV('ò'), 'o', 0},
+ {IV('ó'), 'o', 0},
+ {IV('ô'), 'o', 0},
+ {IV('õ'), 'o', 0},
+ {IV('ö'), 'o', 0},
+ //{IV('÷'), 0xB8, 0},
+ {IV('ø'), 'o', 0},
+ {IV('ù'), 'u', 0},
+ {IV('ú'), 'u', 0},
+ {IV('û'), 'u', 0},
+ {IV('ü'), 'u', 0}, // FC
+ {IV('ý'), 'y', 0}, // FD
+ {IV('ÿ'), 'y', 0}, // FF
+
+ {IV('Ą'), 'A', 0}, // 0104
+ {IV('ą'), 'a', 0}, // 0105
+ {IV('Ć'), 'C', 0}, // 0106
+ {IV('ć'), 'c', 0}, // 0107
+ {IV('Č'), 'C', 0}, // 010C
+ {IV('č'), 'c', 0}, // 010D
+ {IV('Ď'), 'D', 0}, // 010E
+ {IV('ď'), 'd', 0}, // 010F
+ {IV('đ'), 'd', 0}, // 0111
+ {IV('ę'), 'e', 0}, // 0119
+ {IV('Ě'), 'E', 0}, // 011A
+ {IV('ě'), 'e', 0}, // 011B
+ {IV('ğ'), 'g', 0}, // 011F
+ {IV('İ'), 'I', 0}, // 0130
+ {IV('ı'), 'i', 0}, // 0131
+
+ {IV('Ł'), 'L', 0}, // 0141
+ {IV('ł'), 'l', 0}, // 0142
+ {IV('Ń'), 'N', 0}, // 0143
+ {IV('ń'), 'n', 0}, // 0144
+ {IV('ň'), 'n', 0}, // 0148
+
+ {IV('Ř'), 'R', 0}, // 0158
+ {IV('ř'), 'r', 0}, // 0159
+ {IV('Ś'), 'S', 0}, // 015A
+ {IV('ś'), 's', 0}, // 015B
+ {IV('ş'), 's', 0}, // 015F
+ {IV('Š'), 'S', 0}, // 0160
+ {IV('š'), 's', 0}, // 0161
+ {IV('ť'), 't', 0}, // 0165
+ {IV('ů'), 'u', 0}, // 016F
+ {IV('ż'), 'z', 0}, // 017C
+ {IV('Ž'), 'Z', 0}, // 017D
+ {IV('ž'), 'z', 0}, // 017E
+ {IV('ƒ'), 'f', 0}, // 0192
+
+ {IV('ˣ'), 'x', 0}, // 02E3
+
+ #if ENABLED(DISPLAY_CHARSET_ISO10646_VI)
+
+ // Map Vietnamese phonetics
+
+ //{IV('à'), 'a', 0}, {IV('À'), 'A', 0},
+ {IV('ạ'), 'a', 0}, {IV('Ạ'), 'A', 0},
+ {IV('ả'), 'a', 0}, {IV('Ả'), 'A', 0},
+ //{IV('ã'), 'a', 0}, {IV('Ã'), 'A', 0},
+ //{IV('á'), 'á', 0}, {IV('Á'), 'A', 0},
+ {IV('Ạ'), 'A', 0},
+ {IV('ă'), 'a', 0}, {IV('Ă'), 'A', 0},
+ {IV('ằ'), 'a', 0}, {IV('Ằ'), 'A', 0},
+ {IV('ẳ'), 'a', 0}, {IV('Ẳ'), 'A', 0},
+ {IV('ẵ'), 'a', 0}, {IV('Ẵ'), 'A', 0},
+ {IV('ắ'), 'a', 0}, {IV('Ắ'), 'A', 0},
+ {IV('ặ'), 'a', 0}, {IV('Ặ'), 'A', 0},
+ {IV('â'), 'a', 0}, {IV('Â'), 'A', 0},
+ {IV('ầ'), 'a', 0}, {IV('Ầ'), 'A', 0},
+ {IV('ẩ'), 'a', 0}, {IV('Ẩ'), 'A', 0},
+ {IV('ẫ'), 'a', 0}, {IV('Ẫ'), 'A', 0},
+ {IV('ấ'), 'a', 0}, {IV('Ấ'), 'A', 0},
+ {IV('ậ'), 'a', 0}, {IV('Ậ'), 'A', 0},
+ //{IV('đ'), 'd', 0},
+ {IV('Đ'), 'D', 0},
+ {IV('e'), 'e', 0}, {IV('E'), 'E', 0},
+ {IV('è'), 'e', 0}, {IV('È'), 'E', 0},
+ {IV('ẻ'), 'e', 0}, {IV('Ẻ'), 'E', 0},
+ {IV('ẽ'), 'e', 0}, {IV('Ẽ'), 'E', 0},
+ {IV('é'), 'e', 0}, {IV('É'), 'E', 0},
+ {IV('ẹ'), 'e', 0}, {IV('Ẹ'), 'E', 0},
+ {IV('ê'), 'e', 0}, {IV('Ê'), 'E', 0},
+ {IV('ề'), 'e', 0}, {IV('Ề'), 'E', 0},
+ {IV('ể'), 'e', 0}, {IV('Ể'), 'E', 0},
+ {IV('ễ'), 'e', 0}, {IV('Ễ'), 'E', 0},
+ {IV('ế'), 'e', 0}, {IV('Ế'), 'E', 0},
+ {IV('ệ'), 'e', 0}, {IV('Ệ'), 'E', 0},
+ {IV('i'), 'i', 0}, {IV('I'), 'I', 0},
+ //{IV('ì'), 'ì', 0}, {IV('Ì'), 'Ì', 0},
+ {IV('ỉ'), 'ỉ', 0}, {IV('Ỉ'), 'Ỉ', 0},
+ {IV('ĩ'), 'ĩ', 0}, {IV('Ĩ'), 'Ĩ', 0},
+ {IV('í'), 'í', 0}, {IV('Í'), 'Í', 0},
+ {IV('ị'), 'ị', 0}, {IV('Ị'), 'Ị', 0},
+ {IV('o'), 'o', 0}, {IV('O'), 'O', 0},
+ {IV('ò'), 'o', 0}, {IV('Ò'), 'O', 0},
+ {IV('ỏ'), 'o', 0}, {IV('Ỏ'), 'O', 0},
+ {IV('õ'), 'o', 0}, {IV('Õ'), 'O', 0},
+ {IV('ó'), 'o', 0}, {IV('Ó'), 'O', 0},
+ {IV('ọ'), 'o', 0}, {IV('Ọ'), 'O', 0},
+ {IV('ô'), 'o', 0}, {IV('Ô'), 'O', 0},
+ {IV('ồ'), 'o', 0}, {IV('Ồ'), 'O', 0},
+ {IV('ổ'), 'o', 0}, {IV('Ổ'), 'O', 0},
+ {IV('ỗ'), 'o', 0}, {IV('Ỗ'), 'O', 0},
+ {IV('ố'), 'o', 0}, {IV('Ố'), 'O', 0},
+ {IV('ộ'), 'o', 0}, {IV('Ộ'), 'O', 0},
+ {IV('ơ'), 'o', 0}, {IV('Ơ'), 'O', 0},
+ {IV('ờ'), 'o', 0}, {IV('Ờ'), 'O', 0},
+ {IV('ở'), 'o', 0}, {IV('Ở'), 'O', 0},
+ {IV('ỡ'), 'o', 0}, {IV('Ỡ'), 'O', 0},
+ {IV('ớ'), 'o', 0}, {IV('Ớ'), 'O', 0},
+ {IV('ợ'), 'o', 0}, {IV('Ợ'), 'O', 0},
+ {IV('ù'), 'u', 0}, {IV('Ù'), 'U', 0},
+ {IV('ủ'), 'u', 0}, {IV('Ủ'), 'U', 0},
+ {IV('ũ'), 'u', 0}, {IV('Ũ'), 'U', 0},
+ //{IV('ú'), 'u', 0}, {IV('Ú'), 'U', 0},
+ {IV('ụ'), 'u', 0}, {IV('Ụ'), 'U', 0},
+ {IV('ư'), 'u', 0}, {IV('Ư'), 'U', 0},
+ {IV('ừ'), 'u', 0}, {IV('Ừ'), 'U', 0},
+ {IV('ử'), 'u', 0}, {IV('Ử'), 'U', 0},
+ {IV('ữ'), 'u', 0}, {IV('Ữ'), 'U', 0},
+ {IV('ứ'), 'u', 0}, {IV('Ứ'), 'U', 0},
+ {IV('ự'), 'u', 0}, {IV('Ự'), 'U', 0},
+ {IV('y'), 'y', 0}, {IV('Y'), 'Y', 0},
+
+ #endif
+
+ #if ENABLED(DISPLAY_CHARSET_ISO10646_GREEK)
+
+ {IV('΄'), '\'', 0}, // 0384
+ {IV('΅'), '\'', 0}, // 0385
+ {IV('Ά'), 'A', 0}, // 0386
+ {IV('·'), '.', 0}, // 0387
+ {IV('Έ'), 'E', 0}, // 0388
+ {IV('Ή'), 'H', 0}, // 0389
+ {IV('Ί'), 'I', 0}, // 038A
+ {IV('Ό'), 'O', 0}, // 038C
+ {IV('Ύ'), 'Y', 0}, // 038E
+ {IV('Ώ'), 'O', 0}, // 038F
+ {IV('ΐ'), 'i', 0}, // 0390
+ {IV('Α'), 'A', 0}, // 0391
+ {IV('Β'), 'B', 0}, // 0392
+ {IV('Γ'), 'T', 0}, // 0393, Gamma
+ {IV('Δ'), '4', 0}, // 0394, Delta, ◿
+ {IV('Ε'), 'E', 0}, // 0395
+ {IV('Ζ'), 'Z', 0}, // 0396
+ {IV('Η'), 'H', 0}, // 0397
+ {IV('Θ'), '0', 0}, // 0398, Theta
+ {IV('Ι'), 'I', 0}, // 0399
+ {IV('Κ'), 'K', 0}, // 039A
+ {IV('Λ'), '^', 0}, // 039B, Lambda
+ {IV('Μ'), 'M', 0}, // 039C
+ {IV('Ν'), 'N', 0}, // 039D
+ {IV('Ξ'), '3', 0}, // 039E, Xi
+ {IV('Ο'), 'O', 0}, // 039F
+ {IV('Π'), 'n', 0}, // 03A0, Pi
+ {IV('Ρ'), 'P', 0}, // 03A1
+ {IV('Σ'), 'E', 0}, // 03A3, Sigma
+ {IV('Τ'), 'T', 0}, // 03A4
+ {IV('Υ'), 'Y', 0}, // 03A5, Upsilon
+ {IV('Φ'), 'p', 0}, // 03A6, Phi
+ {IV('Χ'), 'X', 0}, // 03A7
+ {IV('Ψ'), 'P', 0}, // 03A8, Psi
+ {IV('Ω'), 'O', 0}, // 03A9, Omega
+ {IV('Ϊ'), 'I', 0}, // 03AA
+ {IV('Ϋ'), 'Y', 0}, // 03AB
+ {IV('ά'), 'a', 0}, // 03AC
+ {IV('έ'), 'e', 0}, // 03AD
+ {IV('ή'), 'n', 0}, // 03AE
+ {IV('ί'), 'i', 0}, // 03AF
+ {IV('ΰ'), 'v', 0}, // 03B0
+ {IV('α'), 'a', 0}, // 03B1, alpha
+ {IV('β'), 'B', 0}, // 03B2, beta
+ {IV('γ'), 'v', 0}, // 03B3, gamma
+ {IV('δ'), 'd', 0}, // 03B4, delta
+ {IV('ε'), 'e', 0}, // 03B5, epsilon
+ {IV('ζ'), 'Z', 0}, // 03B6, zeta
+ {IV('η'), 'n', 0}, // 03B7, eta
+ {IV('θ'), '0', 0}, // 03B8, theta
+ {IV('ι'), 'i', 0}, // 03B9, lota
+ {IV('κ'), 'k', 0}, // 03BA, kappa
+ {IV('λ'), 'L', 0}, // 03BB, lambda
+ {IV('μ'), 'u', 0}, // 03BC, mu
+ {IV('ν'), 'v', 0}, // 03BD, nu
+ {IV('ξ'), 'e', 0}, // 03BE, xi
+ {IV('ο'), 'o', 0}, // 03BF
+ {IV('π'), 'n', 0}, // 03C0, pi
+ {IV('ρ'), 'p', 0}, // 03C1, rho
+ {IV('ς'), 'c', 0}, // 03C2
+ {IV('σ'), 'o', 0}, // 03C3, sigma
+ {IV('τ'), 't', 0}, // 03C4, tau
+ {IV('υ'), 'v', 0}, // 03C5, upsilon
+ {IV('φ'), 'p', 0}, // 03C6
+ {IV('χ'), 'X', 0}, // 03C7, chi
+ {IV('ψ'), 'W', 0}, // 03C8, psi
+ {IV('ω'), 'w', 0}, // 03C9, omega
+ {IV('ϊ'), 'i', 0}, // 03CA
+ {IV('ϋ'), 'v', 0}, // 03CB
+ {IV('ό'), 'o', 0}, // 03CC
+ {IV('ύ'), 'v', 0}, // 03CD
+ {IV('ώ'), 'w', 0}, // 03CE
+
+ #endif
+
+ #if ENABLED(DISPLAY_CHARSET_ISO10646_5)
+ // Map CYRILLIC code to plain ASCII
+ {IV('Ё'), 'E', 0}, // 0401
+ {IV('А'), 'A', 0}, // 0410
+ {IV('Б'), 'b', 0}, // 0411
+ {IV('В'), 'B', 0}, // 0412
+ {IV('Г'), 'T', 0}, // 0413
+ {IV('Д'), 'Q', 0}, // 0414
+ {IV('Е'), 'E', 0}, // 0415
+ {IV('Ж'), '*', 0}, // 0416
+ {IV('З'), 'E', 0}, // 0417
+ {IV('И'), 'N', 0}, // 0418
+ {IV('Й'), 'N', 0}, // 0419
+ {IV('К'), 'K', 0}, // 041A
+ {IV('Л'), 'T', 0}, // 041B
+ {IV('М'), 'M', 0}, // 041C
+ {IV('Н'), 'H', 0}, // 041D
+ {IV('О'), 'O', 0}, // 041E
+ {IV('П'), 'n', 0}, // 041F
+ {IV('Р'), 'P', 0}, // 0420
+ {IV('С'), 'C', 0}, // 0421
+ {IV('Т'), 'T', 0}, // 0422
+ {IV('У'), 'Y', 0},
+ {IV('Ф'), 'o', 0},
+ {IV('Х'), 'X', 0},
+ {IV('Ц'), 'U', 0},
+ {IV('Ч'), 'y', 0},
+ {IV('Ш'), 'W', 0},
+ {IV('Щ'), 'W', 0},
+ {IV('Ъ'), 'b', 0},
+ {IV('Ы'), 'b', '|'},
+ {IV('Ь'), 'b'},
+ {IV('Э'), 'e'},
+ {IV('Ю'), '|', 'O'},
+ {IV('Я'), '9', '|'}, // 042F
+
+ {IV('а'), 'a', 0}, // 0430
+ {IV('б'), '6', 0}, // 0431
+ {IV('в'), 'B', 0}, // 0432,
+ {IV('г'), 'r', 0}, // 0433
+ {IV('д'), 'a', 0}, // 0434,
+ {IV('е'), 'e', 0}, // 0435
+ {IV('ж'), '*', 0}, // 0436
+ {IV('з'), 'e', 0}, // 0437,
+ {IV('и'), 'u', 0}, // 0438
+ {IV('й'), 'u', 0}, // 0439,
+ {IV('к'), 'k', 0}, // 043A
+ {IV('л'), 'n', 0},
+ {IV('м'), 'm', 0},
+ {IV('н'), 'H', 0},
+ {IV('о'), 'o', 0},
+ {IV('п'), 'n', 0},
+ {IV('р'), 'p', 0},
+ {IV('с'), 'c', 0},
+ {IV('т'), 't', 0},
+ {IV('у'), 'y', 0},
+ {IV('ф'), 'q', 'p'},
+ {IV('х'), 'x', 0},
+ {IV('ц'), 'u', 0},
+ {IV('ч'), 'y', 0},
+ {IV('ш'), 'w', 0},
+ {IV('щ'), 'w', 0},
+ {IV('ъ'), 'b', 0},
+ {IV('ы'), 'b', '|'},
+ {IV('ь'), 'b', 0},
+ {IV('э'), 'e', 0},
+ {IV('ю'), '|', 'o'},
+ {IV('я'), 'g', 0}, // 044F
+ {IV('ё'), 'e', 0}, // 0451
+
+ #endif
+
+ {IV('•'), '.', 0}, // 2022 ·
+ {IV('℞'), 'P', 'x'}, // 211E ℞ Pt ASCII 158
+ {IV('™'), 'T', 'M'}, // 2122
+ {IV('←'), '<', '-'}, // 2190
+ {IV('→'), '-', '>'}, // 2192, Marlin special: '⮈⮉⮊⮋➤→⏵➟➠➡' LCD_STR_ARROW_RIGHT (0x03)
+ //{IV('↰'), '<', 0}, // 21B0, Marlin special: '⮥⮭⮉⇧↑↰⤴' LCD_STR_UPLEVEL (0x04)
+ {IV('↰'), 0x03, 0}, // 21B0, Marlin special: '⮥⮭⮉⇧↑↰⤴' LCD_STR_UPLEVEL (0x04)
+ {IV('↻'), 0x04, 0}, // 21BB Marlin special: '↻↺⟳⟲' LCD_STR_REFRESH (0x01)
+ {IV('∼'), '~', 0}, // 223C
+ {IV('≈'), '~', '='}, // 2248
+ {IV('≠'), '!', '='}, // 2260
+ {IV('≡'), '=', 0}, // 2261
+ {IV('≤'), '<', '='},// 2264, ≤≥ ⩽⩾
+ {IV('≥'), '>', '='}, // 2265
+ {IV('⏱'), 0x07, 0}, // 23F1, Marlin special: '🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚🕛🕜🕝🕞🕟🕠🕡🕢🕣🕤🕥🕦🕧 ⌚⌛⏰⏱⏳⧖⧗' LCD_STR_CLOCK (0x05)
+
+ {IV('゠'), '=', 0}, // 30A0
+
+ // ⏰⏱⏲⏳◴◵◶◷
+ // ⏻⏼♁♂
+ //{IV(''), 0x00, 0}, // Marlin special: '' LCD_STR_BEDTEMP (0x07)
+ {IV('🌡'), 0x02, 0}, // D83CDF21 Marlin special: '🌡' LCD_STR_THERMOMETER (0x08)
+ {IV('📂'), 0x05, 0}, // D83DDCC2 Marlin special: '📁📂' LCD_STR_FOLDER (0x02)
+ //{IV(''), 0x06, 0}, // Marlin special: '' LCD_STR_FEEDRATE (0x06)
+};
+
+/* return v1 - v2 */
+static int hd44780_charmap_compare(hd44780_charmap_t * v1, hd44780_charmap_t * v2) {
+ return (v1->uchar < v2->uchar) ? -1 : (v1->uchar > v2->uchar) ? 1 : 0;
+}
+
+static int pf_bsearch_cb_comp_hd4map_pgm(void *userdata, size_t idx, void * data_pin) {
+ hd44780_charmap_t localval;
+ hd44780_charmap_t *p_hd44780_charmap = (hd44780_charmap_t *)userdata;
+ memcpy_P(&localval, p_hd44780_charmap + idx, sizeof(localval));
+ return hd44780_charmap_compare(&localval, (hd44780_charmap_t *)data_pin);
+}
+
+void lcd_moveto(const lcd_uint_t col, const lcd_uint_t row) { lcd.setCursor(col, row); }
+
+void lcd_put_int(const int i) { lcd.print(i); }
+
+// return < 0 on error
+// return the advanced cols
+int lcd_put_wchar_max(wchar_t c, pixel_len_t max_length) {
+
+ // find the HD44780 internal ROM first
+ int ret;
+ size_t idx = 0;
+ hd44780_charmap_t pinval;
+ hd44780_charmap_t *copy_address = nullptr;
+ pinval.uchar = c;
+ pinval.idx = -1;
+
+ if (max_length < 1) return 0;
+
+ // TODO: fix the '\\' that doesn't exist in the HD44870
+ if (c < 128) {
+ lcd.write((uint8_t)c);
+ return 1;
+ }
+ copy_address = nullptr;
+ ret = pf_bsearch_r((void *)g_hd44780_charmap_device, COUNT(g_hd44780_charmap_device), pf_bsearch_cb_comp_hd4map_pgm, (void *)&pinval, &idx);
+ if (ret >= 0) {
+ copy_address = (hd44780_charmap_t *)(g_hd44780_charmap_device + idx);
+ }
+ else {
+ ret = pf_bsearch_r((void *)g_hd44780_charmap_common, COUNT(g_hd44780_charmap_common), pf_bsearch_cb_comp_hd4map_pgm, (void *)&pinval, &idx);
+ if (ret >= 0) copy_address = (hd44780_charmap_t *)(g_hd44780_charmap_common + idx);
+ }
+
+ if (ret >= 0) {
+ hd44780_charmap_t localval;
+ // found
+ memcpy_P(&localval, copy_address, sizeof(localval));
+ lcd.write(localval.idx);
+ if (max_length >= 2 && localval.idx2 > 0) {
+ lcd.write(localval.idx2);
+ return 2;
+ }
+ return 1;
+ }
+
+ // Not found, print '?' instead
+ lcd.write((uint8_t)'?');
+ return 1;
+}
+
+/**
+ * @brief Draw a UTF-8 string
+ *
+ * @param utf8_str : the UTF-8 string
+ * @param cb_read_byte : the callback function to read one byte from the utf8_str (from RAM or ROM)
+ * @param max_length : the pixel length of the string allowed (or number of slots in HD44780)
+ *
+ * @return the number of pixels advanced
+ *
+ * Draw a UTF-8 string
+ */
+static int lcd_put_u8str_max_cb(const char * utf8_str, uint8_t (*cb_read_byte)(uint8_t * str), pixel_len_t max_length) {
+ pixel_len_t ret = 0;
+ uint8_t *p = (uint8_t *)utf8_str;
+ while (ret < max_length) {
+ wchar_t ch = 0;
+ p = get_utf8_value_cb(p, cb_read_byte, &ch);
+ if (!ch) break;
+ ret += lcd_put_wchar_max(ch, max_length - ret);
+ }
+ return (int)ret;
+}
+
+int lcd_put_u8str_max(const char * utf8_str, pixel_len_t max_length) {
+ return lcd_put_u8str_max_cb(utf8_str, read_byte_ram, max_length);
+}
+
+int lcd_put_u8str_max_P(PGM_P utf8_str_P, pixel_len_t max_length) {
+ return lcd_put_u8str_max_cb(utf8_str_P, read_byte_rom, max_length);
+}
+
+#if ENABLED(DEBUG_LCDPRINT)
+
+ int test_hd44780_charmap(hd44780_charmap_t *data, size_t size, char *name, char flg_show_contents) {
+ int ret;
+ size_t idx = 0;
+ hd44780_charmap_t preval = {0, 0, 0};
+ hd44780_charmap_t pinval = {0, 0, 0};
+ char flg_error = 0;
+
+ int i;
+
+ TRACE("Test %s\n", name);
+
+ for (i = 0; i < size; i ++) {
+ memcpy_P(&pinval, &(data[i]), sizeof(pinval));
+
+ if (flg_show_contents) {
+ #if 1
+ TRACE("[% 4d] % 6" PRIu32 "(0x%04" PRIX32 ") --> 0x%02X,0x%02X%s\n", i, pinval.uchar, pinval.uchar, (unsigned int)(pinval.idx), (unsigned int)(pinval.idx2), (preval.uchar < pinval.uchar?"":" <--- ERROR"));
+ #else
+ TRACE("[% 4d]", i);
+ TRACE("% 6" PRIu32 "(0x%04" PRIX32 "),", pinval.uchar, pinval.uchar);
+ TRACE("0x%02X,", (unsigned int)(pinval.idx));
+ TRACE("0x%02X,", (unsigned int)(pinval.idx2));
+ TRACE("%s", (preval.uchar < pinval.uchar?"":" <--- ERROR"));
+ #endif
+ }
+ if (preval.uchar >= pinval.uchar) {
+ flg_error = 1;
+ //TRACE("Error: out of order in array %s: idx=%d, val=%d(0x%x)\n", name, i, pinval.uchar, pinval.uchar);
+ //return -1;
+ }
+ memcpy(&preval, &pinval, sizeof(pinval));
+
+ ret = pf_bsearch_r((void *)data, size, pf_bsearch_cb_comp_hd4map_pgm, (void *)&pinval, &idx);
+ if (ret < 0) {
+ flg_error = 1;
+ TRACE("Error: not found item in array %s: idx=%d, val=%d(0x%x)\n", name, i, pinval.uchar, pinval.uchar);
+ //return -1;
+ }
+ if (idx != i) {
+ flg_error = 1;
+ TRACE("Error: wrong index found item in array %s: idx=%d, val=%d(0x%x)\n", name, i, pinval.uchar, pinval.uchar);
+ //return -1;
+ }
+ }
+ if (flg_error) {
+ TRACE("\nError: in array %s\n\n", name);
+ return -1;
+ }
+ TRACE("\nPASS array %s\n\n", name);
+ return 0;
+ }
+
+ int test_hd44780_charmap_all() {
+ int flg_error = 0;
+ if (test_hd44780_charmap(g_hd44780_charmap_device, COUNT(g_hd44780_charmap_device), "g_hd44780_charmap_device", 0) < 0) {
+ flg_error = 1;
+ test_hd44780_charmap(g_hd44780_charmap_device, COUNT(g_hd44780_charmap_device), "g_hd44780_charmap_device", 1);
+ }
+ if (test_hd44780_charmap(g_hd44780_charmap_common, COUNT(g_hd44780_charmap_common), "g_hd44780_charmap_common", 0) < 0) {
+ flg_error = 1;
+ test_hd44780_charmap(g_hd44780_charmap_common, COUNT(g_hd44780_charmap_common), "g_hd44780_charmap_common", 1);
+ }
+ if (flg_error) {
+ TRACE("\nFAILED in hd44780 tests!\n");
+ return -1;
+ }
+ TRACE("\nPASS in hd44780 tests.\n");
+ return 0;
+ }
+
+#endif // DEBUG_LCDPRINT
+
+#endif // HAS_MARLINUI_HD44780
diff --git a/Marlin/src/lcd/HD44780/marlinui_HD44780.cpp b/Marlin/src/lcd/HD44780/marlinui_HD44780.cpp
new file mode 100644
index 0000000..635751b
--- /dev/null
+++ b/Marlin/src/lcd/HD44780/marlinui_HD44780.cpp
@@ -0,0 +1,1518 @@
+/**
+ * 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_MARLINUI_HD44780
+
+/**
+ * marlinui_HD44780.cpp
+ *
+ * LCD display implementations for Hitachi HD44780.
+ * These are the most common LCD character displays.
+ */
+
+#include "marlinui_HD44780.h"
+#include "../marlinui.h"
+#include "../../libs/numtostr.h"
+
+#include "../../sd/cardreader.h"
+#include "../../module/temperature.h"
+#include "../../module/printcounter.h"
+#include "../../module/planner.h"
+#include "../../module/motion.h"
+
+#if DISABLED(LCD_PROGRESS_BAR) && BOTH(FILAMENT_LCD_DISPLAY, SDSUPPORT)
+ #include "../../feature/filwidth.h"
+ #include "../../gcode/parser.h"
+#endif
+
+#if ENABLED(AUTO_BED_LEVELING_UBL)
+ #include "../../feature/bedlevel/bedlevel.h"
+#endif
+
+//
+// Create LCD instance and chipset-specific information
+//
+
+#if ENABLED(LCD_I2C_TYPE_PCF8575)
+
+ LCD_CLASS lcd(LCD_I2C_ADDRESS, LCD_I2C_PIN_EN, LCD_I2C_PIN_RW, LCD_I2C_PIN_RS, LCD_I2C_PIN_D4, LCD_I2C_PIN_D5, LCD_I2C_PIN_D6, LCD_I2C_PIN_D7);
+
+#elif EITHER(LCD_I2C_TYPE_MCP23017, LCD_I2C_TYPE_MCP23008)
+
+ LCD_CLASS lcd(LCD_I2C_ADDRESS
+ #ifdef DETECT_DEVICE
+ , 1
+ #endif
+ );
+
+#elif ENABLED(LCD_I2C_TYPE_PCA8574)
+
+ LCD_CLASS lcd(LCD_I2C_ADDRESS, LCD_WIDTH, LCD_HEIGHT);
+
+#elif ENABLED(SR_LCD_2W_NL)
+
+ // 2 wire Non-latching LCD SR from:
+ // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
+
+ LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN
+ #if PIN_EXISTS(SR_STROBE)
+ , SR_STROBE_PIN
+ #endif
+ );
+
+#elif ENABLED(SR_LCD_3W_NL)
+
+ // NewLiquidCrystal was not working
+ // https://github.com/mikeshub/SailfishLCD
+ // uses the code directly from Sailfish
+
+ LCD_CLASS lcd(SR_STROBE_PIN, SR_DATA_PIN, SR_CLK_PIN);
+
+#elif ENABLED(LCM1602)
+
+ LCD_CLASS lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
+
+#else
+
+ // Standard direct-connected LCD implementations
+ LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5, LCD_PINS_D6, LCD_PINS_D7);
+
+#endif
+
+static void createChar_P(const char c, const byte * const ptr) {
+ byte temp[8];
+ LOOP_L_N(i, 8)
+ temp[i] = pgm_read_byte(&ptr[i]);
+ lcd.createChar(c, temp);
+}
+
+#if ENABLED(LCD_PROGRESS_BAR)
+ #define LCD_STR_PROGRESS "\x03\x04\x05"
+#endif
+
+#if ENABLED(LCD_USE_I2C_BUZZER)
+ void MarlinUI::buzz(const long duration, const uint16_t freq) {
+ if (!buzzer_enabled) return;
+ lcd.buzz(duration, freq);
+ }
+#endif
+
+void MarlinUI::set_custom_characters(const HD44780CharSet screen_charset/*=CHARSET_INFO*/) {
+ #if NONE(LCD_PROGRESS_BAR, SHOW_BOOTSCREEN)
+ UNUSED(screen_charset);
+ #endif
+
+ // CHARSET_BOOT
+ #if ENABLED(SHOW_BOOTSCREEN)
+ const static PROGMEM byte corner[4][8] = { {
+ B00000,
+ B00000,
+ B00000,
+ B00000,
+ B00001,
+ B00010,
+ B00100,
+ B00100
+ }, {
+ B00000,
+ B00000,
+ B00000,
+ B11100,
+ B11100,
+ B01100,
+ B00100,
+ B00100
+ }, {
+ B00100,
+ B00010,
+ B00001,
+ B00000,
+ B00000,
+ B00000,
+ B00000,
+ B00000
+ }, {
+ B00100,
+ B01000,
+ B10000,
+ B00000,
+ B00000,
+ B00000,
+ B00000,
+ B00000
+ } };
+ #endif // SHOW_BOOTSCREEN
+
+ // CHARSET_INFO
+ const static PROGMEM byte bedTemp[8] = {
+ B00000,
+ B11111,
+ B10101,
+ B10001,
+ B10101,
+ B11111,
+ B00000,
+ B00000
+ };
+
+ const static PROGMEM byte degree[8] = {
+ B01100,
+ B10010,
+ B10010,
+ B01100,
+ B00000,
+ B00000,
+ B00000,
+ B00000
+ };
+
+ const static PROGMEM byte thermometer[8] = {
+ B00100,
+ B01010,
+ B01010,
+ B01010,
+ B01010,
+ B10001,
+ B10001,
+ B01110
+ };
+
+ const static PROGMEM byte uplevel[8] = {
+ B00100,
+ B01110,
+ B11111,
+ B00100,
+ B11100,
+ B00000,
+ B00000,
+ B00000
+ };
+
+ const static PROGMEM byte feedrate[8] = {
+ #if LCD_INFO_SCREEN_STYLE == 1
+ B00000,
+ B00100,
+ B10010,
+ B01001,
+ B10010,
+ B00100,
+ B00000,
+ B00000
+ #else
+ B11100,
+ B10000,
+ B11000,
+ B10111,
+ B00101,
+ B00110,
+ B00101,
+ B00000
+ #endif
+ };
+
+ const static PROGMEM byte clock[8] = {
+ B00000,
+ B01110,
+ B10011,
+ B10101,
+ B10001,
+ B01110,
+ B00000,
+ B00000
+ };
+
+ #if ENABLED(LCD_PROGRESS_BAR)
+
+ // CHARSET_INFO
+ const static PROGMEM byte progress[3][8] = { {
+ B00000,
+ B10000,
+ B10000,
+ B10000,
+ B10000,
+ B10000,
+ B10000,
+ B00000
+ }, {
+ B00000,
+ B10100,
+ B10100,
+ B10100,
+ B10100,
+ B10100,
+ B10100,
+ B00000
+ }, {
+ B00000,
+ B10101,
+ B10101,
+ B10101,
+ B10101,
+ B10101,
+ B10101,
+ B00000
+ } };
+
+ #endif // LCD_PROGRESS_BAR
+
+ #if BOTH(SDSUPPORT, HAS_LCD_MENU)
+
+ // CHARSET_MENU
+ const static PROGMEM byte refresh[8] = {
+ B00000,
+ B00110,
+ B11001,
+ B11000,
+ B00011,
+ B10011,
+ B01100,
+ B00000,
+ };
+ const static PROGMEM byte folder[8] = {
+ B00000,
+ B11100,
+ B11111,
+ B10001,
+ B10001,
+ B11111,
+ B00000,
+ B00000
+ };
+
+ #endif // SDSUPPORT
+
+ #if ENABLED(SHOW_BOOTSCREEN)
+ // Set boot screen corner characters
+ if (screen_charset == CHARSET_BOOT) {
+ for (uint8_t i = 4; i--;)
+ createChar_P(i, corner[i]);
+ }
+ else
+ #endif
+ { // Info Screen uses 5 special characters
+ createChar_P(LCD_STR_BEDTEMP[0], bedTemp);
+ createChar_P(LCD_STR_DEGREE[0], degree);
+ createChar_P(LCD_STR_THERMOMETER[0], thermometer);
+ createChar_P(LCD_STR_FEEDRATE[0], feedrate);
+ createChar_P(LCD_STR_CLOCK[0], clock);
+
+ #if ENABLED(LCD_PROGRESS_BAR)
+ if (screen_charset == CHARSET_INFO) { // 3 Progress bar characters for info screen
+ for (int16_t i = 3; i--;)
+ createChar_P(LCD_STR_PROGRESS[i], progress[i]);
+ }
+ else
+ #endif
+ {
+ createChar_P(LCD_STR_UPLEVEL[0], uplevel);
+ #if BOTH(SDSUPPORT, HAS_LCD_MENU)
+ // SD Card sub-menu special characters
+ createChar_P(LCD_STR_REFRESH[0], refresh);
+ createChar_P(LCD_STR_FOLDER[0], folder);
+ #endif
+ }
+ }
+
+}
+
+void MarlinUI::init_lcd() {
+
+ #if ENABLED(LCD_I2C_TYPE_PCF8575)
+ lcd.begin(LCD_WIDTH, LCD_HEIGHT);
+ #ifdef LCD_I2C_PIN_BL
+ lcd.setBacklightPin(LCD_I2C_PIN_BL, POSITIVE);
+ lcd.setBacklight(HIGH);
+ #endif
+
+ #elif ENABLED(LCD_I2C_TYPE_MCP23017)
+ lcd.setMCPType(LTI_TYPE_MCP23017);
+ lcd.begin(LCD_WIDTH, LCD_HEIGHT);
+ update_indicators();
+
+ #elif ENABLED(LCD_I2C_TYPE_MCP23008)
+ lcd.setMCPType(LTI_TYPE_MCP23008);
+ lcd.begin(LCD_WIDTH, LCD_HEIGHT);
+
+ #elif ENABLED(LCD_I2C_TYPE_PCA8574)
+ lcd.init();
+ lcd.backlight();
+
+ #else
+ lcd.begin(LCD_WIDTH, LCD_HEIGHT);
+ #endif
+
+ set_custom_characters(on_status_screen() ? CHARSET_INFO : CHARSET_MENU);
+
+ lcd.clear();
+}
+
+bool MarlinUI::detected() {
+ return (true
+ #if EITHER(LCD_I2C_TYPE_MCP23017, LCD_I2C_TYPE_MCP23008) && defined(DETECT_DEVICE)
+ && lcd.LcdDetected() == 1
+ #endif
+ );
+}
+
+#if HAS_SLOW_BUTTONS
+ uint8_t MarlinUI::read_slow_buttons() {
+ #if ENABLED(LCD_I2C_TYPE_MCP23017)
+ // Reading these buttons is too slow for interrupt context
+ // so they are read during LCD update in the main loop.
+ uint8_t slow_bits = lcd.readButtons()
+ #if !BUTTON_EXISTS(ENC)
+ << B_I2C_BTN_OFFSET
+ #endif
+ ;
+ #if ENABLED(LCD_I2C_VIKI)
+ if ((slow_bits & (B_MI | B_RI)) && PENDING(millis(), next_button_update_ms)) // LCD clicked
+ slow_bits &= ~(B_MI | B_RI); // Disable LCD clicked buttons if screen is updated
+ #endif
+ return slow_bits;
+ #endif // LCD_I2C_TYPE_MCP23017
+ }
+#endif
+
+void MarlinUI::clear_lcd() { lcd.clear(); }
+
+#if ENABLED(SHOW_BOOTSCREEN)
+
+ void lcd_erase_line(const lcd_uint_t line) {
+ lcd_moveto(0, line);
+ for (uint8_t i = LCD_WIDTH + 1; --i;)
+ lcd_put_wchar(' ');
+ }
+
+ // Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line
+ void lcd_scroll(const lcd_uint_t col, const lcd_uint_t line, PGM_P const text, const uint8_t len, const int16_t time) {
+ uint8_t slen = utf8_strlen_P(text);
+ if (slen < len) {
+ lcd_put_u8str_max_P(col, line, text, len);
+ for (; slen < len; ++slen) lcd_put_wchar(' ');
+ safe_delay(time);
+ }
+ else {
+ PGM_P p = text;
+ int dly = time / _MAX(slen, 1);
+ LOOP_LE_N(i, slen) {
+
+ // Print the text at the correct place
+ lcd_put_u8str_max_P(col, line, p, len);
+
+ // Fill with spaces
+ for (uint8_t ix = slen - i; ix < len; ++ix) lcd_put_wchar(' ');
+
+ // Delay
+ safe_delay(dly);
+
+ // Advance to the next UTF8 valid position
+ p++;
+ while (!START_OF_UTF8_CHAR(pgm_read_byte(p))) p++;
+ }
+ }
+ }
+
+ static void logo_lines(PGM_P const extra) {
+ int16_t indent = (LCD_WIDTH - 8 - utf8_strlen_P(extra)) / 2;
+ lcd_put_wchar(indent, 0, '\x00'); lcd_put_u8str_P(PSTR( "------" )); lcd_put_wchar('\x01');
+ lcd_put_u8str_P(indent, 1, PSTR("|Marlin|")); lcd_put_u8str_P(extra);
+ lcd_put_wchar(indent, 2, '\x02'); lcd_put_u8str_P(PSTR( "------" )); lcd_put_wchar('\x03');
+ }
+
+ void MarlinUI::show_bootscreen() {
+ set_custom_characters(CHARSET_BOOT);
+ lcd.clear();
+
+ #define LCD_EXTRA_SPACE (LCD_WIDTH-8)
+
+ #define CENTER_OR_SCROLL(STRING,DELAY) \
+ lcd_erase_line(3); \
+ if (utf8_strlen(STRING) <= LCD_WIDTH) { \
+ lcd_put_u8str_P((LCD_WIDTH - utf8_strlen_P(PSTR(STRING))) / 2, 3, PSTR(STRING)); \
+ safe_delay(DELAY); \
+ } \
+ else { \
+ lcd_scroll(0, 3, PSTR(STRING), LCD_WIDTH, DELAY); \
+ }
+
+ //
+ // Show the Marlin logo with splash line 1
+ //
+ if (LCD_EXTRA_SPACE >= utf8_strlen(SHORT_BUILD_VERSION) + 1) {
+ //
+ // Show the Marlin logo, splash line1, and splash line 2
+ //
+ logo_lines(PSTR(" " SHORT_BUILD_VERSION));
+ CENTER_OR_SCROLL(MARLIN_WEBSITE_URL, 2000);
+ }
+ else {
+ //
+ // Show the Marlin logo and short build version
+ // After a delay show the website URL
+ //
+ logo_lines(NUL_STR);
+ CENTER_OR_SCROLL(SHORT_BUILD_VERSION, 1500);
+ CENTER_OR_SCROLL(MARLIN_WEBSITE_URL, 1500);
+ #ifdef STRING_SPLASH_LINE3
+ CENTER_OR_SCROLL(STRING_SPLASH_LINE3, 1500);
+ #endif
+ }
+
+ lcd.clear();
+ safe_delay(100);
+ set_custom_characters(CHARSET_INFO);
+ lcd.clear();
+ }
+
+#endif // SHOW_BOOTSCREEN
+
+void MarlinUI::draw_kill_screen() {
+ lcd_put_u8str(0, 0, status_message);
+ lcd_uint_t y = 2;
+ #if LCD_HEIGHT >= 4
+ lcd_put_u8str_P(0, y++, GET_TEXT(MSG_HALTED));
+ #endif
+ lcd_put_u8str_P(0, y, GET_TEXT(MSG_PLEASE_RESET));
+}
+
+//
+// Before homing, blink '123' <-> '???'.
+// Homed but unknown... '123' <-> ' '.
+// Homed and known, display constantly.
+//
+FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const bool blink) {
+ lcd_put_wchar('X' + uint8_t(axis));
+ if (blink)
+ lcd_put_u8str(value);
+ else if (axis_should_home(axis))
+ while (const char c = *value++) lcd_put_wchar(c <= '.' ? c : '?');
+ else if (NONE(HOME_AFTER_DEACTIVATE, DISABLE_REDUCED_ACCURACY_WARNING) && !axis_is_trusted(axis))
+ lcd_put_u8str_P(axis == Z_AXIS ? PSTR(" ") : PSTR(" "));
+ else
+ 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);
+ const float t1 = (isBed ? thermalManager.degBed() : thermalManager.degHotend(heater_id)),
+ t2 = (isBed ? thermalManager.degTargetBed() : thermalManager.degTargetHotend(heater_id));
+ #else
+ const float t1 = thermalManager.degHotend(heater_id), t2 = thermalManager.degTargetHotend(heater_id);
+ #endif
+
+ 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(' ');
+ }
+}
+
+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);
+}
+
+#if HAS_PRINT_PROGRESS
+
+ FORCE_INLINE void _draw_print_progress() {
+ const uint8_t progress = ui.get_progress_percent();
+ lcd_put_u8str_P(PSTR(TERN(SDSUPPORT, "SD", "P:")));
+ if (progress)
+ lcd_put_u8str(ui8tostr3rj(progress));
+ else
+ lcd_put_u8str_P(PSTR("---"));
+ lcd_put_wchar('%');
+ }
+
+#endif
+
+#if ENABLED(LCD_PROGRESS_BAR)
+
+ void MarlinUI::draw_progress_bar(const uint8_t percent) {
+ const int16_t tix = (int16_t)(percent * (LCD_WIDTH) * 3) / 100,
+ cel = tix / 3,
+ rem = tix % 3;
+ uint8_t i = LCD_WIDTH;
+ char msg[LCD_WIDTH + 1], b = ' ';
+ msg[LCD_WIDTH] = '\0';
+ while (i--) {
+ if (i == cel - 1)
+ b = LCD_STR_PROGRESS[2];
+ else if (i == cel && rem != 0)
+ b = LCD_STR_PROGRESS[rem - 1];
+ msg[i] = b;
+ }
+ lcd_put_u8str(msg);
+ }
+
+#endif // LCD_PROGRESS_BAR
+
+void MarlinUI::draw_status_message(const bool blink) {
+
+ lcd_moveto(0, LCD_HEIGHT - 1);
+
+ #if ENABLED(LCD_PROGRESS_BAR)
+
+ // Draw the progress bar if the message has shown long enough
+ // or if there is no message set.
+ if (ELAPSED(millis(), progress_bar_ms + PROGRESS_BAR_MSG_TIME) || !has_status()) {
+ const uint8_t progress = get_progress_percent();
+ if (progress > 2) return draw_progress_bar(progress);
+ }
+
+ #elif BOTH(FILAMENT_LCD_DISPLAY, SDSUPPORT)
+
+ // Alternate Status message and Filament display
+ if (ELAPSED(millis(), next_filament_display)) {
+ lcd_put_u8str_P(PSTR("Dia "));
+ lcd_put_u8str(ftostr12ns(filwidth.measured_mm));
+ lcd_put_u8str_P(PSTR(" V"));
+ lcd_put_u8str(i16tostr3rj(planner.volumetric_percent(parser.volumetric_enabled)));
+ lcd_put_wchar('%');
+ return;
+ }
+
+ #endif // FILAMENT_LCD_DISPLAY && SDSUPPORT
+
+ #if ENABLED(STATUS_MESSAGE_SCROLLING)
+ static bool last_blink = false;
+
+ // Get the UTF8 character count of the string
+ uint8_t slen = utf8_strlen(status_message);
+
+ // If the string fits into the LCD, just print it and do not scroll it
+ if (slen <= LCD_WIDTH) {
+
+ // The string isn't scrolling and may not fill the screen
+ lcd_put_u8str(status_message);
+
+ // Fill the rest with spaces
+ while (slen < LCD_WIDTH) { lcd_put_wchar(' '); ++slen; }
+ }
+ else {
+ // String is larger than the available space in screen.
+
+ // Get a pointer to the next valid UTF8 character
+ // and the string remaining length
+ uint8_t rlen;
+ const char *stat = status_and_len(rlen);
+ lcd_put_u8str_max(stat, LCD_WIDTH); // The string leaves space
+
+ // If the remaining string doesn't completely fill the screen
+ if (rlen < LCD_WIDTH) {
+ lcd_put_wchar('.'); // Always at 1+ spaces left, draw a dot
+ uint8_t chars = LCD_WIDTH - rlen; // Amount of space left in characters
+ if (--chars) { // Draw a second dot if there's space
+ lcd_put_wchar('.');
+ if (--chars)
+ lcd_put_u8str_max(status_message, chars); // Print a second copy of the message
+ }
+ }
+ if (last_blink != blink) {
+ last_blink = blink;
+ advance_status_scroll();
+ }
+ }
+ #else
+ UNUSED(blink);
+
+ // Get the UTF8 character count of the string
+ uint8_t slen = utf8_strlen(status_message);
+
+ // Just print the string to the LCD
+ lcd_put_u8str_max(status_message, LCD_WIDTH);
+
+ // Fill the rest with spaces if there are missing spaces
+ while (slen < LCD_WIDTH) {
+ lcd_put_wchar(' ');
+ ++slen;
+ }
+ #endif
+}
+
+/**
+ * LCD_INFO_SCREEN_STYLE 0 : Classic Status Screen
+ *
+ * 16x2 |000/000 B000/000|
+ * |0123456789012345|
+ *
+ * 16x4 |000/000 B000/000|
+ * |SD---% Z 000.00|
+ * |F---% T--:--|
+ * |0123456789012345|
+ *
+ * 20x2 |T000/000° B000/000° |
+ * |01234567890123456789|
+ *
+ * 20x4 |T000/000° B000/000° |
+ * |X 000 Y 000 Z000.000|
+ * |F---% SD---% T--:--|
+ * |01234567890123456789|
+ *
+ * LCD_INFO_SCREEN_STYLE 1 : Průša-style Status Screen
+ *
+ * |T000/000° Z 000.00 |
+ * |B000/000° F---% |
+ * |SD---% T--:-- |
+ * |01234567890123456789|
+ *
+ * |T000/000° Z 000.00 |
+ * |T000/000° F---% |
+ * |B000/000° SD---% |
+ * |01234567890123456789|
+ */
+
+inline uint8_t draw_elapsed_or_remaining_time(uint8_t timepos, const bool blink) {
+ char buffer[14];
+
+ #if ENABLED(SHOW_REMAINING_TIME)
+ const bool show_remain = TERN1(ROTATE_PROGRESS_DISPLAY, blink) && (printingIsActive() || marlin_state == MF_SD_COMPLETE);
+ if (show_remain) {
+ #if ENABLED(USE_M73_REMAINING_TIME)
+ duration_t remaining = ui.get_remaining_time();
+ #else
+ uint8_t progress = ui.get_progress_percent();
+ uint32_t elapsed = print_job_timer.duration();
+ duration_t remaining = (progress > 0) ? ((elapsed * 25600 / progress) >> 8) - elapsed : 0;
+ #endif
+ timepos -= remaining.toDigital(buffer);
+ lcd_put_wchar(timepos, 2, 'R');
+ }
+ #else
+ constexpr bool show_remain = false;
+ #endif
+
+ if (!show_remain) {
+ duration_t elapsed = print_job_timer.duration();
+ timepos -= elapsed.toDigital(buffer);
+ lcd_put_wchar(timepos, 2, LCD_STR_CLOCK[0]);
+ }
+ lcd_put_u8str(buffer);
+ return timepos;
+}
+
+void MarlinUI::draw_status_screen() {
+
+ const bool blink = get_blink();
+ lcd_moveto(0, 0);
+
+ #if LCD_INFO_SCREEN_STYLE == 0
+
+ // ========== Line 1 ==========
+
+ #if LCD_WIDTH < 20
+
+ //
+ // Hotend 0 Temperature
+ //
+ _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);
+ #endif
+
+ #else // LCD_WIDTH >= 20
+
+ //
+ // Hotend 0 Temperature
+ //
+ _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);
+ #endif
+
+ #endif // LCD_WIDTH >= 20
+
+ // ========== Line 2 ==========
+
+ #if LCD_HEIGHT > 2
+
+ #if LCD_WIDTH < 20
+
+ #if HAS_PRINT_PROGRESS
+ lcd_moveto(0, 2);
+ _draw_print_progress();
+ #endif
+
+ #else // LCD_WIDTH >= 20
+
+ lcd_moveto(0, 1);
+
+ // If the first line has two extruder temps,
+ // show more temperatures on the next line
+
+ #if HOTENDS > 2 || (HAS_MULTI_HOTEND && HAS_HEATED_BED)
+
+ #if HOTENDS > 2
+ _draw_heater_status(H_E2, LCD_STR_THERMOMETER[0], blink);
+ lcd_moveto(10, 1);
+ #endif
+
+ _draw_bed_status(blink);
+
+ #else // HOTENDS <= 2 && (HOTENDS <= 1 || !HAS_HEATED_BED)
+
+ #if HAS_DUAL_MIXING
+
+ // Two-component mix / gradient instead of XY
+
+ char mixer_messages[12];
+ const char *mix_label;
+ #if ENABLED(GRADIENT_MIX)
+ if (mixer.gradient.enabled) {
+ mixer.update_mix_from_gradient();
+ mix_label = "Gr";
+ }
+ else
+ #endif
+ {
+ mixer.update_mix_from_vtool();
+ mix_label = "Mx";
+ }
+ sprintf_P(mixer_messages, PSTR("%s %d;%d%% "), mix_label, int(mixer.mix[0]), int(mixer.mix[1]));
+ lcd_put_u8str(mixer_messages);
+
+ #else // !HAS_DUAL_MIXING
+
+ const bool show_e_total = TERN0(LCD_SHOW_E_TOTAL, printingIsActive() || marlin_state == MF_SD_COMPLETE);
+
+ if (show_e_total) {
+ #if ENABLED(LCD_SHOW_E_TOTAL)
+ char tmp[20];
+ const uint8_t escale = e_move_accumulator >= 100000.0f ? 10 : 1; // After 100m switch to cm
+ sprintf_P(tmp, PSTR("E %ld%cm "), uint32_t(_MAX(e_move_accumulator, 0.0f)) / escale, escale == 10 ? 'c' : 'm'); // 1234567mm
+ lcd_put_u8str(tmp);
+ #endif
+ }
+ else {
+ const xy_pos_t lpos = current_position.asLogical();
+ _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink);
+ lcd_put_wchar(' ');
+ _draw_axis_value(Y_AXIS, ftostr4sign(lpos.y), blink);
+ }
+
+ #endif // !HAS_DUAL_MIXING
+
+ #endif // HOTENDS <= 2 && (HOTENDS <= 1 || !HAS_HEATED_BED)
+
+ #endif // LCD_WIDTH >= 20
+
+ lcd_moveto(LCD_WIDTH - 8, 1);
+ _draw_axis_value(Z_AXIS, ftostr52sp(LOGICAL_Z_POSITION(current_position.z)), blink);
+
+ #if HAS_LEVELING && !HAS_HEATED_BED
+ lcd_put_wchar(planner.leveling_active || blink ? '_' : ' ');
+ #endif
+
+ #endif // LCD_HEIGHT > 2
+
+ // ========== Line 3 ==========
+
+ #if LCD_HEIGHT > 3
+
+ lcd_put_wchar(0, 2, LCD_STR_FEEDRATE[0]);
+ lcd_put_u8str(i16tostr3rj(feedrate_percentage));
+ lcd_put_wchar('%');
+
+ const uint8_t timepos = draw_elapsed_or_remaining_time(LCD_WIDTH - 1, blink);
+
+ #if LCD_WIDTH >= 20
+ lcd_moveto(timepos - 7, 2);
+ #if HAS_PRINT_PROGRESS
+ _draw_print_progress();
+ #else
+ char c;
+ uint16_t per;
+ #if HAS_FAN0
+ if (true
+ #if EXTRUDERS && ENABLED(ADAPTIVE_FAN_SLOWING)
+ && (blink || thermalManager.fan_speed_scaler[0] < 128)
+ #endif
+ ) {
+ uint16_t spd = thermalManager.fan_speed[0];
+ if (blink) c = 'F';
+ #if ENABLED(ADAPTIVE_FAN_SLOWING)
+ else { c = '*'; spd = thermalManager.scaledFanSpeed(0, spd); }
+ #endif
+ per = thermalManager.fanPercent(spd);
+ }
+ else
+ #endif
+ {
+ #if EXTRUDERS
+ c = 'E';
+ per = planner.flow_percentage[0];
+ #endif
+ }
+ lcd_put_wchar(c);
+ lcd_put_u8str(i16tostr3rj(per));
+ lcd_put_wchar('%');
+ #endif
+ #endif
+
+ #endif // LCD_HEIGHT > 3
+
+ #elif LCD_INFO_SCREEN_STYLE == 1
+
+ // ========== Line 1 ==========
+
+ //
+ // Hotend 0 Temperature
+ //
+ _draw_heater_status(H_E0, LCD_STR_THERMOMETER[0], blink);
+
+ //
+ // Z Coordinate
+ //
+ lcd_moveto(LCD_WIDTH - 9, 0);
+ _draw_axis_value(Z_AXIS, ftostr52sp(LOGICAL_Z_POSITION(current_position.z)), blink);
+
+ #if HAS_LEVELING && (HAS_MULTI_HOTEND || !HAS_HEATED_BED)
+ lcd_put_wchar(LCD_WIDTH - 1, 0, planner.leveling_active || blink ? '_' : ' ');
+ #endif
+
+ // ========== Line 2 ==========
+
+ //
+ // Hotend 1 or Bed Temperature
+ //
+ lcd_moveto(0, 1);
+ #if HAS_MULTI_HOTEND
+ _draw_heater_status(H_E1, LCD_STR_THERMOMETER[0], blink);
+ #elif HAS_HEATED_BED
+ _draw_bed_status(blink);
+ #endif
+
+ lcd_put_wchar(LCD_WIDTH - 9, 1, LCD_STR_FEEDRATE[0]);
+ lcd_put_u8str(i16tostr3rj(feedrate_percentage));
+ lcd_put_wchar('%');
+
+ // ========== Line 3 ==========
+
+ //
+ // SD Percent, Hotend 2, or Bed
+ //
+ lcd_moveto(0, 2);
+ #if HOTENDS > 2
+ _draw_heater_status(H_E2, LCD_STR_THERMOMETER[0], blink);
+ #elif HAS_MULTI_HOTEND && HAS_HEATED_BED
+ _draw_bed_status(blink);
+ #elif HAS_PRINT_PROGRESS
+ #define DREW_PRINT_PROGRESS 1
+ _draw_print_progress();
+ #endif
+
+ //
+ // Elapsed Time or SD Percent
+ //
+ lcd_moveto(LCD_WIDTH - 9, 2);
+
+ #if HAS_PRINT_PROGRESS && !DREW_PRINT_PROGRESS
+
+ _draw_print_progress();
+
+ #else
+
+ (void)draw_elapsed_or_remaining_time(LCD_WIDTH - 4, blink);
+
+ #endif
+
+ #endif // LCD_INFO_SCREEN_STYLE 1
+
+ // ========= Last Line ========
+
+ //
+ // Status Message (which may be a Progress Bar or Filament display)
+ //
+ draw_status_message(blink);
+}
+
+#if HAS_LCD_MENU
+
+ #include "../menu/menu.h"
+
+ #if ENABLED(ADVANCED_PAUSE_FEATURE)
+
+ void MarlinUI::draw_hotend_status(const uint8_t row, const uint8_t extruder) {
+ if (row < LCD_HEIGHT) {
+ lcd_moveto(LCD_WIDTH - 9, row);
+ _draw_heater_status((heater_id_t)extruder, LCD_STR_THERMOMETER[0], get_blink());
+ }
+ }
+
+ #endif // ADVANCED_PAUSE_FEATURE
+
+ // Draw a static item with no left-right margin required. Centered by default.
+ void MenuItem_static::draw(const uint8_t row, PGM_P const pstr, const uint8_t style/*=SS_DEFAULT*/, const char * const vstr/*=nullptr*/) {
+ int8_t n = LCD_WIDTH;
+ lcd_moveto(0, row);
+ const int8_t plen = pstr ? utf8_strlen_P(pstr) : 0,
+ vlen = vstr ? utf8_strlen(vstr) : 0;
+ if (style & SS_CENTER) {
+ int8_t pad = (LCD_WIDTH - plen - vlen) / 2;
+ while (--pad >= 0) { lcd_put_wchar(' '); n--; }
+ }
+ if (plen) n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, n);
+ if (vlen) n -= lcd_put_u8str_max(vstr, n);
+ for (; n > 0; --n) lcd_put_wchar(' ');
+ }
+
+ // Draw a generic menu item with pre_char (if selected) and post_char
+ void MenuItemBase::_draw(const bool sel, const uint8_t row, PGM_P const pstr, const char pre_char, const char post_char) {
+ lcd_put_wchar(0, row, sel ? pre_char : ' ');
+ uint8_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2);
+ for (; n; --n) lcd_put_wchar(' ');
+ lcd_put_wchar(post_char);
+ }
+
+ // Draw a menu item with a (potentially) editable value
+ void MenuEditItemBase::draw(const bool sel, const uint8_t row, PGM_P const pstr, const char* const inStr, const bool pgm) {
+ const uint8_t vlen = inStr ? (pgm ? utf8_strlen_P(inStr) : utf8_strlen(inStr)) : 0;
+ lcd_put_wchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
+ uint8_t n = lcd_put_u8str_ind_P(pstr, itemIndex, itemString, LCD_WIDTH - 2 - vlen);
+ if (vlen) {
+ lcd_put_wchar(':');
+ for (; n; --n) lcd_put_wchar(' ');
+ if (pgm) lcd_put_u8str_P(inStr); else lcd_put_u8str(inStr);
+ }
+ }
+
+ // Low-level draw_edit_screen can be used to draw an edit screen from anyplace
+ void MenuEditItemBase::draw_edit_screen(PGM_P const pstr, const char* const value/*=nullptr*/) {
+ ui.encoder_direction_normal();
+ uint8_t n = lcd_put_u8str_ind_P(0, 1, pstr, itemIndex, itemString, LCD_WIDTH - 1);
+ if (value) {
+ lcd_put_wchar(':'); n--;
+ const uint8_t len = utf8_strlen(value) + 1; // Plus one for a leading space
+ const lcd_uint_t valrow = n < len ? 2 : 1; // Value on the next row if it won't fit
+ lcd_put_wchar(LCD_WIDTH - len, valrow, ' '); // Right-justified, padded, leading space
+ lcd_put_u8str(value);
+ }
+ }
+
+ // The Select Screen presents a prompt and two "buttons"
+ void MenuItem_confirm::draw_select_screen(PGM_P const yes, PGM_P const no, const bool yesno, PGM_P const pref, const char * const string/*=nullptr*/, PGM_P const suff/*=nullptr*/) {
+ ui.draw_select_screen_prompt(pref, string, suff);
+ SETCURSOR(0, LCD_HEIGHT - 1);
+ lcd_put_wchar(yesno ? ' ' : '['); lcd_put_u8str_P(no); lcd_put_wchar(yesno ? ' ' : ']');
+ SETCURSOR_RJ(utf8_strlen_P(yes) + 2, LCD_HEIGHT - 1);
+ lcd_put_wchar(yesno ? '[' : ' '); lcd_put_u8str_P(yes); lcd_put_wchar(yesno ? ']' : ' ');
+ }
+
+ #if ENABLED(SDSUPPORT)
+
+ void MenuItem_sdbase::draw(const bool sel, const uint8_t row, PGM_P const, CardReader &theCard, const bool isDir) {
+ lcd_put_wchar(0, row, sel ? LCD_STR_ARROW_RIGHT[0] : ' ');
+ constexpr uint8_t maxlen = LCD_WIDTH - 2;
+ uint8_t n = maxlen - lcd_put_u8str_max(ui.scrolled_filename(theCard, maxlen, row, sel), maxlen);
+ for (; n; --n) lcd_put_wchar(' ');
+ lcd_put_wchar(isDir ? LCD_STR_FOLDER[0] : ' ');
+ }
+
+ #endif
+
+ #if ENABLED(LCD_HAS_STATUS_INDICATORS)
+
+ void MarlinUI::update_indicators() {
+ // Set the LEDS - referred to as backlights by the LiquidTWI2 library
+ static uint8_t ledsprev = 0;
+ uint8_t leds = 0;
+
+ if (TERN0(HAS_HEATED_BED, thermalManager.degTargetBed() > 0)) leds |= LED_A;
+ if (TERN0(HAS_HOTEND, thermalManager.degTargetHotend(0) > 0)) leds |= LED_B;
+
+ #if HAS_FAN
+ if ( TERN0(HAS_FAN0, thermalManager.fan_speed[0])
+ || TERN0(HAS_FAN1, thermalManager.fan_speed[1])
+ || TERN0(HAS_FAN2, thermalManager.fan_speed[2])
+ || TERN0(HAS_FAN3, thermalManager.fan_speed[3])
+ || TERN0(HAS_FAN4, thermalManager.fan_speed[4])
+ || TERN0(HAS_FAN5, thermalManager.fan_speed[5])
+ || TERN0(HAS_FAN6, thermalManager.fan_speed[6])
+ || TERN0(HAS_FAN7, thermalManager.fan_speed[7])
+ ) leds |= LED_C;
+ #endif // HAS_FAN
+
+ if (TERN0(HAS_MULTI_HOTEND, thermalManager.degTargetHotend(1) > 0)) leds |= LED_C;
+
+ if (leds != ledsprev) {
+ lcd.setBacklight(leds);
+ ledsprev = leds;
+ }
+ }
+
+ #endif // LCD_HAS_STATUS_INDICATORS
+
+ #if ENABLED(AUTO_BED_LEVELING_UBL)
+
+ #define HD44780_CHAR_WIDTH 5
+ #define HD44780_CHAR_HEIGHT 8
+ #define MESH_MAP_COLS 7
+ #define MESH_MAP_ROWS 4
+
+ #define CHAR_LINE_TOP 0
+ #define CHAR_LINE_BOT 1
+ #define CHAR_EDGE_L 2
+ #define CHAR_EDGE_R 3
+ #define CHAR_UL_UL 4
+ #define CHAR_LR_UL 5
+ #define CHAR_UL_LR 6
+ #define CHAR_LR_LR 7
+
+ #define TOP_LEFT _BV(0)
+ #define TOP_RIGHT _BV(1)
+ #define LOWER_LEFT _BV(2)
+ #define LOWER_RIGHT _BV(3)
+
+ /**
+ * Possible map screens:
+ *
+ * 16x2 |X000.00 Y000.00|
+ * |(00,00) Z00.000|
+ *
+ * 20x2 | X:000.00 Y:000.00 |
+ * | (00,00) Z:00.000 |
+ *
+ * 16x4 |+-------+(00,00)|
+ * || |X000.00|
+ * || |Y000.00|
+ * |+-------+Z00.000|
+ *
+ * 20x4 | +-------+ (00,00) |
+ * | | | X:000.00|
+ * | | | Y:000.00|
+ * | +-------+ Z:00.000|
+ */
+
+ typedef struct {
+ uint8_t custom_char_bits[HD44780_CHAR_HEIGHT];
+ } custom_char;
+
+ typedef struct {
+ lcd_uint_t column, row,
+ x_pixel_offset, y_pixel_offset;
+ uint8_t x_pixel_mask;
+ } coordinate;
+
+ void add_edges_to_custom_char(custom_char &custom, const coordinate &ul, const coordinate &lr, const coordinate &brc, const uint8_t cell_location);
+ FORCE_INLINE static void clear_custom_char(custom_char * const cc) { ZERO(cc->custom_char_bits); }
+
+ coordinate pixel_location(int16_t x, int16_t y) {
+ coordinate ret_val;
+ int16_t xp, yp, r, c;
+
+ x++; y++; // +1 because lines on the left and top
+
+ c = x / (HD44780_CHAR_WIDTH);
+ r = y / (HD44780_CHAR_HEIGHT);
+
+ ret_val.column = c;
+ ret_val.row = r;
+
+ xp = x - c * (HD44780_CHAR_WIDTH); // Get the pixel offsets into the character cell
+ xp = HD44780_CHAR_WIDTH - 1 - xp; // Column within relevant character cell (0 on the right)
+ yp = y - r * (HD44780_CHAR_HEIGHT);
+
+ ret_val.x_pixel_mask = _BV(xp);
+ ret_val.x_pixel_offset = xp;
+ ret_val.y_pixel_offset = yp;
+ return ret_val;
+ }
+
+ inline coordinate pixel_location(const lcd_uint_t x, const lcd_uint_t y) { return pixel_location((int16_t)x, (int16_t)y); }
+
+ void prep_and_put_map_char(custom_char &chrdata, const coordinate &ul, const coordinate &lr, const coordinate &brc, const uint8_t cl, const char c, const lcd_uint_t x, const lcd_uint_t y) {
+ add_edges_to_custom_char(chrdata, ul, lr, brc, cl);
+ lcd.createChar(c, (uint8_t*)&chrdata);
+ lcd_put_wchar(x, y, c);
+ }
+
+ void MarlinUI::ubl_plot(const uint8_t x_plot, const uint8_t y_plot) {
+
+ #if LCD_WIDTH >= 20
+ #define _LCD_W_POS 12
+ #define _PLOT_X 1
+ #define _MAP_X 3
+ #define _LABEL(C,X,Y) lcd_put_u8str_P(X, Y, C)
+ #define _XLABEL(X,Y) _LABEL(X_LBL,X,Y)
+ #define _YLABEL(X,Y) _LABEL(Y_LBL,X,Y)
+ #define _ZLABEL(X,Y) _LABEL(Z_LBL,X,Y)
+ #else
+ #define _LCD_W_POS 8
+ #define _PLOT_X 0
+ #define _MAP_X 1
+ #define _LABEL(X,Y,C) lcd_put_wchar(X, Y, C)
+ #define _XLABEL(X,Y) _LABEL('X',X,Y)
+ #define _YLABEL(X,Y) _LABEL('Y',X,Y)
+ #define _ZLABEL(X,Y) _LABEL('Z',X,Y)
+ #endif
+
+ #if LCD_HEIGHT <= 3 // 16x2 or 20x2 display
+
+ /**
+ * Show X and Y positions
+ */
+ _XLABEL(_PLOT_X, 0);
+ lcd_put_u8str(ftostr52(LOGICAL_X_POSITION(ubl.mesh_index_to_xpos(x_plot))));
+ _YLABEL(_LCD_W_POS, 0);
+ lcd_put_u8str(ftostr52(LOGICAL_Y_POSITION(ubl.mesh_index_to_ypos(y_plot))));
+
+ lcd_moveto(_PLOT_X, 0);
+
+ #else // 16x4 or 20x4 display
+
+ coordinate upper_left, lower_right, bottom_right_corner;
+ custom_char new_char;
+ uint8_t i, n, n_rows, n_cols;
+ lcd_uint_t j, k, l, m, bottom_line, right_edge,
+ x_map_pixels, y_map_pixels,
+ pixels_per_x_mesh_pnt, pixels_per_y_mesh_pnt,
+ suppress_x_offset = 0, suppress_y_offset = 0;
+
+ const uint8_t y_plot_inv = (GRID_MAX_POINTS_Y - 1) - y_plot;
+
+ upper_left.column = 0;
+ upper_left.row = 0;
+ lower_right.column = 0;
+ lower_right.row = 0;
+
+ clear_lcd();
+
+ x_map_pixels = (HD44780_CHAR_WIDTH) * (MESH_MAP_COLS) - 2; // Minus 2 because we are drawing a box around the map
+ y_map_pixels = (HD44780_CHAR_HEIGHT) * (MESH_MAP_ROWS) - 2;
+
+ pixels_per_x_mesh_pnt = x_map_pixels / (GRID_MAX_POINTS_X);
+ pixels_per_y_mesh_pnt = y_map_pixels / (GRID_MAX_POINTS_Y);
+
+ if (pixels_per_x_mesh_pnt >= HD44780_CHAR_WIDTH) { // There are only 2 custom characters available, so the X
+ pixels_per_x_mesh_pnt = HD44780_CHAR_WIDTH; // Size of the mesh point needs to fit within them independent
+ suppress_x_offset = 1; // Of where the starting pixel is located.
+ }
+
+ if (pixels_per_y_mesh_pnt >= HD44780_CHAR_HEIGHT) { // There are only 2 custom characters available, so the Y
+ pixels_per_y_mesh_pnt = HD44780_CHAR_HEIGHT; // Size of the mesh point needs to fit within them independent
+ suppress_y_offset = 1; // Of where the starting pixel is located.
+ }
+
+ x_map_pixels = pixels_per_x_mesh_pnt * (GRID_MAX_POINTS_X); // Now we have the right number of pixels to make both
+ y_map_pixels = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y); // Directions fit nicely
+
+ right_edge = pixels_per_x_mesh_pnt * (GRID_MAX_POINTS_X) + 1; // Find location of right edge within the character cell
+ bottom_line = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 1; // Find location of bottome line within the character cell
+
+ n_rows = bottom_line / (HD44780_CHAR_HEIGHT) + 1;
+ n_cols = right_edge / (HD44780_CHAR_WIDTH) + 1;
+
+ for (i = 0; i < n_cols; i++) {
+ lcd_put_wchar(i, 0, CHAR_LINE_TOP); // Box Top line
+ lcd_put_wchar(i, n_rows - 1, CHAR_LINE_BOT); // Box Bottom line
+ }
+
+ for (j = 0; j < n_rows; j++) {
+ lcd_put_wchar(0, j, CHAR_EDGE_L); // Box Left edge
+ lcd_put_wchar(n_cols - 1, j, CHAR_EDGE_R); // Box Right edge
+ }
+
+ /**
+ * If the entire 4th row is not in use, do not put vertical bars all the way down to the bottom of the display
+ */
+
+ k = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 2;
+ l = (HD44780_CHAR_HEIGHT) * n_rows;
+ if (l > k && l - k >= (HD44780_CHAR_HEIGHT) / 2) {
+ lcd_put_wchar(0, n_rows - 1, ' '); // Box Left edge
+ lcd_put_wchar(n_cols - 1, n_rows - 1, ' '); // Box Right edge
+ }
+
+ clear_custom_char(&new_char);
+ new_char.custom_char_bits[0] = 0b11111U; // Char #0 is used for the box top line
+ lcd.createChar(CHAR_LINE_TOP, (uint8_t*)&new_char);
+
+ clear_custom_char(&new_char);
+ k = (GRID_MAX_POINTS_Y) * pixels_per_y_mesh_pnt + 1; // Row of pixels for the bottom box line
+ l = k % (HD44780_CHAR_HEIGHT); // Row within relevant character cell
+ new_char.custom_char_bits[l] = 0b11111U; // Char #1 is used for the box bottom line
+ lcd.createChar(CHAR_LINE_BOT, (uint8_t*)&new_char);
+
+ clear_custom_char(&new_char);
+ for (j = 0; j < HD44780_CHAR_HEIGHT; j++)
+ new_char.custom_char_bits[j] = 0b10000U; // Char #2 is used for the box left edge
+ lcd.createChar(CHAR_EDGE_L, (uint8_t*)&new_char);
+
+ clear_custom_char(&new_char);
+ m = (GRID_MAX_POINTS_X) * pixels_per_x_mesh_pnt + 1; // Column of pixels for the right box line
+ n = m % (HD44780_CHAR_WIDTH); // Column within relevant character cell
+ i = HD44780_CHAR_WIDTH - 1 - n; // Column within relevant character cell (0 on the right)
+ for (j = 0; j < HD44780_CHAR_HEIGHT; j++)
+ new_char.custom_char_bits[j] = (uint8_t)_BV(i); // Char #3 is used for the box right edge
+ lcd.createChar(CHAR_EDGE_R, (uint8_t*)&new_char);
+
+ i = x_plot * pixels_per_x_mesh_pnt - suppress_x_offset;
+ j = y_plot_inv * pixels_per_y_mesh_pnt - suppress_y_offset;
+ upper_left = pixel_location(i, j);
+
+ k = (x_plot + 1) * pixels_per_x_mesh_pnt - 1 - suppress_x_offset;
+ l = (y_plot_inv + 1) * pixels_per_y_mesh_pnt - 1 - suppress_y_offset;
+ lower_right = pixel_location(k, l);
+
+ bottom_right_corner = pixel_location(x_map_pixels, y_map_pixels);
+
+ /**
+ * First, handle the simple case where everything is within a single character cell.
+ * If part of the Mesh Plot is outside of this character cell, we will follow up
+ * and deal with that next.
+ */
+
+ clear_custom_char(&new_char);
+ const lcd_uint_t ypix = _MIN(upper_left.y_pixel_offset + pixels_per_y_mesh_pnt, HD44780_CHAR_HEIGHT);
+ for (j = upper_left.y_pixel_offset; j < ypix; j++) {
+ i = upper_left.x_pixel_mask;
+ for (k = 0; k < pixels_per_x_mesh_pnt; k++) {
+ new_char.custom_char_bits[j] |= i;
+ i >>= 1;
+ }
+ }
+
+ prep_and_put_map_char(new_char, upper_left, lower_right, bottom_right_corner, TOP_LEFT, CHAR_UL_UL, upper_left.column, upper_left.row);
+
+ /**
+ * Next, check for two side by side character cells being used to display the Mesh Point
+ * If found... do the right hand character cell next.
+ */
+ if (upper_left.column == lower_right.column - 1) {
+ l = upper_left.x_pixel_offset;
+ clear_custom_char(&new_char);
+ for (j = upper_left.y_pixel_offset; j < ypix; j++) {
+ i = _BV(HD44780_CHAR_WIDTH - 1); // Fill in the left side of the right character cell
+ for (k = 0; k < pixels_per_x_mesh_pnt - 1 - l; k++) {
+ new_char.custom_char_bits[j] |= i;
+ i >>= 1;
+ }
+ }
+ prep_and_put_map_char(new_char, upper_left, lower_right, bottom_right_corner, TOP_RIGHT, CHAR_LR_UL, lower_right.column, upper_left.row);
+ }
+
+ /**
+ * Next, check for two character cells stacked on top of each other being used to display the Mesh Point
+ */
+ if (upper_left.row == lower_right.row - 1) {
+ l = HD44780_CHAR_HEIGHT - upper_left.y_pixel_offset; // Number of pixel rows in top character cell
+ k = pixels_per_y_mesh_pnt - l; // Number of pixel rows in bottom character cell
+ clear_custom_char(&new_char);
+ for (j = 0; j < k; j++) {
+ i = upper_left.x_pixel_mask;
+ for (m = 0; m < pixels_per_x_mesh_pnt; m++) { // Fill in the top side of the bottom character cell
+ new_char.custom_char_bits[j] |= i;
+ if (!(i >>= 1)) break;
+ }
+ }
+ prep_and_put_map_char(new_char, upper_left, lower_right, bottom_right_corner, LOWER_LEFT, CHAR_UL_LR, upper_left.column, lower_right.row);
+ }
+
+ /**
+ * Next, check for four character cells being used to display the Mesh Point. If that is
+ * what is here, we work to fill in the character cell that is down one and to the right one
+ * from the upper_left character cell.
+ */
+
+ if (upper_left.column == lower_right.column - 1 && upper_left.row == lower_right.row - 1) {
+ l = HD44780_CHAR_HEIGHT - upper_left.y_pixel_offset; // Number of pixel rows in top character cell
+ k = pixels_per_y_mesh_pnt - l; // Number of pixel rows in bottom character cell
+ clear_custom_char(&new_char);
+ for (j = 0; j < k; j++) {
+ l = upper_left.x_pixel_offset;
+ i = _BV(HD44780_CHAR_WIDTH - 1); // Fill in the left side of the right character cell
+ for (m = 0; m < pixels_per_x_mesh_pnt - 1 - l; m++) { // Fill in the top side of the bottom character cell
+ new_char.custom_char_bits[j] |= i;
+ i >>= 1;
+ }
+ }
+ prep_and_put_map_char(new_char, upper_left, lower_right, bottom_right_corner, LOWER_RIGHT, CHAR_LR_LR, lower_right.column, lower_right.row);
+ }
+
+ #endif
+
+ /**
+ * Print plot position
+ */
+ lcd_put_wchar(_LCD_W_POS, 0, '(');
+ lcd_put_u8str(ui8tostr3rj(x_plot));
+ lcd_put_wchar(',');
+ lcd_put_u8str(ui8tostr3rj(y_plot));
+ lcd_put_wchar(')');
+
+ #if LCD_HEIGHT <= 3 // 16x2 or 20x2 display
+
+ /**
+ * Print Z values
+ */
+ _ZLABEL(_LCD_W_POS, 1);
+ if (!isnan(ubl.z_values[x_plot][y_plot]))
+ lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
+ else
+ lcd_put_u8str_P(PSTR(" -----"));
+
+ #else // 16x4 or 20x4 display
+
+ /**
+ * Show all values at right of screen
+ */
+ _XLABEL(_LCD_W_POS, 1);
+ lcd_put_u8str(ftostr52(LOGICAL_X_POSITION(ubl.mesh_index_to_xpos(x_plot))));
+ _YLABEL(_LCD_W_POS, 2);
+ lcd_put_u8str(ftostr52(LOGICAL_Y_POSITION(ubl.mesh_index_to_ypos(y_plot))));
+
+ /**
+ * Show the location value
+ */
+ _ZLABEL(_LCD_W_POS, 3);
+ if (!isnan(ubl.z_values[x_plot][y_plot]))
+ lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
+ else
+ lcd_put_u8str_P(PSTR(" -----"));
+
+ #endif // LCD_HEIGHT > 3
+ }
+
+ void add_edges_to_custom_char(custom_char &custom, const coordinate &ul, const coordinate &lr, const coordinate &brc, const uint8_t cell_location) {
+ uint8_t i, k;
+ int16_t n_rows = lr.row - ul.row + 1,
+ n_cols = lr.column - ul.column + 1;
+
+ /**
+ * Check if Top line of box needs to be filled in
+ */
+
+ if (ul.row == 0 && (cell_location & (TOP_LEFT|TOP_RIGHT))) { // Only fill in the top line for the top character cells
+
+ if (n_cols == 1) {
+ if (ul.column != brc.column)
+ custom.custom_char_bits[0] = 0xFF; // Single column in middle
+ else
+ for (i = brc.x_pixel_offset; i < HD44780_CHAR_WIDTH; i++) // Single column on right side
+ SBI(custom.custom_char_bits[0], i);
+ }
+ else if ((cell_location & TOP_LEFT) || lr.column != brc.column) // Multiple column in the middle or with right cell in middle
+ custom.custom_char_bits[0] = 0xFF;
+ else
+ for (i = brc.x_pixel_offset; i < HD44780_CHAR_WIDTH; i++)
+ SBI(custom.custom_char_bits[0], i);
+ }
+
+ /**
+ * Check if left line of box needs to be filled in
+ */
+ if (cell_location & (TOP_LEFT|LOWER_LEFT)) {
+ if (ul.column == 0) { // Left column of characters on LCD Display
+ k = ul.row == brc.row ? brc.y_pixel_offset : HD44780_CHAR_HEIGHT; // If it isn't the last row... do the full character cell
+ for (i = 0; i < k; i++)
+ SBI(custom.custom_char_bits[i], HD44780_CHAR_WIDTH - 1);
+ }
+ }
+
+ /**
+ * Check if bottom line of box needs to be filled in
+ */
+
+ // Single row of mesh plot cells
+ if (n_rows == 1 /* && (cell_location & (TOP_LEFT|TOP_RIGHT)) */ && ul.row == brc.row) {
+ if (n_cols == 1) // Single row, single column case
+ k = ul.column == brc.column ? brc.x_pixel_mask : 0x01;
+ else if (cell_location & TOP_RIGHT) // Single row, multiple column case
+ k = lr.column == brc.column ? brc.x_pixel_mask : 0x01;
+ else // Single row, left of multiple columns
+ k = 0x01;
+ while (k < _BV(HD44780_CHAR_WIDTH)) {
+ custom.custom_char_bits[brc.y_pixel_offset] |= k;
+ k <<= 1;
+ }
+ }
+
+ // Double row of characters on LCD Display
+ // And this is a bottom custom character
+ if (n_rows == 2 && (cell_location & (LOWER_LEFT|LOWER_RIGHT)) && lr.row == brc.row) {
+ if (n_cols == 1) // Double row, single column case
+ k = ul.column == brc.column ? brc.x_pixel_mask : 0x01;
+ else if (cell_location & LOWER_RIGHT) // Double row, multiple column case
+ k = lr.column == brc.column ? brc.x_pixel_mask : 0x01;
+ else // Double row, left of multiple columns
+ k = 0x01;
+ while (k < _BV(HD44780_CHAR_WIDTH)) {
+ custom.custom_char_bits[brc.y_pixel_offset] |= k;
+ k <<= 1;
+ }
+ }
+
+ /**
+ * Check if right line of box needs to be filled in
+ */
+
+ // Nothing to do if the lower right part of the mesh pnt isn't in the same column as the box line
+ if (lr.column == brc.column) {
+ // This mesh point is in the same character cell as the right box line
+ if (ul.column == brc.column || (cell_location & (TOP_RIGHT|LOWER_RIGHT))) {
+ // If not the last row... do the full character cell
+ k = ul.row == brc.row ? brc.y_pixel_offset : HD44780_CHAR_HEIGHT;
+ for (i = 0; i < k; i++) custom.custom_char_bits[i] |= brc.x_pixel_mask;
+ }
+ }
+ }
+
+ #endif // AUTO_BED_LEVELING_UBL
+
+#endif // HAS_LCD_MENU
+
+#endif // HAS_MARLINUI_HD44780
diff --git a/Marlin/src/lcd/HD44780/marlinui_HD44780.h b/Marlin/src/lcd/HD44780/marlinui_HD44780.h
new file mode 100644
index 0000000..604d26a
--- /dev/null
+++ b/Marlin/src/lcd/HD44780/marlinui_HD44780.h
@@ -0,0 +1,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
+
+/**
+ * Hitachi HD44780 display defines and headers
+ */
+
+#include "../../inc/MarlinConfig.h"
+
+#if ENABLED(LCD_I2C_TYPE_PCF8575)
+
+ // NOTE: These are register-mapped pins on the PCF8575 controller, not Arduino pins.
+ #define LCD_I2C_PIN_BL 3
+ #define LCD_I2C_PIN_EN 2
+ #define LCD_I2C_PIN_RW 1
+ #define LCD_I2C_PIN_RS 0
+ #define LCD_I2C_PIN_D4 4
+ #define LCD_I2C_PIN_D5 5
+ #define LCD_I2C_PIN_D6 6
+ #define LCD_I2C_PIN_D7 7
+
+ #include <Wire.h>
+ #include <LCD.h>
+ #include <LiquidCrystal_I2C.h>
+ #define LCD_CLASS LiquidCrystal_I2C
+
+#elif ENABLED(LCD_I2C_TYPE_MCP23017)
+
+ // For the LED indicators (which may be mapped to different events in update_indicators())
+ #define LCD_HAS_STATUS_INDICATORS
+ #define LED_A 0x04 //100
+ #define LED_B 0x02 //010
+ #define LED_C 0x01 //001
+
+ #include <Wire.h>
+ #include <LiquidTWI2.h>
+ #define LCD_CLASS LiquidTWI2
+
+#elif ENABLED(LCD_I2C_TYPE_MCP23008)
+
+ #include <Wire.h>
+ #include <LiquidTWI2.h>
+ #define LCD_CLASS LiquidTWI2
+
+#elif ENABLED(LCD_I2C_TYPE_PCA8574)
+
+ #include <LiquidCrystal_I2C.h>
+ #define LCD_CLASS LiquidCrystal_I2C
+
+#elif ENABLED(SR_LCD_2W_NL)
+
+ // 2 wire Non-latching LCD SR from:
+ // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
+ #include <LCD.h>
+ #include <LiquidCrystal_SR.h>
+ #define LCD_CLASS LiquidCrystal_SR
+
+#elif ENABLED(SR_LCD_3W_NL)
+
+ // NewLiquidCrystal didn't work, so this uses
+ // https://github.com/mikeshub/SailfishLCD
+
+ #include <SailfishLCD.h>
+ #define LCD_CLASS LiquidCrystalSerial
+
+#elif ENABLED(LCM1602)
+
+ #include <Wire.h>
+ #include <LCD.h>
+ #include <LiquidCrystal_I2C.h>
+ #define LCD_CLASS LiquidCrystal_I2C
+
+#else
+
+ // Standard directly connected LCD implementations
+ #include <LiquidCrystal.h>
+ #define LCD_CLASS LiquidCrystal
+
+#endif
+
+#include "../fontutils.h"
+#include "../lcdprint.h"
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.