uGFX/ugfx
2
0
Fork 0
Code Issues 2 Pull requests Projects Releases Wiki Activity

Backport GDISP low level drivers to GLCD

Browse source 
see GLCD/readme.txt
This commit is contained in:
Andrew Hannam 2012-08-06 11:30:02 +10:00
parent 9a0521a85e
commit 34075031de
13 changed files with 1238 additions and 2395 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
glcd/console.c
View file

@ -20,7 +20,6 @@
#include "ch.h" #include "ch.h"
#include "fonts.h"
#include "glcd.h" #include "glcd.h"
#include "console.h" #include "console.h"
@ -80,7 +79,7 @@ static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t time) {
return 0; return 0;
} }
static chnflags_t getflags(void *ip) { static uint16_t getflags(void *ip) {
_chn_get_and_clear_flags_impl(ip); _chn_get_and_clear_flags_impl(ip);
} }
@ -98,7 +97,7 @@ msg_t lcdConsoleInit(GLCDConsole *console, uint16_t x0, uint16_t y0, uint16_t wi
console->vmt = &vmt; console->vmt = &vmt;
/* read font, get height */ /* read font, get height */
console->fy = font[FONT_TABLE_HEIGHT_IDX]; console->fy = lcdGetFontHeight(font);
/* calculate the size of the console as an integer multiple of characters height*/ /* calculate the size of the console as an integer multiple of characters height*/
console->sx = width; console->sx = width;
@ -115,6 +114,7 @@ msg_t lcdConsoleInit(GLCDConsole *console, uint16_t x0, uint16_t y0, uint16_t wi
console->font = font; console->font = font;
lcdFillArea(x0, y0, x0+width, y0+height, console->bkcolor); lcdFillArea(x0, y0, x0+width, y0+height, console->bkcolor);
return RDY_OK;
} }
msg_t lcdConsolePut(GLCDConsole *console, char c) { msg_t lcdConsolePut(GLCDConsole *console, char c) {
@ -157,7 +157,7 @@ msg_t lcdConsolePut(GLCDConsole *console, char c) {
/* update cursor */ /* update cursor */
console->cx += width; console->cx += width;
} }
return RDY_OK;
} }
msg_t lcdConsoleWrite(GLCDConsole *console, uint8_t *bp, size_t n) { msg_t lcdConsoleWrite(GLCDConsole *console, uint8_t *bp, size_t n) {

767
glcd/fonts.c
View file

@ -1,767 +0,0 @@
/*
ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver 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.
ChibiOS-LCD-Driver 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 <http://www.gnu.org/licenses/>.
*/
#include "fonts.h"
#if 1 // font_Small - for side buttons
//
// Medium bold font, height = 11 (including the decenders)
// The font table contains 3 sections: Header, Table Of Character Indexes, Pixel data
//
// The Header contains two bytes:
// Byte0 = Font height (including decenders)
// Byte1 = Number of additional pixels that should be drawn right of char
// Byte2 = Recommended line spacing
// Byte3 = Height of decenders
// Byte4 = Unused byte
//
// The Table Of Character Indexes, is a table of 2 byte words that index to the pixel data within this table
// Word0 = Index into this table to the pixels for ASCII char 0x20
// Word1 = Index into this table to the pixels for ASCII char 0x21
// Word2 = Index into this table to the pixels for ASCII char 0x22
// ...
// Word95 = Index into this table to the pixels for ASCII char 0x7F
//
// The Pixel data table contains the bitmap for each character
// Data is written in columns of pixels, each column is 16 bits (2 bytes)
// Byte0 = width of the ASCII 0x20 character in pixels
// Byte1 = pixel data for the 0x20 char's 1st top column, bit 0 is the top pixel, bit 7 is the 8th pixel down from the top
// Byte2 = pixel data for the 0x20 char's 1st bottom column, bit 0 is the 9th pixel
// Byte5 = pixel data for the 0x20 char's 2nd top column
// Byte6 = pixel data for the 0x20 char's 2nd bottom column
// ... = remaining pairs of bytes of the columns in the 0x20 char
// ... = width of the 0x21 char in pixels
// ... = pixel data for the 0x21 char
// ...
//
const uint8_t font_Small[] = {
0x0B, 0x00, 0x0E, 0x02, 0x00,
0xC5, 0x00, 0xCE, 0x00, 0xD5, 0x00, 0xE2, 0x00, 0xF3, 0x00, 0x02, 0x01,
0x15, 0x01, 0x24, 0x01, 0x2B, 0x01, 0x34, 0x01, 0x3D, 0x01, 0x48, 0x01,
0x57, 0x01, 0x60, 0x01, 0x69, 0x01, 0x70, 0x01, 0x7D, 0x01, 0x8C, 0x01,
0x9B, 0x01, 0xAA, 0x01, 0xB9, 0x01, 0xC8, 0x01, 0xD7, 0x01, 0xE6, 0x01,
0xF5, 0x01, 0x04, 0x02, 0x13, 0x02, 0x1A, 0x02, 0x23, 0x02, 0x30, 0x02,
0x3F, 0x02, 0x4C, 0x02, 0x5B, 0x02, 0x74, 0x02, 0x85, 0x02, 0x94, 0x02,
0xA5, 0x02, 0xB6, 0x02, 0xC5, 0x02, 0xD4, 0x02, 0xE5, 0x02, 0xF6, 0x02,
0xFD, 0x02, 0x08, 0x03, 0x19, 0x03, 0x28, 0x03, 0x3B, 0x03, 0x4C, 0x03,
0x5D, 0x03, 0x6E, 0x03, 0x7F, 0x03, 0x90, 0x03, 0x9F, 0x03, 0xAE, 0x03,
0xBF, 0x03, 0xD0, 0x03, 0xE9, 0x03, 0xFA, 0x03, 0x0B, 0x04, 0x1C, 0x04,
0x25, 0x04, 0x32, 0x04, 0x3B, 0x04, 0x4A, 0x04, 0x59, 0x04, 0x62, 0x04,
0x71, 0x04, 0x80, 0x04, 0x8F, 0x04, 0x9E, 0x04, 0xAD, 0x04, 0xB6, 0x04,
0xC5, 0x04, 0xD4, 0x04, 0xDB, 0x04, 0xE2, 0x04, 0xF1, 0x04, 0xF8, 0x04,
0x0B, 0x05, 0x1A, 0x05, 0x29, 0x05, 0x38, 0x05, 0x47, 0x05, 0x50, 0x05,
0x5D, 0x05, 0x66, 0x05, 0x75, 0x05, 0x84, 0x05, 0x97, 0x05, 0xA4, 0x05,
0xB1, 0x05, 0xBE, 0x05, 0xC9, 0x05, 0xD0, 0x05, 0xDB, 0x05, 0xEC, 0x05,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
0x7F, 0x01, 0x7F, 0x01, 0x06, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
0x00, 0x07, 0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x44, 0x00, 0xFF, 0x01,
0xFF, 0x01, 0x44, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x44, 0x00, 0x07, 0x00,
0x00, 0x8C, 0x00, 0x9E, 0x01, 0xFF, 0x03, 0xFF, 0x03, 0xE6, 0x01, 0xC4,
0x00, 0x09, 0x00, 0x00, 0x82, 0x00, 0xC7, 0x00, 0x65, 0x00, 0xB7, 0x00,
0xDA, 0x01, 0x4C, 0x01, 0xC6, 0x01, 0x82, 0x00, 0x07, 0x00, 0x00, 0xE6,
0x00, 0xFF, 0x01, 0x3F, 0x01, 0xE6, 0x01, 0xE0, 0x01, 0x20, 0x01, 0x03,
0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x04, 0x00, 0x00, 0xFE, 0x03, 0xFF,
0x07, 0x01, 0x04, 0x04, 0x00, 0x00, 0x01, 0x04, 0xFF, 0x07, 0xFE, 0x03,
0x05, 0x00, 0x00, 0x0A, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x0A, 0x00, 0x07,
0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0x20, 0x00,
0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x04,
0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00,
0x01, 0x00, 0x01, 0x06, 0x00, 0x00, 0x80, 0x01, 0xE0, 0x01, 0x78, 0x00,
0x1F, 0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0xFE, 0x00, 0xFF, 0x01, 0x01,
0x01, 0x01, 0x01, 0xFF, 0x01, 0xFE, 0x00, 0x07, 0x00, 0x00, 0x02, 0x00,
0x02, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00,
0x00, 0x82, 0x01, 0xC3, 0x01, 0x61, 0x01, 0x31, 0x01, 0x1F, 0x01, 0x0E,
0x01, 0x07, 0x00, 0x00, 0x82, 0x00, 0x83, 0x01, 0x11, 0x01, 0x11, 0x01,
0xFF, 0x01, 0xEE, 0x00, 0x07, 0x00, 0x00, 0x60, 0x00, 0x78, 0x00, 0x5E,
0x00, 0xFF, 0x01, 0xFF, 0x01, 0x40, 0x00, 0x07, 0x00, 0x00, 0x9F, 0x00,
0x9F, 0x01, 0x09, 0x01, 0x09, 0x01, 0xF9, 0x01, 0xF1, 0x00, 0x07, 0x00,
0x00, 0xFE, 0x00, 0xFF, 0x01, 0x11, 0x01, 0x11, 0x01, 0xF3, 0x01, 0xE2,
0x00, 0x07, 0x00, 0x00, 0x01, 0x00, 0xC1, 0x01, 0xF1, 0x01, 0x3D, 0x00,
0x0F, 0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0xEE, 0x00, 0xFF, 0x01, 0x11,
0x01, 0x11, 0x01, 0xFF, 0x01, 0xEE, 0x00, 0x07, 0x00, 0x00, 0x8E, 0x00,
0x9F, 0x01, 0x11, 0x01, 0x11, 0x01, 0xFF, 0x01, 0xFE, 0x00, 0x03, 0x00,
0x00, 0x08, 0x01, 0x08, 0x01, 0x04, 0x00, 0x00, 0x00, 0x02, 0x08, 0x03,
0x08, 0x01, 0x06, 0x00, 0x00, 0x20, 0x00, 0x70, 0x00, 0xD8, 0x00, 0x8C,
0x01, 0x04, 0x01, 0x07, 0x00, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00,
0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x06, 0x00, 0x00, 0x04, 0x01, 0x8C,
0x01, 0xD8, 0x00, 0x70, 0x00, 0x20, 0x00, 0x07, 0x00, 0x00, 0x02, 0x00,
0x03, 0x00, 0x61, 0x01, 0x71, 0x01, 0x1F, 0x00, 0x0E, 0x00, 0x0C, 0x00,
0x00, 0x78, 0x00, 0xFE, 0x01, 0x86, 0x01, 0x33, 0x03, 0x79, 0x02, 0x49,
0x02, 0x79, 0x02, 0x7B, 0x02, 0x46, 0x02, 0x7E, 0x00, 0x78, 0x00, 0x08,
0x80, 0x01, 0xF0, 0x01, 0x7C, 0x00, 0x4F, 0x00, 0x4F, 0x00, 0x7C, 0x00,
0xF0, 0x01, 0x80, 0x01, 0x07, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x11,
0x01, 0x11, 0x01, 0xFF, 0x01, 0xEE, 0x00, 0x08, 0x00, 0x00, 0xFE, 0x00,
0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x83, 0x01, 0x82, 0x00,
0x08, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x83,
0x01, 0xFE, 0x00, 0x7C, 0x00, 0x07, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01,
0x11, 0x01, 0x11, 0x01, 0x11, 0x01, 0x01, 0x01, 0x07, 0x00, 0x00, 0xFF,
0x01, 0xFF, 0x01, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x01, 0x00, 0x08,
0x00, 0x00, 0xFE, 0x00, 0xFF, 0x01, 0x01, 0x01, 0x11, 0x01, 0x91, 0x01,
0xF3, 0x01, 0xF2, 0x01, 0x08, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x10,
0x00, 0x10, 0x00, 0x10, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x03, 0x00, 0x00,
0xFF, 0x01, 0xFF, 0x01, 0x05, 0xC0, 0x00, 0xC0, 0x01, 0x00, 0x01, 0xFF,
0x01, 0xFF, 0x00, 0x08, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x3C, 0x00,
0x66, 0x00, 0xC3, 0x00, 0x81, 0x01, 0x00, 0x01, 0x07, 0x00, 0x00, 0xFF,
0x01, 0xFF, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x09,
0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x3C, 0x00, 0xF0, 0x00, 0xF0, 0x00,
0x3C, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x08, 0x00, 0x00, 0xFF, 0x01, 0xFF,
0x01, 0x1E, 0x00, 0x38, 0x00, 0xE0, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x08,
0x00, 0x00, 0xFE, 0x00, 0xFF, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0xFF, 0x01, 0xFE, 0x00, 0x08, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x11,
0x00, 0x11, 0x00, 0x11, 0x00, 0x1F, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x00,
0xFE, 0x00, 0xFF, 0x01, 0x01, 0x01, 0x41, 0x01, 0xC1, 0x01, 0xFF, 0x03,
0xFE, 0x02, 0x08, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x11, 0x00, 0x11,
0x00, 0x11, 0x00, 0xFF, 0x01, 0xEE, 0x01, 0x07, 0x00, 0x00, 0x8E, 0x00,
0x9F, 0x01, 0x11, 0x01, 0x11, 0x01, 0xF3, 0x01, 0xE2, 0x00, 0x07, 0x00,
0x00, 0x01, 0x00, 0x01, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x01, 0x00, 0x01,
0x00, 0x08, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x01, 0x00, 0x01, 0x00, 0x01,
0x00, 0x01, 0xFF, 0x01, 0xFF, 0x00, 0x08, 0x03, 0x00, 0x1F, 0x00, 0x7C,
0x00, 0xE0, 0x01, 0xE0, 0x01, 0x7C, 0x00, 0x1F, 0x00, 0x03, 0x00, 0x0C,
0x03, 0x00, 0x1F, 0x00, 0x7C, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0x7C, 0x00,
0x7C, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0x7C, 0x00, 0x1F, 0x00, 0x03, 0x00,
0x08, 0x83, 0x01, 0xC7, 0x01, 0x6C, 0x00, 0x38, 0x00, 0x38, 0x00, 0x6C,
0x00, 0xC7, 0x01, 0x83, 0x01, 0x08, 0x03, 0x00, 0x07, 0x00, 0x0C, 0x00,
0xF8, 0x01, 0xF8, 0x01, 0x0C, 0x00, 0x07, 0x00, 0x03, 0x00, 0x08, 0x81,
0x01, 0xC1, 0x01, 0x61, 0x01, 0x31, 0x01, 0x19, 0x01, 0x0D, 0x01, 0x07,
0x01, 0x03, 0x01, 0x04, 0x00, 0x00, 0xFF, 0x07, 0xFF, 0x07, 0x01, 0x04,
0x06, 0x00, 0x00, 0x07, 0x00, 0x1F, 0x00, 0x78, 0x00, 0xE0, 0x01, 0x80,
0x01, 0x04, 0x00, 0x00, 0x01, 0x04, 0xFF, 0x07, 0xFF, 0x07, 0x07, 0x00,
0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x01, 0x00, 0x03, 0x00, 0x02,
0x00, 0x07, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04,
0x00, 0x04, 0x00, 0x04, 0x04, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x02,
0x00, 0x07, 0x00, 0x00, 0xC0, 0x00, 0xE8, 0x01, 0x28, 0x01, 0x28, 0x01,
0xF8, 0x01, 0xF0, 0x01, 0x07, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x08,
0x01, 0x08, 0x01, 0xF8, 0x01, 0xF0, 0x00, 0x07, 0x00, 0x00, 0xF0, 0x00,
0xF8, 0x01, 0x08, 0x01, 0x08, 0x01, 0x98, 0x01, 0x90, 0x00, 0x07, 0x00,
0x00, 0xF0, 0x00, 0xF8, 0x01, 0x08, 0x01, 0x08, 0x01, 0xFF, 0x01, 0xFF,
0x01, 0x07, 0x00, 0x00, 0xF0, 0x00, 0xF8, 0x01, 0x28, 0x01, 0x28, 0x01,
0xB8, 0x01, 0xB0, 0x00, 0x04, 0x00, 0x00, 0xFE, 0x01, 0xFF, 0x01, 0x09,
0x00, 0x07, 0x00, 0x00, 0xF0, 0x04, 0xF8, 0x05, 0x08, 0x05, 0x08, 0x05,
0xF8, 0x07, 0xF8, 0x03, 0x07, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x18,
0x00, 0x08, 0x00, 0xF8, 0x01, 0xF0, 0x01, 0x03, 0x00, 0x00, 0xF9, 0x01,
0xF9, 0x01, 0x03, 0x00, 0x00, 0xF9, 0x07, 0xF9, 0x07, 0x07, 0x00, 0x00,
0xFF, 0x01, 0xFF, 0x01, 0x70, 0x00, 0xD8, 0x00, 0x88, 0x01, 0x00, 0x01,
0x03, 0x00, 0x00, 0xFF, 0x01, 0xFF, 0x01, 0x09, 0x00, 0x00, 0xF8, 0x01,
0xF8, 0x01, 0x08, 0x00, 0xF8, 0x01, 0xF8, 0x01, 0x08, 0x00, 0xF8, 0x01,
0xF0, 0x01, 0x07, 0x00, 0x00, 0xF8, 0x01, 0xF8, 0x01, 0x18, 0x00, 0x08,
0x00, 0xF8, 0x01, 0xF0, 0x01, 0x07, 0x00, 0x00, 0xF0, 0x00, 0xF8, 0x01,
0x08, 0x01, 0x08, 0x01, 0xF8, 0x01, 0xF0, 0x00, 0x07, 0x00, 0x00, 0xF8,
0x07, 0xF8, 0x07, 0x08, 0x01, 0x08, 0x01, 0xF8, 0x01, 0xF0, 0x00, 0x07,
0x00, 0x00, 0xF0, 0x00, 0xF8, 0x01, 0x08, 0x01, 0x08, 0x01, 0xF8, 0x07,
0xF8, 0x07, 0x04, 0x00, 0x00, 0xF8, 0x01, 0xF8, 0x01, 0x08, 0x00, 0x06,
0x00, 0x00, 0x90, 0x00, 0xB8, 0x01, 0x68, 0x01, 0xD8, 0x01, 0x90, 0x00,
0x04, 0x00, 0x00, 0xFE, 0x00, 0xFE, 0x01, 0x08, 0x01, 0x07, 0x00, 0x00,
0xF8, 0x00, 0xF8, 0x01, 0x00, 0x01, 0x80, 0x01, 0xF8, 0x01, 0xF8, 0x01,
0x07, 0x00, 0x00, 0x18, 0x00, 0x78, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0x78,
0x00, 0x18, 0x00, 0x09, 0x00, 0x00, 0x78, 0x00, 0xF8, 0x01, 0xE0, 0x01,
0x78, 0x00, 0x78, 0x00, 0xE0, 0x01, 0xF8, 0x01, 0x78, 0x00, 0x06, 0x00,
0x00, 0x98, 0x01, 0xF8, 0x01, 0x60, 0x00, 0xF8, 0x01, 0x98, 0x01, 0x06,
0x00, 0x04, 0x78, 0x04, 0xF8, 0x07, 0x80, 0x03, 0xF8, 0x00, 0x78, 0x00,
0x06, 0x00, 0x00, 0x88, 0x01, 0xC8, 0x01, 0x68, 0x01, 0x38, 0x01, 0x18,
0x01, 0x05, 0x00, 0x00, 0x10, 0x00, 0xFF, 0x01, 0xEF, 0x03, 0x00, 0x02,
0x03, 0x00, 0x00, 0xFF, 0x03, 0xFF, 0x03, 0x05, 0x00, 0x00, 0x00, 0x02,
0xEF, 0x03, 0xFF, 0x01, 0x10, 0x00, 0x08, 0x00, 0x00, 0x04, 0x00, 0x06,
0x00, 0x02, 0x00, 0x06, 0x00, 0x04, 0x00, 0x06, 0x00, 0x02, 0x00, 0x04,
0x00, 0x00, 0xFE, 0x03, 0xFE, 0x03, 0xFE, 0x03
};
#endif
#if 1 // font_Larger (Tahoma, 11Bold)
//
// Medium bold font, height = 11 (including the decenders)
// The font table contains 3 sections: Header, Table Of Character Indexes, Pixel data
//
// The Header contains two bytes:
// Byte0 = Font height (including decenders)
// Byte1 = Number of additional pixels that should be drawn right of char
// Byte2 = Recommended line spacing
// Byte3 = Height of decenders
// Byte4 = Unused byte
//
// The Table Of Character Indexes, is a table of 2 byte words that index to the pixel data within this table
// Word0 = Index into this table to the pixels for ASCII char 0x20
// Word1 = Index into this table to the pixels for ASCII char 0x21
// Word2 = Index into this table to the pixels for ASCII char 0x22
// ...
// Word95 = Index into this table to the pixels for ASCII char 0x7F
//
// The Pixel data table contains the bitmap for each character
// Data is written in columns of pixels, each column is 16 bits (2 bytes)
// Byte0 = width of the ASCII 0x20 character in pixels
// Byte1 = pixel data for the 0x20 char's 1st top column, bit 0 is the top pixel, bit 7 is the 8th pixel down from the top
// Byte2 = pixel data for the 0x20 char's 1st bottom column, bit 0 is the 9th pixel
// Byte5 = pixel data for the 0x20 char's 2nd top column
// Byte6 = pixel data for the 0x20 char's 2nd bottom column
// ... = remaining pairs of bytes of the columns in the 0x20 char
// ... = width of the 0x21 char in pixels
// ... = pixel data for the 0x21 char
// ...
//
const uint8_t font_Larger[] = {
0x0C, 0x01, 0x0D, 0x02, 0x00,
0xC5, 0x00, 0xCE, 0x00, 0xD5, 0x00, 0xE0, 0x00, 0xF1, 0x00, 0x00, 0x01,
0x1B, 0x01, 0x2C, 0x01, 0x31, 0x01, 0x3A, 0x01, 0x43, 0x01, 0x52, 0x01,
0x63, 0x01, 0x6A, 0x01, 0x73, 0x01, 0x7A, 0x01, 0x85, 0x01, 0x94, 0x01,
0xA3, 0x01, 0xB2, 0x01, 0xC1, 0x01, 0xD0, 0x01, 0xDF, 0x01, 0xEE, 0x01,
0xFD, 0x01, 0x0C, 0x02, 0x1B, 0x02, 0x22, 0x02, 0x29, 0x02, 0x3C, 0x02,
0x4D, 0x02, 0x60, 0x02, 0x6D, 0x02, 0x80, 0x02, 0x91, 0x02, 0xA0, 0x02,
0xAF, 0x02, 0xC0, 0x02, 0xCD, 0x02, 0xD8, 0x02, 0xE7, 0x02, 0xF8, 0x02,
0x01, 0x03, 0x0C, 0x03, 0x1B, 0x03, 0x28, 0x03, 0x3D, 0x03, 0x4C, 0x03,
0x5D, 0x03, 0x6C, 0x03, 0x7D, 0x03, 0x8E, 0x03, 0x9D, 0x03, 0xAA, 0x03,
0xB9, 0x03, 0xC8, 0x03, 0xDF, 0x03, 0xEE, 0x03, 0xFB, 0x03, 0x08, 0x04,
0x11, 0x04, 0x1C, 0x04, 0x25, 0x04, 0x38, 0x04, 0x49, 0x04, 0x54, 0x04,
0x61, 0x04, 0x70, 0x04, 0x7B, 0x04, 0x8A, 0x04, 0x97, 0x04, 0xA2, 0x04,
0xB1, 0x04, 0xC0, 0x04, 0xC5, 0x04, 0xCC, 0x04, 0xD9, 0x04, 0xDE, 0x04,
0xF3, 0x04, 0x02, 0x05, 0x11, 0x05, 0x20, 0x05, 0x2F, 0x05, 0x38, 0x05,
0x43, 0x05, 0x4E, 0x05, 0x5D, 0x05, 0x6A, 0x05, 0x7F, 0x05, 0x8C, 0x05,
0x99, 0x05, 0xA4, 0x05, 0xB1, 0x05, 0xBA, 0x05, 0xC7, 0x05, 0xDA, 0x05,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
0x7E, 0x03, 0x7E, 0x03, 0x05, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
0x00, 0x07, 0x00, 0x08, 0xC0, 0x00, 0xD8, 0x03, 0xF8, 0x00, 0xDE, 0x00,
0xD8, 0x03, 0xF8, 0x00, 0xDE, 0x00, 0x18, 0x00, 0x07, 0x18, 0x01, 0x3C,
0x02, 0x64, 0x02, 0xFF, 0x0F, 0x64, 0x02, 0xC4, 0x03, 0x88, 0x01, 0x0D,
0x1C, 0x00, 0x3E, 0x00, 0x22, 0x00, 0x3E, 0x02, 0x1C, 0x01, 0xC0, 0x00,
0x20, 0x00, 0x18, 0x00, 0xC4, 0x01, 0xE2, 0x03, 0x20, 0x02, 0xE0, 0x03,
0xC0, 0x01, 0x08, 0xCC, 0x01, 0xFE, 0x03, 0x32, 0x02, 0x72, 0x02, 0xDE,
0x03, 0x8C, 0x01, 0xE0, 0x03, 0x60, 0x02, 0x02, 0x07, 0x00, 0x07, 0x00,
0x04, 0xF8, 0x01, 0xFE, 0x07, 0x07, 0x0E, 0x01, 0x08, 0x04, 0x01, 0x08,
0x07, 0x0E, 0xFE, 0x07, 0xF8, 0x01, 0x07, 0x00, 0x00, 0x0A, 0x00, 0x04,
0x00, 0x1F, 0x00, 0x1F, 0x00, 0x04, 0x00, 0x0A, 0x00, 0x08, 0x00, 0x00,
0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xFC, 0x01, 0x20, 0x00, 0x20, 0x00,
0x20, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x07, 0x04, 0x20, 0x00,
0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
0x03, 0x05, 0x00, 0x0C, 0x80, 0x03, 0x60, 0x00, 0x1C, 0x00, 0x03, 0x00,
0x07, 0xFC, 0x01, 0xFE, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0xFE,
0x03, 0xFC, 0x01, 0x07, 0x00, 0x00, 0x04, 0x02, 0x04, 0x02, 0xFE, 0x03,
0xFE, 0x03, 0x00, 0x02, 0x00, 0x02, 0x07, 0x04, 0x02, 0x02, 0x03, 0x82,
0x03, 0xC2, 0x02, 0x62, 0x02, 0x3E, 0x02, 0x1C, 0x02, 0x07, 0x04, 0x01,
0x02, 0x02, 0x22, 0x02, 0x22, 0x02, 0x22, 0x02, 0xFE, 0x03, 0xDC, 0x01,
0x07, 0x60, 0x00, 0x50, 0x00, 0x48, 0x00, 0x44, 0x00, 0xFE, 0x03, 0xFE,
0x03, 0x40, 0x00, 0x07, 0x00, 0x01, 0x1E, 0x02, 0x1E, 0x02, 0x12, 0x02,
0x12, 0x02, 0xF2, 0x03, 0xE2, 0x01, 0x07, 0xF8, 0x01, 0xFC, 0x03, 0x16,
0x02, 0x12, 0x02, 0x12, 0x02, 0xF2, 0x03, 0xE0, 0x01, 0x07, 0x02, 0x00,
0x02, 0x00, 0x82, 0x03, 0xE2, 0x03, 0x7A, 0x00, 0x1E, 0x00, 0x06, 0x00,
0x07, 0xDC, 0x01, 0xFE, 0x03, 0x22, 0x02, 0x22, 0x02, 0x22, 0x02, 0xFE,
0x03, 0xDC, 0x01, 0x07, 0x3C, 0x00, 0x7E, 0x02, 0x42, 0x02, 0x42, 0x02,
0x42, 0x03, 0xFE, 0x01, 0xFC, 0x00, 0x03, 0x00, 0x00, 0x18, 0x03, 0x18,
0x03, 0x03, 0x00, 0x00, 0x18, 0x0F, 0x18, 0x07, 0x09, 0x00, 0x00, 0x60,
0x00, 0x60, 0x00, 0x90, 0x00, 0x90, 0x00, 0x08, 0x01, 0x08, 0x01, 0x04,
0x02, 0x04, 0x02, 0x08, 0x00, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00,
0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x09, 0x00, 0x00, 0x04,
0x02, 0x04, 0x02, 0x08, 0x01, 0x08, 0x01, 0x90, 0x00, 0x90, 0x00, 0x60,
0x00, 0x60, 0x00, 0x06, 0x04, 0x00, 0x02, 0x00, 0x62, 0x03, 0x72, 0x03,
0x1E, 0x00, 0x0C, 0x00, 0x09, 0xF8, 0x01, 0x04, 0x02, 0xF2, 0x04, 0xFA,
0x05, 0x0A, 0x05, 0xFA, 0x04, 0xFA, 0x05, 0x04, 0x01, 0xF8, 0x00, 0x08,
0x80, 0x03, 0xF0, 0x03, 0xFC, 0x00, 0x8E, 0x00, 0x8E, 0x00, 0xFC, 0x00,
0xF0, 0x03, 0x80, 0x03, 0x07, 0xFE, 0x03, 0xFE, 0x03, 0x22, 0x02, 0x22,
0x02, 0x22, 0x02, 0xFE, 0x03, 0xDC, 0x01, 0x07, 0xFC, 0x01, 0xFE, 0x03,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x8C, 0x01, 0x08, 0xFE,
0x03, 0xFE, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x06, 0x03, 0xFC,
0x01, 0xF8, 0x00, 0x06, 0xFE, 0x03, 0xFE, 0x03, 0x22, 0x02, 0x22, 0x02,
0x22, 0x02, 0x22, 0x02, 0x05, 0xFE, 0x03, 0xFE, 0x03, 0x22, 0x00, 0x22,
0x00, 0x22, 0x00, 0x07, 0xFC, 0x01, 0xFE, 0x03, 0x02, 0x02, 0x02, 0x02,
0x22, 0x02, 0xE2, 0x03, 0xEC, 0x03, 0x08, 0xFE, 0x03, 0xFE, 0x03, 0x20,
0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xFE, 0x03, 0xFE, 0x03, 0x04,
0x02, 0x02, 0xFE, 0x03, 0xFE, 0x03, 0x02, 0x02, 0x05, 0x00, 0x02, 0x02,
0x02, 0x02, 0x02, 0xFE, 0x03, 0xFE, 0x01, 0x07, 0xFE, 0x03, 0xFE, 0x03,
0x70, 0x00, 0xD8, 0x00, 0x8C, 0x01, 0x06, 0x03, 0x02, 0x02, 0x06, 0xFE,
0x03, 0xFE, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x0A,
0xFE, 0x03, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0x30, 0x00,
0x18, 0x00, 0x0C, 0x00, 0xFE, 0x03, 0xFE, 0x03, 0x07, 0xFE, 0x03, 0x0E,
0x00, 0x1C, 0x00, 0x70, 0x00, 0xE0, 0x01, 0x80, 0x03, 0xFE, 0x03, 0x08,
0xFC, 0x01, 0xFE, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0xFE, 0x03, 0xFC, 0x01, 0x07, 0xFE, 0x03, 0xFE, 0x03, 0x42, 0x00, 0x42,
0x00, 0x42, 0x00, 0x7E, 0x00, 0x3C, 0x00, 0x08, 0xFC, 0x01, 0xFE, 0x03,
0x02, 0x02, 0x02, 0x02, 0x02, 0x06, 0x02, 0x0E, 0xFE, 0x0B, 0xFC, 0x09,
0x08, 0xFE, 0x03, 0xFE, 0x03, 0x22, 0x00, 0x62, 0x00, 0xE2, 0x00, 0xBE,
0x01, 0x1C, 0x03, 0x00, 0x02, 0x07, 0x9C, 0x01, 0x3E, 0x02, 0x22, 0x02,
0x22, 0x02, 0x22, 0x02, 0xE2, 0x03, 0xCC, 0x01, 0x06, 0x02, 0x00, 0x02,
0x00, 0xFE, 0x03, 0xFE, 0x03, 0x02, 0x00, 0x02, 0x00, 0x07, 0xFE, 0x01,
0xFE, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xFE, 0x03, 0xFE, 0x01,
0x07, 0x0E, 0x00, 0x7E, 0x00, 0xF0, 0x03, 0x80, 0x03, 0xF0, 0x03, 0x7E,
0x00, 0x0E, 0x00, 0x0B, 0x1E, 0x00, 0xFE, 0x00, 0xE0, 0x03, 0xE0, 0x03,
0xFC, 0x00, 0x0E, 0x00, 0xFC, 0x00, 0xE0, 0x03, 0xE0, 0x03, 0xFE, 0x00,
0x1E, 0x00, 0x07, 0x06, 0x03, 0x8E, 0x03, 0xF8, 0x00, 0x70, 0x00, 0xF8,
0x00, 0x8E, 0x03, 0x06, 0x03, 0x06, 0x0E, 0x00, 0x3E, 0x00, 0xF0, 0x03,
0xF0, 0x03, 0x3E, 0x00, 0x0E, 0x00, 0x06, 0x82, 0x03, 0xC2, 0x03, 0x62,
0x02, 0x32, 0x02, 0x1E, 0x02, 0x0E, 0x02, 0x04, 0xFF, 0x0F, 0xFF, 0x0F,
0x01, 0x08, 0x01, 0x08, 0x05, 0x03, 0x00, 0x1C, 0x00, 0x60, 0x00, 0x80,
0x03, 0x00, 0x0C, 0x04, 0x01, 0x08, 0x01, 0x08, 0xFF, 0x0F, 0xFF, 0x0F,
0x09, 0x00, 0x00, 0x10, 0x00, 0x08, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02,
0x00, 0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
0x05, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x02, 0x00, 0x06,
0x80, 0x01, 0xD0, 0x03, 0x48, 0x02, 0x48, 0x02, 0xF8, 0x03, 0xF0, 0x03,
0x07, 0xFF, 0x03, 0xFF, 0x03, 0x10, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF8,
0x03, 0xF0, 0x01, 0x05, 0xF0, 0x01, 0xF8, 0x03, 0x08, 0x02, 0x08, 0x02,
0x08, 0x02, 0x07, 0xF0, 0x01, 0xF8, 0x03, 0x08, 0x02, 0x08, 0x02, 0x08,
0x01, 0xFF, 0x03, 0xFF, 0x03, 0x06, 0xF0, 0x01, 0xF8, 0x03, 0x48, 0x02,
0x48, 0x02, 0x78, 0x02, 0x70, 0x01, 0x05, 0x08, 0x00, 0xFE, 0x03, 0xFF,
0x03, 0x09, 0x00, 0x01, 0x00, 0x07, 0xF0, 0x01, 0xF8, 0x0B, 0x08, 0x0A,
0x08, 0x0A, 0x08, 0x09, 0xF8, 0x0F, 0xF8, 0x07, 0x07, 0xFF, 0x03, 0xFF,
0x03, 0x10, 0x00, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03, 0xF0, 0x03, 0x02,
0xFA, 0x03, 0xFA, 0x03, 0x03, 0x08, 0x08, 0xFA, 0x0F, 0xFA, 0x07, 0x06,
0xFF, 0x03, 0xFF, 0x03, 0xE0, 0x00, 0xB0, 0x01, 0x18, 0x03, 0x08, 0x02,
0x02, 0xFF, 0x03, 0xFF, 0x03, 0x0A, 0xF8, 0x03, 0xF8, 0x03, 0x08, 0x00,
0x08, 0x00, 0xF8, 0x03, 0xF0, 0x03, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x03,
0xF0, 0x03, 0x07, 0xF8, 0x03, 0xF8, 0x03, 0x10, 0x00, 0x08, 0x00, 0x08,
0x00, 0xF8, 0x03, 0xF0, 0x03, 0x07, 0xF0, 0x01, 0xF8, 0x03, 0x08, 0x02,
0x08, 0x02, 0x08, 0x02, 0xF8, 0x03, 0xF0, 0x01, 0x07, 0xF8, 0x0F, 0xF8,
0x0F, 0x10, 0x02, 0x08, 0x02, 0x08, 0x02, 0xF8, 0x03, 0xF0, 0x01, 0x07,
0xF0, 0x01, 0xF8, 0x03, 0x08, 0x02, 0x08, 0x02, 0x08, 0x01, 0xF8, 0x0F,
0xF8, 0x0F, 0x04, 0xF8, 0x03, 0xF8, 0x03, 0x10, 0x00, 0x18, 0x00, 0x05,
0x30, 0x01, 0x78, 0x02, 0x48, 0x02, 0xC8, 0x03, 0x90, 0x01, 0x05, 0x08,
0x00, 0xFE, 0x01, 0xFE, 0x03, 0x08, 0x02, 0x08, 0x02, 0x07, 0xF8, 0x01,
0xF8, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00, 0x01, 0xF8, 0x03, 0xF8, 0x03,
0x06, 0x38, 0x00, 0xF8, 0x00, 0xC0, 0x03, 0xC0, 0x03, 0xF8, 0x00, 0x38,
0x00, 0x0A, 0x18, 0x00, 0xF8, 0x00, 0xE0, 0x03, 0x80, 0x03, 0xF8, 0x00,
0xF8, 0x00, 0x80, 0x03, 0xE0, 0x03, 0xF8, 0x00, 0x18, 0x00, 0x06, 0x18,
0x03, 0xB8, 0x03, 0xE0, 0x00, 0xE0, 0x00, 0xB8, 0x03, 0x18, 0x03, 0x06,
0x38, 0x00, 0xF8, 0x0C, 0xC0, 0x0F, 0xC0, 0x03, 0xF8, 0x00, 0x38, 0x00,
0x05, 0x88, 0x03, 0xC8, 0x03, 0x68, 0x02, 0x38, 0x02, 0x18, 0x02, 0x06,
0x20, 0x00, 0x20, 0x00, 0xFE, 0x07, 0xDF, 0x0F, 0x01, 0x08, 0x01, 0x08,
0x04, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x0F, 0xFF, 0x0F, 0x06, 0x01, 0x08,
0x01, 0x08, 0xDF, 0x0F, 0xFE, 0x07, 0x20, 0x00, 0x20, 0x00, 0x09, 0xE0,
0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x60, 0x00, 0xC0, 0x00, 0xC0,
0x00, 0xC0, 0x00, 0x70, 0x00, 0x06, 0x00, 0x00, 0xFE, 0x03, 0xFE, 0x03,
0x02, 0x02, 0xFE, 0x03, 0xFE, 0x03
};
#endif
#if 1 // font_MediumBold (UI Font)
// The font table contains 3 sections: Header, Table Of Character Indexes, Pixel data
//
// The Header contains two bytes:
// Byte0 = Font height (including decenders)
// Byte1 = Number of additional pixels that should be drawn right of char
// Byte2 = Recommended line spacing
// Byte3 = Height of decenders
// Byte4 = Unused byte
//
// The Table Of Character Indexes, is a table of 2 byte words that index to the pixel data within this table
// Word0 = Index into this table to the pixels for ASCII char 0x20
// Word1 = Index into this table to the pixels for ASCII char 0x21
// Word2 = Index into this table to the pixels for ASCII char 0x22
// ...
// Word95 = Index into this table to the pixels for ASCII char 0x7F
//
// The Pixel data table contains the bitmap for each character
// Data is written in columns of pixels, each column is 16 bits (2 bytes)
// Byte0 = width of the ASCII 0x20 character in pixels
// Byte1 = pixel data for the 0x20 char's 1st top column, bit 0 is the top pixel, bit 7 is the 8th pixel down from the top
// Byte2 = pixel data for the 0x20 char's 1st bottom column, bit 0 is the 9th pixel
// Byte5 = pixel data for the 0x20 char's 2nd top column
// Byte6 = pixel data for the 0x20 char's 2nd bottom column
// ... = remaining pairs of bytes of the columns in the 0x20 char
// ... = width of the 0x21 char in pixels
// ... = pixel data for the 0x21 char
// ...
//
const uint8_t font_MediumBold[] = {
0x0D, 0x00, 0x0F, 0x02, 0x00,
0xC5, 0x00, 0xD2, 0x00, 0xD9, 0x00, 0xE6, 0x00, 0xF7, 0x00, 0x06, 0x01,
0x21, 0x01, 0x34, 0x01, 0x3B, 0x01, 0x46, 0x01, 0x51, 0x01, 0x5E, 0x01,
0x6F, 0x01, 0x76, 0x01, 0x81, 0x01, 0x88, 0x01, 0x97, 0x01, 0xA6, 0x01,
0xB5, 0x01, 0xC4, 0x01, 0xD3, 0x01, 0xE2, 0x01, 0xF1, 0x01, 0x00, 0x02,
0x0F, 0x02, 0x1E, 0x02, 0x2D, 0x02, 0x34, 0x02, 0x3B, 0x02, 0x4C, 0x02,
0x5D, 0x02, 0x6E, 0x02, 0x7B, 0x02, 0x90, 0x02, 0xA1, 0x02, 0xB0, 0x02,
0xBF, 0x02, 0xD0, 0x02, 0xDF, 0x02, 0xEE, 0x02, 0xFF, 0x02, 0x10, 0x03,
0x1B, 0x03, 0x26, 0x03, 0x35, 0x03, 0x44, 0x03, 0x57, 0x03, 0x68, 0x03,
0x79, 0x03, 0x88, 0x03, 0x99, 0x03, 0xAA, 0x03, 0xB9, 0x03, 0xCA, 0x03,
0xDB, 0x03, 0xEA, 0x03, 0x01, 0x04, 0x10, 0x04, 0x1F, 0x04, 0x2E, 0x04,
0x39, 0x04, 0x48, 0x04, 0x53, 0x04, 0x66, 0x04, 0x77, 0x04, 0x82, 0x04,
0x91, 0x04, 0xA0, 0x04, 0xAD, 0x04, 0xBC, 0x04, 0xCB, 0x04, 0xD6, 0x04,
0xE5, 0x04, 0xF4, 0x04, 0xFB, 0x04, 0x04, 0x05, 0x13, 0x05, 0x1A, 0x05,
0x31, 0x05, 0x40, 0x05, 0x4F, 0x05, 0x5E, 0x05, 0x6D, 0x05, 0x7A, 0x05,
0x87, 0x05, 0x92, 0x05, 0xA1, 0x05, 0xB0, 0x05, 0xC3, 0x05, 0xD2, 0x05,
0xE1, 0x05, 0xEE, 0x05, 0xFD, 0x05, 0x06, 0x06, 0x15, 0x06, 0x26, 0x06,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x00, 0x00, 0xFC, 0x02, 0xFC, 0x02, 0x06, 0x00, 0x00, 0x0E,
0x00, 0x0E, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x08, 0x00, 0x00,
0x80, 0x00, 0x90, 0x03, 0xF0, 0x00, 0x9C, 0x03, 0xF0, 0x00, 0x9C, 0x00,
0x10, 0x00, 0x07, 0x00, 0x00, 0x30, 0x01, 0x78, 0x02, 0xC8, 0x0F, 0x7E,
0x02, 0xC8, 0x03, 0x90, 0x01, 0x0D, 0x00, 0x00, 0x38, 0x00, 0x7C, 0x00,
0x44, 0x00, 0x7C, 0x00, 0x38, 0x03, 0xC0, 0x00, 0x30, 0x00, 0xCC, 0x01,
0xE0, 0x03, 0x20, 0x02, 0xE0, 0x03, 0xC0, 0x01, 0x09, 0x00, 0x00, 0xD8,
0x01, 0xFC, 0x03, 0x24, 0x02, 0x7C, 0x02, 0xD8, 0x02, 0x80, 0x01, 0x60,
0x03, 0x20, 0x02, 0x03, 0x00, 0x00, 0x0E, 0x00, 0x0E, 0x00, 0x05, 0x00,
0x00, 0xF0, 0x01, 0xFC, 0x07, 0x0E, 0x0E, 0x02, 0x08, 0x05, 0x00, 0x00,
0x02, 0x08, 0x0E, 0x0E, 0xFC, 0x07, 0xF0, 0x01, 0x06, 0x00, 0x00, 0x14,
0x00, 0x08, 0x00, 0x3E, 0x00, 0x08, 0x00, 0x14, 0x00, 0x08, 0x00, 0x00,
0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0xF8, 0x03, 0x40, 0x00, 0x40, 0x00,
0x40, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x07, 0x05, 0x00, 0x00,
0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x40, 0x00, 0x03, 0x00, 0x00, 0x00,
0x03, 0x00, 0x03, 0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x0F, 0xE0, 0x03,
0xF8, 0x00, 0x1E, 0x00, 0x06, 0x00, 0x07, 0x00, 0x00, 0xF8, 0x01, 0xFC,
0x03, 0x04, 0x02, 0x04, 0x02, 0xFC, 0x03, 0xF8, 0x01, 0x07, 0x00, 0x00,
0x00, 0x00, 0x08, 0x02, 0xFC, 0x03, 0xFC, 0x03, 0x00, 0x02, 0x00, 0x00,
0x07, 0x00, 0x00, 0x08, 0x03, 0x8C, 0x03, 0xC4, 0x02, 0x64, 0x02, 0x3C,
0x02, 0x18, 0x02, 0x07, 0x00, 0x00, 0x08, 0x01, 0x0C, 0x03, 0x24, 0x02,
0x24, 0x02, 0xFC, 0x03, 0xD8, 0x01, 0x07, 0x00, 0x00, 0xC0, 0x00, 0xA0,
0x00, 0x90, 0x00, 0xF8, 0x03, 0xFC, 0x03, 0x80, 0x00, 0x07, 0x00, 0x00,
0x00, 0x01, 0x3C, 0x03, 0x3C, 0x02, 0x24, 0x02, 0xE4, 0x03, 0xC4, 0x01,
0x07, 0x00, 0x00, 0xF0, 0x01, 0xF8, 0x03, 0x2C, 0x02, 0x24, 0x02, 0xE4,
0x03, 0xC0, 0x01, 0x07, 0x00, 0x00, 0x04, 0x00, 0x04, 0x03, 0xC4, 0x03,
0xF4, 0x00, 0x3C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x00, 0xD8, 0x01, 0xFC,
0x03, 0x24, 0x02, 0x24, 0x02, 0xFC, 0x03, 0xD8, 0x01, 0x07, 0x00, 0x00,
0x38, 0x00, 0x7C, 0x02, 0x44, 0x02, 0x44, 0x03, 0xFC, 0x01, 0xF8, 0x00,
0x03, 0x00, 0x00, 0x30, 0x03, 0x30, 0x03, 0x03, 0x00, 0x00, 0x30, 0x0F,
0x30, 0x07, 0x08, 0x00, 0x00, 0x40, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0x10,
0x01, 0x10, 0x01, 0x08, 0x02, 0x08, 0x02, 0x08, 0x00, 0x00, 0x90, 0x00,
0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00, 0x90, 0x00,
0x08, 0x00, 0x00, 0x08, 0x02, 0x08, 0x02, 0x10, 0x01, 0x10, 0x01, 0xA0,
0x00, 0xA0, 0x00, 0x40, 0x00, 0x06, 0x00, 0x00, 0x08, 0x00, 0xC4, 0x02,
0xE4, 0x02, 0x3C, 0x00, 0x18, 0x00, 0x0A, 0x00, 0x00, 0xF0, 0x01, 0x08,
0x02, 0xE4, 0x04, 0xF4, 0x05, 0x14, 0x05, 0xF4, 0x05, 0xF4, 0x05, 0x04,
0x01, 0xF8, 0x00, 0x08, 0x00, 0x00, 0x80, 0x03, 0xF0, 0x03, 0xFC, 0x00,
0x8C, 0x00, 0xFC, 0x00, 0xF0, 0x03, 0x80, 0x03, 0x07, 0x00, 0x00, 0xFC,
0x03, 0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0xFC, 0x03, 0xD8, 0x01, 0x07,
0x00, 0x00, 0xF8, 0x01, 0xFC, 0x03, 0x04, 0x02, 0x04, 0x02, 0x04, 0x02,
0x08, 0x01, 0x08, 0x00, 0x00, 0xFC, 0x03, 0xFC, 0x03, 0x04, 0x02, 0x04,
0x02, 0x0C, 0x03, 0xF8, 0x01, 0xF0, 0x00, 0x07, 0x00, 0x00, 0xFC, 0x03,
0xFC, 0x03, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0x24, 0x02, 0x07, 0x00,
0x00, 0xFC, 0x03, 0xFC, 0x03, 0x24, 0x00, 0x24, 0x00, 0x24, 0x00, 0x24,
0x00, 0x08, 0x00, 0x00, 0xF8, 0x01, 0xFC, 0x03, 0x04, 0x02, 0x04, 0x02,
0x44, 0x02, 0xC4, 0x03, 0xC8, 0x03, 0x08, 0x00, 0x00, 0xFC, 0x03, 0xFC,
0x03, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xFC, 0x03, 0xFC, 0x03, 0x05,
0x00, 0x00, 0x04, 0x02, 0xFC, 0x03, 0xFC, 0x03, 0x04, 0x02, 0x05, 0x00,
0x02, 0x04, 0x02, 0x04, 0x02, 0xFC, 0x03, 0xFC, 0x01, 0x07, 0x00, 0x00,
0xFC, 0x03, 0xFC, 0x03, 0xF0, 0x00, 0x98, 0x01, 0x0C, 0x03, 0x04, 0x02,
0x07, 0x00, 0x00, 0xFC, 0x03, 0xFC, 0x03, 0x00, 0x02, 0x00, 0x02, 0x00,
0x02, 0x00, 0x02, 0x09, 0x00, 0x00, 0xFC, 0x03, 0x1C, 0x00, 0x38, 0x00,
0x70, 0x00, 0x20, 0x00, 0x10, 0x00, 0xF8, 0x03, 0xFC, 0x03, 0x08, 0x00,
0x00, 0xFC, 0x03, 0x18, 0x00, 0x30, 0x00, 0x60, 0x00, 0xC0, 0x00, 0x80,
0x01, 0xFC, 0x03, 0x08, 0x00, 0x00, 0xF8, 0x01, 0xFC, 0x03, 0x04, 0x02,
0x04, 0x02, 0x04, 0x02, 0xFC, 0x03, 0xF8, 0x01, 0x07, 0x00, 0x00, 0xFC,
0x03, 0xFC, 0x03, 0x44, 0x00, 0x44, 0x00, 0x7C, 0x00, 0x38, 0x00, 0x08,
0x00, 0x00, 0xF8, 0x01, 0xFC, 0x03, 0x04, 0x02, 0x04, 0x06, 0x04, 0x0E,
0xFC, 0x0B, 0xF8, 0x09, 0x08, 0x00, 0x00, 0xFC, 0x03, 0xFC, 0x03, 0x44,
0x00, 0xC4, 0x00, 0xFC, 0x01, 0x38, 0x03, 0x00, 0x02, 0x07, 0x00, 0x00,
0x38, 0x01, 0x7C, 0x02, 0x64, 0x02, 0x64, 0x02, 0xE4, 0x03, 0xC8, 0x01,
0x08, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0xFC, 0x03, 0xFC, 0x03, 0x04,
0x00, 0x04, 0x00, 0x04, 0x00, 0x08, 0x00, 0x00, 0xFC, 0x01, 0xFC, 0x03,
0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0xFC, 0x03, 0xFC, 0x01, 0x07, 0x00,
0x00, 0x1C, 0x00, 0xFC, 0x00, 0xE0, 0x03, 0xE0, 0x03, 0xFC, 0x00, 0x1C,
0x00, 0x0B, 0x00, 0x00, 0x1C, 0x00, 0xFC, 0x00, 0xE0, 0x03, 0xC0, 0x03,
0x7C, 0x00, 0x7C, 0x00, 0xC0, 0x03, 0xE0, 0x03, 0xFC, 0x00, 0x1C, 0x00,
0x07, 0x00, 0x00, 0x0C, 0x03, 0x9C, 0x03, 0xF0, 0x00, 0xF0, 0x00, 0x9C,
0x03, 0x0C, 0x03, 0x07, 0x00, 0x00, 0x0C, 0x00, 0x3C, 0x00, 0xF0, 0x03,
0xF0, 0x03, 0x3C, 0x00, 0x0C, 0x00, 0x07, 0x00, 0x00, 0x84, 0x03, 0xC4,
0x03, 0xE4, 0x02, 0x74, 0x02, 0x3C, 0x02, 0x1C, 0x02, 0x05, 0x00, 0x00,
0xFE, 0x0F, 0xFE, 0x0F, 0x02, 0x08, 0x02, 0x08, 0x07, 0x00, 0x00, 0x06,
0x00, 0x1E, 0x00, 0xF8, 0x00, 0xE0, 0x03, 0x00, 0x0F, 0x00, 0x0C, 0x05,
0x00, 0x00, 0x02, 0x08, 0x02, 0x08, 0xFE, 0x0F, 0xFE, 0x0F, 0x09, 0x00,
0x00, 0x20, 0x00, 0x30, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x18,
0x00, 0x30, 0x00, 0x20, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08,
0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x05, 0x00,
0x00, 0x00, 0x00, 0x02, 0x00, 0x06, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00,
0x80, 0x01, 0xD0, 0x03, 0x50, 0x02, 0x50, 0x02, 0xF0, 0x03, 0xE0, 0x03,
0x07, 0x00, 0x00, 0xFE, 0x03, 0xFE, 0x03, 0x10, 0x02, 0x10, 0x02, 0xF0,
0x03, 0xE0, 0x01, 0x06, 0x00, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x10, 0x02,
0x10, 0x02, 0x10, 0x02, 0x07, 0x00, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x10,
0x02, 0x10, 0x02, 0xFE, 0x03, 0xFE, 0x03, 0x07, 0x00, 0x00, 0xE0, 0x01,
0xF0, 0x03, 0x50, 0x02, 0x50, 0x02, 0x70, 0x02, 0x60, 0x01, 0x05, 0x10,
0x00, 0xFC, 0x03, 0xFE, 0x03, 0x12, 0x00, 0x12, 0x00, 0x07, 0x00, 0x00,
0xE0, 0x01, 0xF0, 0x0B, 0x10, 0x0A, 0x10, 0x0A, 0xF0, 0x0F, 0xF0, 0x07,
0x07, 0x00, 0x00, 0xFE, 0x03, 0xFE, 0x03, 0x10, 0x00, 0x10, 0x00, 0xF0,
0x03, 0xE0, 0x03, 0x03, 0x00, 0x00, 0xF4, 0x03, 0xF4, 0x03, 0x04, 0x00,
0x08, 0x10, 0x08, 0xF4, 0x0F, 0xF4, 0x07, 0x07, 0x00, 0x00, 0xFE, 0x03,
0xFE, 0x03, 0xC0, 0x00, 0xE0, 0x01, 0x30, 0x03, 0x10, 0x02, 0x03, 0x00,
0x00, 0xFE, 0x03, 0xFE, 0x03, 0x0B, 0x00, 0x00, 0xF0, 0x03, 0xF0, 0x03,
0x10, 0x00, 0x10, 0x00, 0xF0, 0x03, 0xE0, 0x03, 0x10, 0x00, 0x10, 0x00,
0xF0, 0x03, 0xE0, 0x03, 0x07, 0x00, 0x00, 0xF0, 0x03, 0xF0, 0x03, 0x10,
0x00, 0x10, 0x00, 0xF0, 0x03, 0xE0, 0x03, 0x07, 0x00, 0x00, 0xE0, 0x01,
0xF0, 0x03, 0x10, 0x02, 0x10, 0x02, 0xF0, 0x03, 0xE0, 0x01, 0x07, 0x00,
0x00, 0xF0, 0x0F, 0xF0, 0x0F, 0x10, 0x02, 0x10, 0x02, 0xF0, 0x03, 0xE0,
0x01, 0x07, 0x00, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x10, 0x02, 0x10, 0x02,
0xF0, 0x0F, 0xF0, 0x0F, 0x06, 0x00, 0x00, 0xF0, 0x03, 0xF0, 0x03, 0x20,
0x00, 0x30, 0x00, 0x30, 0x00, 0x06, 0x00, 0x00, 0x60, 0x02, 0xF0, 0x02,
0xD0, 0x02, 0xD0, 0x03, 0x90, 0x01, 0x05, 0x10, 0x00, 0xFC, 0x01, 0xFC,
0x03, 0x10, 0x02, 0x10, 0x02, 0x07, 0x00, 0x00, 0xF0, 0x01, 0xF0, 0x03,
0x00, 0x02, 0x00, 0x02, 0xF0, 0x03, 0xF0, 0x03, 0x07, 0x00, 0x00, 0x70,
0x00, 0xF0, 0x01, 0x80, 0x03, 0x80, 0x03, 0xF0, 0x01, 0x70, 0x00, 0x09,
0x00, 0x00, 0xF0, 0x00, 0xF0, 0x03, 0x00, 0x03, 0xF0, 0x00, 0xF0, 0x00,
0x00, 0x03, 0xF0, 0x03, 0xF0, 0x00, 0x07, 0x00, 0x00, 0x30, 0x03, 0xF0,
0x03, 0xC0, 0x00, 0xC0, 0x00, 0xF0, 0x03, 0x30, 0x03, 0x07, 0x00, 0x00,
0x30, 0x00, 0xF0, 0x0C, 0xC0, 0x0F, 0xC0, 0x03, 0xF0, 0x00, 0x30, 0x00,
0x06, 0x00, 0x00, 0x10, 0x03, 0x90, 0x03, 0xD0, 0x02, 0x70, 0x02, 0x30,
0x02, 0x07, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0xFC, 0x07, 0xBE, 0x0F,
0x02, 0x08, 0x02, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x0F, 0xFE,
0x0F, 0x07, 0x00, 0x00, 0x02, 0x08, 0x02, 0x08, 0xBE, 0x0F, 0xFC, 0x07,
0x40, 0x00, 0x40, 0x00, 0x08, 0x00, 0x00, 0xC0, 0x01, 0x20, 0x00, 0x20,
0x00, 0xC0, 0x00, 0x00, 0x01, 0x00, 0x01, 0xE0, 0x00, 0x04, 0xFC, 0x03,
0xFC, 0x03, 0xFC, 0x03, 0xFC, 0x03
};
#endif
#if 0 // font_MediumBold (UI Font Option 2)
//
// Font table for Tahoma font, height = 11 (including the decenders)
// The font table contains 3 sections: Header, Table Of Character Indexes, Pixel data
//
// The Header contains two bytes:
// Byte0 = Font height (including decenders)
// Byte1 = Number of additional pixels that should be drawn right of char
// Byte2 = Recommended line spacing
// Byte3 = Height of decenders
// Byte4 = Unused byte
//
// The Table Of Character Indexes, is a table of 2 byte words that index to the pixel data within this table
// Word0 = Index into this table to the pixels for ASCII char 0x20
// Word1 = Index into this table to the pixels for ASCII char 0x21
// Word2 = Index into this table to the pixels for ASCII char 0x22
// ...
// Word95 = Index into this table to the pixels for ASCII char 0x7F
//
// The Pixel data table contains the bitmap for each character
// Data is written in columns of pixels, each column is 16 bits (2 bytes)
// Byte0 = width of the ASCII 0x20 character in pixels
// Byte1 = pixel data for the 0x20 char's 1st top column, bit 0 is the top pixel, bit 7 is the 8th pixel down from the top
// Byte2 = pixel data for the 0x20 char's 1st bottom column, bit 0 is the 9th pixel
// Byte5 = pixel data for the 0x20 char's 2nd top column
// Byte6 = pixel data for the 0x20 char's 2nd bottom column
// ... = remaining pairs of bytes of the columns in the 0x20 char
// ... = width of the 0x21 char in pixels
// ... = pixel data for the 0x21 char
// ...
//
const uint8_t font_MediumBold[] = {
0x0B, 0x01, 0x0D, 0x02, 0x00,
0xC5, 0x00, 0xCE, 0x00, 0xD3, 0x00, 0xDE, 0x00, 0xEF, 0x00, 0xFC, 0x00,
0x15, 0x01, 0x26, 0x01, 0x2B, 0x01, 0x34, 0x01, 0x3D, 0x01, 0x4A, 0x01,
0x5B, 0x01, 0x60, 0x01, 0x69, 0x01, 0x6E, 0x01, 0x79, 0x01, 0x86, 0x01,
0x93, 0x01, 0xA0, 0x01, 0xAD, 0x01, 0xBA, 0x01, 0xC7, 0x01, 0xD4, 0x01,
0xE1, 0x01, 0xEE, 0x01, 0xFB, 0x01, 0x00, 0x02, 0x05, 0x02, 0x16, 0x02,
0x27, 0x02, 0x38, 0x02, 0x43, 0x02, 0x56, 0x02, 0x65, 0x02, 0x72, 0x02,
0x7F, 0x02, 0x8E, 0x02, 0x99, 0x02, 0xA4, 0x02, 0xB3, 0x02, 0xC2, 0x02,
0xCB, 0x02, 0xD6, 0x02, 0xE3, 0x02, 0xEE, 0x02, 0x01, 0x03, 0x0E, 0x03,
0x1D, 0x03, 0x2A, 0x03, 0x39, 0x03, 0x48, 0x03, 0x55, 0x03, 0x62, 0x03,
0x71, 0x03, 0x7E, 0x03, 0x93, 0x03, 0xA0, 0x03, 0xAD, 0x03, 0xBA, 0x03,
0xC3, 0x03, 0xCE, 0x03, 0xD7, 0x03, 0xE6, 0x03, 0xF5, 0x03, 0xFE, 0x03,
0x0B, 0x04, 0x18, 0x04, 0x23, 0x04, 0x30, 0x04, 0x3D, 0x04, 0x46, 0x04,
0x53, 0x04, 0x60, 0x04, 0x65, 0x04, 0x6C, 0x04, 0x79, 0x04, 0x7E, 0x04,
0x93, 0x04, 0xA0, 0x04, 0xAD, 0x04, 0xBA, 0x04, 0xC7, 0x04, 0xD0, 0x04,
0xDB, 0x04, 0xE4, 0x04, 0xF1, 0x04, 0xFE, 0x04, 0x0F, 0x05, 0x1C, 0x05,
0x29, 0x05, 0x34, 0x05, 0x41, 0x05, 0x4A, 0x05, 0x57, 0x05, 0x68, 0x05,
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x7E, 0x01,
0x7E, 0x01, 0x05, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07,
0x00, 0x08, 0xC0, 0x00, 0xD8, 0x03, 0xF8, 0x00, 0xDE, 0x00, 0xD8, 0x03,
0xF8, 0x00, 0xDE, 0x00, 0x18, 0x00, 0x06, 0x98, 0x00, 0x3C, 0x01, 0xE4,
0x07, 0x3F, 0x01, 0xE4, 0x01, 0xC8, 0x00, 0x0C, 0x1C, 0x00, 0x3E, 0x00,
0x22, 0x00, 0x3E, 0x00, 0x9C, 0x01, 0x60, 0x00, 0x18, 0x00, 0xE6, 0x00,
0xF0, 0x01, 0x10, 0x01, 0xF0, 0x01, 0xE0, 0x00, 0x08, 0xEC, 0x00, 0xFE,
0x01, 0x12, 0x01, 0x3E, 0x01, 0x6C, 0x01, 0xC0, 0x00, 0xB0, 0x01, 0x10,
0x01, 0x02, 0x07, 0x00, 0x07, 0x00, 0x04, 0xF8, 0x00, 0xFE, 0x03, 0x07,
0x07, 0x01, 0x04, 0x04, 0x01, 0x04, 0x07, 0x07, 0xFE, 0x03, 0xF8, 0x00,
0x06, 0x0A, 0x00, 0x04, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x04, 0x00, 0x0A,
0x00, 0x08, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0xFC, 0x01,
0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x02, 0x80, 0x07, 0x80, 0x03, 0x04,
0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x02, 0x80, 0x01, 0x80,
0x01, 0x05, 0x00, 0x06, 0x80, 0x01, 0x70, 0x00, 0x0C, 0x00, 0x03, 0x00,
0x06, 0xFC, 0x00, 0xFE, 0x01, 0x02, 0x01, 0x02, 0x01, 0xFE, 0x01, 0xFC,
0x00, 0x06, 0x00, 0x00, 0x04, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0x00, 0x01,
0x00, 0x00, 0x06, 0x84, 0x01, 0xC6, 0x01, 0x62, 0x01, 0x32, 0x01, 0x1E,
0x01, 0x0C, 0x01, 0x06, 0x84, 0x00, 0x86, 0x01, 0x12, 0x01, 0x12, 0x01,
0xFE, 0x01, 0xEC, 0x00, 0x06, 0x60, 0x00, 0x50, 0x00, 0x48, 0x00, 0xFC,
0x01, 0xFE, 0x01, 0x40, 0x00, 0x06, 0x80, 0x00, 0x9E, 0x01, 0x1E, 0x01,
0x12, 0x01, 0xF2, 0x01, 0xE2, 0x00, 0x06, 0xFC, 0x00, 0xFE, 0x01, 0x12,
0x01, 0x12, 0x01, 0xF2, 0x01, 0xE0, 0x00, 0x06, 0x02, 0x00, 0x02, 0x00,
0xC2, 0x01, 0xFA, 0x01, 0x3E, 0x00, 0x06, 0x00, 0x06, 0xEC, 0x00, 0xFE,
0x01, 0x12, 0x01, 0x12, 0x01, 0xFE, 0x01, 0xEC, 0x00, 0x06, 0x1C, 0x00,
0x3E, 0x01, 0x22, 0x01, 0x22, 0x01, 0xFE, 0x01, 0xFC, 0x00, 0x02, 0x98,
0x01, 0x98, 0x01, 0x02, 0x98, 0x07, 0x98, 0x03, 0x08, 0x00, 0x00, 0x20,
0x00, 0x50, 0x00, 0x50, 0x00, 0x88, 0x00, 0x88, 0x00, 0x04, 0x01, 0x04,
0x01, 0x08, 0x00, 0x00, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x48, 0x00,
0x48, 0x00, 0x48, 0x00, 0x48, 0x00, 0x08, 0x00, 0x00, 0x04, 0x01, 0x04,
0x01, 0x88, 0x00, 0x88, 0x00, 0x50, 0x00, 0x50, 0x00, 0x20, 0x00, 0x05,
0x04, 0x00, 0x62, 0x01, 0x72, 0x01, 0x1E, 0x00, 0x0C, 0x00, 0x09, 0xF8,
0x00, 0x04, 0x01, 0x72, 0x02, 0xFA, 0x02, 0x8A, 0x02, 0x7A, 0x02, 0xFA,
0x02, 0x84, 0x00, 0x78, 0x00, 0x07, 0xC0, 0x01, 0xF8, 0x01, 0x7E, 0x00,
0x46, 0x00, 0x7E, 0x00, 0xF8, 0x01, 0xC0, 0x01, 0x06, 0xFE, 0x01, 0xFE,
0x01, 0x12, 0x01, 0x12, 0x01, 0xFE, 0x01, 0xEC, 0x00, 0x06, 0xFC, 0x00,
0xFE, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x07, 0xFE,
0x01, 0xFE, 0x01, 0x02, 0x01, 0x02, 0x01, 0x86, 0x01, 0xFC, 0x00, 0x78,
0x00, 0x05, 0xFE, 0x01, 0xFE, 0x01, 0x12, 0x01, 0x12, 0x01, 0x12, 0x01,
0x05, 0xFE, 0x01, 0xFE, 0x01, 0x12, 0x00, 0x12, 0x00, 0x12, 0x00, 0x07,
0xFC, 0x00, 0xFE, 0x01, 0x02, 0x01, 0x02, 0x01, 0x22, 0x01, 0xE2, 0x01,
0xE2, 0x01, 0x07, 0xFE, 0x01, 0xFE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x10,
0x00, 0xFE, 0x01, 0xFE, 0x01, 0x04, 0x02, 0x01, 0xFE, 0x01, 0xFE, 0x01,
0x02, 0x01, 0x05, 0x00, 0x01, 0x02, 0x01, 0x02, 0x01, 0xFE, 0x01, 0xFE,
0x00, 0x06, 0xFE, 0x01, 0xFE, 0x01, 0x78, 0x00, 0xCC, 0x00, 0x86, 0x01,
0x02, 0x01, 0x05, 0xFE, 0x01, 0xFE, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x01, 0x09, 0xFE, 0x01, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x30, 0x00,
0x18, 0x00, 0x0C, 0x00, 0xFE, 0x01, 0xFE, 0x01, 0x06, 0xFE, 0x01, 0x0E,
0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0xFE, 0x01, 0x07, 0xFC, 0x00,
0xFE, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0xFE, 0x01, 0xFC, 0x00,
0x06, 0xFE, 0x01, 0xFE, 0x01, 0x22, 0x00, 0x22, 0x00, 0x3E, 0x00, 0x1C,
0x00, 0x07, 0xFC, 0x00, 0xFE, 0x01, 0x02, 0x01, 0x02, 0x03, 0x02, 0x07,
0xFE, 0x05, 0xFC, 0x04, 0x07, 0xFE, 0x01, 0xFE, 0x01, 0x22, 0x00, 0x62,
0x00, 0xFE, 0x00, 0x9C, 0x01, 0x00, 0x01, 0x06, 0x1C, 0x01, 0x3E, 0x01,
0x32, 0x01, 0x32, 0x01, 0xF2, 0x01, 0xE2, 0x00, 0x06, 0x02, 0x00, 0x02,
0x00, 0xFE, 0x01, 0xFE, 0x01, 0x02, 0x00, 0x02, 0x00, 0x07, 0xFE, 0x00,
0xFE, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0xFE, 0x01, 0xFE, 0x00,
0x06, 0x0E, 0x00, 0x7E, 0x00, 0xF0, 0x01, 0xF0, 0x01, 0x7E, 0x00, 0x0E,
0x00, 0x0A, 0x0E, 0x00, 0x7E, 0x00, 0xF0, 0x01, 0xE0, 0x01, 0x3E, 0x00,
0x3E, 0x00, 0xE0, 0x01, 0xF0, 0x01, 0x7E, 0x00, 0x0E, 0x00, 0x06, 0x86,
0x01, 0xCE, 0x01, 0x78, 0x00, 0x78, 0x00, 0xCE, 0x01, 0x86, 0x01, 0x06,
0x06, 0x00, 0x1E, 0x00, 0xF8, 0x01, 0xF8, 0x01, 0x1E, 0x00, 0x06, 0x00,
0x06, 0xC2, 0x01, 0xE2, 0x01, 0x72, 0x01, 0x3A, 0x01, 0x1E, 0x01, 0x0E,
0x01, 0x04, 0xFF, 0x07, 0xFF, 0x07, 0x01, 0x04, 0x01, 0x04, 0x05, 0x03,
0x00, 0x0C, 0x00, 0x70, 0x00, 0x80, 0x01, 0x00, 0x06, 0x04, 0x01, 0x04,
0x01, 0x04, 0xFF, 0x07, 0xFF, 0x07, 0x07, 0x10, 0x00, 0x08, 0x00, 0x04,
0x00, 0x02, 0x00, 0x04, 0x00, 0x08, 0x00, 0x10, 0x00, 0x07, 0x00, 0x04,
0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04, 0x00, 0x04,
0x04, 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x02, 0x00, 0x06, 0xC0, 0x00,
0xE8, 0x01, 0x28, 0x01, 0x28, 0x01, 0xF8, 0x01, 0xF0, 0x01, 0x06, 0xFF,
0x01, 0xFF, 0x01, 0x08, 0x01, 0x08, 0x01, 0xF8, 0x01, 0xF0, 0x00, 0x05,
0xF0, 0x00, 0xF8, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0x01, 0x06, 0xF0,
0x00, 0xF8, 0x01, 0x08, 0x01, 0x08, 0x01, 0xFF, 0x01, 0xFF, 0x01, 0x06,
0xF0, 0x00, 0xF8, 0x01, 0x28, 0x01, 0x28, 0x01, 0x38, 0x01, 0x30, 0x01,
0x04, 0xFE, 0x01, 0xFF, 0x01, 0x09, 0x00, 0x01, 0x00, 0x06, 0xF0, 0x00,
0xF8, 0x05, 0x08, 0x05, 0x08, 0x05, 0xF8, 0x07, 0xF8, 0x03, 0x06, 0xFF,
0x01, 0xFF, 0x01, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x01, 0xF0, 0x01, 0x02,
0xFA, 0x01, 0xFA, 0x01, 0x03, 0x08, 0x04, 0xFA, 0x07, 0xFA, 0x03, 0x06,
0xFF, 0x01, 0xFF, 0x01, 0x60, 0x00, 0xF0, 0x00, 0x98, 0x01, 0x08, 0x01,
0x02, 0xFF, 0x01, 0xFF, 0x01, 0x0A, 0xF8, 0x01, 0xF8, 0x01, 0x08, 0x00,
0x08, 0x00, 0xF8, 0x01, 0xF0, 0x01, 0x08, 0x00, 0x08, 0x00, 0xF8, 0x01,
0xF0, 0x01, 0x06, 0xF8, 0x01, 0xF8, 0x01, 0x08, 0x00, 0x08, 0x00, 0xF8,
0x01, 0xF0, 0x01, 0x06, 0xF0, 0x00, 0xF8, 0x01, 0x08, 0x01, 0x08, 0x01,
0xF8, 0x01, 0xF0, 0x00, 0x06, 0xF8, 0x07, 0xF8, 0x07, 0x08, 0x01, 0x08,
0x01, 0xF8, 0x01, 0xF0, 0x00, 0x06, 0xF0, 0x00, 0xF8, 0x01, 0x08, 0x01,
0x08, 0x01, 0xF8, 0x07, 0xF8, 0x07, 0x04, 0xF8, 0x01, 0xF8, 0x01, 0x10,
0x00, 0x18, 0x00, 0x05, 0x30, 0x01, 0x78, 0x01, 0x68, 0x01, 0xE8, 0x01,
0xC8, 0x00, 0x04, 0xFE, 0x00, 0xFE, 0x01, 0x08, 0x01, 0x08, 0x01, 0x06,
0xF8, 0x00, 0xF8, 0x01, 0x00, 0x01, 0x00, 0x01, 0xF8, 0x01, 0xF8, 0x01,
0x06, 0x18, 0x00, 0x78, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0x78, 0x00, 0x18,
0x00, 0x08, 0x78, 0x00, 0xF8, 0x01, 0xC0, 0x01, 0x78, 0x00, 0x78, 0x00,
0xC0, 0x01, 0xF8, 0x01, 0x78, 0x00, 0x06, 0x98, 0x01, 0xF8, 0x01, 0x60,
0x00, 0x60, 0x00, 0xF8, 0x01, 0x98, 0x01, 0x06, 0x18, 0x00, 0x78, 0x06,
0xE0, 0x07, 0xE0, 0x01, 0x78, 0x00, 0x18, 0x00, 0x05, 0x88, 0x01, 0xC8,
0x01, 0x68, 0x01, 0x38, 0x01, 0x18, 0x01, 0x06, 0x20, 0x00, 0x20, 0x00,
0xFE, 0x03, 0xDF, 0x07, 0x01, 0x04, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
0x00, 0xFF, 0x07, 0xFF, 0x07, 0x06, 0x01, 0x04, 0x01, 0x04, 0xDF, 0x07,
0xFE, 0x03, 0x20, 0x00, 0x20, 0x00, 0x08, 0x60, 0x00, 0x10, 0x00, 0x10,
0x00, 0x30, 0x00, 0x60, 0x00, 0x40, 0x00, 0x40, 0x00, 0x30, 0x00, 0x04,
0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01
};
#endif
#if 1 // font_LargeNumbers
//
// Large numbers font, height = 16 (including the decenders)
// Characters include: 0 - 9, -, +, ., %, :, Space, Comma
// The font table contains 3 sections: Header, Table Of Character Indexes, Pixel data
//
// The Header contains two bytes:
// Byte0 = Font height (including decenders)
// Byte1 = Number of additional pixels that should be drawn right of char
// Byte2 = Recommended line spacing
// Byte3 = Height of decenders
// Byte4 = Unused byte
//
// The Table Of Character Indexes, is a table of 2 byte words that index to the pixel data within this table
// Word0 = Index into this table to the pixels for ASCII char 0x20
// Word1 = Index into this table to the pixels for ASCII char 0x21
// Word2 = Index into this table to the pixels for ASCII char 0x22
// ...
// Word95 = Index into this table to the pixels for ASCII char 0x7F
//
// The Pixel data table contains the bitmap for each character
// Data is written in columns of pixels, each column is 16 bits (2 bytes)
// Byte0 = width of the ASCII 0x20 character in pixels
// Byte1 = pixel data for the 0x20 char's 1st top column, bit 0 is the top pixel, bit 7 is the 8th pixel down from the top
// Byte2 = pixel data for the 0x20 char's 1st bottom column, bit 0 is the 9th pixel
// Byte5 = pixel data for the 0x20 char's 2nd top column
// Byte6 = pixel data for the 0x20 char's 2nd bottom column
// ... = remaining pairs of bytes of the columns in the 0x20 char
// ... = width of the 0x21 char in pixels
// ... = pixel data for the 0x21 char
// ...
//
const uint8_t font_LargeNumbers[] = {
0x10, 0x02, 0x15, 0x01, 0x00,
0xC5, 0x00, 0xC6, 0x00, 0xC7, 0x00, 0xC8, 0x00, 0xC9, 0x00, 0xCA, 0x00,
0xE9, 0x00, 0xEA, 0x00, 0xEB, 0x00, 0xEC, 0x00, 0xED, 0x00, 0xEE, 0x00,
0x05, 0x01, 0x0C, 0x01, 0x19, 0x01, 0x20, 0x01, 0x21, 0x01, 0x36, 0x01,
0x4B, 0x01, 0x60, 0x01, 0x75, 0x01, 0x8A, 0x01, 0x9F, 0x01, 0xB4, 0x01,
0xC9, 0x01, 0xDE, 0x01,
0xF3, 0x01, 0xFC, 0x01, 0xFD, 0x01, 0xFE, 0x01,
0xFF, 0x01, 0x00, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, 0x02, 0x04, 0x02,
0x05, 0x02, 0x06, 0x02, 0x07, 0x02, 0x08, 0x02, 0x09, 0x02, 0x0A, 0x02,
0x0B, 0x02, 0x0C, 0x02, 0x0D, 0x02, 0x0E, 0x02, 0x0F, 0x02, 0x10, 0x02,
0x11, 0x02, 0x12, 0x02, 0x13, 0x02, 0x14, 0x02, 0x15, 0x02, 0x16, 0x02,
0x17, 0x02, 0x18, 0x02, 0x19, 0x02, 0x1A, 0x02, 0x1B, 0x02, 0x1C, 0x02,
0x1D, 0x02, 0x1E, 0x02, 0x1F, 0x02, 0x20, 0x02, 0x21, 0x02, 0x22, 0x02,
0x23, 0x02, 0x24, 0x02, 0x25, 0x02, 0x26, 0x02, 0x27, 0x02, 0x28, 0x02,
0x29, 0x02, 0x2A, 0x02, 0x2B, 0x02, 0x2C, 0x02, 0x2D, 0x02, 0x2E, 0x02,
0x2F, 0x02, 0x30, 0x02, 0x31, 0x02, 0x32, 0x02, 0x33, 0x02, 0x34, 0x02,
0x35, 0x02, 0x36, 0x02, 0x37, 0x02, 0x38, 0x02, 0x39, 0x02, 0x3A, 0x02,
0x3B, 0x02, 0x3C, 0x02, 0x3D, 0x02, 0x3E, 0x02, 0x3F, 0x02, 0x40, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x7E, 0x00, 0xFF, 0x00, 0xC3, 0x00,
0xC3, 0x80, 0xFF, 0xE0, 0x7E, 0x7C, 0x00, 0x1F, 0xC0, 0x07, 0xF0, 0x00,
0x3E, 0x7E, 0x0F, 0xFF, 0x03, 0xC3, 0x00, 0xC3, 0x00, 0xFF, 0x00, 0x7E,
0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0xC0, 0x01, 0xC0, 0x01, 0xC0, 0x01,
0xC0, 0x01, 0xFC, 0x1F, 0xFC, 0x1F, 0xFC, 0x1F, 0xC0, 0x01, 0xC0, 0x01,
0xC0, 0x01, 0xC0, 0x01, 0x03, 0x00, 0x70, 0x00, 0x70, 0x00, 0xF0, 0x06,
0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x07,
0x03, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x0A, 0xF8, 0x0F, 0xFE,
0x3F, 0xFE, 0x3F, 0x07, 0x70, 0x03, 0x60, 0x03, 0x60, 0x07, 0x70, 0xFE,
0x3F, 0xFE, 0x3F, 0xF8, 0x0F, 0x0A, 0x00, 0x00, 0x70, 0x00, 0x38, 0x00,
0x38, 0x00, 0x1C, 0x00, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF, 0x7F, 0x00, 0x00,
0x00, 0x00, 0x0A, 0x0C, 0x60, 0x0E, 0x70, 0x0F, 0x7C, 0x07, 0x7E, 0x03,
0x6F, 0x83, 0x67, 0xC7, 0x63, 0xFF, 0x61, 0xFE, 0x60, 0x3C, 0x60, 0x0A,
0x0C, 0x18, 0x0E, 0x38, 0x0F, 0x78, 0xC3, 0x70, 0xC3, 0x60, 0xE3, 0x60,
0xFF, 0x71, 0xFE, 0x3F, 0x3C, 0x3F, 0x00, 0x0E, 0x0A, 0x00, 0x0F, 0xC0,
0x0D, 0xE0, 0x0C, 0x38, 0x0C, 0x1E, 0x0C, 0xFF, 0x7F, 0xFF, 0x7F, 0xFF,
0x7F, 0x00, 0x0C, 0x00, 0x0C, 0x0A, 0xC0, 0x18, 0xFC, 0x38, 0xFF, 0x78,
0x7F, 0x70, 0x63, 0x60, 0x63, 0x60, 0xE3, 0x70, 0xE3, 0x3F, 0xC3, 0x3F,
0x80, 0x0F, 0x0A, 0xF8, 0x0F, 0xFE, 0x3F, 0xFE, 0x3F, 0xC7, 0x70, 0x63,
0x60, 0x63, 0x60, 0xE7, 0x70, 0xEF, 0x3F, 0xC6, 0x3F, 0x04, 0x0F, 0x0A,
0x03, 0x00, 0x03, 0x00, 0x03, 0x78, 0x03, 0x7F, 0xC3, 0x7F, 0xF3, 0x07,
0xFB, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x07, 0x00, 0x0A, 0x1C, 0x1E, 0x3E,
0x3F, 0xFF, 0x7F, 0xE7, 0x71, 0xC3, 0x60, 0xC3, 0x60, 0xE7, 0x71, 0xFF,
0x7F, 0x3E, 0x3F, 0x1C, 0x1E, 0x0A, 0x78, 0x10, 0xFE, 0x39, 0xFE, 0x7B,
0x87, 0x73, 0x03, 0x63, 0x03, 0x63, 0x87, 0x71, 0xFE, 0x3F, 0xFE, 0x3F,
0xF8, 0x0F, 0x04, 0x00, 0x00, 0x38, 0x0E, 0x38, 0x0E, 0x38, 0x0E, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
#endif

39
glcd/fonts.h
View file

@ -1,39 +0,0 @@
/*
ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver 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.
ChibiOS-LCD-Driver 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 <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#ifndef _FONT_
#define _FONT_
#define FONT_TABLE_HEIGHT_IDX 0
#define FONT_TABLE_PAD_AFTER_CHAR_IDX 1
#define FONT_TABLE_LINE_SPACING_IDX 2
#define FONT_TABLE_DECENDERS_HEIGHT_IDX 3
#define FONT_TABLE_UNUSED_IDX 4
#define FONT_TABLE_CHAR_LOOKUP_IDX 5
extern const uint8_t font_Small[];
extern const uint8_t font_Larger[];
//extern const uint8_t font_Medium[];
extern const uint8_t font_MediumBold[];
extern const uint8_t font_LargeNumbers[];
#endif

437
glcd/glcd.c
View file

@ -18,19 +18,62 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "ch.h"
#include "hal.h"
#ifdef UNUSED
#elif defined(__GNUC__)
# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
#elif defined(__LCLINT__)
# define UNUSED(x) /*@unused@*/ x
#else
# define UNUSED(x) x
#endif
/* Hack 1: Manually load the low level driver capabilities first so we can
* control what we implement with hardware scrolling and pixel read.
*/
#include "gdisp_lld_config.h"
/* Hack 2: Force on the bits of functionality that glcd needs. */
#define HAL_USE_GDISP TRUE
#define GDISP_NEED_VALIDATION FALSE /* The original glcd didn't so we don't here either */
#define GDISP_NEED_CIRCLE TRUE
#define GDISP_NEED_ELLIPSE TRUE
#define GDISP_NEED_TEXT TRUE
#define GDISP_NEED_SCROLL GDISP_HARDWARE_SCROLL
#define GDISP_NEED_PIXELREAD GDISP_HARDWARE_PIXELREAD
#define GDISP_NEED_CONTROL TRUE
#define GDISP_NEED_MULTITHREAD FALSE /* We implement multi-thread here */
/* Now load the low level driver and font structure definitions */
#include "gdisp_lld.h"
#include "gdisp_fonts.h"
/* Hack 3: GLCD only supports RGB565. Anything else would require significant API changes. */
#ifndef GDISP_PIXELFORMAT_RGB565
#error "GLCD only support drivers with RGB565 pixel format"
#endif
/* Now load the glcd headers */
#include "glcd.h" #include "glcd.h"
#include "glcdWorker.h" #include "glcdWorker.h"
#define EMSG(a) const struct a *emsg = (const struct a*)msg /* Hack 4: Include the emulation code and font tables.
* We have to include it here rather than compiling
* the files as we need to pass our control defines
* as they are not being defined by the application.
* We need to turn off the inclusion of gdisp.h due
* to conflicting type defines etc.
*/
#define _GDISP_H // Prevent gdisp.h from being included
#include "gdisp_emulation.c"
#include "gdisp_fonts.c"
#define EMSG(a) struct a *emsg = (struct a*)msg
uint16_t lcd_width, lcd_height;
static Thread *workerThread = NULL; static Thread *workerThread = NULL;
/* internal functions; don't include in header */
inline glcd_result_t _lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
inline glcd_result_t _lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n);
glcd_result_t _lcdDrawChar(struct glcd_msg_draw_char *m);
static WORKING_AREA(waGLCDWorkerThread, GLCD_WORKER_SIZE); static WORKING_AREA(waGLCDWorkerThread, GLCD_WORKER_SIZE);
static msg_t ThreadGLCDWorker(void *arg) { static msg_t ThreadGLCDWorker(void *arg) {
(void)arg; (void)arg;
@ -48,88 +91,88 @@ static msg_t ThreadGLCDWorker(void *arg) {
switch(msg->action) { switch(msg->action) {
case GLCD_SET_POWERMODE: { case GLCD_SET_POWERMODE: {
EMSG(glcd_msg_powermode); EMSG(glcd_msg_powermode);
lld_lcdSetPowerMode(emsg->powermode); gdisp_lld_control(GDISP_CONTROL_POWER, (void *)(int)emsg->powermode);
result = GLCD_DONE; result = GLCD_DONE;
break; break;
} }
case GLCD_SET_ORIENTATION: { case GLCD_SET_ORIENTATION: {
EMSG(glcd_msg_orientation); EMSG(glcd_msg_orientation);
lld_lcdSetOrientation(emsg->newOrientation); gdisp_lld_control(GDISP_CONTROL_ORIENTATION, (void *)(int)emsg->newOrientation);
result = GLCD_DONE; result = GLCD_DONE;
break; break;
} }
case GLCD_SET_WINDOW: {
EMSG(glcd_msg_set_window);
lld_lcdSetWindow(emsg->x0, emsg->y0, emsg->x1, emsg->y1);
result = GLCD_DONE;
break;
}
case GLCD_FILL_AREA: { case GLCD_FILL_AREA: {
EMSG(glcd_msg_fill_area); EMSG(glcd_msg_fill_area);
result = _lcdFillArea(emsg->x0, emsg->y0, emsg->x1, emsg->y1, emsg->color); gdisp_lld_fillarea(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1,emsg->y1-emsg->y0+1,emsg->color);
result = GLCD_DONE;
break; break;
} }
case GLCD_WRITE_AREA: { case GLCD_WRITE_AREA: {
EMSG(glcd_msg_write_area); EMSG(glcd_msg_write_area);
result = _lcdWriteArea(emsg->x0, emsg->y0, emsg->x1, emsg->y1, emsg->buffer, emsg->size); gdisp_lld_blitarea(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1, emsg->y1-emsg->y0+1, emsg->buffer);
result = GLCD_DONE;
break; break;
} }
case GLCD_CLEAR: { case GLCD_CLEAR: {
EMSG(glcd_msg_clear); EMSG(glcd_msg_clear);
lld_lcdClear(emsg->color); gdisp_lld_clear(emsg->color);
result = GLCD_DONE; result = GLCD_DONE;
break; break;
} }
case GLCD_GET_PIXEL_COLOR: { case GLCD_GET_PIXEL_COLOR: {
EMSG(glcd_msg_get_pixel_color); /* Hack 5: This may now fail if the low level driver doesn't
* support it. Previously this support was required
* in the driver by GLCD
*/
#if GDISP_HARDWARE_READPIXEL
((struct glcd_msg_get_pixel_color *)emsg)->color = ((struct glcd_msg_get_pixel_color *)emsg)->color =
lld_lcdGetPixelColor(emsg->x, emsg->y); gdisp_lld_getpixelcolor(emsg->x, emsg->y);
result = GLCD_DONE; result = GLCD_DONE;
#else
EMSG(glcd_msg_get_pixel_color);
((struct glcd_msg_get_pixel_color *)emsg)->color = 0;
result = GLCD_FAILED;
#endif
break; break;
} }
case GLCD_DRAW_PIXEL: { case GLCD_DRAW_PIXEL: {
EMSG(glcd_msg_draw_pixel); EMSG(glcd_msg_draw_pixel);
lld_lcdDrawPixel(emsg->x, emsg->y, emsg->color); gdisp_lld_drawpixel(emsg->x, emsg->y, emsg->color);
result = GLCD_DONE;
break;
}
case GLCD_WRITE_STREAM_START: {
lld_lcdWriteStreamStart();
result = GLCD_DONE;
break;
}
case GLCD_WRITE_STREAM_STOP: {
lld_lcdWriteStreamStop();
result = GLCD_DONE;
break;
}
case GLCD_WRITE_STREAM: {
EMSG(glcd_msg_write_stream);
lld_lcdWriteStream(emsg->buffer, emsg->size);
result = GLCD_DONE; result = GLCD_DONE;
break; break;
} }
case GLCD_VERTICAL_SCROLL: { case GLCD_VERTICAL_SCROLL: {
/* Hack 6: This may now fail if the low level driver doesn't
* support it. Previously this support was required
* in the driver by GLCD
*/
#if GDISP_HARDWARE_SCROLL
EMSG(glcd_msg_vertical_scroll); EMSG(glcd_msg_vertical_scroll);
lld_lcdVerticalScroll(emsg->x0, emsg->y0, emsg->x1, emsg->y1, emsg->lines); gdisp_lld_verticalscroll(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1, emsg->y1-emsg->y0+1, emsg->lines, 0);
result = GLCD_DONE; result = GLCD_DONE;
#else
result = GLCD_FAILED;
#endif
break; break;
} }
case GLCD_DRAW_CHAR: { case GLCD_DRAW_CHAR: {
EMSG(glcd_msg_draw_char); EMSG(glcd_msg_draw_char);
result = _lcdDrawChar(emsg); if (emsg->tpText)
gdisp_lld_drawchar(emsg->cx, emsg->cy, emsg->c, emsg->font, emsg->color);
else
gdisp_lld_fillchar(emsg->cx, emsg->cy, emsg->c, emsg->font, emsg->color, emsg->bkcolor);
/* We can't normally access a high level function here but in this case it is safe
* because the routine only accesses const data members (multi-thread safe).
*/
emsg->ret_width = lcdMeasureChar(emsg->c, emsg->font);
result = GLCD_DONE;
break; break;
} }
@ -147,27 +190,22 @@ static msg_t ThreadGLCDWorker(void *arg) {
return 0; return 0;
} }
void lcdInit(GLCDDriver *glcdp) { void lcdInit(GLCDDriver *UNUSED(glcdp)) {
workerThread = chThdCreateStatic(waGLCDWorkerThread, sizeof(waGLCDWorkerThread), NORMALPRIO, ThreadGLCDWorker, NULL); workerThread = chThdCreateStatic(waGLCDWorkerThread, sizeof(waGLCDWorkerThread), NORMALPRIO, ThreadGLCDWorker, NULL);
lld_lcdInit(); gdisp_lld_init();
lcd_width = lcdGetWidth();
lcd_height = lcdGetHeight();
lcdSetPowerMode(powerOn);
lcdSetOrientation(portrait);
} }
uint16_t lcdGetHeight(void) { uint16_t lcdGetHeight(void) {
return lld_lcdGetHeight(); return GDISP.Height;
} }
uint16_t lcdGetWidth(void) { uint16_t lcdGetWidth(void) {
return lld_lcdGetWidth(); return GDISP.Width;
} }
uint16_t lcdGetOrientation(void) { uint16_t lcdGetOrientation(void) {
return lld_lcdGetOrientation(); return GDISP.Orientation;
} }
glcd_result_t lcdSetPowerMode(uint8_t powerMode) { glcd_result_t lcdSetPowerMode(uint8_t powerMode) {
@ -188,18 +226,6 @@ glcd_result_t lcdSetOrientation(uint8_t newOrientation) {
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg); return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
} }
glcd_result_t lcdSetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
struct glcd_msg_set_window msg;
msg.action = GLCD_SET_WINDOW;
msg.x0 = x0;
msg.y0 = y0;
msg.x1 = x1;
msg.y1 = y1;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) { glcd_result_t lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
struct glcd_msg_fill_area msg; struct glcd_msg_fill_area msg;
@ -213,12 +239,6 @@ glcd_result_t lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, ui
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg); return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
} }
inline glcd_result_t _lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
lld_lcdFillArea(x0, y0, x1, y1, color);
return GLCD_DONE;
}
glcd_result_t lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n) { glcd_result_t lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n) {
struct glcd_msg_write_area msg; struct glcd_msg_write_area msg;
@ -233,15 +253,6 @@ glcd_result_t lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, u
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg); return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
} }
inline glcd_result_t _lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n) {
lld_lcdSetWindow(x0, y0, x1, y1);
lld_lcdWriteStreamStart();
lld_lcdWriteStream(buffer, n);
lld_lcdWriteStreamStop();
return GLCD_DONE;
}
glcd_result_t lcdClear(uint16_t color) { glcd_result_t lcdClear(uint16_t color) {
struct glcd_msg_clear msg; struct glcd_msg_clear msg;
@ -274,32 +285,6 @@ glcd_result_t lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color) {
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg); return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
} }
glcd_result_t lcdWriteStreamStart(void) {
struct glcd_msg_write_stream_start msg;
msg.action = GLCD_WRITE_STREAM_START;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdWriteStreamStop(void) {
struct glcd_msg_write_stream_stop msg;
msg.action = GLCD_WRITE_STREAM_STOP;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdWriteStream(uint16_t *buffer, uint16_t size) {
struct glcd_msg_write_stream msg;
msg.action = GLCD_WRITE_STREAM;
msg.buffer = buffer;
msg.size = size;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdVerticalScroll(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, int16_t lines) { glcd_result_t lcdVerticalScroll(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, int16_t lines) {
struct glcd_msg_vertical_scroll msg; struct glcd_msg_vertical_scroll msg;
@ -314,60 +299,16 @@ glcd_result_t lcdVerticalScroll(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t
} }
void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) { void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
// speed improvement if vertical or horizontal struct glcd_msg_draw_line msg;
if(x0 == x1) {
lcdFillArea(x0, y0, x0+1, y1, color);
} else if (y0 == y1) {
lcdFillArea(x0, y0, x1, y0+1, color);
} else { msg.action = GLCD_DRAW_LINE;
int16_t dy, dx; msg.x0 = x0;
int16_t addx = 1, addy = 1; msg.y0 = y0;
int16_t P, diff; msg.x1 = x1;
msg.y1 = y1;
msg.color = color;
int16_t i = 0; chMsgSend(workerThread, (msg_t)&msg);
dx = abs((int16_t)(x1 - x0));
dy = abs((int16_t)(y1 - y0));
if(x0 > x1)
addx = -1;
if(y0 > y1)
addy = -1;
if(dx >= dy) {
dy *= 2;
P = dy - dx;
diff = P - dx;
for(; i<=dx; ++i) {
lcdDrawPixel(x0, y0, color);
if(P < 0) {
P += dy;
x0 += addx;
} else {
P += diff;
x0 += addx;
y0 += addy;
}
}
} else {
dx *= 2;
P = dx - dy;
diff = P - dy;
for(; i<=dy; ++i) {
lcdDrawPixel(x0, y0, color);
if(P < 0) {
P += dx;
y0 += addy;
} else {
P += diff;
x0 += addx;
y0 += addy;
}
}
}
}
} }
uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) { uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) {
@ -388,77 +329,31 @@ uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t col
return msg.ret_width; return msg.ret_width;
} }
glcd_result_t _lcdDrawChar(struct glcd_msg_draw_char *m) { void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color) {
/* Working pointer */ struct glcd_msg_draw_circle msg;
const uint8_t* ptr;
uint8_t x, y;
/* Variables to store character details */ msg.action = GLCD_DRAW_CIRCLE;
uint8_t charWidth; msg.x = x;
uint8_t charHeight = lcdGetFontHeight(m->font); msg.y = y;
uint8_t padAfterChar = m->font[FONT_TABLE_PAD_AFTER_CHAR_IDX]; msg.radius = radius;
msg.filled = filled;
msg.color = color;
/* Local var to hold offset in font table */ chMsgSend(workerThread, (msg_t)&msg);
uint16_t charStartOffset; }
/* Working buffer for fast non-transparent text rendering [patch by Badger] */ void lcdDrawEllipse(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint8_t filled, uint16_t color) {
static uint16_t buf[20*16]; struct glcd_msg_draw_ellipse msg;
/* No support for nongraphic characters, so just ignore them */ msg.action = GLCD_DRAW_ELLIPSE;
if(m->c < 0x20 || m->c > 0x7F) { msg.x = x;
return GLCD_DONE; msg.y = y;
} msg.a = a;
msg.b = b;
msg.filled = filled;
msg.color = color;
/* Read the offset of the character data in the font table from the lookup table */ chMsgSend(workerThread, (msg_t)&msg);
charStartOffset = *(uint16_t*)(&m->font[FONT_TABLE_CHAR_LOOKUP_IDX + (m->c - 0x20) * 2]);
/* After we're done, position the pointer at the offset.
* The first byte that is immediately read will be the font width
* After that, actual 16-bit font data follows, first column down */
ptr = m->font + charStartOffset;
charWidth = *(ptr++);
/* Loop through the data and display. The font data is LSB first, down the column */
for(x = 0; x < charWidth; x++) {
/* Get the font bitmap data for the column */
uint16_t charData = *(uint16_t*)ptr;
for(y = 0; y < charHeight; y++) {
/* Draw the LSB on the screen accordingly. */
if(!m->tpText) {
/* Store data into working buffer (patch by Badger),
* Then write it all onto the LCD in one stroke */
buf[y*charWidth + x] = (charData & 0x01) ? m->color : m->bkcolor;
} else {
/* Just draw the needed pixels onto the LCD */
if (charData & 0x01)
lcdDrawPixel(m->cx+x, m->cy+y, m->color);
}
/* Shift the data down by one bit */
charData >>= 1;
}
/* Increment pointer by 2 bytes to the next column */
ptr += 2;
}
if(!m->tpText) {
/* [Patch by Badger] Write all in one stroke */
_lcdWriteArea(m->cx, m->cy, m->cx+charWidth, m->cy+charHeight, buf, charWidth*charHeight);
/* Do padding after character, if needed for solid text rendering
* TODO: To be optimised */
if (padAfterChar != 0) {
_lcdFillArea(m->cx+charWidth, m->cy+charHeight, m->cx+charWidth+padAfterChar, m->cy+charHeight, m->bkcolor);
}
}
/* Return the width of the character, we need it so that lcdDrawString may work
* We don't have a static address counter */
m->ret_width = charWidth + padAfterChar;
return GLCD_DONE;
} }
/* WARNING: No boundary checks! Unpredictable behaviour if text exceeds boundary */ /* WARNING: No boundary checks! Unpredictable behaviour if text exceeds boundary */
@ -471,25 +366,7 @@ void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_
} }
uint16_t lcdMeasureChar(char c, font_t font) { uint16_t lcdMeasureChar(char c, font_t font) {
/* Variables to store character details */ return (_getCharWidth(font, c)+font->charPadding) * font->xscale;
uint8_t charWidth;
uint8_t padAfterChar = font[FONT_TABLE_PAD_AFTER_CHAR_IDX];
/* Local var to hold offset in font table */
uint16_t charStartOffset;
/* No support for nongraphic characters, so just ignore them */
if(c < 0x20 || c > 0x7F) {
return 0;
}
/* Read the offset of the character data in the font table from the lookup table */
charStartOffset = *(uint16_t*)(&font[FONT_TABLE_CHAR_LOOKUP_IDX + (c - 0x20) * 2]);
/* Retrurn the byte at the offset, that's our charWidth */
charWidth = *(font + charStartOffset);
return charWidth+padAfterChar;
} }
uint16_t lcdMeasureString(const char *str, font_t font) { uint16_t lcdMeasureString(const char *str, font_t font) {
@ -502,6 +379,10 @@ uint16_t lcdMeasureString(const char *str, font_t font) {
return result; return result;
} }
uint16_t lcdGetFontHeight(font_t font) {
return font->height;
}
uint16_t lcdBGR2RGB(uint16_t color) { uint16_t lcdBGR2RGB(uint16_t color) {
uint16_t r, g, b, rgb; uint16_t r, g, b, rgb;
@ -515,8 +396,8 @@ uint16_t lcdBGR2RGB(uint16_t color) {
} }
void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color) { void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color) {
uint16_t i, TempX; uint16_t TempX;
uint16_t j, TempY; uint16_t TempY;
if (x0 > x1) { if (x0 > x1) {
TempX = x1; TempX = x1;
@ -548,67 +429,3 @@ void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const
/* Abhishek: default to solid text for this? */ /* Abhishek: default to solid text for this? */
lcdDrawString(x0+off_left, y0+off_up, str, font, fontColor, bkColor, solid); lcdDrawString(x0+off_left, y0+off_up, str, font, fontColor, bkColor, solid);
} }
void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color) {
int16_t a, b, P;
a = 0;
b = radius;
P = 1 - radius;
do {
if(filled) {
lcdDrawLine(x-a, y+b, x+a, y+b, color);
lcdDrawLine(x-a, y-b, x+a, y-b, color);
lcdDrawLine(x-b, y+a, x+b, y+a, color);
lcdDrawLine(x-b, y-a, x+b, y-a, color);
} else {
lcdDrawPixel(a+x, b+y, color);
lcdDrawPixel(b+x, a+y, color);
lcdDrawPixel(x-a, b+y, color);
lcdDrawPixel(x-b, a+y, color);
lcdDrawPixel(b+x, y-a, color);
lcdDrawPixel(a+x, y-b, color);
lcdDrawPixel(x-a, y-b, color);
lcdDrawPixel(x-b, y-a, color);
}
if(P < 0)
P += 3 + 2*a++;
else
P += 5 + 2*(a++ - b--);
} while(a <= b);
}
void lcdDrawEllipse(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint8_t filled, uint16_t color) {
int dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */
long a2 = a*a, b2 = b*b;
long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */
do {
if(filled){
lcdDrawLine(x-dx,y+dy,x+dx,y+dy, color);
lcdDrawLine(x-dx,y-dy,x+dx,y-dy, color);
}else{
lcdDrawPixel(x+dx, y+dy, color); /* I. Quadrant */
lcdDrawPixel(x-dx, y+dy, color); /* II. Quadrant */
lcdDrawPixel(x-dx, y-dy, color); /* III. Quadrant */
lcdDrawPixel(x+dx, y-dy, color); /* IV. Quadrant */
}
e2 = 2*err;
if(e2 < (2*dx+1)*b2) {
dx++;
err += (2*dx+1)*b2;
}
if(e2 > -(2*dy-1)*a2) {
dy--;
err -= (2*dy-1)*a2;
}
} while(dy >= 0);
while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */
lcdDrawPixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
lcdDrawPixel(x-dx, y, color);
}
}

