From 34075031de2dd0695e0e239c1dad0429fcc3e2f1 Mon Sep 17 00:00:00 2001
From: Andrew Hannam <andrewh@inmarket.com.au>
Date: Mon, 6 Aug 2012 11:30:02 +1000
Subject: Backport GDISP low level drivers to GLCD
see GLCD/readme.txt
---
glcd/console.c | 342 ++++-----
glcd/fonts.c | 767 --------------------
glcd/fonts.h | 39 -
glcd/glcd.c | 1045 +++++++++++----------------
glcd/glcd.h | 271 +++----
glcd/glcd.mk | 10 +-
glcd/glcdWorker.h | 323 +++++----
glcd/readme.txt | 25 +
halext/drivers/gdispS6d1121/s6d1121_lld.c.h | 735 +++++++------------
halext/drivers/gdispTestStub/gdisp_lld.c | 2 +-
halext/include/gdisp.h | 20 -
halext/include/gdisp_lld.h | 24 +
halext/include/glcd.h | 30 +-
13 files changed, 1238 insertions(+), 2395 deletions(-)
delete mode 100644 glcd/fonts.c
delete mode 100644 glcd/fonts.h
create mode 100644 glcd/readme.txt
diff --git a/glcd/console.c b/glcd/console.c
index 714351d0..caddfce2 100644
--- a/glcd/console.c
+++ b/glcd/console.c
@@ -1,171 +1,171 @@
-/*
- 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 "ch.h"
-
-#include "fonts.h"
-#include "glcd.h"
-#include "console.h"
-
-/*
- * Interface implementation. The interface is write only
- */
-
-static size_t writes(void *ip, const uint8_t *bp, size_t n) {
- return lcdConsoleWrite((GLCDConsole *)ip, bp, n);
-}
-
-static size_t reads(void *ip, uint8_t *bp, size_t n) {
- (void)ip;
- (void)bp;
- (void)n;
-
- return 0;
-}
-
-static msg_t put(void *ip, uint8_t b) {
- return lcdConsolePut((GLCDConsole *)ip, (char)b);
-}
-
-static msg_t get(void *ip) {
- (void)ip;
-
- return RDY_OK;
-}
-
-static msg_t putt(void *ip, uint8_t b, systime_t timeout) {
- (void)timeout;
-
- /* TODO: handle timeout */
-
- return lcdConsolePut((GLCDConsole *)ip, (char)b);
-}
-
-static msg_t gett(void *ip, systime_t timeout) {
- (void)ip;
- (void)timeout;
-
- return RDY_OK;
-}
-
-static size_t writet(void *ip, const uint8_t *bp, size_t n, systime_t time) {
- (void)time;
-
- return lcdConsoleWrite((GLCDConsole *)ip, bp, n);
-}
-
-static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t time) {
- (void)ip;
- (void)bp;
- (void)n;
- (void)time;
-
- return 0;
-}
-
-static chnflags_t getflags(void *ip) {
- _chn_get_and_clear_flags_impl(ip);
-}
-
-static const struct GLCDConsoleVMT vmt = {
- writes, reads, put, get,
- putt, gett, writet, readt,
- getflags
-};
-
-
-msg_t lcdConsoleInit(GLCDConsole *console, uint16_t x0, uint16_t y0, uint16_t width, uint16_t height, font_t font, uint16_t bkcolor, uint16_t color) {
- const uint8_t* ptr;
- uint16_t chi;
- uint16_t x,y;
-
- console->vmt = &vmt;
- /* read font, get height */
- console->fy = font[FONT_TABLE_HEIGHT_IDX];
-
- /* calculate the size of the console as an integer multiple of characters height*/
- console->sx = width;
- console->sy = (((int16_t)(height/console->fy))-1)*console->fy;
-
- console->cx = 0;
- console->cy = 0;
- console->x0 = x0;
- console->y0 = y0;
-
- console->bkcolor = bkcolor;
- console->color = color;
-
- console->font = font;
-
- lcdFillArea(x0, y0, x0+width, y0+height, console->bkcolor);
-}
-
-msg_t lcdConsolePut(GLCDConsole *console, char c) {
- uint8_t width;
-
- if(c == '\n') {
- /* clear the text at the end of the line */
- if(console->cx < console->sx)
- lcdFillArea(console->x0 + console->cx, console->y0 + console->cy,
- console->x0 + console->sx, console->y0 + console->cy + console->fy,
- console->bkcolor);
- console->cx = 0;
- console->cy += console->fy;
- } else if(c == '\r') {
- /* TODO: work backwards through the buffer to the start of the current line */
- //console->cx = 0;
- } else {
- width = lcdMeasureChar(c, console->font);
- if((console->cx + width) >= console->sx) {
- /* clear the text at the end of the line */
- lcdFillArea(console->x0 + console->cx, console->y0 + console->cy,
- console->x0 + console->cx + width, console->y0 + console->cy + console->fy,
- console->bkcolor);
- console->cx = 0;
- console->cy += console->fy;
- }
-
- if((console->cy > console->sy)) {
-
- lcdVerticalScroll(console->x0, console->y0, console->x0 + console->sx,
- console->y0 + console->sy + console->fy, console->fy);
- /* reset the cursor */
- console->cx = 0;
- console->cy = console->sy;
- }
-
- lcdDrawChar(console->x0 + console->cx, console->y0 + console->cy, c,
- console->font, console->color, console->bkcolor, solid);
-
- /* update cursor */
- console->cx += width;
- }
-
-}
-
-msg_t lcdConsoleWrite(GLCDConsole *console, uint8_t *bp, size_t n) {
- size_t i;
- for(i = 0; i < n; i++)
- lcdConsolePut(console, bp[i]);
-
- return RDY_OK;
-}
-
-
+/*
+ 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 "ch.h"
+
+#include "glcd.h"
+#include "console.h"
+
+/*
+ * Interface implementation. The interface is write only
+ */
+
+static size_t writes(void *ip, const uint8_t *bp, size_t n) {
+ return lcdConsoleWrite((GLCDConsole *)ip, bp, n);
+}
+
+static size_t reads(void *ip, uint8_t *bp, size_t n) {
+ (void)ip;
+ (void)bp;
+ (void)n;
+
+ return 0;
+}
+
+static msg_t put(void *ip, uint8_t b) {
+ return lcdConsolePut((GLCDConsole *)ip, (char)b);
+}
+
+static msg_t get(void *ip) {
+ (void)ip;
+
+ return RDY_OK;
+}
+
+static msg_t putt(void *ip, uint8_t b, systime_t timeout) {
+ (void)timeout;
+
+ /* TODO: handle timeout */
+
+ return lcdConsolePut((GLCDConsole *)ip, (char)b);
+}
+
+static msg_t gett(void *ip, systime_t timeout) {
+ (void)ip;
+ (void)timeout;
+
+ return RDY_OK;
+}
+
+static size_t writet(void *ip, const uint8_t *bp, size_t n, systime_t time) {
+ (void)time;
+
+ return lcdConsoleWrite((GLCDConsole *)ip, bp, n);
+}
+
+static size_t readt(void *ip, uint8_t *bp, size_t n, systime_t time) {
+ (void)ip;
+ (void)bp;
+ (void)n;
+ (void)time;
+
+ return 0;
+}
+
+static uint16_t getflags(void *ip) {
+ _chn_get_and_clear_flags_impl(ip);
+}
+
+static const struct GLCDConsoleVMT vmt = {
+ writes, reads, put, get,
+ putt, gett, writet, readt,
+ getflags
+};
+
+
+msg_t lcdConsoleInit(GLCDConsole *console, uint16_t x0, uint16_t y0, uint16_t width, uint16_t height, font_t font, uint16_t bkcolor, uint16_t color) {
+ const uint8_t* ptr;
+ uint16_t chi;
+ uint16_t x,y;
+
+ console->vmt = &vmt;
+ /* read font, get height */
+ console->fy = lcdGetFontHeight(font);
+
+ /* calculate the size of the console as an integer multiple of characters height*/
+ console->sx = width;
+ console->sy = (((int16_t)(height/console->fy))-1)*console->fy;
+
+ console->cx = 0;
+ console->cy = 0;
+ console->x0 = x0;
+ console->y0 = y0;
+
+ console->bkcolor = bkcolor;
+ console->color = color;
+
+ console->font = font;
+
+ lcdFillArea(x0, y0, x0+width, y0+height, console->bkcolor);
+ return RDY_OK;
+}
+
+msg_t lcdConsolePut(GLCDConsole *console, char c) {
+ uint8_t width;
+
+ if(c == '\n') {
+ /* clear the text at the end of the line */
+ if(console->cx < console->sx)
+ lcdFillArea(console->x0 + console->cx, console->y0 + console->cy,
+ console->x0 + console->sx, console->y0 + console->cy + console->fy,
+ console->bkcolor);
+ console->cx = 0;
+ console->cy += console->fy;
+ } else if(c == '\r') {
+ /* TODO: work backwards through the buffer to the start of the current line */
+ //console->cx = 0;
+ } else {
+ width = lcdMeasureChar(c, console->font);
+ if((console->cx + width) >= console->sx) {
+ /* clear the text at the end of the line */
+ lcdFillArea(console->x0 + console->cx, console->y0 + console->cy,
+ console->x0 + console->cx + width, console->y0 + console->cy + console->fy,
+ console->bkcolor);
+ console->cx = 0;
+ console->cy += console->fy;
+ }
+
+ if((console->cy > console->sy)) {
+
+ lcdVerticalScroll(console->x0, console->y0, console->x0 + console->sx,
+ console->y0 + console->sy + console->fy, console->fy);
+ /* reset the cursor */
+ console->cx = 0;
+ console->cy = console->sy;
+ }
+
+ lcdDrawChar(console->x0 + console->cx, console->y0 + console->cy, c,
+ console->font, console->color, console->bkcolor, solid);
+
+ /* update cursor */
+ console->cx += width;
+ }
+ return RDY_OK;
+}
+
+msg_t lcdConsoleWrite(GLCDConsole *console, uint8_t *bp, size_t n) {
+ size_t i;
+ for(i = 0; i < n; i++)
+ lcdConsolePut(console, bp[i]);
+
+ return RDY_OK;
+}
+
+
diff --git a/glcd/fonts.c b/glcd/fonts.c
deleted file mode 100644
index 7f8a5c98..00000000
--- a/glcd/fonts.c
+++ /dev/null
@@ -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
-
diff --git a/glcd/fonts.h b/glcd/fonts.h
deleted file mode 100644
index a94b5252..00000000
--- a/glcd/fonts.h
+++ /dev/null
@@ -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
diff --git a/glcd/glcd.c b/glcd/glcd.c
index 5ae7c097..9d4db9cf 100644
--- a/glcd/glcd.c
+++ b/glcd/glcd.c
@@ -1,614 +1,431 @@
-/*
- 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 "glcd.h"
-#include "glcdWorker.h"
-
-#define EMSG(a) const struct a *emsg = (const struct a*)msg
-
-uint16_t lcd_width, lcd_height;
-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 msg_t ThreadGLCDWorker(void *arg) {
- (void)arg;
- Thread *p;
-
- chRegSetThreadName("GLCDWorker");
-
- while(TRUE) {
- /* Wait for msg with work to do. */
- p = chMsgWait();
- struct glcd_msg_base *msg = (struct glcd_msg_base*)chMsgGet(p);
- glcd_result_t result = GLCD_PROGRESS;
-
- /* do work here */
- switch(msg->action) {
- case GLCD_SET_POWERMODE: {
- EMSG(glcd_msg_powermode);
- lld_lcdSetPowerMode(emsg->powermode);
- result = GLCD_DONE;
- break;
- }
-
- case GLCD_SET_ORIENTATION: {
- EMSG(glcd_msg_orientation);
- lld_lcdSetOrientation(emsg->newOrientation);
- result = GLCD_DONE;
- 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: {
- EMSG(glcd_msg_fill_area);
- result = _lcdFillArea(emsg->x0, emsg->y0, emsg->x1, emsg->y1, emsg->color);
- break;
- }
-
- case GLCD_WRITE_AREA: {
- EMSG(glcd_msg_write_area);
- result = _lcdWriteArea(emsg->x0, emsg->y0, emsg->x1, emsg->y1, emsg->buffer, emsg->size);
- break;
- }
-
- case GLCD_CLEAR: {
- EMSG(glcd_msg_clear);
- lld_lcdClear(emsg->color);
- result = GLCD_DONE;
- break;
- }
-
- case GLCD_GET_PIXEL_COLOR: {
- EMSG(glcd_msg_get_pixel_color);
- ((struct glcd_msg_get_pixel_color *)emsg)->color =
- lld_lcdGetPixelColor(emsg->x, emsg->y);
- result = GLCD_DONE;
- break;
- }
-
- case GLCD_DRAW_PIXEL: {
- EMSG(glcd_msg_draw_pixel);
- lld_lcdDrawPixel(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;
- break;
- }
-
- case GLCD_VERTICAL_SCROLL: {
- EMSG(glcd_msg_vertical_scroll);
- lld_lcdVerticalScroll(emsg->x0, emsg->y0, emsg->x1, emsg->y1, emsg->lines);
- result = GLCD_DONE;
- break;
- }
-
- case GLCD_DRAW_CHAR: {
- EMSG(glcd_msg_draw_char);
- result = _lcdDrawChar(emsg);
- break;
- }
-
- default: {
- result = GLCD_FAILED;
- break;
- }
- }
-
- /* Done, release msg again. */
- chMsgRelease(p, (msg_t)result);
-
- }
-
- return 0;
-}
-
-void lcdInit(GLCDDriver *glcdp) {
- workerThread = chThdCreateStatic(waGLCDWorkerThread, sizeof(waGLCDWorkerThread), NORMALPRIO, ThreadGLCDWorker, NULL);
-
- lld_lcdInit();
- lcd_width = lcdGetWidth();
- lcd_height = lcdGetHeight();
-
- lcdSetPowerMode(powerOn);
- lcdSetOrientation(portrait);
-}
-
-uint16_t lcdGetHeight(void) {
- return lld_lcdGetHeight();
-}
-
-uint16_t lcdGetWidth(void) {
- return lld_lcdGetWidth();
-}
-
-uint16_t lcdGetOrientation(void) {
- return lld_lcdGetOrientation();
-}
-
-glcd_result_t lcdSetPowerMode(uint8_t powerMode) {
- struct glcd_msg_powermode msg;
-
- msg.action = GLCD_SET_POWERMODE;
- msg.powermode = powerMode;
-
- return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
-}
-
-glcd_result_t lcdSetOrientation(uint8_t newOrientation) {
- struct glcd_msg_orientation msg;
-
- msg.action = GLCD_SET_ORIENTATION;
- msg.newOrientation = newOrientation;
-
- 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) {
- struct glcd_msg_fill_area msg;
-
- msg.action = GLCD_FILL_AREA;
- msg.x0 = x0;
- msg.y0 = y0;
- msg.x1 = x1;
- msg.y1 = y1;
- msg.color = color;
-
- 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) {
- struct glcd_msg_write_area msg;
-
- msg.action = GLCD_WRITE_AREA;
- msg.x0 = x0;
- msg.y0 = y0;
- msg.x1 = x1;
- msg.y1 = y1;
- msg.buffer = buffer;
- msg.size = n;
-
- 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) {
- struct glcd_msg_clear msg;
-
- msg.action = GLCD_CLEAR;
- msg.color = color;
-
- return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
-}
-
-uint16_t lcdGetPixelColor(uint16_t x, uint16_t y) {
- struct glcd_msg_get_pixel_color msg;
-
- msg.action = GLCD_GET_PIXEL_COLOR;
- msg.x = x;
- msg.y = y;
-
- chMsgSend(workerThread, (msg_t)&msg);
-
- return msg.color;
-}
-
-glcd_result_t lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color) {
- struct glcd_msg_draw_pixel msg;
-
- msg.action = GLCD_DRAW_PIXEL;
- msg.x = x;
- msg.y = y;
- msg.color = color;
-
- 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) {
- struct glcd_msg_vertical_scroll msg;
-
- msg.action = GLCD_VERTICAL_SCROLL;
- msg.x0 = x0;
- msg.y0 = y0;
- msg.x1 = x1;
- msg.y1 = y1;
- msg.lines = lines;
-
- return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
-}
-
-void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
- // speed improvement if vertical or horizontal
- if(x0 == x1) {
- lcdFillArea(x0, y0, x0+1, y1, color);
- } else if (y0 == y1) {
- lcdFillArea(x0, y0, x1, y0+1, color);
-
- } else {
- int16_t dy, dx;
- int16_t addx = 1, addy = 1;
- int16_t P, diff;
-
- int16_t i = 0;
- 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) {
- struct glcd_msg_draw_char msg;
-
- msg.action = GLCD_DRAW_CHAR;
- msg.cx = cx;
- msg.cy = cy;
- msg.c = c;
- msg.font = font;
- msg.color = color;
- msg.bkcolor = bkcolor;
- msg.tpText = tpText;
- msg.ret_width = 0;
-
- chMsgSend(workerThread, (msg_t)&msg);
-
- return msg.ret_width;
-}
-
-glcd_result_t _lcdDrawChar(struct glcd_msg_draw_char *m) {
- /* Working pointer */
- const uint8_t* ptr;
- uint8_t x, y;
-
- /* Variables to store character details */
- uint8_t charWidth;
- uint8_t charHeight = lcdGetFontHeight(m->font);
- uint8_t padAfterChar = m->font[FONT_TABLE_PAD_AFTER_CHAR_IDX];
-
- /* Local var to hold offset in font table */
- uint16_t charStartOffset;
-
- /* Working buffer for fast non-transparent text rendering [patch by Badger] */
- static uint16_t buf[20*16];
-
- /* No support for nongraphic characters, so just ignore them */
- if(m->c < 0x20 || m->c > 0x7F) {
- return GLCD_DONE;
- }
-
- /* Read the offset of the character data in the font table from the lookup table */
- 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 */
-void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) {
- uint16_t cx = x, cy = y;
-
- while (*str) {
- cx += lcdDrawChar(cx, cy, *str++, font, color, bkcolor, tpText);
- }
-}
-
-uint16_t lcdMeasureChar(char c, font_t font) {
- /* Variables to store character details */
- 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 result = 0;
-
- /* Measure each char width, add it, return the result */
- while (*str)
- result += lcdMeasureChar(*str++, font);
-
- return result;
-}
-
-uint16_t lcdBGR2RGB(uint16_t color) {
- uint16_t r, g, b, rgb;
-
- b = ( color>>0 ) & 0x1f;
- g = ( color>>5 ) & 0x3f;
- r = ( color>>11 ) & 0x1f;
-
- rgb = (b<<11) + (g<<5) + (r<<0);
-
- return( rgb );
-}
-
-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 j, TempY;
-
- if (x0 > x1) {
- TempX = x1;
- x1 = x0;
- x0 = TempX;
- }
- if (y0 > y1) {
- TempY = y1;
- y1 = y0;
- y0 = TempY;
- }
- if(filled) {
- lcdFillArea(x0, y0, x1+1, y1+1, color);
- } else {
- lcdDrawLine(x0, y0, x1, y0, color);
- lcdDrawLine(x0, y1, x1, y1, color);
- lcdDrawLine(x0, y0, x0, y1, color);
- lcdDrawLine(x1, y0, x1, y1+1, color);
- }
-}
-
-void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char* str, font_t font, uint16_t fontColor, uint16_t bkColor) {
- uint16_t off_left, off_up;
-
- off_left = ((x1-x0)-lcdMeasureString(str, font))/2;
- off_up = ((y1-y0) - lcdGetFontHeight(font)) / 2;
-
- lcdDrawRect(x0, y0, x1, y1, filled, bkColor);
- /* Abhishek: default to solid text for this? */
- 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);
- }
-}
-
+/*
+ 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 "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 "glcdWorker.h"
+
+/* 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
+
+static Thread *workerThread = NULL;
+
+static WORKING_AREA(waGLCDWorkerThread, GLCD_WORKER_SIZE);
+static msg_t ThreadGLCDWorker(void *arg) {
+ (void)arg;
+ Thread *p;
+
+ chRegSetThreadName("GLCDWorker");
+
+ while(TRUE) {
+ /* Wait for msg with work to do. */
+ p = chMsgWait();
+ struct glcd_msg_base *msg = (struct glcd_msg_base*)chMsgGet(p);
+ glcd_result_t result = GLCD_PROGRESS;
+
+ /* do work here */
+ switch(msg->action) {
+ case GLCD_SET_POWERMODE: {
+ EMSG(glcd_msg_powermode);
+ gdisp_lld_control(GDISP_CONTROL_POWER, (void *)(int)emsg->powermode);
+ result = GLCD_DONE;
+ break;
+ }
+
+ case GLCD_SET_ORIENTATION: {
+ EMSG(glcd_msg_orientation);
+ gdisp_lld_control(GDISP_CONTROL_ORIENTATION, (void *)(int)emsg->newOrientation);
+ result = GLCD_DONE;
+ break;
+ }
+ case GLCD_FILL_AREA: {
+ EMSG(glcd_msg_fill_area);
+ gdisp_lld_fillarea(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1,emsg->y1-emsg->y0+1,emsg->color);
+ result = GLCD_DONE;
+ break;
+ }
+
+ case GLCD_WRITE_AREA: {
+ EMSG(glcd_msg_write_area);
+ gdisp_lld_blitarea(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1, emsg->y1-emsg->y0+1, emsg->buffer);
+ result = GLCD_DONE;
+ break;
+ }
+
+ case GLCD_CLEAR: {
+ EMSG(glcd_msg_clear);
+ gdisp_lld_clear(emsg->color);
+ result = GLCD_DONE;
+ break;
+ }
+
+ case GLCD_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 =
+ gdisp_lld_getpixelcolor(emsg->x, emsg->y);
+ result = GLCD_DONE;
+#else
+ EMSG(glcd_msg_get_pixel_color);
+ ((struct glcd_msg_get_pixel_color *)emsg)->color = 0;
+ result = GLCD_FAILED;
+#endif
+ break;
+ }
+
+ case GLCD_DRAW_PIXEL: {
+ EMSG(glcd_msg_draw_pixel);
+ gdisp_lld_drawpixel(emsg->x, emsg->y, emsg->color);
+ result = GLCD_DONE;
+ break;
+ }
+
+ 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);
+ gdisp_lld_verticalscroll(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1, emsg->y1-emsg->y0+1, emsg->lines, 0);
+ result = GLCD_DONE;
+#else
+ result = GLCD_FAILED;
+#endif
+ break;
+ }
+
+ case GLCD_DRAW_CHAR: {
+ EMSG(glcd_msg_draw_char);
+ 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;
+ }
+
+ default: {
+ result = GLCD_FAILED;
+ break;
+ }
+ }
+
+ /* Done, release msg again. */
+ chMsgRelease(p, (msg_t)result);
+
+ }
+
+ return 0;
+}
+
+void lcdInit(GLCDDriver *UNUSED(glcdp)) {
+ workerThread = chThdCreateStatic(waGLCDWorkerThread, sizeof(waGLCDWorkerThread), NORMALPRIO, ThreadGLCDWorker, NULL);
+
+ gdisp_lld_init();
+}
+
+uint16_t lcdGetHeight(void) {
+ return GDISP.Height;
+}
+
+uint16_t lcdGetWidth(void) {
+ return GDISP.Width;
+}
+
+uint16_t lcdGetOrientation(void) {
+ return GDISP.Orientation;
+}
+
+glcd_result_t lcdSetPowerMode(uint8_t powerMode) {
+ struct glcd_msg_powermode msg;
+
+ msg.action = GLCD_SET_POWERMODE;
+ msg.powermode = powerMode;
+
+ return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
+}
+
+glcd_result_t lcdSetOrientation(uint8_t newOrientation) {
+ struct glcd_msg_orientation msg;
+
+ msg.action = GLCD_SET_ORIENTATION;
+ msg.newOrientation = newOrientation;
+
+ 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) {
+ struct glcd_msg_fill_area msg;
+
+ msg.action = GLCD_FILL_AREA;
+ msg.x0 = x0;
+ msg.y0 = y0;
+ msg.x1 = x1;
+ msg.y1 = y1;
+ msg.color = color;
+
+ return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
+}
+
+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;
+
+ msg.action = GLCD_WRITE_AREA;
+ msg.x0 = x0;
+ msg.y0 = y0;
+ msg.x1 = x1;
+ msg.y1 = y1;
+ msg.buffer = buffer;
+ msg.size = n;
+
+ return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
+}
+
+glcd_result_t lcdClear(uint16_t color) {
+ struct glcd_msg_clear msg;
+
+ msg.action = GLCD_CLEAR;
+ msg.color = color;
+
+ return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
+}
+
+uint16_t lcdGetPixelColor(uint16_t x, uint16_t y) {
+ struct glcd_msg_get_pixel_color msg;
+
+ msg.action = GLCD_GET_PIXEL_COLOR;
+ msg.x = x;
+ msg.y = y;
+
+ chMsgSend(workerThread, (msg_t)&msg);
+
+ return msg.color;
+}
+
+glcd_result_t lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color) {
+ struct glcd_msg_draw_pixel msg;
+
+ msg.action = GLCD_DRAW_PIXEL;
+ msg.x = x;
+ msg.y = y;
+ msg.color = color;
+
+ 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) {
+ struct glcd_msg_vertical_scroll msg;
+
+ msg.action = GLCD_VERTICAL_SCROLL;
+ msg.x0 = x0;
+ msg.y0 = y0;
+ msg.x1 = x1;
+ msg.y1 = y1;
+ msg.lines = lines;
+
+ return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
+}
+
+void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
+ struct glcd_msg_draw_line msg;
+
+ msg.action = GLCD_DRAW_LINE;
+ msg.x0 = x0;
+ msg.y0 = y0;
+ msg.x1 = x1;
+ msg.y1 = y1;
+ msg.color = color;
+
+ chMsgSend(workerThread, (msg_t)&msg);
+}
+
+uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) {
+ struct glcd_msg_draw_char msg;
+
+ msg.action = GLCD_DRAW_CHAR;
+ msg.cx = cx;
+ msg.cy = cy;
+ msg.c = c;
+ msg.font = font;
+ msg.color = color;
+ msg.bkcolor = bkcolor;
+ msg.tpText = tpText;
+ msg.ret_width = 0;
+
+ chMsgSend(workerThread, (msg_t)&msg);
+
+ return msg.ret_width;
+}
+
+void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color) {
+ struct glcd_msg_draw_circle msg;
+
+ msg.action = GLCD_DRAW_CIRCLE;
+ msg.x = x;
+ msg.y = y;
+ msg.radius = radius;
+ msg.filled = filled;
+ msg.color = color;
+
+ chMsgSend(workerThread, (msg_t)&msg);
+}
+
+void lcdDrawEllipse(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint8_t filled, uint16_t color) {
+ struct glcd_msg_draw_ellipse msg;
+
+ msg.action = GLCD_DRAW_ELLIPSE;
+ msg.x = x;
+ msg.y = y;
+ msg.a = a;
+ msg.b = b;
+ msg.filled = filled;
+ msg.color = color;
+
+ chMsgSend(workerThread, (msg_t)&msg);
+}
+
+/* WARNING: No boundary checks! Unpredictable behaviour if text exceeds boundary */
+void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) {
+ uint16_t cx = x, cy = y;
+
+ while (*str) {
+ cx += lcdDrawChar(cx, cy, *str++, font, color, bkcolor, tpText);
+ }
+}
+
+uint16_t lcdMeasureChar(char c, font_t font) {
+ return (_getCharWidth(font, c)+font->charPadding) * font->xscale;
+}
+
+uint16_t lcdMeasureString(const char *str, font_t font) {
+ uint16_t result = 0;
+
+ /* Measure each char width, add it, return the result */
+ while (*str)
+ result += lcdMeasureChar(*str++, font);
+
+ return result;
+}
+
+uint16_t lcdGetFontHeight(font_t font) {
+ return font->height;
+}
+
+uint16_t lcdBGR2RGB(uint16_t color) {
+ uint16_t r, g, b, rgb;
+
+ b = ( color>>0 ) & 0x1f;
+ g = ( color>>5 ) & 0x3f;
+ r = ( color>>11 ) & 0x1f;
+
+ rgb = (b<<11) + (g<<5) + (r<<0);
+
+ return( rgb );
+}
+
+void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color) {
+ uint16_t TempX;
+ uint16_t TempY;
+
+ if (x0 > x1) {
+ TempX = x1;
+ x1 = x0;
+ x0 = TempX;
+ }
+ if (y0 > y1) {
+ TempY = y1;
+ y1 = y0;
+ y0 = TempY;
+ }
+ if(filled) {
+ lcdFillArea(x0, y0, x1+1, y1+1, color);
+ } else {
+ lcdDrawLine(x0, y0, x1, y0, color);
+ lcdDrawLine(x0, y1, x1, y1, color);
+ lcdDrawLine(x0, y0, x0, y1, color);
+ lcdDrawLine(x1, y0, x1, y1+1, color);
+ }
+}
+
+void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char* str, font_t font, uint16_t fontColor, uint16_t bkColor) {
+ uint16_t off_left, off_up;
+
+ off_left = ((x1-x0)-lcdMeasureString(str, font))/2;
+ off_up = ((y1-y0) - lcdGetFontHeight(font)) / 2;
+
+ lcdDrawRect(x0, y0, x1, y1, filled, bkColor);
+ /* Abhishek: default to solid text for this? */
+ lcdDrawString(x0+off_left, y0+off_up, str, font, fontColor, bkColor, solid);
+}
diff --git a/glcd/glcd.h b/glcd/glcd.h
index b16e1bb9..9fee528d 100644
--- a/glcd/glcd.h
+++ b/glcd/glcd.h
@@ -1,123 +1,148 @@
-/*
- 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 GLCD_H
-#define GLCD_H
-
-#include "ch.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 LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)
-
-/* LCD color */
-#define White 0xFFFF
-#define Black 0x0000
-#define Grey 0xF7DE
-#define Blue 0x001F
-#define Blue2 0x051F
-#define Red 0xF800
-#define Magenta 0xF81F
-#define Green 0x07E0
-#define Cyan 0x7FFF
-#define Yellow 0xFFE0
-
-#define RGB565CONVERT(red, green, blue) \
-(uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 ))
-
-enum orientation {portrait, landscape, portraitInv, landscapeInv};
-enum filled {frame, filled};
-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.
- */
-typedef struct GLCDDriver GLCDDriver;
-
-struct GLCDDriver {
-};
-
-enum glcd_result { GLCD_DONE,
- GLCD_FAILED,
- GLCD_PROGRESS,
- };
-
-typedef enum glcd_result glcd_result_t;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Core functions */
-void lcdInit(GLCDDriver *GLCDD1);
-glcd_result_t lcdClear(uint16_t color);
-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 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);
-
-/* Drawing functions */
-glcd_result_t lcdDrawPixel(uint16_t x, uint16_t y, uint16_t point);
-void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
-void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color);
-void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char* str, font_t font, uint16_t fontColor, uint16_t bkColor);
-void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color);
-void lcdDrawEllipse(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint8_t filled, uint16_t color);
-
-/* Text Rendering Functions */
-uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText);
-void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText);
-
-/* Character measuring functions */
-uint16_t lcdMeasureChar(char c, font_t font);
-uint16_t lcdMeasureString(const char* str, font_t font);
-
-/* Size and orientation related */
-uint16_t lcdGetHeight(void);
-uint16_t lcdGetWidth(void);
-uint16_t lcdGetOrientation(void);
-
-/* BGR->RGB and pixel readback */
-uint16_t lcdBGR2RGB(uint16_t color);
-uint16_t lcdGetPixelColor(uint16_t x, uint16_t y);
-
-/* Scrolling function */
-glcd_result_t lcdVerticalScroll(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, int16_t lines);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+/*
+ 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 GLCD_H
+#define GLCD_H
+
+#include "ch.h"
+#include "hal.h"
+
+#define PORTRAIT (lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv)
+#define LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)
+
+/* 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 Black 0x0000
+#define Grey 0xF7DE
+#define Blue 0x001F
+#define Blue2 0x051F
+#define Red 0xF800
+#define Magenta 0xF81F
+#define Green 0x07E0
+#define Cyan 0x7FFF
+#define Yellow 0xFFE0
+
+#define RGB565CONVERT(red, green, blue) \
+(uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 ))
+
+#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 transparency {solid, transparent};
+
+/**
+ * @brief Structure representing a GLCD driver.
+ */
+typedef struct GLCDDriver GLCDDriver;
+
+struct GLCDDriver {
+};
+
+enum glcd_result { GLCD_DONE,
+ GLCD_FAILED,
+ GLCD_PROGRESS,
+ };
+
+typedef enum glcd_result glcd_result_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Core functions */
+void lcdInit(GLCDDriver *GLCDD1);
+glcd_result_t lcdClear(uint16_t color);
+glcd_result_t lcdSetOrientation(uint8_t newOrientation);
+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 lcdSetPowerMode(uint8_t powerMode);
+
+/* Drawing functions */
+glcd_result_t lcdDrawPixel(uint16_t x, uint16_t y, uint16_t point);
+void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
+void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color);
+void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char* str, font_t font, uint16_t fontColor, uint16_t bkColor);
+void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color);
+void lcdDrawEllipse(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint8_t filled, uint16_t color);
+
+/* Text Rendering Functions */
+uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText);
+void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText);
+
+/* Character measuring functions */
+uint16_t lcdMeasureChar(char c, font_t font);
+uint16_t lcdMeasureString(const char* str, font_t font);
+uint16_t lcdGetFontHeight(font_t font);
+
+/* Size and orientation related */
+uint16_t lcdGetHeight(void);
+uint16_t lcdGetWidth(void);
+uint16_t lcdGetOrientation(void);
+
+/* BGR->RGB and pixel readback */
+uint16_t lcdBGR2RGB(uint16_t color);
+uint16_t lcdGetPixelColor(uint16_t x, uint16_t y);
+
+/* Scrolling function */
+glcd_result_t lcdVerticalScroll(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, int16_t lines);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/glcd/glcd.mk b/glcd/glcd.mk
index 2b968472..22ed8922 100644
--- a/glcd/glcd.mk
+++ b/glcd/glcd.mk
@@ -1,5 +1,5 @@
-LCD_GLCD_SRC = $(LCDLIB)/glcd/glcd.c \
- $(LCDLIB)/glcd/fonts.c \
- $(LCDLIB)/glcd/console.c
-
-LCD_GLCD_INC = $(LCDLIB)/glcd
+LCD_GLCD_SRC = $(LCDLIB)/glcd/glcd.c \
+ $(LCDLIB)/glcd/console.c
+
+LCD_GLCD_INC = $(LCDLIB)/glcd \
+ ${CHIBIOS}/os/halext/include ${CHIBIOS}/os/halext/src
diff --git a/glcd/glcdWorker.h b/glcd/glcdWorker.h
index 5c8bdd56..0d29d2da 100644
--- a/glcd/glcdWorker.h
+++ b/glcd/glcdWorker.h
@@ -1,153 +1,170 @@
-/*
- 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 GLCD_WORKER_H
-#define GLCD_WORKER_H
-
-#include "glcd.h"
-
-#define GLCD_WORKER_SIZE 512
-
-enum glcd_action { GLCD_SET_POWERMODE,
- GLCD_SET_ORIENTATION,
- GLCD_SET_WINDOW,
- GLCD_FILL_AREA,
- GLCD_WRITE_AREA,
- GLCD_CLEAR,
- GLCD_GET_PIXEL_COLOR,
- GLCD_DRAW_PIXEL,
- GLCD_WRITE_STREAM_START,
- GLCD_WRITE_STREAM_STOP,
- GLCD_WRITE_STREAM,
- GLCD_VERTICAL_SCROLL,
- GLCD_DRAW_CHAR,
- };
-
-#define _glcd_msg_base \
- enum glcd_action action;
-
-struct glcd_msg_base {
- _glcd_msg_base
-};
-
-struct glcd_msg_powermode {
- _glcd_msg_base
-
- uint8_t powermode;
-};
-
-struct glcd_msg_orientation {
- _glcd_msg_base
-
- uint8_t newOrientation;
-};
-
-struct glcd_msg_set_window {
- _glcd_msg_base
-
- uint16_t x0;
- uint16_t y0;
- uint16_t x1;
- uint16_t y1;
-};
-
-struct glcd_msg_fill_area {
- _glcd_msg_base
-
- uint16_t x0;
- uint16_t y0;
- uint16_t x1;
- uint16_t y1;
- uint16_t color;
-};
-
-struct glcd_msg_write_area {
- _glcd_msg_base
-
- uint16_t x0;
- uint16_t y0;
- uint16_t x1;
- uint16_t y1;
- uint16_t *buffer;
- size_t size;
-};
-
-struct glcd_msg_clear {
- _glcd_msg_base
-
- uint16_t color;
-};
-
-struct glcd_msg_get_pixel_color {
- _glcd_msg_base
-
- uint16_t x;
- uint16_t y;
- uint16_t color;
-};
-
-struct glcd_msg_draw_pixel {
- _glcd_msg_base
-
- uint16_t x;
- uint16_t y;
- 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 {
- _glcd_msg_base
-
- uint16_t x0;
- uint16_t y0;
- uint16_t x1;
- uint16_t y1;
- int16_t lines;
-};
-
-struct glcd_msg_draw_char {
- _glcd_msg_base;
-
- uint16_t cx;
- uint16_t cy;
- uint16_t color;
- uint16_t bkcolor;
- uint16_t ret_width;
- char c;
- font_t font;
- bool_t tpText;
-};
-
-#endif
-
+/*
+ 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 GLCD_WORKER_H
+#define GLCD_WORKER_H
+
+#include "glcd.h"
+
+#define GLCD_WORKER_SIZE 512
+
+enum glcd_action { GLCD_SET_POWERMODE,
+ GLCD_SET_ORIENTATION,
+ GLCD_FILL_AREA,
+ GLCD_WRITE_AREA,
+ GLCD_CLEAR,
+ GLCD_GET_PIXEL_COLOR,
+ GLCD_DRAW_PIXEL,
+ GLCD_VERTICAL_SCROLL,
+ GLCD_DRAW_CHAR,
+ GLCD_DRAW_LINE,
+ GLCD_DRAW_CIRCLE,
+ GLCD_DRAW_ELLIPSE,
+ };
+
+#define _glcd_msg_base \
+ enum glcd_action action;
+
+struct glcd_msg_base {
+ _glcd_msg_base
+};
+
+struct glcd_msg_powermode {
+ _glcd_msg_base
+
+ uint8_t powermode;
+};
+
+struct glcd_msg_orientation {
+ _glcd_msg_base
+
+ uint8_t newOrientation;
+};
+
+struct glcd_msg_set_window {
+ _glcd_msg_base
+
+ uint16_t x0;
+ uint16_t y0;
+ uint16_t x1;
+ uint16_t y1;
+};
+
+struct glcd_msg_fill_area {
+ _glcd_msg_base
+
+ uint16_t x0;
+ uint16_t y0;
+ uint16_t x1;
+ uint16_t y1;
+ uint16_t color;
+};
+
+struct glcd_msg_write_area {
+ _glcd_msg_base
+
+ uint16_t x0;
+ uint16_t y0;
+ uint16_t x1;
+ uint16_t y1;
+ uint16_t *buffer;
+ size_t size;
+};
+
+struct glcd_msg_clear {
+ _glcd_msg_base
+
+ uint16_t color;
+};
+
+struct glcd_msg_get_pixel_color {
+ _glcd_msg_base
+
+ uint16_t x;
+ uint16_t y;
+ uint16_t color;
+};
+
+struct glcd_msg_draw_pixel {
+ _glcd_msg_base
+
+ uint16_t x;
+ uint16_t y;
+ uint16_t color;
+};
+
+struct glcd_msg_vertical_scroll {
+ _glcd_msg_base
+
+ uint16_t x0;
+ uint16_t y0;
+ uint16_t x1;
+ uint16_t y1;
+ 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 {
+ _glcd_msg_base;
+
+ uint16_t cx;
+ uint16_t cy;
+ uint16_t color;
+ uint16_t bkcolor;
+ uint16_t ret_width;
+ char c;
+ font_t font;
+ bool_t tpText;
+};
+
+#endif
+
diff --git a/glcd/readme.txt b/glcd/readme.txt
new file mode 100644
index 00000000..985e87c3
--- /dev/null
+++ b/glcd/readme.txt
@@ -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.
\ No newline at end of file
diff --git a/halext/drivers/gdispS6d1121/s6d1121_lld.c.h b/halext/drivers/gdispS6d1121/s6d1121_lld.c.h
index bc929660..c1539fe7 100644
--- a/halext/drivers/gdispS6d1121/s6d1121_lld.c.h
+++ b/halext/drivers/gdispS6d1121/s6d1121_lld.c.h
@@ -1,491 +1,244 @@
-<<<<<<< HEAD
-/*
- 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 */
-=======
-/*
- 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
+/*
+ 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 */
diff --git a/halext/drivers/gdispTestStub/gdisp_lld.c b/halext/drivers/gdispTestStub/gdisp_lld.c
index 2b80f997..44431e30 100644
--- a/halext/drivers/gdispTestStub/gdisp_lld.c
+++ b/halext/drivers/gdispTestStub/gdisp_lld.c
@@ -308,7 +308,7 @@ void gdisp_lld_drawpixel(coord_t UNUSED(x), coord_t UNUSED(y), color_t UNUSED(co
}
#endif
-#if GDISP_HARDWARE_CONTROL || defined(__DOXYGEN__)
+#if (GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL) || defined(__DOXYGEN__)
/**
* @brief Driver Control
* @detail Unsupported control codes are ignored.
diff --git a/halext/include/gdisp.h b/halext/include/gdisp.h
index 24a8b1b4..d284c125 100644
--- a/halext/include/gdisp.h
+++ b/halext/include/gdisp.h
@@ -59,26 +59,6 @@
#define Pink HTML2COLOR(0xFFC0CB)
#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. */
/*===========================================================================*/
diff --git a/halext/include/gdisp_lld.h b/halext/include/gdisp_lld.h
index bef4f96a..970fd712 100644
--- a/halext/include/gdisp_lld.h
+++ b/halext/include/gdisp_lld.h
@@ -36,6 +36,30 @@
#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. */
/*===========================================================================*/
diff --git a/halext/include/glcd.h b/halext/include/glcd.h
index 0712ed02..54c5158d 100644
--- a/halext/include/glcd.h
+++ b/halext/include/glcd.h
@@ -45,13 +45,21 @@ enum powermode {powerOff, powerOn, sleepOn, sleepOff};
#define sleepOn powerSleep
#define sleepOff powerOn
-#define font_Small (&fontSmall)
-#define font_Larger (&fontLarger)
-#define font_MediumBold (&fontUI1)
-#define font_LargeNumbers (&fontLargeNumbers)
+#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)
#define GLCDDriver GDISPDriver
-#define GLCDD1 GDISP1
+#define GLCDD GDISP
enum glcd_result { GLCD_DONE,
GLCD_FAILED,
@@ -63,10 +71,10 @@ typedef enum glcd_result glcd_result_t;
/* Core functions */
#define lcdInit(dvr) gdispInit(dvr)
#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 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 */
#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 */
#define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(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 */
-#define lcdGetHeight() (GDISP1.Height)
-#define lcdGetWidth() (GDISP1.Width)
-#define lcdGetOrientation() (GDISP1.Orientation)
+#define lcdGetHeight() (GDISP.Height)
+#define lcdGetWidth() (GDISP.Width)
+#define lcdGetOrientation() (GDISP.Orientation)
/* BGR->RGB and pixel readback */
#define lcdBGR2RGB(c) RGB2COLOR(BLUE_OF(c),GREEN_OF(c),RED_OF(c))
--
cgit v1.2.3