andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Changes in ultralcd_implementation_hitachi_HD44780.h in detail 

Top -> down:
We don't need LiquidCrystalRus.cpp and LiquidCrystalRus.h any more. Functionality is now in utf_mapper.h
Comment on LCD_STR_BEDTEMP about behaviour in strings.
Change LCD_STR_ARROW_RIGHT from "\x7E" to ">" because "\x7E" is only ARROW_RIGHT on displays with DISPLAY_CHARSET_HD44780_JAPAN.
Introduce the counting UTF8 enabled lcd_print functions.
Replace the old lcd.print functions and make use of them.
A bit of reformatting around the changes.
pull/1/head
AnHardt 10 years ago
parent
6fc2ccd568
commit
255ca68123
3 changed files with 79 additions and 602 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 393
      Marlin/LiquidCrystalRus.cpp
  2. 129
      Marlin/LiquidCrystalRus.h
  3. 95
      Marlin/ultralcd_implementation_hitachi_HD44780.h

393
Marlin/LiquidCrystalRus.cpp
View File

@ -1,393 +0,0 @@
#include "LiquidCrystalRus.h"
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
// it is a Russian alphabet translation
// except 0401 --> 0xa2 = ╗, 0451 --> 0xb5
const PROGMEM uint8_t utf_recode[] =
{ 0x41,0xa0,0x42,0xa1,0xe0,0x45,0xa3,0xa4,
0xa5,0xa6,0x4b,0xa7,0x4d,0x48,0x4f,0xa8,
0x50,0x43,0x54,0xa9,0xaa,0x58,0xe1,0xab,
0xac,0xe2,0xad,0xae,0x62,0xaf,0xb0,0xb1,
0x61,0xb2,0xb3,0xb4,0xe3,0x65,0xb6,0xb7,
0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0x6f,0xbe,
0x70,0x63,0xbf,0x79,0xe4,0x78,0xe5,0xc0,
0xc1,0xe6,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7
};
// When the display powers up, it is configured as follows:
//
// 1. Display clear
// 2. Function set:
// DL = 1; 8-bit interface data
// N = 0; 1-line display
// F = 0; 5x8 dot character font
// 3. Display on/off control:
// D = 0; Display off
// C = 0; Cursor off
// B = 0; Blinking off
// 4. Entry mode set:
// I/D = 1; Increment by 1
// S = 0; No shift
//
// Note, however, that resetting the Arduino doesn't reset the LCD, so we
// can't assume that it's in that state when a sketch starts (and the
// LiquidCrystal constructor is called).
//
// modified 27 Jul 2011
// by Ilya V. Danilov http://mk90.ru/
LiquidCrystalRus::LiquidCrystalRus(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
init(0, rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7);
}
LiquidCrystalRus::LiquidCrystalRus(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
init(0, rs, 255, enable, d0, d1, d2, d3, d4, d5, d6, d7);
}
LiquidCrystalRus::LiquidCrystalRus(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
{
init(1, rs, rw, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}
LiquidCrystalRus::LiquidCrystalRus(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
{
init(1, rs, 255, enable, d0, d1, d2, d3, 0, 0, 0, 0);
}
void LiquidCrystalRus::init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7)
{
_rs_pin = rs;
_rw_pin = rw;
_enable_pin = enable;
_data_pins[0] = d0;
_data_pins[1] = d1;
_data_pins[2] = d2;
_data_pins[3] = d3;
_data_pins[4] = d4;
_data_pins[5] = d5;
_data_pins[6] = d6;
_data_pins[7] = d7;
pinMode(_rs_pin, OUTPUT);
// we can save 1 pin by not using RW. Indicate by passing 255 instead of pin#
if (_rw_pin != 255) {
pinMode(_rw_pin, OUTPUT);
}
pinMode(_enable_pin, OUTPUT);
if (fourbitmode)
_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
else
_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;
begin(16, 1);
}
void LiquidCrystalRus::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
if (lines > 1) {
_displayfunction |= LCD_2LINE;
}
_numlines = lines;
_currline = 0;
// for some 1 line displays you can select a 10 pixel high font
if ((dotsize != 0) && (lines == 1)) {
_displayfunction |= LCD_5x10DOTS;
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
delayMicroseconds(50000);
// Now we pull both RS and R/W low to begin commands
digitalWrite(_rs_pin, LOW);
digitalWrite(_enable_pin, LOW);
if (_rw_pin != 255) {
digitalWrite(_rw_pin, LOW);
}
//put the LCD into 4 bit or 8 bit mode
if (! (_displayfunction & LCD_8BITMODE)) {
// this is according to the Hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode
writeNbits(0x03,4);
delayMicroseconds(4500); // wait min 4.1ms
// second try
writeNbits(0x03,4);
delayMicroseconds(4500); // wait min 4.1ms
// third go!
writeNbits(0x03,4);
delayMicroseconds(150);
// finally, set to 8-bit interface
writeNbits(0x02,4);
} else {
// this is according to the Hitachi HD44780 datasheet
// page 45 figure 23
// Send function set command sequence
command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(4500); // wait more than 4.1ms
// second try
command(LCD_FUNCTIONSET | _displayfunction);
delayMicroseconds(150);
// third go
command(LCD_FUNCTIONSET | _displayfunction);
}
// finally, set # lines, font size, etc.
command(LCD_FUNCTIONSET | _displayfunction);
// turn the display on with no cursor or blinking default
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
display();
// clear it off
clear();
// Initialize to default text direction (for romance languages)
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
command(LCD_ENTRYMODESET | _displaymode);
}
void LiquidCrystalRus::setDRAMModel(uint8_t model) {
_dram_model = model;
}
/********** high level commands, for the user! */
void LiquidCrystalRus::clear()
{
command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystalRus::home()
{
command(LCD_RETURNHOME); // set cursor position to zero
delayMicroseconds(2000); // this command takes a long time!
}
void LiquidCrystalRus::setCursor(uint8_t col, uint8_t row)
{
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
if ( row >= _numlines ) {
row = _numlines-1; // we count rows starting w/0
}
command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}
// Turn the display on/off (quickly)
void LiquidCrystalRus::noDisplay() {
_displaycontrol &= ~LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystalRus::display() {
_displaycontrol |= LCD_DISPLAYON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turns the underline cursor on/off
void LiquidCrystalRus::noCursor() {
_displaycontrol &= ~LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystalRus::cursor() {
_displaycontrol |= LCD_CURSORON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// Turn on and off the blinking cursor
void LiquidCrystalRus::noBlink() {
_displaycontrol &= ~LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
void LiquidCrystalRus::blink() {
_displaycontrol |= LCD_BLINKON;
command(LCD_DISPLAYCONTROL | _displaycontrol);
}
// These commands scroll the display without changing the RAM
void LiquidCrystalRus::scrollDisplayLeft(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}
void LiquidCrystalRus::scrollDisplayRight(void) {
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}
// This is for text that flows Left to Right
void LiquidCrystalRus::leftToRight(void) {
_displaymode |= LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This is for text that flows Right to Left
void LiquidCrystalRus::rightToLeft(void) {
_displaymode &= ~LCD_ENTRYLEFT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'right justify' text from the cursor
void LiquidCrystalRus::autoscroll(void) {
_displaymode |= LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// This will 'left justify' text from the cursor
void LiquidCrystalRus::noAutoscroll(void) {
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
command(LCD_ENTRYMODESET | _displaymode);
}
// Allows us to fill the first 8 CGRAM locations
// with custom characters
void LiquidCrystalRus::createChar(uint8_t location, uint8_t charmap[]) {
location &= 0x7; // we only have 8 locations 0-7
command(LCD_SETCGRAMADDR | (location << 3));
for (int i=0; i<8; i++) {
write(charmap[i]);
}
}
/*********** mid level commands, for sending data/cmds */
inline void LiquidCrystalRus::command(uint8_t value) {
send(value, LOW);
}
#if defined(ARDUINO) && ARDUINO >= 100
size_t LiquidCrystalRus::write(uint8_t value)
#else
void LiquidCrystalRus::write(uint8_t value)
#endif
{
uint8_t out_char=value;
if (_dram_model == LCD_DRAM_WH1601) {
uint8_t ac=recv(LOW) & 0x7f;
if (ac>7 && ac<0x14) command(LCD_SETDDRAMADDR | (0x40+ac-8));
}
if (value>=0x80) { // UTF-8 handling
if (value >= 0xc0) {
utf_hi_char = value - 0xd0;
} else {
value &= 0x3f;
if (!utf_hi_char && (value == 1))
send(0xa2,HIGH); // ╗
else if ((utf_hi_char == 1) && (value == 0x11))
send(0xb5,HIGH); // ╦
else
send(pgm_read_byte_near(utf_recode + value + (utf_hi_char<<6) - 0x10), HIGH);
}
} else send(out_char, HIGH);
#if defined(ARDUINO) && ARDUINO >= 100
return 1; // assume success
#endif
}
/************ low level data pushing commands **********/
// write either command or data, with automatic 4/8-bit selection
void LiquidCrystalRus::send(uint8_t value, uint8_t mode) {
digitalWrite(_rs_pin, mode);
// if there is a RW pin indicated, set it low to Write
if (_rw_pin != 255) {
digitalWrite(_rw_pin, LOW);
}
if (_displayfunction & LCD_8BITMODE) {
writeNbits(value,8);
} else {
writeNbits(value>>4,4);
writeNbits(value,4);
}
}
// read data, with automatic 4/8-bit selection
uint8_t LiquidCrystalRus::recv(uint8_t mode) {
uint8_t retval;
digitalWrite(_rs_pin, mode);
// if there is a RW pin indicated, set it low to Write
if (_rw_pin != 255) {
digitalWrite(_rw_pin, HIGH);
}
if (_displayfunction & LCD_8BITMODE) {
retval = readNbits(8);
} else {
retval = readNbits(4) << 4;
retval |= readNbits(4);
}
return retval;
}
void LiquidCrystalRus::pulseEnable() {
digitalWrite(_enable_pin, LOW);
delayMicroseconds(1);
digitalWrite(_enable_pin, HIGH);
delayMicroseconds(1); // enable pulse must be >450ns
digitalWrite(_enable_pin, LOW);
delayMicroseconds(100); // commands need > 37us to settle
}
void LiquidCrystalRus::writeNbits(uint8_t value, uint8_t n) {
for (int i = 0; i < n; i++) {
pinMode(_data_pins[i], OUTPUT);
digitalWrite(_data_pins[i], (value >> i) & 0x01);
}
pulseEnable();
}
uint8_t LiquidCrystalRus::readNbits(uint8_t n) {
uint8_t retval=0;
for (int i = 0; i < n; i++) {
pinMode(_data_pins[i], INPUT);
}
digitalWrite(_enable_pin, LOW);
delayMicroseconds(1);
digitalWrite(_enable_pin, HIGH);
delayMicroseconds(1); // enable pulse must be >450ns
for (int i = 0; i < n; i++) {
retval |= (digitalRead(_data_pins[i]) == HIGH)?(1 << i):0;
}
digitalWrite(_enable_pin, LOW);
return retval;
}

129
Marlin/LiquidCrystalRus.h
View File

@ -1,129 +0,0 @@
//
// based on LiquidCrystal library from ArduinoIDE, see http://arduino.cc
// modified 27 Jul 2011
// by Ilya V. Danilov http://mk90.ru/
//
#ifndef LiquidCrystalRus_h
#define LiquidCrystalRus_h
#include <inttypes.h>
#include "Print.h"
// commands
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80
// flags for display entry mode
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00
// flags for display on/off control
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00
// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00
// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00
// enum for
#define LCD_DRAM_Normal 0x00
#define LCD_DRAM_WH1601 0x01
class LiquidCrystalRus : public Print {
public:
LiquidCrystalRus(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
LiquidCrystalRus(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
LiquidCrystalRus(uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3);
LiquidCrystalRus(uint8_t rs, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3);
void init(uint8_t fourbitmode, uint8_t rs, uint8_t rw, uint8_t enable,
uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3,
uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7);
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS);
void clear();
void home();
void noDisplay();
void display();
void noBlink();
void blink();
void noCursor();
void cursor();
void scrollDisplayLeft();
void scrollDisplayRight();
void leftToRight();
void rightToLeft();
void autoscroll();
void noAutoscroll();
void createChar(uint8_t, uint8_t[]);
void setCursor(uint8_t, uint8_t);
#if defined(ARDUINO) && ARDUINO >= 100
virtual size_t write(uint8_t);
using Print::write;
#else
virtual void write(uint8_t);
#endif
void command(uint8_t);
void setDRAMModel(uint8_t);
private:
void send(uint8_t, uint8_t);
void writeNbits(uint8_t, uint8_t);
uint8_t recv(uint8_t);
uint8_t readNbits(uint8_t);
void pulseEnable();
uint8_t _rs_pin; // LOW: command. HIGH: character.
uint8_t _rw_pin; // LOW: write to LCD. HIGH: read from LCD.
uint8_t _enable_pin; // activated by a HIGH pulse.
uint8_t _data_pins[8];
uint8_t _displayfunction;
uint8_t _displaycontrol;
uint8_t _displaymode;
uint8_t _initialized;
uint8_t _numlines,_currline;
uint8_t _dram_model;
uint8_t utf_hi_char; // UTF-8 high part
};
#endif

95
Marlin/ultralcd_implementation_hitachi_HD44780.h
View File

@ -179,25 +179,20 @@
// 2 wire Non-latching LCD SR from: // 2 wire Non-latching LCD SR from:
// https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
#elif defined(SR_LCD_2W_NL) #elif defined(SR_LCD_2W_NL)
extern "C" void __cxa_pure_virtual() { while (1); } extern "C" void __cxa_pure_virtual() { while (1); }
#include <LCD.h> #include <LCD.h>
#include <LiquidCrystal_SR.h> #include <LiquidCrystal_SR.h>
#define LCD_CLASS LiquidCrystal_SR #define LCD_CLASS LiquidCrystal_SR
LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN); LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN);
#else #else
// Standard directly connected LCD implementations // Standard directly connected LCD implementations
#ifdef LANGUAGE_RU
#include "LiquidCrystalRus.h"
#define LCD_CLASS LiquidCrystalRus
#else
#include <LiquidCrystal.h> #include <LiquidCrystal.h>
#define LCD_CLASS LiquidCrystal #define LCD_CLASS LiquidCrystal
#endif
LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5,LCD_PINS_D6,LCD_PINS_D7); //RS,Enable,D4,D5,D6,D7 LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5,LCD_PINS_D6,LCD_PINS_D7); //RS,Enable,D4,D5,D6,D7
#endif #endif
#include "utf_mapper.h"
#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT) #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
static uint16_t progressBarTick = 0; static uint16_t progressBarTick = 0;
#if PROGRESS_MSG_EXPIRE > 0 #if PROGRESS_MSG_EXPIRE > 0
@ -207,7 +202,7 @@
#endif #endif
/* Custom characters defined in the first 8 characters of the LCD */ /* Custom characters defined in the first 8 characters of the LCD */
#define LCD_STR_BEDTEMP "\x00" #define LCD_STR_BEDTEMP "\x00" // this will have 'unexpected' results when used in a string!
#define LCD_STR_DEGREE "\x01" #define LCD_STR_DEGREE "\x01"
#define LCD_STR_THERMOMETER "\x02" #define LCD_STR_THERMOMETER "\x02"
#define LCD_STR_UPLEVEL "\x03" #define LCD_STR_UPLEVEL "\x03"
@ -215,7 +210,8 @@
#define LCD_STR_FOLDER "\x05" #define LCD_STR_FOLDER "\x05"
#define LCD_STR_FEEDRATE "\x06" #define LCD_STR_FEEDRATE "\x06"
#define LCD_STR_CLOCK "\x07" #define LCD_STR_CLOCK "\x07"
#define LCD_STR_ARROW_RIGHT "\x7E" /* from the default character set */ //#define LCD_STR_ARROW_RIGHT "\x7E" /* from the default character set. Only available on DISPLAY_CHARSET_HD44780_JAPAN - at this place!*/
#define LCD_STR_ARROW_RIGHT ">" /* from the default character set */
static void lcd_set_custom_characters( static void lcd_set_custom_characters(
#if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT) #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
@ -405,15 +401,31 @@ static void lcd_implementation_clear()
{ {
lcd.clear(); lcd.clear();
} }
/* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */ /* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */
static void lcd_printPGM(const char* str) char lcd_printPGM(const char* str) {
{
char c; char c;
while((c = pgm_read_byte(str++)) != '\0') char n = 0;
{ while((c = pgm_read_byte(str++))) {
lcd.write(c); n += charset_mapper(c);
} }
return n;
} }
char lcd_print(char* str) {
char c;
char i = 0;
char n = 0;
while((c = str[i++])) {
n += charset_mapper(c);
}
return n;
}
unsigned lcd_print(char c) {
return charset_mapper(c);
}
/* /*
Possible status screens: Possible status screens:
16x2 |0123456789012345| 16x2 |0123456789012345|
@ -608,8 +620,9 @@ static void lcd_implementation_status_screen()
} }
#endif //FILAMENT_LCD_DISPLAY #endif //FILAMENT_LCD_DISPLAY
lcd.print(lcd_status_message); lcd_print(lcd_status_message);
} }
static void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, char pre_char, char post_char) static void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, char pre_char, char post_char)
{ {
char c; char c;
@ -623,12 +636,12 @@ static void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, c
lcd.print(pre_char); lcd.print(pre_char);
while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
{ {
lcd.print(c); n -= lcd_print(c);
pstr++; pstr++;
if ((pgm_read_byte(pstr) & 0xc0) != 0x80) n--;
} }
while(n--) while(n--) {
lcd.print(' '); lcd.print(' ');
}
lcd.print(post_char); lcd.print(post_char);
lcd.print(' '); lcd.print(' ');
} }
@ -643,16 +656,14 @@ static void lcd_implementation_drawmenu_setting_edit_generic(uint8_t row, const
#endif #endif
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.print(pre_char); lcd.print(pre_char);
while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) {
{ n -= lcd_print(c);
lcd.print(c);
pstr++; pstr++;
if ((pgm_read_byte(pstr) & 0xc0) != 0x80) n--;
} }
lcd.print(':'); lcd.print(':');
while(n--) while(n--)
lcd.print(' '); lcd.print(' ');
lcd.print(data); lcd_print(data);
} }
static void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, const char* pstr, char pre_char, const char* data) static void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, const char* pstr, char pre_char, const char* data)
{ {
@ -665,11 +676,9 @@ static void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, cons
#endif #endif
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.print(pre_char); lcd.print(pre_char);
while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) {
{ n -= lcd_print(c);
lcd.print(c);
pstr++; pstr++;
if ((pgm_read_byte(pstr) & 0xc0) != 0x80) n--;
} }
lcd.print(':'); lcd.print(':');
while(n--) while(n--)
@ -726,7 +735,7 @@ void lcd_implementation_drawedit(const char* pstr, char* value)
#else #else
lcd.setCursor(LCD_WIDTH -1 - lcd_strlen(value), 1); lcd.setCursor(LCD_WIDTH -1 - lcd_strlen(value), 1);
#endif #endif
lcd.print(value); lcd_print(value);
} }
static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename)
{ {
@ -741,9 +750,8 @@ static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char*
} }
while( ((c = *filename) != '\0') && (n>0) ) while( ((c = *filename) != '\0') && (n>0) )
{ {
lcd.print(c); n -= lcd_print(c);
filename++; filename++;
n--;
} }
while(n--) while(n--)
lcd.print(' '); lcd.print(' ');
@ -761,51 +769,42 @@ static void lcd_implementation_drawmenu_sdfile(uint8_t row, const char* pstr, co
} }
while( ((c = *filename) != '\0') && (n>0) ) while( ((c = *filename) != '\0') && (n>0) )
{ {
lcd.print(c); n -= lcd_print(c);
filename++; filename++;
n--;
} }
while(n--) while(n--)
lcd.print(' '); lcd.print(' ');
} }
static void lcd_implementation_drawmenu_sddirectory_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) static void lcd_implementation_drawmenu_sddirectory_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) {
{
char c; char c;
uint8_t n = LCD_WIDTH - 2; uint8_t n = LCD_WIDTH - 2;
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.print('>'); lcd.print('>');
lcd.print(LCD_STR_FOLDER[0]); lcd.print(LCD_STR_FOLDER[0]);
if (longFilename[0] != '\0') if (longFilename[0] != '\0') {
{
filename = longFilename; filename = longFilename;
longFilename[LCD_WIDTH-2] = '\0'; longFilename[LCD_WIDTH-2] = '\0';
} }
while( ((c = *filename) != '\0') && (n>0) ) while( ((c = *filename) != '\0') && (n>0) ) {
{ n -= lcd_print(c);
lcd.print(c);
filename++; filename++;
n--;
} }
while(n--) while(n--)
lcd.print(' '); lcd.print(' ');
} }
static void lcd_implementation_drawmenu_sddirectory(uint8_t row, const char* pstr, const char* filename, char* longFilename) static void lcd_implementation_drawmenu_sddirectory(uint8_t row, const char* pstr, const char* filename, char* longFilename) {
{
char c; char c;
uint8_t n = LCD_WIDTH - 2; uint8_t n = LCD_WIDTH - 2;
lcd.setCursor(0, row); lcd.setCursor(0, row);
lcd.print(' '); lcd.print(' ');
lcd.print(LCD_STR_FOLDER[0]); lcd.print(LCD_STR_FOLDER[0]);
if (longFilename[0] != '\0') if (longFilename[0] != '\0') {
{
filename = longFilename; filename = longFilename;
longFilename[LCD_WIDTH-2] = '\0'; longFilename[LCD_WIDTH-2] = '\0';
} }
while( ((c = *filename) != '\0') && (n>0) ) while( ((c = *filename) != '\0') && (n>0) ) {
{ n -= lcd_print(c);
lcd.print(c);
filename++; filename++;
n--;
} }
while(n--) while(n--)
lcd.print(' '); lcd.print(' ');

Write Preview
Loading…
Cancel
Save