59
glcd/glcd.h
View file

@ -23,19 +23,42 @@
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "fonts.h"
#if !defined(LCD_USE_FSMC) && !defined(LCD_USE_GPIO) && !defined(LCD_USE_SPI)
#include "glcdconf.h"
#endif
#include "ssd1289_lld.h"
#include "s6d1121_lld.h"
#define PORTRAIT (lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv) #define PORTRAIT (lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv)
#define LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv) #define LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)
/* LCD color */ /* New fonts */
extern const struct font fontSmall;
extern const struct font fontSmallDouble;
extern const struct font fontSmallNarrow;
extern const struct font fontLarger;
extern const struct font fontLargerDouble;
extern const struct font fontLargerNarrow;
extern const struct font fontUI1;
extern const struct font fontUI1Double;
extern const struct font fontUI1Narrow;
extern const struct font fontUI2;
extern const struct font fontUI2Double;
extern const struct font fontUI2Narrow;
extern const struct font fontLargeNumbers;
extern const struct font fontLargeNumbersDouble;
extern const struct font fontLargeNumbersNarrow;
/* Old font names */
#define font_Small (&fontSmall)
#define font_SmallDouble (&fontSmallDouble)
#define font_SmallNarrow (&fontSmall)
#define font_Larger (&fontLarger)
#define font_LargerDouble (&fontLargerDouble)
#define font_LargerNarrow (&fontLargerNarrow)
#define font_MediumBold (&fontUI1)
#define font_MediumBoldDouble (&fontUI1Double)
#define font_MediumBoldNarrow (&fontUI1Narrow)
#define font_LargeNumbers (&fontLargeNumbers)
#define font_LargeNumbersDouble (&fontLargeNumbersDouble)
#define font_LargeNumbersNarrow (&fontLargeNumbersNarrow)
/* LCD color - Note that GLCD only supports 16 bit color in the API */
#define White 0xFFFF #define White 0xFFFF
#define Black 0x0000 #define Black 0x0000
#define Grey 0xF7DE #define Grey 0xF7DE
@ -50,15 +73,17 @@
#define RGB565CONVERT(red, green, blue) \ #define RGB565CONVERT(red, green, blue) \
(uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 )) (uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 ))
enum orientation {portrait, landscape, portraitInv, landscapeInv}; #ifndef _GDISP_LLD_H
/* Don't double define these at the low level driver */
typedef const struct font *font_t;
enum orientation {portrait, landscape, portraitInv, landscapeInv};
enum powermode {powerOff, powerSleep, powerOn};
#define sleepOn powerSleep
#define sleepOff powerOn
#endif
enum filled {frame, filled}; enum filled {frame, filled};
enum transparency {solid, transparent}; enum transparency {solid, transparent};
enum powermode {powerOff, powerOn, sleepOn, sleepOff};
typedef const uint8_t* font_t;
// A few macros
#define lcdGetFontHeight(font) (font[FONT_TABLE_HEIGHT_IDX])
/** /**
* @brief Structure representing a GLCD driver. * @brief Structure representing a GLCD driver.
@ -83,7 +108,6 @@ extern "C" {
void lcdInit(GLCDDriver *GLCDD1); void lcdInit(GLCDDriver *GLCDD1);
glcd_result_t lcdClear(uint16_t color); glcd_result_t lcdClear(uint16_t color);
glcd_result_t lcdSetOrientation(uint8_t newOrientation); glcd_result_t lcdSetOrientation(uint8_t newOrientation);
glcd_result_t lcdSetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
glcd_result_t lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color); glcd_result_t lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
glcd_result_t lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n); glcd_result_t lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n);
glcd_result_t lcdSetPowerMode(uint8_t powerMode); glcd_result_t lcdSetPowerMode(uint8_t powerMode);
@ -103,6 +127,7 @@ void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_
/* Character measuring functions */ /* Character measuring functions */
uint16_t lcdMeasureChar(char c, font_t font); uint16_t lcdMeasureChar(char c, font_t font);
uint16_t lcdMeasureString(const char* str, font_t font); uint16_t lcdMeasureString(const char* str, font_t font);
uint16_t lcdGetFontHeight(font_t font);
/* Size and orientation related */ /* Size and orientation related */
uint16_t lcdGetHeight(void); uint16_t lcdGetHeight(void);

