SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

[2.0.x] Buffer overflow and scroll fix, UTF8 cleanup (#10844)

Browse source
This commit is contained in:
Eduardo José Tagle 2018-05-26 01:32:37 -03:00 committed by Scott Lahteine
parent 235facd545
commit 6f330f397e
17 changed files with 413 additions and 671 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
Marlin/src/HAL/HAL_AVR/HAL_spi_AVR.cpp
View file

@ -162,22 +162,15 @@ void spiBegin (void) {
// away. When clock is not known, use a loop instead, which generates
// shorter code.
if (__builtin_constant_p(spiClock)) {
if (spiClock >= F_CPU / 2) {
clockDiv = 0;
} else if (spiClock >= F_CPU / 4) {
clockDiv = 1;
} else if (spiClock >= F_CPU / 8) {
clockDiv = 2;
} else if (spiClock >= F_CPU / 16) {
clockDiv = 3;
} else if (spiClock >= F_CPU / 32) {
clockDiv = 4;
} else if (spiClock >= F_CPU / 64) {
clockDiv = 5;
} else {
clockDiv = 6;
if (spiClock >= F_CPU / 2) clockDiv = 0;
else if (spiClock >= F_CPU / 4) clockDiv = 1;
else if (spiClock >= F_CPU / 8) clockDiv = 2;
else if (spiClock >= F_CPU / 16) clockDiv = 3;
else if (spiClock >= F_CPU / 32) clockDiv = 4;
else if (spiClock >= F_CPU / 64) clockDiv = 5;
else clockDiv = 6;
}
} else {
else {
uint32_t clockSetting = F_CPU / 2;
clockDiv = 0;
while (clockDiv < 6 && spiClock < clockSetting) {
@ -187,8 +180,7 @@ void spiBegin (void) {
}
// Compensate for the duplicate fosc/64
if (clockDiv == 6)
clockDiv = 7;
if (clockDiv == 6) clockDiv = 7;
// Invert the SPI2X bit
clockDiv ^= 0x1;

1
Marlin/src/feature/bedlevel/ubl/ubl.h
View file

@ -56,7 +56,6 @@ extern uint8_t ubl_cnt;
///////////////////////////////////////////////////////////////////////////////////////////////////////
#if ENABLED(ULTRA_LCD)
extern char lcd_status_message[];
void lcd_quick_feedback(const bool clear_buttons);
#endif

6
Marlin/src/gcode/bedlevel/G26.cpp
View file

@ -135,10 +135,6 @@
// External references
#if ENABLED(ULTRA_LCD)
extern char lcd_status_message[];
#endif
// Private functions
static uint16_t circle_flags[16], horizontal_mesh_line_flags[16], vertical_mesh_line_flags[16];
@ -508,8 +504,6 @@ inline bool prime_nozzle() {
wait_for_release();
strcpy_P(lcd_status_message, PSTR("Done Priming")); // Hack to get the message up. May be obsolete.
lcd_setstatusPGM(PSTR("Done Priming"), 99);
lcd_quick_feedback(true);
lcd_external_control = false;

5
Marlin/src/gcode/calibrate/G33.cpp
View file

@ -519,15 +519,12 @@ void GcodeSuite::G33() {
}
// Report settings
const char* checkingac = PSTR("Checking... AC");
serialprintPGM(checkingac);
if (verbose_level == 0) SERIAL_PROTOCOLPGM(" (DRY-RUN)");
if (set_up) SERIAL_PROTOCOLPGM(" (SET-UP)");
SERIAL_EOL();
char mess[11];
strcpy_P(mess, checkingac);
lcd_setstatus(mess);
lcd_setstatusPGM(checkingac);
print_calibration_settings(_endstop_results, _angle_results);

89
Marlin/src/lcd/dogm/status_screen_DOGM.h
View file

@ -33,7 +33,7 @@ FORCE_INLINE void _draw_centered_temp(const int16_t temp, const uint8_t x, const
const char * const str = itostr3(temp);
lcd_moveto(x - (str[0] != ' ' ? 0 : str[1] != ' ' ? 1 : 2) * DOG_CHAR_WIDTH / 2, y);
lcd_put_u8str(str);
lcd_put_u8str_rom(PSTR(LCD_STR_DEGREE " "));
lcd_put_u8str_P(PSTR(LCD_STR_DEGREE " "));
}
#ifndef HEAT_INDICATOR_X
@ -113,7 +113,7 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
else {
#if DISABLED(HOME_AFTER_DEACTIVATE) && DISABLED(DISABLE_REDUCED_ACCURACY_WARNING)
if (!axis_known_position[axis])
lcd_put_u8str_rom(axis == Z_AXIS ? PSTR(" ") : PSTR(" "));
lcd_put_u8str_P(axis == Z_AXIS ? PSTR(" ") : PSTR(" "));
else
#endif
lcd_put_u8str(value);
@ -124,36 +124,77 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
inline void lcd_implementation_status_message(const bool blink) {
#if ENABLED(STATUS_MESSAGE_SCROLLING)
static bool last_blink = false;
const uint8_t slen = utf8_strlen(lcd_status_message);
const char *stat = lcd_status_message + status_scroll_pos;
if (slen <= LCD_WIDTH)
lcd_put_u8str(stat); // The string isn't scrolling
else {
if (status_scroll_pos <= slen - LCD_WIDTH)
lcd_put_u8str(stat); // The string fills the screen
else {
uint8_t chars = LCD_WIDTH;
if (status_scroll_pos < slen) { // First string still visible
lcd_put_u8str(stat); // The string leaves space
chars -= slen - status_scroll_pos; // Amount of space left
// Get the UTF8 character count of the string
uint8_t slen = utf8_strlen(lcd_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(lcd_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
const char *stat = lcd_status_message + status_scroll_offset;
// Get the string remaining length
const uint8_t rlen = utf8_strlen(stat);
// If we have enough characters to display
if (rlen >= LCD_WIDTH) {
// The remaining string fills the screen - Print it
lcd_put_u8str_max(stat, LCD_PIXEL_WIDTH);
}
else {
// The remaining string does not completely fill the screen
lcd_put_u8str_max(stat, LCD_PIXEL_WIDTH); // The string leaves space
uint8_t chars = LCD_WIDTH - rlen; // Amount of space left in characters
lcd_put_wchar('.'); // Always at 1+ spaces left, draw a dot
if (--chars) { // Draw a second dot if there's space
lcd_put_wchar('.');
if (--chars) {
if (status_scroll_pos < slen + 1) // Draw a second dot if there's space
--chars, lcd_put_wchar('.');
if (chars) lcd_put_u8str_max(lcd_status_message, chars); // Print a second copy of the message
// Print a second copy of the message
lcd_put_u8str_max(lcd_status_message, LCD_PIXEL_WIDTH - ((rlen+2) * DOG_CHAR_WIDTH));
}
}
}
if (last_blink != blink) {
last_blink = blink;
// Skip any non-printing bytes
if (status_scroll_pos < slen) while (!PRINTABLE(lcd_status_message[status_scroll_pos])) status_scroll_pos++;
if (++status_scroll_pos >= slen + 2) status_scroll_pos = 0;
// Adjust by complete UTF8 characters
if (status_scroll_offset < slen) {
status_scroll_offset++;
while (!START_OF_UTF8_CHAR(lcd_status_message[status_scroll_offset]))
status_scroll_offset++;
}
else
status_scroll_offset = 0;
}
}
#else
UNUSED(blink);
lcd_put_u8str(lcd_status_message);
// Get the UTF8 character count of the string
uint8_t slen = utf8_strlen(lcd_status_message);
// Just print the string to the LCD
lcd_put_u8str_max(lcd_status_message, LCD_PIXEL_WIDTH);
// Fill the rest with spaces if there are missing spaces
while (slen < LCD_WIDTH) {
lcd_put_wchar(' ');
++slen;
}
#endif
}
@ -417,7 +458,7 @@ static void lcd_implementation_status_screen() {
lcd_put_wchar('%');
lcd_setFont(FONT_MENU);
lcd_moveto(47, 50);
lcd_put_wchar(LCD_STR_FILAM_DIA[0]); // lcd_put_u8str_rom(PSTR(LCD_STR_FILAM_DIA));
lcd_put_wchar(LCD_STR_FILAM_DIA[0]); // lcd_put_u8str_P(PSTR(LCD_STR_FILAM_DIA));
lcd_moveto(93, 50);
lcd_put_wchar(LCD_STR_FILAM_MUL[0]);
#endif
@ -437,10 +478,10 @@ static void lcd_implementation_status_screen() {
lcd_implementation_status_message(blink);
}
else {
lcd_put_u8str_rom(PSTR(LCD_STR_FILAM_DIA));
lcd_put_u8str_P(PSTR(LCD_STR_FILAM_DIA));
lcd_put_wchar(':');
lcd_put_u8str(wstring);
lcd_put_u8str_rom(PSTR(" " LCD_STR_FILAM_MUL));
lcd_put_u8str_P(PSTR(" " LCD_STR_FILAM_MUL));
lcd_put_wchar(':');
lcd_put_u8str(mstring);
lcd_put_wchar('%');

75
Marlin/src/lcd/dogm/status_screen_lite_ST7920.h
View file

@ -615,36 +615,71 @@ void ST7920_Lite_Status_Screen::draw_feedrate_percentage(const uint8_t percentag
void ST7920_Lite_Status_Screen::draw_status_message(const char *str) {
set_ddram_address(DDRAM_LINE_4);
begin_data();
#if ENABLED(STATUS_MESSAGE_SCROLLING)
const uint8_t lcd_len = 16;
const uint8_t padding = 2;
uint8_t str_len = strlen(str);
#if ENABLED(STATUS_MESSAGE_SCROLLING)
// Trim whitespace at the end of the str, as for some reason
// messages like "Card Inserted" are padded with many spaces
while (str_len && str[str_len - 1] == ' ') str_len--;
uint8_t slen = utf8_strlen(str);
if (str_len <= lcd_len) {
// It all fits on the LCD without scrolling
// If the string fits into the LCD, just print it and do not scroll it
if (slen <= lcd_len) {
// The string isn't scrolling and may not fill the screen
write_str(str);
// Fill the rest with spaces
while (slen < lcd_len) {
write_byte(' ');
++slen;
}
}
else {
// Print the message repeatedly until covering the LCD
uint8_t c = status_scroll_pos;
for (uint8_t n = 0; n < lcd_len; n++) {
write_byte(c < str_len ? str[c] : ' ');
c++;
c %= str_len + padding; // Wrap around
// String is larger than the available space in screen.
// Get a pointer to the next valid UTF8 character
const char *stat = str + status_scroll_offset;
// Get the string remaining length
const uint8_t rlen = utf8_strlen(stat);
// If we have enough characters to display
if (rlen >= lcd_len) {
// The remaining string fills the screen - Print it
write_str(stat, lcd_len);
}
else {
// The remaining string does not completely fill the screen
write_str(stat); // The string leaves space
uint8_t chars = lcd_len - rlen; // Amount of space left in characters
write_byte('.'); // Always at 1+ spaces left, draw a dot
if (--chars) { // Draw a second dot if there's space
write_byte('.');
if (--chars)
write_str(str, chars); // Print a second copy of the message
}
}
// Scroll the message
if (status_scroll_pos == str_len + padding)
status_scroll_pos = 0;
// Adjust by complete UTF8 characters
if (status_scroll_offset < slen) {
status_scroll_offset++;
while (!START_OF_UTF8_CHAR(str[status_scroll_offset]))
status_scroll_offset++;
}
else
status_scroll_pos++;
status_scroll_offset = 0;
}
#else
write_str(str, 16);
// Get the UTF8 character count of the string
uint8_t slen = utf8_strlen(str);
// Just print the string to the LCD
write_str(str, lcd_len);
// Fill the rest with spaces if there are missing spaces
while (slen < lcd_len) {
write_byte(' ');
++slen;
}
#endif
}
@ -792,7 +827,7 @@ void ST7920_Lite_Status_Screen::update_status_or_position(bool forceUpdate) {
*/
if (forceUpdate || status_changed()) {
#if ENABLED(STATUS_MESSAGE_SCROLLING)
status_scroll_pos = 0;
status_scroll_offset = 0;
#endif
#if STATUS_EXPIRE_SECONDS
countdown = lcd_status_message[0] ? STATUS_EXPIRE_SECONDS : 0;

182
Marlin/src/lcd/fontutils.cpp
View file

@ -16,56 +16,14 @@
#include "fontutils.h"
uint8_t read_byte_ram(uint8_t * str) { return *str; }
uint8_t read_byte_rom(uint8_t * str) { return pgm_read_byte(str); }
#if DEBUG
#ifdef ARDUINO
#include <Arduino.h>
#include <stdarg.h>
void serial_printf_P(const char *format, ...) {
static char buff[128];
va_list args;
va_start(args,format);
vsnprintf_P(buff,sizeof(buff),format,args);
va_end(args);
buff[sizeof(buff)/sizeof(buff[0])-1]='\0';
//Serial.print(buff);
SERIAL_ECHO(buff); SERIAL_EOL;
uint8_t read_byte_ram(uint8_t * str) {
return *str;
}
#endif
#endif
uint8_t read_byte_rom(uint8_t * str) {
return pgm_read_byte(str);
}
#ifdef __WIN32__ // or whatever
#define PRIiSZ "ld"
#define PRIuSZ "Iu"
#else
#define PRIiSZ "zd"
#define PRIuSZ "zu"
#endif
#define PRIiOFF "lld"
#define PRIuOFF "llu"
#define DBGMSG(a,b, ...) TRACE( #__VA_ARGS__ )
//typedef int (* pf_bsearch_cb_comp_t)(void *userdata, size_t idx, void * data_pin); /*"data_list[idx] - *data_pin"*/
/**
* @brief 折半方式查找记录
*
* @param userdata : 用户数据指针
* @param num_data : 数据个数
* @param cb_comp : 比较两个数据的回调函数
* @param data_pinpoint : 所要查找的 匹配数据指针
* @param ret_idx : 查找到的位置;如果没有找到，则返回如添加该记录时其所在的位置。
*
* @return 找到则返回0，否则返回<0
*
* 折半方式查找记录, psl->marr 中指向的数据已经以先小后大方式排好序
*/
/**
* @brief Using binary search to find the position by data_pin
*
@ -82,21 +40,11 @@ uint8_t read_byte_rom(uint8_t * str) { return pgm_read_byte(str); }
int pf_bsearch_r(void *userdata, size_t num_data, pf_bsearch_cb_comp_t cb_comp, void *data_pinpoint, size_t *ret_idx) {
int retcomp;
FU_ASSERT(NULL != ret_idx);
/* 查找合适的位置 */
if (num_data < 1) {
*ret_idx = 0;
DBGMSG (PFDBG_CATLOG_PF, PFDBG_LEVEL_ERROR, "num_data(%" PRIuSZ ") < 1", num_data);
return -1;
}
/* 折半查找 */
/* 为了不出现负数，以免缩小索引的所表示的数据范围
* (负数表明减少一位二进制位的使用)，
* 内部 ileft 和 iright使用从1开始的下标，
* 即1表示C语言中的0, 2表示语言中的1，以此类推。
* 对外还是使用以 0 为开始的下标
*/
size_t i = 0, ileft = 1, iright = num_data;
bool flg_found = false;
for (; ileft <= iright;) {
@ -122,28 +70,15 @@ int pf_bsearch_r(void *userdata, size_t num_data, pf_bsearch_cb_comp_t cb_comp,
*ret_idx = i;
else if (ileft >= i + 2)
*ret_idx = i + 1;
//DBGMSG (PFDBG_CATLOG_PF, PFDBG_LEVEL_DEBUG, "not found! num_data=%" PRIuSZ "; ileft=%" PRIuSZ ", iright=%" PRIuSZ ", i=%" PRIuSZ "", num_data, ileft, iright, i);
return -1;
}
/**
* @brief 转换 UTF-8 编码的一个字符为本地的 Unicode 字符(wchar_t)
*
* @param pstart : 存储 UTF-8 字符的指针
* @param cb_read_byte : 读取字符的函数；用于8位MCU ROM
* @param pval : 需要返回的 Unicode 字符存放地址指针
*
* @return 成功返回下个 UTF-8 字符的位置
*
* 转换 UTF-8 编码的一个字符为本地的 Unicode 字符(wchar_t)
*/
/* This function gets the character at the pstart position, interpreting UTF8 multybyte sequences
and returns the pointer to the next character */
uint8_t* get_utf8_value_cb(uint8_t *pstart, read_byte_cb_t cb_read_byte, wchar_t *pval) {
uint32_t val = 0;
uint8_t *p = pstart;
FU_ASSERT(NULL != pstart);
FU_ASSERT(NULL != cb_read_byte);
uint8_t valcur = cb_read_byte(p);
if (0 == (0x80 & valcur)) {
val = valcur;
@ -215,113 +150,34 @@ uint8_t* get_utf8_value_cb(uint8_t *pstart, read_byte_cb_t cb_read_byte, wchar_t
val |= (valcur & 0x3F);
p++;
}
else if (0x80 == (0xC0 & valcur)) {
/* error? */
TRACE("ERR 1");
else if (0x80 == (0xC0 & valcur))
for (; 0x80 == (0xC0 & valcur); ) { p++; valcur = cb_read_byte(p); }
}
else {
/* error */
TRACE("ERR 2");
else
for (; ((0xFE & valcur) > 0xFC); ) { p++; valcur = cb_read_byte(p); }
}
/*
if (val == 0) {
p = NULL;
*/
/*
}
else if (pstart + maxlen < p) {
p = pstart;
if (pval) *pval = 0;
}
*/
if (pval) *pval = val;
return p;
}
// uint8_t * get_utf8_value_cb (uint8_t *pstart, read_byte_cb_t cb_read_byte, wchar_t *pval);
int utf8_strlen_cb(const char *pstart, read_byte_cb_t cb_read_byte) {
wchar_t ch;
uint8_t *pnext;
int cnt = 0;
static inline uint8_t utf8_strlen_cb(const char *pstart, read_byte_cb_t cb_read_byte) {
for (pnext = (uint8_t *)pstart; ; ) {
uint8_t cnt = 0;
uint8_t *pnext = (uint8_t *)pstart;
for (;;) {
wchar_t ch;
pnext = get_utf8_value_cb(pnext, cb_read_byte, &ch);
if (pnext == NULL || ch == 0) break;
if (!ch) break;
cnt++;
TRACE("cnt=%d, ch=0x%X", cnt, (int)ch);
}
return cnt;
}
int
my_strlen_P(const char *pstart)
{
const char *p;
FU_ASSERT(NULL != pstart);
p = pstart;
while (p && pgm_read_byte(p) != '\0') p ++;
return (p - pstart);
uint8_t utf8_strlen(const char *pstart) {
return utf8_strlen_cb(pstart, read_byte_ram);
}
uint8_t utf8_strlen(const char *pstart) { return utf8_strlen_cb(pstart, read_byte_ram); }
uint8_t utf8_strlen_P(const char *pstart) { return utf8_strlen_cb(pstart, read_byte_rom); }
char* utf8_strncpy_cb( char * destination, const char *source, size_t num, int len_src, read_byte_cb_t cb_read_byte) {
uint8_t *p = (uint8_t *)source;
uint8_t *d = (uint8_t *)destination;
FU_ASSERT(NULL != destination);
FU_ASSERT(NULL != source);
FU_ASSERT(NULL != cb_read_byte);
uint8_t *pend = p + len_src;
while (p < pend) {
uint8_t valcur = cb_read_byte(p);
size_t len = 0;
if (0 == (0x80 & valcur))
len = 1;
else if (0xC0 == (0xE0 & valcur))
len = 2;
else if (0xE0 == (0xF0 & valcur))
len = 3;
else if (0xF0 == (0xF8 & valcur))
len = 4;
else if (0xF8 == (0xFC & valcur))
len = 5;
else if (0xFC == (0xFE & valcur))
len = 6;
else if (0x80 == (0xC0 & valcur)) {
/* error? */
for (; 0x80 == (0xC0 & valcur) && (p < pend); ) { p++; valcur = cb_read_byte(p); }
}
else {
/* error */
for (; ((0xFE & valcur) > 0xFC) && (p < pend); ) { p++; valcur = cb_read_byte(p); }
}
if (len < num) {
for (size_t i = 0; i < len; i++) {
valcur = cb_read_byte(p);
*d = valcur;
d++;
p++;
}
}
else
break;
}
*d = 0;
return destination;
uint8_t utf8_strlen_P(const char *pstart) {
return utf8_strlen_cb(pstart, read_byte_rom);
}
char* utf8_strncpy(char * destination, const char * source, size_t num) {
return utf8_strncpy_cb(destination, source, num, strlen(source), read_byte_ram);
}
char* utf8_strncpy_P(char * destination, const char * source, size_t num) {
return utf8_strncpy_cb(destination, source, num, my_strlen_P(source), read_byte_rom);
}

125
Marlin/src/lcd/fontutils.h
View file

@ -9,56 +9,17 @@
#ifndef _FONT_UTILS_H
#define _FONT_UTILS_H
#define DEBUG 0
#ifdef ARDUINO
#include <Arduino.h>
#else // ARDUINO
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#endif // ARDUINO
#ifndef pgm_read_word_near // __AVR__
#include <stdint.h>
#include <string.h>
#include <assert.h>
//#define pgm_read_word_near(a) *((uint16_t *)(a))
#define pgm_read_word_near(a) (*(a))
#define pgm_read_byte_near(a) *((uint8_t *)(a))
#define pgm_read_byte pgm_read_byte_near
#elif defined(__AVR__)
#include <avr/pgmspace.h>
#endif
#ifndef PROGMEM
#define PROGMEM
#define strlen_P strlen
#define memcpy_P memcpy
#define vsnprintf_P vsnprintf
#endif // PROGMEM
#ifdef __cplusplus
extern "C" {
#endif
#include "../core/macros.h"
#include <stddef.h> // wchar_t
#include <stdint.h> // uint32_t
// read a byte from ROM or RAM
typedef uint8_t (*read_byte_cb_t)(uint8_t * str);
//inline uint8_t read_byte_ram(uint8_t * str) { return *str; }
//inline uint8_t read_byte_rom(uint8_t * str) { return pgm_read_byte(str); }
uint8_t read_byte_ram(uint8_t * str);
uint8_t read_byte_rom(uint8_t * str);
#ifdef __cplusplus
}
#endif
#include <stddef.h> // wchar_t
#include <stdint.h> // uint32_t
#ifdef ARDUINO
// there's overflow of the wchar_t due to the 2-byte size in Arduino
// sizeof(wchar_t)=2; sizeof(size_t)=2; sizeof(uint32_t)=4;
// sizeof(int)=2; sizeof(long)=4; sizeof(unsigned)=2;
@ -66,94 +27,22 @@ uint8_t read_byte_rom(uint8_t * str);
#define wchar_t uint32_t
//typedef uint32_t wchar_t;
#else
#include <sys/types.h> // ssize_t
#include <assert.h>
// x86_64
// sizeof(wchar_t)=4; sizeof(size_t)=8; sizeof(uint32_t)=4;
// sizeof(int)=4; sizeof(long)=8; sizeof(unsigned)=4;
//#define wchar_t uint32_t
#define wchar_t size_t
#ifndef PRIu32
#define PRIu32 "lu"
#endif
#ifndef PRIX32
#define PRIX32 "lX"
#endif
#endif
#define UNUSED_VARIABLE(a) ((void)(a))
#ifndef MIN
#define MIN(a,b) (((a)>(b))?(b):(a))
#endif
#ifndef NUM_ARRAY
#define NUM_ARRAY(a) (sizeof(a)/sizeof((a)[0]))
#endif // NUM_ARRAY
#ifdef __cplusplus
extern "C" {
#endif
//#define pixel_len_t u8g_uint_t
#define pixel_len_t uint16_t
//#define pixel_len_t uint8_t
//typedef uint16_t pixel_len_t;
typedef uint16_t pixel_len_t;
#define PIXEL_LEN_NOLIMIT ((pixel_len_t)(-1))
/* Perform binary search */
typedef int (* pf_bsearch_cb_comp_t)(void *userdata, size_t idx, void * data_pin); /*"data_list[idx] - *data_pin"*/
int pf_bsearch_r(void *userdata, size_t num_data, pf_bsearch_cb_comp_t cb_comp, void *data_pinpoint, size_t *ret_idx);
//wchar_t get_val_utf82uni(uint8_t *pstart);
//uint8_t * get_utf8_value(uint8_t *pstart, wchar_t *pval);
/* Get the character, decoding multibyte UTF8 characters and returning a pointer to the start of the next UTF8 character */
uint8_t* get_utf8_value_cb(uint8_t *pstart, read_byte_cb_t cb_read_byte, wchar_t *pval);
/* Returns lenght of string in CHARACTERS, NOT BYTES */
uint8_t utf8_strlen(const char *pstart);
uint8_t utf8_strlen_P(const char *pstart);
char * utf8_strncpy(char * destination, const char * source, size_t num);
char * utf8_strncpy_P(char * destination, const char * source, size_t num);
int my_strlen_P(const char *pstart);
#if 0 // DEBUG
#if 0 //defined(ARDUINO)
#if defined(__AVR__)
#define TRACE(fmt, ...) {static const PROGMEM char CONSTSTR[] = "%d %d " fmt " {ln:%d;}\n"; serial_printf_P(CONSTSTR, millis(), ##__VA_ARGS__, __LINE__); }
#else
#define TRACE(fmt, ...) {static const PROGMEM char CONSTSTR[] = "%d " fmt " {ln:%d, fn:" __FILE__ "}\n"; serial_printf_P(CONSTSTR, millis(), ##__VA_ARGS__, __LINE__); }
#endif
#define FU_ASSERT(a) if (!(a)) {TRACE("Assert: " # a ); }
#ifdef __cplusplus
extern "C" {
#endif
void serial_printf_P(const char *format, ...);
#ifdef __cplusplus
}
#endif
#else // ARDUINO
#include <stdio.h>
#define FU_ASSERT(a) if (!(a)) {printf("Assert: " # a); exit(1);}
#define TRACE(fmt, ...) fprintf(stdout, "[%s()] " fmt " {ln:%d, fn:" __FILE__ "}\n", __func__, ##__VA_ARGS__, __LINE__)
//#else
//#define FU_ASSERT(a)
//#define TRACE(...)
#endif // ARDUINO
#else // DEBUG
#define TRACE(fmt, ...)
#define FU_ASSERT(a)
#endif // DEBUG
#ifdef __cplusplus
}
#endif
#endif // _FONT_UTILS_H

14
Marlin/src/lcd/lcdprint.h
View file

@ -17,11 +17,7 @@
#include "u8g_fontutf8.h"
#endif
#define PRINTABLE(C) (((C) & 0xC0u) != 0x80u)
#ifdef __cplusplus
extern "C" {
#endif
#define START_OF_UTF8_CHAR(C) (((C) & 0xC0u) != 0x80u)
int lcd_glyph_height(void);
@ -49,15 +45,11 @@ int lcd_put_u8str_max(const char * utf8_str, pixel_len_t max_length);
*
* Draw a ROM UTF-8 string
*/
int lcd_put_u8str_max_rom(const char * utf8_str_P, pixel_len_t max_length);
int lcd_put_u8str_max_P(const char * utf8_str_P, pixel_len_t max_length);
void lcd_moveto(int col, int row);
#ifdef __cplusplus
}
#endif
#define lcd_put_u8str_rom(str) lcd_put_u8str_max_rom(str, PIXEL_LEN_NOLIMIT)
inline int lcd_put_u8str_P(const char *str) { return lcd_put_u8str_max_P(str, PIXEL_LEN_NOLIMIT); }
inline int lcd_put_u8str(const char* str) { return lcd_put_u8str_max(str, PIXEL_LEN_NOLIMIT); }

95
Marlin/src/lcd/lcdprint_hd44780.cpp
View file

@ -24,7 +24,6 @@
#include "fontutils.h"
#include "lcdprint.h"
#if defined(ARDUINO)
#include "ultralcd_common_HD44780.h"
#ifndef LCD_CLASS
#include <LiquidCrystal.h>
@ -32,12 +31,6 @@
#endif
extern LCD_CLASS lcd;
LCD_CLASS *plcd = &lcd;
#define _lcd_write(a) plcd->write(a)
#define _lcd_setcursor(col, row) plcd->setCursor((col), (row));
#else
#define _lcd_write(a) TRACE("Write LCD: %c (%d)", (a), (int)(a));
#define _lcd_setcursor(col, row) TRACE("Set cursor LCD: (%d,%d)", (col), (row));
#endif
int lcd_glyph_height(void) { return 1; }
@ -878,25 +871,10 @@ static const hd44780_charmap_t g_hd44780_charmap_common[] PROGMEM = {
/* return v1 - v2 */
static int hd44780_charmap_compare(hd44780_charmap_t * v1, hd44780_charmap_t * v2) {
FU_ASSERT(NULL != v1);
FU_ASSERT(NULL != v2);
TRACE("compare char1 %" PRIu32 "(0x%" PRIX32 ")", v1->uchar, v1->uchar);
TRACE("compare char2 %" PRIu32 "(0x%" PRIX32 ")", v2->uchar, v2->uchar);
if (v1->uchar < v2->uchar) {
TRACE("compare return -1");
if (v1->uchar < v2->uchar)
return -1;
} else if (v1->uchar > v2->uchar) {
TRACE("compare return 1");
else if (v1->uchar > v2->uchar)
return 1;
}
#if 0
if (v1->idx < v2->idx) {
return -1;
} else if (v1->idx > v2->idx) {
return 1;
}
#endif
TRACE("compare return 0");
return 0;
}
@ -909,9 +887,7 @@ static int pf_bsearch_cb_comp_hd4map_pgm(void *userdata, size_t idx, void * data
#if DEBUG
int
test_hd44780_charmap(hd44780_charmap_t *data, size_t size, char *name, char flg_show_contents)
{
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};
@ -963,9 +939,7 @@ test_hd44780_charmap(hd44780_charmap_t *data, size_t size, char *name, char flg_
return 0;
}
int
test_hd44780_charmap_all(void)
{
int test_hd44780_charmap_all(void) {
int flg_error = 0;
if (test_hd44780_charmap(g_hd44780_charmap_device, NUM_ARRAY(g_hd44780_charmap_device), "g_hd44780_charmap_device", 0) < 0) {
flg_error = 1;
@ -986,18 +960,17 @@ test_hd44780_charmap_all(void)
#endif // DEBUG
void lcd_moveto(int col, int row) {
TRACE("Move to: (%d,%d)", col, row);
_lcd_setcursor(col, row);
plcd->setCursor(col, row);
}
// 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 localval;
hd44780_charmap_t *copy_address = NULL;
pinval.uchar = c;
pinval.idx = -1;
@ -1006,37 +979,33 @@ int lcd_put_wchar_max(wchar_t c, pixel_len_t max_length) {
// TODO: fix the '\\' that doesnt exist in the HD44870
if (c < 128) {
//TRACE("draw char: regular %d", (int)c);
_lcd_write((uint8_t)c);
plcd->write((uint8_t)c);
return 1;
}
copy_address = NULL;
ret = pf_bsearch_r((void *)g_hd44780_charmap_device, NUM_ARRAY(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, NUM_ARRAY(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);
}
else {
ret = pf_bsearch_r((void *)g_hd44780_charmap_common, NUM_ARRAY(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
FU_ASSERT(NULL != copy_address);
memcpy_P(&localval, copy_address, sizeof(localval));
FU_ASSERT((localval.uchar == c) && (localval.uchar == pinval.uchar));
TRACE("draw char: %" PRIu32 "(0x%" PRIX32 ") at ROM %d(+%d)", c, c, (int)localval.idx, (int)localval.idx2);
_lcd_write(localval.idx);
plcd->write(localval.idx);
if (max_length >= 2 && localval.idx2 > 0) {
_lcd_write(localval.idx2);
plcd->write(localval.idx2);
return 2;
}
return 1;
}
// print '?' instead
TRACE("draw char: Not found " PRIu32 "(0x%" PRIX32 ")", c, c);
_lcd_write((uint8_t)'?');
// Not found, print '?' instead
plcd->write((uint8_t)'?');
return 1;
}
@ -1044,7 +1013,6 @@ int lcd_put_wchar_max(wchar_t c, pixel_len_t max_length) {
* @brief Draw a UTF-8 string
*
* @param utf8_str : the UTF-8 string
* @param len : the byte length of the string (returned by strlen(utf8_str) or strlen_P(utf8_str) )
* @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)
*
@ -1052,39 +1020,24 @@ int lcd_put_wchar_max(wchar_t c, pixel_len_t max_length) {
*
* Draw a UTF-8 string
*/
static int lcd_put_u8str_max_cb(const char * utf8_str, uint16_t len, uint8_t (*cb_read_byte)(uint8_t * str), pixel_len_t max_length) {
wchar_t ch;
uint8_t *p, *pend;
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;
TRACE("BEGIN lcd_put_u8str_max_cb(len=%d, maxlen=%d)", len, max_length);
pend = (uint8_t *)utf8_str + len;
for (p = (uint8_t *)utf8_str; (p < pend) && (ret < max_length); ) {
ch = 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 (NULL == p) {
TRACE("No more char, break ...");
break;
}
FU_ASSERT(ret < max_length);
if (!p) 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) {
//TRACE("BEGIN lcd_put_u8str_max(str='%s', len=%d, maxlen=%d)", utf8_str, strlen(utf8_str), max_length);
TRACE("BEGIN lcd_put_u8str_max(str='%s')", utf8_str);
TRACE("BEGIN lcd_put_u8str_max('len=%d)", strlen(utf8_str));
TRACE("BEGIN lcd_put_u8str_max(maxlen=%d)", max_length);
return lcd_put_u8str_max_cb(utf8_str, strlen(utf8_str), read_byte_ram, max_length);
return lcd_put_u8str_max_cb(utf8_str, read_byte_ram, max_length);
}
int lcd_put_u8str_max_rom(const char * utf8_str_P, pixel_len_t max_length) {
//TRACE("BEGIN lcd_put_u8str_max_rom('%s', len=%d, maxlen=%d)", utf8_str_P, strlen_P(utf8_str_P), max_length);
TRACE("BEGIN lcd_put_u8str_max_rom(len=%d)", strlen_P(utf8_str_P));
TRACE("BEGIN lcd_put_u8str_max_rom(maxlen=%d)", max_length);
return lcd_put_u8str_max_cb(utf8_str_P, strlen_P(utf8_str_P), read_byte_rom, max_length);
int lcd_put_u8str_max_P(const char * utf8_str_P, pixel_len_t max_length) {
return lcd_put_u8str_max_cb(utf8_str_P, read_byte_rom, max_length);
}
#endif // DOGLCD

20
Marlin/src/lcd/lcdprint_u8g.cpp
View file

@ -25,25 +25,22 @@ extern U8GLIB *pu8g;
int lcd_glyph_height(void) {
return u8g_GetFontBBXHeight(pu8g->getU8g());
//return u8g_GetFontBBXOffY(pu8g->getU8g());
}
void lcd_moveto(int col, int row) {
TRACE("Move to: (%d,%d)", col, row);
_lcd_setcursor(col, row);
}
// return < 0 on error
// return the advanced pixels
int lcd_put_wchar_max(wchar_t c, pixel_len_t max_length) {
if (c < 256) {
TRACE("draw char: regular %d", (int)c);
_lcd_write((char)c);
return u8g_GetFontBBXWidth(pu8g->getU8g());
}
unsigned int x = pu8g->getPrintCol(),
y = pu8g->getPrintRow(),
ret = uxg_DrawWchar(pu8g->getU8g(), x, y, c, max_length);
TRACE("uxg_DrawWchar(x=%d,y=%d,maxlen=%d", x, y, max_length);
TRACE("u8g->setPrintPos(x=%d + ret=%d,y=%d", x, ret, y);
pu8g->setPrintPos(x + ret, y);
return ret;
@ -53,25 +50,16 @@ int lcd_put_u8str_max(const char * utf8_str, pixel_len_t max_length) {
unsigned int x = pu8g->getPrintCol(),
y = pu8g->getPrintRow(),
ret = uxg_DrawUtf8Str(pu8g->getU8g(), x, y, utf8_str, max_length);
TRACE("uxg_DrawUtf8Str(x=%d,y=%d,maxlen=%d", x, y, max_length);
TRACE("u8g->setPrintPos(x=%d + ret=%d,y=%d", x, ret, y);
pu8g->setPrintPos(x + ret, y);
return ret;
}
int lcd_put_u8str_max_rom(const char * utf8_str_P, pixel_len_t max_length) {
int lcd_put_u8str_max_P(const char * utf8_str_P, pixel_len_t max_length) {
unsigned int x = pu8g->getPrintCol(),
y = pu8g->getPrintRow(),
ret = uxg_DrawUtf8StrP(pu8g->getU8g(), x, y, utf8_str_P, max_length);
TRACE("uxg_DrawUtf8StrP(x=%d,y=%d,maxlen=%d", x, y, max_length);
TRACE("u8g->setPrintPos(x=%d + ret=%d,y=%d", x, ret, y);
pu8g->setPrintPos(x + ret, y);
return ret;
}
#else // !DOGLCD
#define _lcd_write(a) TRACE("Write LCD: %c (%d)", (a), (int)(a));
#define _lcd_setcursor(col, row) TRACE("Set cursor LCD: (%d,%d)", (col), (row));
#endif // !DOGLCD
#endif // DOGLCD

106
Marlin/src/lcd/u8g_fontutf8.cpp
View file

@ -18,28 +18,6 @@
////////////////////////////////////////////////////////////
typedef void font_t;
#ifndef PSTR
#define PSTR(a) a
void* memcpy_from_rom(void *dest, const void * rom_src, size_t sz) {
uint8_t * p;
uint8_t * s;
FU_ASSERT(NULL != dest);
p = (uint8_t*)dest;
s = (uint8_t*)rom_src;
uint8_t c;
while ((p - (uint8_t *)dest) < sz) {
*p = pgm_read_byte(s);
p ++;
s ++;
}
return p;
}
#else
#define memcpy_from_rom memcpy_P
#endif
/**
* @brief the callback function to draw something
*
@ -53,25 +31,14 @@ void* memcpy_from_rom(void *dest, const void * rom_src, size_t sz) {
*/
typedef int (* fontgroup_cb_draw_t)(void *userdata, const font_t *fnt_current, const char *msg);
//extern int fontgroup_init(font_group_t * root, const uxg_fontinfo_t * fntinfo, int number);
//extern int fontgroup_drawstring(font_group_t *group, const font_t *fnt_default, const char *utf8_msg, void *userdata, fontgroup_cb_draw_t cb_draw);
//extern uxg_fontinfo_t* fontgroup_first(font_group_t * root);
////////////////////////////////////////////////////////////
/* return v1 - v2 */
static int fontinfo_compare(uxg_fontinfo_t * v1, uxg_fontinfo_t * v2) {
FU_ASSERT(NULL != v1);
FU_ASSERT(NULL != v2);
if (v1->page < v2->page)
return -1;
else if (v1->page > v2->page)
return 1;
if (v1->page < v2->page) return -1;
else if (v1->page > v2->page) return 1;
if (v1->end < v2->begin)
return -1;
else if (v1->begin > v2->end)
return 1;
if (v1->end < v2->begin) return -1;
else if (v1->begin > v2->end) return 1;
return 0;
}
@ -80,7 +47,7 @@ static int fontinfo_compare(uxg_fontinfo_t * v1, uxg_fontinfo_t * v2) {
static int pf_bsearch_cb_comp_fntifo_pgm (void *userdata, size_t idx, void *data_pin) {
uxg_fontinfo_t *fntinfo = (uxg_fontinfo_t*)userdata;
uxg_fontinfo_t localval;
memcpy_from_rom(&localval, fntinfo + idx, sizeof(localval));
memcpy_P(&localval, fntinfo + idx, sizeof(localval));
return fontinfo_compare(&localval, (uxg_fontinfo_t*)data_pin);
}
@ -92,7 +59,6 @@ typedef struct _font_group_t {
static int fontgroup_init(font_group_t * root, const uxg_fontinfo_t * fntinfo, int number) {
root->m_fntifo = fntinfo;
root->m_fntinfo_num = number;
return 0;
}
@ -105,26 +71,23 @@ static const font_t* fontgroup_find(font_group_t * root, wchar_t val) {
if (pf_bsearch_r((void*)root->m_fntifo, root->m_fntinfo_num, pf_bsearch_cb_comp_fntifo_pgm, (void*)&vcmp, &idx) < 0)
return NULL;
memcpy_from_rom(&vcmp, root->m_fntifo + idx, sizeof(vcmp));
memcpy_P(&vcmp, root->m_fntifo + idx, sizeof(vcmp));
return vcmp.fntdata;
}
static void fontgroup_drawwchar(font_group_t *group, const font_t *fnt_default, wchar_t val, void * userdata, fontgroup_cb_draw_t cb_draw_ram) {
uint8_t buf[2] = {0, 0};
const font_t * fntpqm = NULL;
TRACE("fontgroup_drawwchar char=%d(0x%X)", (int)val, (int)val);
fntpqm = (font_t*)fontgroup_find(group, val);
if (NULL == fntpqm) {
const font_t * fntpqm = (font_t*)fontgroup_find(group, val);
if (!fntpqm) {
// Unknown char, use default font
buf[0] = (uint8_t)(val & 0xFF);
fntpqm = fnt_default;
TRACE("Unknown char %d(0x%X), use default font", (int)val, (int)val);
}
if (fnt_default != fntpqm) {
buf[0] = (uint8_t)(val & 0x7F);
buf[0] |= 0x80; // use upper page to avoid 0x00 error in C. you may want to generate the font data
}
//TRACE("set font: %p; (default=%p)", fntpqm, UXG_DEFAULT_FONT);
cb_draw_ram (userdata, fntpqm, (char*) buf);
}
@ -142,31 +105,27 @@ static void fontgroup_drawwchar(font_group_t *group, const font_t *fnt_default,
*
* Get the screen pixel width of a ROM UTF-8 string
*/
static void fontgroup_drawstring(font_group_t *group, const font_t *fnt_default, const char *utf8_msg, int len_msg, read_byte_cb_t cb_read_byte, void * userdata, fontgroup_cb_draw_t cb_draw_ram) {
uint8_t *pend = (uint8_t*)utf8_msg + len_msg;
for (uint8_t *p = (uint8_t*)utf8_msg; p < pend; ) {
static void fontgroup_drawstring(font_group_t *group, const font_t *fnt_default, const char *utf8_msg, read_byte_cb_t cb_read_byte, void * userdata, fontgroup_cb_draw_t cb_draw_ram) {
uint8_t *p = (uint8_t*)utf8_msg;
for (;;) {
wchar_t val = 0;
p = get_utf8_value_cb(p, cb_read_byte, &val);
if (NULL == p) {
TRACE("No more char, break ...");
break;
}
if (!val) break;
fontgroup_drawwchar(group, fnt_default, val, userdata, cb_draw_ram);
}
}
////////////////////////////////////////////////////////////
static char flag_fontgroup_inited1 = 0;
#define flag_fontgroup_inited flag_fontgroup_inited1
static bool flag_fontgroup_was_inited = false;
static font_group_t g_fontgroup_root = {NULL, 0};
/**
* @brief check if font is loaded
*/
char uxg_Utf8FontIsInited(void) { return flag_fontgroup_inited; }
static inline bool uxg_Utf8FontIsInited(void) { return flag_fontgroup_was_inited; }
int uxg_SetUtf8Fonts (const uxg_fontinfo_t * fntinfo, int number) {
flag_fontgroup_inited = 1;
flag_fontgroup_was_inited = 1;
return fontgroup_init(&g_fontgroup_root, fntinfo, number);
}
@ -182,19 +141,14 @@ struct _uxg_drawu8_data_t {
static int fontgroup_cb_draw_u8g(void *userdata, const font_t *fnt_current, const char *msg) {
struct _uxg_drawu8_data_t * pdata = (_uxg_drawu8_data_t*)userdata;
FU_ASSERT(NULL != userdata);
if (pdata->fnt_prev != fnt_current) {
u8g_SetFont(pdata->pu8g, (const u8g_fntpgm_uint8_t*)fnt_current);
//u8g_SetFontPosBottom(pdata->pu8g);
pdata->fnt_prev = fnt_current;
}
if ((pdata->max_width != PIXEL_LEN_NOLIMIT) && (pdata->adv + u8g_GetStrPixelWidth(pdata->pu8g, (char*)msg) > pdata->max_width)) {
TRACE("return end, adv=%d, width=%d, maxlen=%d", pdata->adv, u8g_GetStrPixelWidth(pdata->pu8g, (char*)msg), pdata->max_width);
if ((pdata->max_width != PIXEL_LEN_NOLIMIT) && (pdata->adv + u8g_GetStrPixelWidth(pdata->pu8g, (char*)msg) > pdata->max_width))
return 1;
}
TRACE("Draw string 0x%X", (int)msg[0]);
pdata->adv += u8g_DrawStr(pdata->pu8g, pdata->x + pdata->adv, pdata->y, (char*) msg);
//TRACE("adv pos= %d", pdata->adv);
return 0;
}
@ -260,7 +214,7 @@ unsigned int uxg_DrawUtf8Str(u8g_t *pu8g, unsigned int x, unsigned int y, const
data.adv = 0;
data.max_width = max_width;
data.fnt_prev = NULL;
fontgroup_drawstring(group, fnt_default, utf8_msg, strlen(utf8_msg), read_byte_ram, (void*)&data, fontgroup_cb_draw_u8g);
fontgroup_drawstring(group, fnt_default, utf8_msg, read_byte_ram, (void*)&data, fontgroup_cb_draw_u8g);
u8g_SetFont(pu8g, (const u8g_fntpgm_uint8_t*)fnt_default);
return data.adv;
@ -285,7 +239,6 @@ unsigned int uxg_DrawUtf8StrP(u8g_t *pu8g, unsigned int x, unsigned int y, const
const font_t *fnt_default = uxg_GetFont(pu8g);
if (!uxg_Utf8FontIsInited()) {
TRACE("Error, utf8string not inited!");
u8g_DrawStrP(pu8g, x, y, (const u8g_pgm_uint8_t *)PSTR("Err: utf8 font not initialized."));
return 0;
}
@ -295,19 +248,15 @@ unsigned int uxg_DrawUtf8StrP(u8g_t *pu8g, unsigned int x, unsigned int y, const
data.adv = 0;
data.max_width = max_width;
data.fnt_prev = NULL;
TRACE("call fontgroup_drawstring");
fontgroup_drawstring(group, fnt_default, utf8_msg, my_strlen_P(utf8_msg), read_byte_rom, (void*)&data, fontgroup_cb_draw_u8g);
TRACE("restore font");
fontgroup_drawstring(group, fnt_default, utf8_msg, read_byte_rom, (void*)&data, fontgroup_cb_draw_u8g);
u8g_SetFont(pu8g, (const u8g_fntpgm_uint8_t*)fnt_default);
TRACE("return %d", data.adv);
return data.adv;
}
static int fontgroup_cb_draw_u8gstrlen(void *userdata, const font_t *fnt_current, const char *msg) {
struct _uxg_drawu8_data_t * pdata = (_uxg_drawu8_data_t*)userdata;
FU_ASSERT(NULL != userdata);
if (pdata->fnt_prev != fnt_current) {
u8g_SetFont(pdata->pu8g, (const u8g_fntpgm_uint8_t*)fnt_current);
u8g_SetFontPosBottom(pdata->pu8g);
@ -332,15 +281,12 @@ int uxg_GetUtf8StrPixelWidth(u8g_t *pu8g, const char *utf8_msg) {
font_group_t *group = &g_fontgroup_root;
const font_t *fnt_default = uxg_GetFont(pu8g);
if (!uxg_Utf8FontIsInited()) {
TRACE("Err: utf8 font not initialized.");
return -1;
}
if (!uxg_Utf8FontIsInited()) return -1;
memset(&data, 0, sizeof(data));
data.pu8g = pu8g;
data.adv = 0;
fontgroup_drawstring(group, fnt_default, utf8_msg, strlen(utf8_msg), read_byte_ram, (void*)&data, fontgroup_cb_draw_u8gstrlen);
fontgroup_drawstring(group, fnt_default, utf8_msg, read_byte_ram, (void*)&data, fontgroup_cb_draw_u8gstrlen);
u8g_SetFont(pu8g, (const u8g_fntpgm_uint8_t*)fnt_default);
return data.adv;
@ -361,14 +307,12 @@ int uxg_GetUtf8StrPixelWidthP(u8g_t *pu8g, const char *utf8_msg) {
font_group_t *group = &g_fontgroup_root;
const font_t *fnt_default = uxg_GetFont(pu8g);
if (!uxg_Utf8FontIsInited()) {
TRACE("Err: utf8 font not initialized.");
return -1;
}
if (!uxg_Utf8FontIsInited()) return -1;
memset(&data, 0, sizeof(data));
data.pu8g = pu8g;
data.adv = 0;
fontgroup_drawstring(group, fnt_default, utf8_msg, my_strlen_P(utf8_msg), read_byte_rom, (void*)&data, fontgroup_cb_draw_u8gstrlen);
fontgroup_drawstring(group, fnt_default, utf8_msg, read_byte_rom, (void*)&data, fontgroup_cb_draw_u8gstrlen);
u8g_SetFont(pu8g, (const u8g_fntpgm_uint8_t*)fnt_default);
return data.adv;
}

22
Marlin/src/lcd/u8g_fontutf8.h
View file

@ -12,11 +12,6 @@
#include <U8glib.h>
#include "fontutils.h"
#ifdef __cplusplus
extern "C" {
#endif
// the macro to indicate a UTF-8 string
// You should to save the C/C++ source in UTF-8 encoding!
// Once you change your UTF-8 strings, you need to call the script uxggenpages.sh to create the font data file fontutf8-data.h
@ -30,21 +25,16 @@ typedef struct _uxg_fontinfo_t {
const u8g_fntpgm_uint8_t *fntdata;
} uxg_fontinfo_t;
extern int uxg_SetUtf8Fonts (const uxg_fontinfo_t * fntinfo, int number); // fntinfo is type of PROGMEM
extern char uxg_Utf8FontIsInited(void);
int uxg_SetUtf8Fonts (const uxg_fontinfo_t * fntinfo, int number); // fntinfo is type of PROGMEM
extern unsigned int uxg_DrawWchar (u8g_t *pu8g, unsigned int x, unsigned int y, wchar_t ch, pixel_len_t max_length);
unsigned int uxg_DrawWchar (u8g_t *pu8g, unsigned int x, unsigned int y, wchar_t ch, pixel_len_t max_length);
extern unsigned int uxg_DrawUtf8Str (u8g_t *pu8g, unsigned int x, unsigned int y, const char *utf8_msg, pixel_len_t max_length);
extern unsigned int uxg_DrawUtf8StrP (u8g_t *pu8g, unsigned int x, unsigned int y, const char *utf8_msg, pixel_len_t max_length);
unsigned int uxg_DrawUtf8Str (u8g_t *pu8g, unsigned int x, unsigned int y, const char *utf8_msg, pixel_len_t max_length);
unsigned int uxg_DrawUtf8StrP (u8g_t *pu8g, unsigned int x, unsigned int y, const char *utf8_msg, pixel_len_t max_length);
extern int uxg_GetUtf8StrPixelWidth(u8g_t *pu8g, const char *utf8_msg);
extern int uxg_GetUtf8StrPixelWidthP(u8g_t *pu8g, const char *utf8_msg);
int uxg_GetUtf8StrPixelWidth(u8g_t *pu8g, const char *utf8_msg);
int uxg_GetUtf8StrPixelWidthP(u8g_t *pu8g, const char *utf8_msg);
#define uxg_GetFont(puxg) ((puxg)->font)
#ifdef __cplusplus
}
#endif
#endif // _UXG_FONTUTF8_H

68
Marlin/src/lcd/ultralcd.cpp
View file

@ -80,7 +80,7 @@
#else
#define MAX_MESSAGE_LENGTH CHARSIZE * 2 * (LCD_WIDTH)
#endif
uint8_t status_scroll_pos = 0;
uint8_t status_scroll_offset = 0;
#else
#define MAX_MESSAGE_LENGTH CHARSIZE * (LCD_WIDTH)
#endif
@ -5360,30 +5360,8 @@ void lcd_update() {
} // ELAPSED(ms, next_lcd_update_ms)
}
inline void pad_message_string() {
uint8_t i = 0, j = 0;
char c;
lcd_status_message[MAX_MESSAGE_LENGTH] = '\0';
while ((c = lcd_status_message[i]) && j < LCD_WIDTH) {
if (PRINTABLE(c)) j++;
i++;
}
if (true
#if ENABLED(STATUS_MESSAGE_SCROLLING)
&& j < LCD_WIDTH
#endif
) {
// pad with spaces to fill up the line
while (j++ < LCD_WIDTH) lcd_status_message[i++] = ' ';
// chop off at the edge
lcd_status_message[i] = '\0';
}
}
void lcd_finishstatus(const bool persist=false) {
pad_message_string();
#if !(ENABLED(LCD_PROGRESS_BAR) && (PROGRESS_MSG_EXPIRE > 0))
UNUSED(persist);
#endif
@ -5401,7 +5379,7 @@ void lcd_finishstatus(const bool persist=false) {
#endif
#if ENABLED(STATUS_MESSAGE_SCROLLING)
status_scroll_pos = 0;
status_scroll_offset = 0;
#endif
}
@ -5413,7 +5391,26 @@ bool lcd_hasstatus() { return (lcd_status_message[0] != '\0'); }
void lcd_setstatus(const char * const message, const bool persist) {
if (lcd_status_message_level > 0) return;
strncpy(lcd_status_message, message, MAX_MESSAGE_LENGTH);
// Here we have a problem. The message is encoded in UTF8, so
// arbitrarily cutting it will be a problem. We MUST be sure
// that there is no cutting in the middle of a multibyte character!
// Get a pointer to the null terminator
const char* pend = message + strlen(message);
// If length of supplied UTF8 string is greater than
// our buffer size, start cutting whole UTF8 chars
while ((pend - message) > MAX_MESSAGE_LENGTH) {
--pend;
while (!START_OF_UTF8_CHAR(*pend)) --pend;
};
// At this point, we have the proper cut point. Use it
uint8_t maxLen = pend - message;
strncpy(lcd_status_message, message, maxLen);
lcd_status_message[maxLen] = '\0';
lcd_finishstatus(persist);
}
@ -5421,7 +5418,26 @@ void lcd_setstatusPGM(const char * const message, int8_t level) {
if (level < 0) level = lcd_status_message_level = 0;
if (level < lcd_status_message_level) return;
lcd_status_message_level = level;
strncpy_P(lcd_status_message, message, MAX_MESSAGE_LENGTH);
// Here we have a problem. The message is encoded in UTF8, so
// arbitrarily cutting it will be a problem. We MUST be sure
// that there is no cutting in the middle of a multibyte character!
// Get a pointer to the null terminator
const char* pend = message + strlen_P(message);
// If length of supplied UTF8 string is greater than
// our buffer size, start cutting whole UTF8 chars
while ((pend - message) > MAX_MESSAGE_LENGTH) {
--pend;
while (!START_OF_UTF8_CHAR(pgm_read_byte(pend))) --pend;
};
// At this point, we have the proper cut point. Use it
uint8_t maxLen = pend - message;
strncpy_P(lcd_status_message, message, maxLen);
lcd_status_message[maxLen] = '\0';
lcd_finishstatus(level > 0);
}

16
Marlin/src/lcd/ultralcd_impl_DOGM.h
View file

@ -341,9 +341,9 @@ void lcd_kill_screen() {
lcd_moveto(0, h4 * 1);
lcd_put_u8str(lcd_status_message);
lcd_moveto(0, h4 * 2);
lcd_put_u8str_rom(PSTR(MSG_HALTED));
lcd_put_u8str_P(PSTR(MSG_HALTED));
lcd_moveto(0, h4 * 3);
lcd_put_u8str_rom(PSTR(MSG_PLEASE_RESET));
lcd_put_u8str_P(PSTR(MSG_PLEASE_RESET));
} while (u8g.nextPage());
}
@ -415,7 +415,7 @@ void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
int8_t pad = (LCD_WIDTH - utf8_strlen_P(pstr)) / 2;
while (--pad >= 0) { lcd_put_wchar(' '); n--; }
}
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
if (NULL != valstr) {
n -= lcd_put_u8str_max(valstr, n);
}
@ -431,7 +431,7 @@ void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
if (lcd_implementation_mark_as_selected(row, isSelected)) {
uint8_t n = LCD_WIDTH - (START_COL) - 2;
n *= DOG_CHAR_WIDTH;
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
while (n - DOG_CHAR_WIDTH > 0) { n -= lcd_put_wchar(' '); }
lcd_moveto(LCD_PIXEL_WIDTH - (DOG_CHAR_WIDTH), row_y2);
lcd_put_wchar(post_char);
@ -451,11 +451,11 @@ void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
const uint8_t vallen = (pgm ? utf8_strlen_P(data) : utf8_strlen((char*)data));
uint8_t n = LCD_WIDTH - (START_COL) - 2 - vallen;
n *= DOG_CHAR_WIDTH;
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
lcd_put_wchar(':');
while (n - DOG_CHAR_WIDTH > 0) { n -= lcd_put_wchar(' '); }
lcd_moveto(LCD_PIXEL_WIDTH - (DOG_CHAR_WIDTH) * vallen, row_y2);
if (pgm) lcd_put_u8str_rom(data); else lcd_put_u8str((char*)data);
if (pgm) lcd_put_u8str_P(data); else lcd_put_u8str((char*)data);
}
}
@ -499,7 +499,7 @@ void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
bool onpage = PAGE_CONTAINS(baseline + 1 - (DOG_CHAR_HEIGHT_EDIT), baseline);
if (onpage) {
lcd_moveto(0, baseline);
lcd_put_u8str_rom(pstr);
lcd_put_u8str_P(pstr);
}
if (value != NULL) {
@ -641,7 +641,7 @@ void lcd_implementation_clear() { } // Automatically cleared by Picture Loop
if (!isnan(ubl.z_values[x_plot][y_plot]))
lcd_put_u8str(ftostr43sign(ubl.z_values[x_plot][y_plot]));
else
lcd_put_u8str_rom(PSTR(" -----"));
lcd_put_u8str_P(PSTR(" -----"));
}
}

170
Marlin/src/lcd/ultralcd_impl_HD44780.h
View file

@ -347,26 +347,51 @@ void lcd_implementation_clear() { lcd.clear(); }
}
// Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line
void lcd_scroll(const int16_t col, const int16_t line, const char* const text, const int16_t len, const int16_t time) {
#if 1
lcd_put_u8str(text);
#else
char tmp[LCD_WIDTH + 1] = {0};
int16_t n = MAX(utf8_strlen_P(text) - len, 0);
for (int16_t i = 0; i <= n; i++) {
utf8_strncpy_p(tmp, text + i, MIN(len, LCD_WIDTH));
void lcd_scroll(const uint8_t col, const uint8_t line, const char* const text, const uint8_t len, const int16_t time) {
uint8_t slen = utf8_strlen_P(text);
if (slen < len) {
// Fits into,
lcd_moveto(col, line);
lcd_put_u8str(tmp);
delay(time / MAX(n, 1));
lcd_put_u8str_max_P(text, len);
while (slen < len) {
lcd_put_wchar(' ');
++slen;
}
safe_delay(time);
}
else {
const char* p = text;
int dly = time / MAX(slen, 1);
for (uint8_t i = 0; i <= slen; i++) {
// Go to the correct place
lcd_moveto(col, line);
// Print the text
lcd_put_u8str_max_P(p, len);
// Fill with spaces
uint8_t ix = slen - i;
while (ix < len) {
lcd_put_wchar(' ');
++ix;
}
// Delay
safe_delay(dly);
// Advance to the next UTF8 valid position
p++;
while (!START_OF_UTF8_CHAR(pgm_read_byte(p))) p++;
}
}
#endif
}
static void logo_lines(const char* const extra) {
int16_t indent = (LCD_WIDTH - 8 - utf8_strlen_P(extra)) / 2;
lcd_moveto(indent, 0); lcd_put_wchar('\x00'); lcd_put_u8str_rom(PSTR( "------" )); lcd_put_wchar('\x01');
lcd_moveto(indent, 1); lcd_put_u8str_rom(PSTR("|Marlin|")); lcd_put_u8str_rom(extra);
lcd_moveto(indent, 2); lcd_put_wchar('\x02'); lcd_put_u8str_rom(PSTR( "------" )); lcd_put_wchar('\x03');
lcd_moveto(indent, 0); lcd_put_wchar('\x00'); lcd_put_u8str_P(PSTR( "------" )); lcd_put_wchar('\x01');
lcd_moveto(indent, 1); lcd_put_u8str_P(PSTR("|Marlin|")); lcd_put_u8str_P(extra);
lcd_moveto(indent, 2); lcd_put_wchar('\x02'); lcd_put_u8str_P(PSTR( "------" )); lcd_put_wchar('\x03');
}
void lcd_bootscreen() {
@ -379,7 +404,7 @@ void lcd_implementation_clear() { lcd.clear(); }
lcd_erase_line(3); \
if (utf8_strlen(STRING) <= LCD_WIDTH) { \
lcd_moveto((LCD_WIDTH - utf8_strlen_P(PSTR(STRING))) / 2, 3); \
lcd_put_u8str_rom(PSTR(STRING)); \
lcd_put_u8str_P(PSTR(STRING)); \
safe_delay(DELAY); \
} \
else { \
@ -452,10 +477,10 @@ void lcd_kill_screen() {
lcd_moveto(0, 2);
#else
lcd_moveto(0, 2);
lcd_put_u8str_rom(PSTR(MSG_HALTED));
lcd_put_u8str_P(PSTR(MSG_HALTED));
lcd_moveto(0, 3);
#endif
lcd_put_u8str_rom(PSTR(MSG_PLEASE_RESET));
lcd_put_u8str_P(PSTR(MSG_PLEASE_RESET));
}
//
@ -473,7 +498,7 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
else {
#if DISABLED(HOME_AFTER_DEACTIVATE) && DISABLED(DISABLE_REDUCED_ACCURACY_WARNING)
if (!axis_known_position[axis])
lcd_put_u8str_rom(axis == Z_AXIS ? PSTR(" ") : PSTR(" "));
lcd_put_u8str_P(axis == Z_AXIS ? PSTR(" ") : PSTR(" "));
else
#endif
lcd_put_u8str(value);
@ -634,11 +659,11 @@ static void lcd_implementation_status_screen() {
#if ENABLED(SDSUPPORT)
lcd_moveto(0, 2);
lcd_put_u8str_rom(PSTR("SD"));
lcd_put_u8str_P(PSTR("SD"));
if (IS_SD_PRINTING)
lcd_put_u8str(itostr3(card.percentDone()));
else
lcd_put_u8str_rom(PSTR("---"));
lcd_put_u8str_P(PSTR("---"));
lcd_put_wchar('%');
#endif // SDSUPPORT
@ -698,11 +723,11 @@ static void lcd_implementation_status_screen() {
#if LCD_WIDTH >= 20 && ENABLED(SDSUPPORT)
lcd_moveto(7, 2);
lcd_put_u8str_rom(PSTR("SD"));
lcd_put_u8str_P(PSTR("SD"));
if (IS_SD_PRINTING)
lcd_put_u8str(itostr3(card.percentDone()));
else
lcd_put_u8str_rom(PSTR("---"));
lcd_put_u8str_P(PSTR("---"));
lcd_put_wchar('%');
#endif // LCD_WIDTH >= 20 && SDSUPPORT
@ -739,9 +764,9 @@ static void lcd_implementation_status_screen() {
// Show Filament Diameter and Volumetric Multiplier %
// After allowing lcd_status_message to show for 5 seconds
if (ELAPSED(millis(), previous_lcd_status_ms + 5000UL)) {
lcd_put_u8str_rom(PSTR("Dia "));
lcd_put_u8str_P(PSTR("Dia "));
lcd_put_u8str(ftostr12ns(filament_width_meas));
lcd_put_u8str_rom(PSTR(" V"));
lcd_put_u8str_P(PSTR(" V"));
lcd_put_u8str(itostr3(100.0 * (
parser.volumetric_enabled
? planner.volumetric_area_nominal / planner.volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM]
@ -756,35 +781,76 @@ static void lcd_implementation_status_screen() {
#if ENABLED(STATUS_MESSAGE_SCROLLING)
static bool last_blink = false;
const uint8_t slen = utf8_strlen(lcd_status_message);
const char *stat = lcd_status_message + status_scroll_pos;
if (slen <= LCD_WIDTH)
lcd_put_u8str(stat); // The string isn't scrolling
else {
if (status_scroll_pos <= slen - LCD_WIDTH)
lcd_put_u8str(stat); // The string fills the screen
else {
uint8_t chars = LCD_WIDTH;
if (status_scroll_pos < slen) { // First string still visible
lcd_put_u8str(stat); // The string leaves space
chars -= slen - status_scroll_pos; // Amount of space left
// Get the UTF8 character count of the string
uint8_t slen = utf8_strlen(lcd_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(lcd_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
const char *stat = lcd_status_message + status_scroll_offset;
// Get the string remaining length
const uint8_t rlen = utf8_strlen(stat);
// If we have enough characters to display
if (rlen >= LCD_WIDTH) {
// The remaining string fills the screen - Print it
lcd_put_u8str_max(stat, LCD_WIDTH);
}
else {
// The remaining string does not completely fill the screen
lcd_put_u8str_max(stat, LCD_WIDTH); // The string leaves space
uint8_t chars = LCD_WIDTH - rlen; // Amount of space left in characters
lcd_put_wchar('.'); // Always at 1+ spaces left, draw a dot
if (--chars) {
if (status_scroll_pos < slen + 1) // Draw a second dot if there's space
--chars, lcd_put_wchar('.');
if (chars) lcd_put_u8str_max(lcd_status_message, chars); // Print a second copy of the message
if (--chars) { // Draw a second dot if there's space
lcd_put_wchar('.');
if (--chars)
lcd_put_u8str_max(lcd_status_message, chars); // Print a second copy of the message
}
}
if (last_blink != blink) {
last_blink = blink;
// Skip any non-printing bytes
if (status_scroll_pos < slen) while (!PRINTABLE(lcd_status_message[status_scroll_pos])) status_scroll_pos++;
if (++status_scroll_pos >= slen + 2) status_scroll_pos = 0;
// Adjust by complete UTF8 characters
if (status_scroll_offset < slen) {
status_scroll_offset++;
while (!START_OF_UTF8_CHAR(lcd_status_message[status_scroll_offset]))
status_scroll_offset++;
}
else
status_scroll_offset = 0;
}
}
#else
lcd_put_u8str(lcd_status_message);
UNUSED(blink);
// Get the UTF8 character count of the string
uint8_t slen = utf8_strlen(lcd_status_message);
// Just print the string to the LCD
lcd_put_u8str_max(lcd_status_message, LCD_WIDTH);
// Fill the rest with spaces if there are missing spaces
while (slen < LCD_WIDTH) {
lcd_put_wchar(' ');
++slen;
}
#endif
}
@ -809,7 +875,7 @@ static void lcd_implementation_status_screen() {
int8_t pad = (LCD_WIDTH - utf8_strlen_P(pstr)) / 2;
while (--pad >= 0) { lcd_put_wchar(' '); n--; }
}
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
if (valstr) n -= lcd_put_u8str_max(valstr, n);
for (; n > 0; --n) lcd_put_wchar(' ');
}
@ -818,7 +884,7 @@ static void lcd_implementation_status_screen() {
uint8_t n = LCD_WIDTH - 2;
lcd_moveto(0, row);
lcd_put_wchar(sel ? pre_char : ' ');
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
while (n--) lcd_put_wchar(' ');
lcd_put_wchar(post_char);
}
@ -827,7 +893,7 @@ static void lcd_implementation_status_screen() {
uint8_t n = LCD_WIDTH - 2 - utf8_strlen(data);
lcd_moveto(0, row);
lcd_put_wchar(sel ? pre_char : ' ');
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
lcd_put_wchar(':');
while (n--) lcd_put_wchar(' ');
lcd_put_u8str(data);
@ -836,10 +902,10 @@ static void lcd_implementation_status_screen() {
uint8_t n = LCD_WIDTH - 2 - utf8_strlen_P(data);
lcd_moveto(0, row);
lcd_put_wchar(sel ? pre_char : ' ');
n -= lcd_put_u8str_max_rom(pstr, n);
n -= lcd_put_u8str_max_P(pstr, n);
lcd_put_wchar(':');
while (n--) lcd_put_wchar(' ');
lcd_put_u8str_rom(data);
lcd_put_u8str_P(data);
}
#define DRAWMENU_SETTING_EDIT_GENERIC(_src) lcd_implementation_drawmenu_setting_edit_generic(sel, row, pstr, '>', _src)
@ -847,7 +913,7 @@ static void lcd_implementation_status_screen() {
void lcd_implementation_drawedit(const char* pstr, const char* const value=NULL) {
lcd_moveto(1, 1);
lcd_put_u8str_rom(pstr);
lcd_put_u8str_P(pstr);
if (value != NULL) {
lcd_put_wchar(':');
int len = utf8_strlen(value);
@ -1293,7 +1359,7 @@ static void lcd_implementation_status_screen() {
if (!isnan(ubl.z_values[x][inverted_y]))
lcd_put_u8str(ftostr43sign(ubl.z_values[x][inverted_y]));
else
lcd_put_u8str_rom(PSTR(" -----"));
lcd_put_u8str_P(PSTR(" -----"));
#else // 16x4 or 20x4 display
@ -1312,7 +1378,7 @@ static void lcd_implementation_status_screen() {
if (!isnan(ubl.z_values[x][inverted_y]))
lcd_put_u8str(ftostr43sign(ubl.z_values[x][inverted_y]));
else
lcd_put_u8str_rom(PSTR(" -----"));
lcd_put_u8str_P(PSTR(" -----"));
#endif // LCD_HEIGHT > 3
}

16
frameworks/CMSIS/LPC1768/lib/usb/usbhw.cpp
View file

@ -563,8 +563,7 @@ uint32_t USB_DMA_Status (uint32_t EPNum) {
uint32_t ptr, val;
ptr = UDCA[EPAdr(EPNum)]; /* Current Descriptor */
if (ptr == 0)
return (USB_DMA_INVALID);
if (ptr == 0) return (USB_DMA_INVALID);
val = *((uint32_t *)(ptr + 3*4)); /* Status Information */
switch ((val >> 1) & 0x0F) {
@ -596,13 +595,8 @@ uint32_t USB_DMA_Status (uint32_t EPNum) {
uint32_t USB_DMA_BufAdr (uint32_t EPNum) {
uint32_t ptr, val;
ptr = UDCA[EPAdr(EPNum)]; /* Current Descriptor */
if (ptr == 0)
{
return ((uint32_t)(-1)); /* DMA Invalid */
}
if (ptr == 0) return ((uint32_t)(-1)); /* DMA Invalid */
val = *((uint32_t *)(ptr + 2*4)); /* Buffer Address */
return (val); /* Current Address */
}
@ -619,12 +613,8 @@ uint32_t USB_DMA_BufAdr (uint32_t EPNum) {
uint32_t USB_DMA_BufCnt (uint32_t EPNum) {
uint32_t ptr, val;
ptr = UDCA[EPAdr(EPNum)]; /* Current Descriptor */
if (ptr == 0)
{
return ((uint32_t)(-1)); /* DMA Invalid */
}
if (ptr == 0) return ((uint32_t)(-1)); /* DMA Invalid */
val = *((uint32_t *)(ptr + 3*4)); /* Status Information */
return (val >> 16); /* Current Count */
}