4
glcd/glcd.mk
View file

@ -1,5 +1,5 @@
LCD_GLCD_SRC = $(LCDLIB)/glcd/glcd.c \ LCD_GLCD_SRC = $(LCDLIB)/glcd/glcd.c \
$(LCDLIB)/glcd/fonts.c \
$(LCDLIB)/glcd/console.c $(LCDLIB)/glcd/console.c
LCD_GLCD_INC = $(LCDLIB)/glcd LCD_GLCD_INC = $(LCDLIB)/glcd \
${CHIBIOS}/os/halext/include ${CHIBIOS}/os/halext/src

55
glcd/glcdWorker.h
View file

@ -27,17 +27,16 @@
enum glcd_action { GLCD_SET_POWERMODE, enum glcd_action { GLCD_SET_POWERMODE,
GLCD_SET_ORIENTATION, GLCD_SET_ORIENTATION,
GLCD_SET_WINDOW,
GLCD_FILL_AREA, GLCD_FILL_AREA,
GLCD_WRITE_AREA, GLCD_WRITE_AREA,
GLCD_CLEAR, GLCD_CLEAR,
GLCD_GET_PIXEL_COLOR, GLCD_GET_PIXEL_COLOR,
GLCD_DRAW_PIXEL, GLCD_DRAW_PIXEL,
GLCD_WRITE_STREAM_START,
GLCD_WRITE_STREAM_STOP,
GLCD_WRITE_STREAM,
GLCD_VERTICAL_SCROLL, GLCD_VERTICAL_SCROLL,
GLCD_DRAW_CHAR, GLCD_DRAW_CHAR,
GLCD_DRAW_LINE,
GLCD_DRAW_CIRCLE,
GLCD_DRAW_ELLIPSE,
}; };
#define _glcd_msg_base \ #define _glcd_msg_base \
@ -111,21 +110,6 @@ struct glcd_msg_draw_pixel {
uint16_t color; uint16_t color;
}; };
struct glcd_msg_write_stream_start {
_glcd_msg_base
};
struct glcd_msg_write_stream_stop {
_glcd_msg_base
};
struct glcd_msg_write_stream {
_glcd_msg_base
uint16_t *buffer;
uint16_t size;
};
struct glcd_msg_vertical_scroll { struct glcd_msg_vertical_scroll {
_glcd_msg_base _glcd_msg_base
@ -136,6 +120,39 @@ struct glcd_msg_vertical_scroll {
int16_t lines; int16_t lines;
}; };
struct glcd_msg_draw_line {
_glcd_msg_base
uint16_t x0;
uint16_t y0;
uint16_t x1;
uint16_t y1;
int16_t color;
};
struct glcd_msg_draw_circle {
_glcd_msg_base
uint16_t x;
uint16_t y;
uint16_t radius;
uint16_t y1;
uint8_t filled;
int16_t color;
};
struct glcd_msg_draw_ellipse {
_glcd_msg_base
uint16_t x;
uint16_t y;
uint16_t a;
uint16_t b;
uint16_t y1;
uint8_t filled;
int16_t color;
};
struct glcd_msg_draw_char { struct glcd_msg_draw_char {
_glcd_msg_base; _glcd_msg_base;

25
glcd/readme.txt Normal file
View file

@ -0,0 +1,25 @@
GLCD now uses the GDISP low level drivers and fonts.
To update your make to use this new version:
Add the low level driver yo want to use to your make file. eg.
include $(CHIBIOS)/os/halext/drivers/gdispTestStub/gdisp_lld.mk
There some restrictions that GLCD places on your use of new features and on the capabilities
of the low level driver.
They are:
1/ GLCD requires a driver that supports RGB565 pixel format. This is a
limitation of the GLCD API. To update the API would create compatability
issues with existing applications.
2/ If you want to use the GLCD scroll or the GLCD read-pixel calls then your
low level driver must support them. If it doesn't these calls will
fail.
3/ You cannot reduce the code size like in GDISP by defining macros to
compile out code that you are not using.
4/ Some of the new features of GDISP like right or center justified text are not
supported as there is no equivelant API in GDISP.
5/ There is no mechanism to send hardware specific commands to the low level driver
such as commands to control the back-light.
What it does do that GDISP currently doesn't:
1/ Asynchronous multi-thread support.

247
halext/drivers/gdispS6d1121/s6d1121_lld.c.h
View file

@ -1,4 +1,3 @@
<<<<<<< HEAD
/* /*
ChibiOS/RT - Copyright (C) 2012 ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
@ -243,249 +242,3 @@ static void lld_lcdResetViewPort(void) {
} }
#endif /* S6D1121_H */ #endif /* S6D1121_H */
=======
/*
ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver 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.
ChibiOS-LCD-Driver 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 <http://www.gnu.org/licenses/>.
*/
#ifndef S6D1121_H
#define S6D1121_H
// I/O assignments
#define LCD_BL_GPIO GPIOB
#define LCD_BL_PIN 8
#define LCD_CS_GPIO GPIOD
#define LCD_CS_PIN 7
#define LCD_RS_GPIO GPIOD
#define LCD_RS_PIN 11
#define LCD_RST_GPIO GPIOD
#define LCD_RST_PIN 10
#define LCD_RD_GPIO GPIOD
#define LCD_RD_PIN 9
#define LCD_WR_GPIO GPIOD
#define LCD_WR_PIN 8
#define LCD_D0_GPIO GPIOD
#define LCD_D4_GPIO GPIOE
/* all interfaces use RST via GPIO */
/* TODO: option to disable RST; assumes RST is tied high */
#define LCD_RST_LOW palClearPad(LCD_RST_GPIO, LCD_RST_PIN)
#define LCD_RST_HIGH palSetPad(LCD_RST_GPIO, LCD_RST_PIN)
#define s6d1121_delay(n) halPolledDelay(MS2RTT(n));
#if defined(LCD_USE_GPIO)
#define LCD_CS_LOW palClearPad(LCD_CS_GPIO, LCD_CS_PIN)
#define LCD_CS_HIGH palSetPad(LCD_CS_GPIO, LCD_CS_PIN)
#define LCD_RS_LOW palClearPad(LCD_RS_GPIO, LCD_RS_PIN)
#define LCD_RS_HIGH palSetPad(LCD_RS_GPIO, LCD_RS_PIN)
#define LCD_RD_LOW palClearPad(LCD_RD_GPIO, LCD_RD_PIN)
#define LCD_RD_HIGH palSetPad(LCD_RD_GPIO, LCD_RD_PIN)
#define LCD_WR_LOW palClearPad(LCD_WR_GPIO, LCD_WR_PIN)
#define LCD_WR_HIGH palSetPad(LCD_WR_GPIO, LCD_WR_PIN)
#define LCD_BL_LOW palClearPad(LCD_BL_GPIO, LCD_BL_PIN)
#define LCD_BL_HIGH palSetPad(LCD_BL_GPIO, LCD_BL_PIN)
static inline void lld_lcddelay(void) { asm volatile ("nop"); asm volatile ("nop"); }
static inline void lld_lcdwrite(uint16_t db) {
LCD_D4_GPIO->BSRR.W=((~db&0xFFF0)<<16)|(db&0xFFF0);
LCD_D0_GPIO->BSRR.W=((~db&0x000F)<<16)|(db&0x000F);
LCD_WR_LOW;
lld_lcddelay();
LCD_WR_HIGH;
}
static __inline uint16_t lld_lcdReadData(void) {
uint16_t value=0;
LCD_RS_HIGH; LCD_WR_HIGH; LCD_RD_LOW;
#ifndef STM32F4XX
// change pin mode to digital input
LCD_DATA_PORT->CRH = 0x47444444;
LCD_DATA_PORT->CRL = 0x47444444;
#endif
#ifndef STM32F4XX
// change pin mode back to digital output
LCD_DATA_PORT->CRH = 0x33333333;
LCD_DATA_PORT->CRL = 0x33333333;
#endif
LCD_RD_HIGH;
return value;
}
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
uint16_t lcdRAM;
LCD_CS_LOW; LCD_RS_LOW;
lld_lcdwrite(lcdReg);
LCD_RS_HIGH;
lcdRAM = lld_lcdReadData();
LCD_CS_HIGH;
return lcdRAM;
}
static void lld_lcdWriteIndex(uint16_t lcdReg) {
LCD_RS_LOW;
lld_lcdwrite(lcdReg);
LCD_RS_HIGH;
}
static void lld_lcdWriteData(uint16_t lcdData) {
lld_lcdwrite(lcdData);
}
static void lld_lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {
LCD_CS_LOW;
lld_lcdWriteIndex(lcdReg);
lld_lcdWriteData(lcdRegValue);
LCD_CS_HIGH;
}
static __inline void lld_lcdWriteStreamStart(void) {
LCD_CS_LOW;
lld_lcdWriteIndex(0x0022);
}
static __inline void lld_lcdWriteStreamStop(void) {
LCD_CS_HIGH;
}
static __inline void lld_lcdWriteStream(uint16_t *buffer, uint16_t size) {
uint16_t i;
for(i = 0; i < size; i++) { lld_lcdwrite(buffer[i]); }
}
static __inline void lld_lcdReadStreamStart(void) { /* TODO */ }
static __inline void lld_lcdReadStreamStop(void) { /* TODO */ }
static __inline void lld_lcdReadStream(uint16_t *UNUSED(buffer), size_t UNUSED(size)) { /* TODO */ }
#elif defined(LCD_USE_FSMC)
#define LCD_REG (*((volatile uint16_t *) 0x60000000)) /* RS = 0 */
#define LCD_RAM (*((volatile uint16_t *) 0x60020000)) /* RS = 1 */
static __inline void lld_lcdWriteIndex(uint16_t index) { LCD_REG = index; }
static __inline void lld_lcdWriteData(uint16_t data) { LCD_RAM = data; }
static __inline void lld_lcdWriteReg(uint16_t lcdReg,uint16_t lcdRegValue) {
LCD_REG = lcdReg;
LCD_RAM = lcdRegValue;
}
static __inline uint16_t lld_lcdReadData(void) { return (LCD_RAM); }
static __inline uint16_t lld_lcdReadReg(uint16_t lcdReg) {
LCD_REG = lcdReg;
return LCD_RAM;
}
static __inline void lld_lcdWriteStreamStart(void) { LCD_REG = 0x0022; }
static __inline void lld_lcdWriteStreamStop(void) {}
static __inline void lld_lcdWriteStream(uint16_t *buffer, uint16_t size) {
uint16_t i;
for(i = 0; i < size; i++) LCD_RAM = buffer[i];
}
static __inline void lld_lcdReadStreamStart(void) { LCD_REG = 0x0022; }
static __inline void lld_lcdReadStreamStop(void) {}
static __inline void lld_lcdReadStream(uint16_t *buffer, size_t size) {
uint16_t i;
volatile uint16_t dummy;
/* throw away first value read */
dummy = LCD_RAM;
for(i = 0; i < size; i++) buffer[i] = LCD_RAM;
}
#elif defined(LCD_USE_SPI)
#error "gdispS6d1121: LCD_USE_SPI not implemented yet"
#else
#error "gdispS6d1121: No known LCD_USE_XXX has been defined"
#endif
static void lld_lcdSetCursor(coord_t x, coord_t y) {
/* R20h - 8 bit
* R21h - 9 bit
*/
switch(GDISP.Orientation) {
case portraitInv:
lld_lcdWriteReg(0x0020, (SCREEN_WIDTH-1-x) & 0x00FF);
lld_lcdWriteReg(0x0021, (SCREEN_HEIGHT-1-y) & 0x01FF);
break;
case portrait:
lld_lcdWriteReg(0x0020, x & 0x00FF);
lld_lcdWriteReg(0x0021, y & 0x01FF);
break;
case landscape:
lld_lcdWriteReg(0x0020, y & 0x00FF);
lld_lcdWriteReg(0x0021, x & 0x01FF);
break;
case landscapeInv:
lld_lcdWriteReg(0x0020, (SCREEN_WIDTH - y - 1) & 0x00FF);
lld_lcdWriteReg(0x0021, (SCREEN_HEIGHT - x - 1) & 0x01FF);
break;
}
}
static void lld_lcdSetViewPort(uint16_t x, uint16_t y, uint16_t cx, uint16_t cy) {
/* HSA / HEA are 8 bit
* VSA / VEA are 9 bit
* use masks 0x00FF and 0x01FF to enforce this
*/
switch(GDISP.Orientation) {
case portrait:
lld_lcdWriteReg(0x46, (((x+cx-1) << 8) & 0xFF00 ) | (x & 0x00FF));
lld_lcdWriteReg(0x48, y & 0x01FF);
lld_lcdWriteReg(0x47, (y+cy-1) & 0x01FF);
break;
case landscape:
lld_lcdWriteReg(0x46, (((x+cx-1) << 8) & 0xFF00) | ((y+cy) & 0x00FF));
lld_lcdWriteReg(0x48, x & 0x01FF);
lld_lcdWriteReg(0x47, (x+cx-1) & 0x01FF);
break;
case portraitInv:
lld_lcdWriteReg(0x46, (((SCREEN_WIDTH-x-1) & 0x00FF) << 8) | ((SCREEN_WIDTH - (x+cx)) & 0x00FF));
lld_lcdWriteReg(0x48, (SCREEN_HEIGHT-(y+cy)) & 0x01FF);
lld_lcdWriteReg(0x47, (SCREEN_HEIGHT-y-1) & 0x01FF);
break;
case landscapeInv:
lld_lcdWriteReg(0x46, (((SCREEN_WIDTH - y - 1) & 0x00FF) << 8) | ((SCREEN_WIDTH - (y+cy)) & 0x00FF));
lld_lcdWriteReg(0x48, (SCREEN_HEIGHT - (x+cx)) & 0x01FF);
lld_lcdWriteReg(0x47, (SCREEN_HEIGHT - x - 1) & 0x01FF);
break;
}
lld_lcdSetCursor(x, y);
}
static void lld_lcdResetViewPort(void) {
switch(GDISP.Orientation) {
case portrait:
case portraitInv:
lld_lcdSetViewPort(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
break;
case landscape:
case landscapeInv:
lld_lcdSetViewPort(0, 0, SCREEN_HEIGHT, SCREEN_WIDTH);
break;
}
}
#endif /* S6D1121_H */
>>>>>>> d61cff7a7976cd9097e5c3634ae4b1be64f736c3

2
halext/drivers/gdispTestStub/gdisp_lld.c
View file

@ -308,7 +308,7 @@ void gdisp_lld_drawpixel(coord_t UNUSED(x), coord_t UNUSED(y), color_t UNUSED(co
} }
#endif #endif
#if GDISP_HARDWARE_CONTROL || defined(__DOXYGEN__) #if (GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL) || defined(__DOXYGEN__)
/** /**
* @brief Driver Control * @brief Driver Control
* @detail Unsupported control codes are ignored. * @detail Unsupported control codes are ignored.

20
halext/include/gdisp.h
View file

@ -59,26 +59,6 @@
#define Pink HTML2COLOR(0xFFC0CB) #define Pink HTML2COLOR(0xFFC0CB)
#define SkyBlue HTML2COLOR(0x87CEEB) #define SkyBlue HTML2COLOR(0x87CEEB)
/**
* @brief Driver Control Constants
* @detail Unsupported control codes are ignored.
* @note The value parameter should always be typecast to (void *).
* @note There are some predefined and some specific to the low level driver.
* @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t
* GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t
* GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver
* that only supports off/on anything other
* than zero is on.
* GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100.
* GDISP_CONTROL_LLD - Low level driver control constants start at
* this value.
*/
#define GDISP_CONTROL_POWER 0
#define GDISP_CONTROL_ORIENTATION 1
#define GDISP_CONTROL_BACKLIGHT 2
#define GDISP_CONTROL_CONTRAST 3
#define GDISP_CONTROL_LLD 1000
/*===========================================================================*/ /*===========================================================================*/
/* Driver pre-compile time settings. */ /* Driver pre-compile time settings. */
/*===========================================================================*/ /*===========================================================================*/

24
halext/include/gdisp_lld.h
View file

@ -36,6 +36,30 @@
#include "gdisp_lld_config.h" #include "gdisp_lld_config.h"
/*===========================================================================*/
/* Constants. */
/*===========================================================================*/
/**
* @brief Driver Control Constants
* @detail Unsupported control codes are ignored.
* @note The value parameter should always be typecast to (void *).
* @note There are some predefined and some specific to the low level driver.
* @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t
* GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t
* GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver
* that only supports off/on anything other
* than zero is on.
* GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100.
* GDISP_CONTROL_LLD - Low level driver control constants start at
* this value.
*/
#define GDISP_CONTROL_POWER 0
#define GDISP_CONTROL_ORIENTATION 1
#define GDISP_CONTROL_BACKLIGHT 2
#define GDISP_CONTROL_CONTRAST 3
#define GDISP_CONTROL_LLD 1000
/*===========================================================================*/ /*===========================================================================*/
/* Error checks. */ /* Error checks. */
/*===========================================================================*/ /*===========================================================================*/

30
halext/include/glcd.h
View file

@ -45,13 +45,21 @@ enum powermode {powerOff, powerOn, sleepOn, sleepOff};
#define sleepOn powerSleep #define sleepOn powerSleep
#define sleepOff powerOn #define sleepOff powerOn
#define font_Small (&fontSmall) #define font_Small (&fontSmall)
#define font_Larger (&fontLarger) #define font_SmallDouble (&fontSmallDouble)
#define font_MediumBold (&fontUI1) #define font_SmallNarrow (&fontSmall)
#define font_LargeNumbers (&fontLargeNumbers) #define font_Larger (&fontLarger)
#define font_LargerDouble (&fontLargerDouble)
#define font_LargerNarrow (&fontLargerNarrow)
#define font_MediumBold (&fontUI1)
#define font_MediumBoldDouble (&fontUI1Double)
#define font_MediumBoldNarrow (&fontUI1Narrow)
#define font_LargeNumbers (&fontLargeNumbers)
#define font_LargeNumbersDouble (&fontLargeNumbersDouble)
#define font_LargeNumbersNarrow (&fontLargeNumbersNarrow)
#define GLCDDriver GDISPDriver #define GLCDDriver GDISPDriver
#define GLCDD1 GDISP1 #define GLCDD GDISP
enum glcd_result { GLCD_DONE, enum glcd_result { GLCD_DONE,
GLCD_FAILED, GLCD_FAILED,
@ -63,10 +71,10 @@ typedef enum glcd_result glcd_result_t;
/* Core functions */ /* Core functions */
#define lcdInit(dvr) gdispInit(dvr) #define lcdInit(dvr) gdispInit(dvr)
#define lcdClear(color) (gdispClear(color), GLCD_DONE) #define lcdClear(color) (gdispClear(color), GLCD_DONE)
#define lcdSetOrientation(newO) (gdispSetOrientation(newO), (GDISP1.Orientation == (newO) ? GLCD_DONE : GLCD_FAILED)) #define lcdSetOrientation(newO) (gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(int)newO), (GDISP1.Orientation == (newO) ? GLCD_DONE : GLCD_FAILED))
#define lcdFillArea(x0,y0,x1,y1,c) (gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)), GLCD_DONE) #define lcdFillArea(x0,y0,x1,y1,c) (gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)), GLCD_DONE)
#define lcdWriteArea(x0,y0,x1,y1,b,n) (gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b)), GLCD_DONE) #define lcdWriteArea(x0,y0,x1,y1,b,n) (gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b)), GLCD_DONE)
#define lcdSetPowerMode(pm) (gdispSetPowerMode(pm), (GDISP1.Powermode == (pm) ? GLCD_DONE : GLCD_FAILED)) #define lcdSetPowerMode(pm) (gdispControl(GDISP_CONTROL_POWER, (void *)(int)pm), (GDISP1.Powermode == (pm) ? GLCD_DONE : GLCD_FAILED))
/* Drawing functions */ /* Drawing functions */
#define lcdDrawPixel(x,y,c) (gdispDrawPixel((x),(y),(c)), GLCD_DONE) #define lcdDrawPixel(x,y,c) (gdispDrawPixel((x),(y),(c)), GLCD_DONE)
@ -83,12 +91,12 @@ typedef enum glcd_result glcd_result_t;
/* Character measuring functions */ /* Character measuring functions */
#define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(f))+(f)->charPadding) #define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(f))+(f)->charPadding)
#define lcdMeasureString(s,f) (gdispGetStringWidth((s),(f))+(f)->charPadding) #define lcdMeasureString(s,f) (gdispGetStringWidth((s),(f))+(f)->charPadding)
#define lcdGetFontHeight(font) gdispGetFontMetric(font, fontHeight) #define lcdGetFontHeight(f) gdispGetFontMetric((f), fontHeight)
/* Size and orientation related */ /* Size and orientation related */
#define lcdGetHeight() (GDISP1.Height) #define lcdGetHeight() (GDISP.Height)
#define lcdGetWidth() (GDISP1.Width) #define lcdGetWidth() (GDISP.Width)
#define lcdGetOrientation() (GDISP1.Orientation) #define lcdGetOrientation() (GDISP.Orientation)
/* BGR->RGB and pixel readback */ /* BGR->RGB and pixel readback */
#define lcdBGR2RGB(c) RGB2COLOR(BLUE_OF(c),GREEN_OF(c),RED_OF(c)) #define lcdBGR2RGB(c) RGB2COLOR(BLUE_OF(c),GREEN_OF(c),RED_OF(c))