diff --git a/gdisp/include/gdisp.h b/gdisp/include/gdisp.h
new file mode 100644
index 00000000..d35830c1
--- /dev/null
+++ b/gdisp/include/gdisp.h
@@ -0,0 +1,404 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> Framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/**
+ * @file gdisp.h
+ * @brief GDISP Graphic Driver macros and structures.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_H
+#define _GDISP_H
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver constants. */
+/*===========================================================================*/
+
+/**
+ * @brief Some basic colors
+ */
+#define White HTML2COLOR(0xFFFFFF)
+#define Black HTML2COLOR(0x000000)
+#define Gray HTML2COLOR(0x808080)
+#define Grey Gray
+#define Blue HTML2COLOR(0x0000FF)
+#define Red HTML2COLOR(0xFF0000)
+#define Fuchsia HTML2COLOR(0xFF00FF)
+#define Magenta Fuchsia
+#define Green HTML2COLOR(0x008000)
+#define Yellow HTML2COLOR(0xFFFF00)
+#define Aqua HTML2COLOR(0x00FFFF)
+#define Cyan Aqua
+#define Lime HTML2COLOR(0x00FF00)
+#define Maroon HTML2COLOR(0x800000)
+#define Navy HTML2COLOR(0x000080)
+#define Olive HTML2COLOR(0x808000)
+#define Purple HTML2COLOR(0x800080)
+#define Silver HTML2COLOR(0xC0C0C0)
+#define Teal HTML2COLOR(0x008080)
+#define Orange HTML2COLOR(0xFFA500)
+#define Pink HTML2COLOR(0xFFC0CB)
+#define SkyBlue HTML2COLOR(0x87CEEB)
+
+/*===========================================================================*/
+/* Driver pre-compile time settings. */
+/*===========================================================================*/
+
+/**
+ * @name GDISP more complex functionality to be compiled
+ * @{
+ */
+/**
+ * @brief Should all operations be clipped to the screen and colors validated.
+ * @details Defaults to TRUE.
+ * @note If this is FALSE, any operations that extend beyond the
+ * edge of the screen will have undefined results. Any
+ * out-of-range colors will produce undefined results.
+ * @note If defined then all low level and high level driver routines
+ * must check the validity of inputs and do something sensible
+ * if they are out of range. It doesn't have to be efficient,
+ * just valid.
+ */
+#ifndef GDISP_NEED_VALIDATION
+ #define GDISP_NEED_VALIDATION TRUE
+#endif
+
+/**
+ * @brief Are circle functions needed.
+ * @details Defaults to TRUE
+ */
+#ifndef GDISP_NEED_CIRCLE
+ #define GDISP_NEED_CIRCLE TRUE
+#endif
+
+/**
+ * @brief Are ellipse functions needed.
+ * @details Defaults to TRUE
+ */
+#ifndef GDISP_NEED_ELLIPSE
+ #define GDISP_NEED_ELLIPSE TRUE
+#endif
+
+/**
+ * @brief Are text functions needed.
+ * @details Defaults to TRUE
+ */
+#ifndef GDISP_NEED_TEXT
+ #define GDISP_NEED_TEXT TRUE
+#endif
+
+/**
+ * @brief Is scrolling needed.
+ * @details Defaults to FALSE
+ */
+#ifndef GDISP_NEED_SCROLL
+ #define GDISP_NEED_SCROLL FALSE
+#endif
+
+/**
+ * @brief Is the capability to read pixels back needed.
+ * @details Defaults to FALSE
+ */
+#ifndef GDISP_NEED_PIXELREAD
+ #define GDISP_NEED_PIXELREAD FALSE
+#endif
+
+/**
+ * @brief Do the drawing functions need to be thread-safe.
+ * @details Defaults to FALSE
+ * @note Turning this on adds two context switches per transaction
+ * so it can significantly slow graphics drawing.
+ */
+#ifndef GDISP_NEED_MULTITHREAD
+ #define GDISP_NEED_MULTITHREAD FALSE
+#endif
+/** @} */
+
+/* Include the low level driver information */
+#include "gdisp_lld.h"
+
+/*===========================================================================*/
+/* Derived constants and error checks. */
+/*===========================================================================*/
+
+#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL
+ #error "GDISP: Hardware scrolling is wanted but not supported."
+#endif
+
+#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD
+ #error "GDISP: Pixel read-back is wanted but not supported."
+#endif
+
+/*===========================================================================*/
+/* Driver data structures and types. */
+/*===========================================================================*/
+
+/* Define the basic Macro's for the various pixel formats */
+
+#if defined(GDISP_PIXELFORMAT_RGB565) || defined(__DOXYGEN__)
+ /**
+ * @brief The color of a pixel.
+ */
+ typedef uint16_t color_t;
+ /**
+ * @brief Convert a number (of any type) to a color_t.
+ * @details Masks any invalid bits in the color
+ */
+ #define COLOR(c) ((color_t)(c))
+ /**
+ * @brief Does the color_t type contain invalid bits that need masking.
+ */
+ #define MASKCOLOR FALSE
+ /**
+ * @brief Convert red, green, blue (each 0 to 255) into a color value.
+ */
+ #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
+ /**
+ * @brief Convert a 6 digit HTML code (hex) into a color value.
+ */
+ #define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
+ /**
+ * @brief Extract the red component (0 to 255) of a color value.
+ */
+ #define RED_OF(c) (((c) & 0xF800)>>8)
+ /**
+ * @brief Extract the green component (0 to 255) of a color value.
+ */
+ #define GREEN_OF(c) (((c)&0x007E)>>3)
+ /**
+ * @brief Extract the blue component (0 to 255) of a color value.
+ */
+ #define BLUE_OF(c) (((c)&0x001F)<<3)
+
+#elif defined(GDISP_PIXELFORMAT_RGB888)
+ typedef uint32_t color_t;
+ #define COLOR(c) ((color_t)(((c) & 0xFFFFFF))
+ #define MASKCOLOR TRUE
+ #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))
+ #define HTML2COLOR(h) ((color_t)(h))
+ #define RED_OF(c) (((c) & 0xFF0000)>>16)
+ #define GREEN_OF(c) (((c)&0x00FF00)>>8)
+ #define BLUE_OF(c) ((c)&0x0000FF)
+
+#elif defined(GDISP_PIXELFORMAT_RGB444)
+ typedef uint16_t color_t;
+ #define COLOR(c) ((color_t)(((c) & 0x0FFF))
+ #define MASKCOLOR TRUE
+ #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4))
+ #define HTML2COLOR(h) ((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4))
+ #define RED_OF(c) (((c) & 0x0F00)>>4)
+ #define GREEN_OF(c) ((c)&0x00F0)
+ #define BLUE_OF(c) (((c)&0x000F)<<4)
+
+#elif defined(GDISP_PIXELFORMAT_RGB332)
+ typedef uint8_t color_t;
+ #define COLOR(c) ((color_t)(c))
+ #define MASKCOLOR FALSE
+ #define RGB2COLOR(r,g,b) ((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6))
+ #define HTML2COLOR(h) ((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6))
+ #define RED_OF(c) ((c) & 0xE0)
+ #define GREEN_OF(c) (((c)&0x1C)<<3)
+ #define BLUE_OF(c) (((c)&0x03)<<6)
+
+#elif defined(GDISP_PIXELFORMAT_RGB666)
+ typedef uint32_t color_t;
+ #define COLOR(c) ((color_t)(((c) & 0x03FFFF))
+ #define MASKCOLOR TRUE
+ #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))
+ #define HTML2COLOR(h) ((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))
+ #define RED_OF(c) (((c) & 0x03F000)>>12)
+ #define GREEN_OF(c) (((c)&0x00FC00)>>8)
+ #define BLUE_OF(c) (((c)&0x00003F)<<2)
+
+#elif !defined(GDISP_PIXELFORMAT_CUSTOM)
+ #error "GDISP: No supported pixel format has been specified."
+#endif
+
+/* Verify information for packed pixels and define a non-packed pixel macro */
+#if !GDISP_PACKED_PIXELS
+ #define gdispPackPixels(buf,cx,x,y,c) { ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }
+#elif !GDISP_HARDWARE_BITFILLS
+ #error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."
+#elif !defined(GDISP_PIXELFORMAT_RGB888) && !defined(GDISP_PIXELFORMAT_RGB444) && !defined(GDISP_PIXELFORMAT_RGB666) && !defined(GDISP_PIXELFORMAT_CUSTOM)
+ #error "GDISP: A packed pixel format has been specified for an unsupported pixel format."
+#endif
+
+/**
+ * @brief The type for a coordinate or length on the screen.
+ */
+typedef uint16_t coord_t;
+/**
+ * @brief The type of a pixel.
+ */
+typedef color_t pixel_t;
+/**
+ * @brief The type of a font.
+ */
+typedef const struct font *font_t;
+/**
+ * @brief Type of a structure representing a GDISP driver.
+ */
+typedef struct GDISPDriver GDISPDriver;
+/**
+ * @brief Type for the screen orientation.
+ */
+typedef enum orientation {portrait, landscape, portraitInv, landscapeInv} gdisp_orientation_t;
+/**
+ * @brief Type for the available power modes for the screen.
+ */
+typedef enum powermode {powerOff, powerSleep, powerOn} gdisp_powermode_t;
+/**
+ * @brief Type for the text justification.
+ */
+typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;
+/**
+ * @brief Type for the font metric.
+ */
+typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;
+
+
+/*===========================================================================*/
+/* External declarations. */
+/*===========================================================================*/
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+/**
+ * @brief Predefined fonts.
+ */
+extern const struct font fontSmall;
+extern const struct font fontLarger;
+extern const struct font fontUI1;
+extern const struct font fontUI2;
+extern const struct font fontLargeNumbers;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if GDISP_NEED_MULTITHREAD
+
+ /* Base Functions */
+ void gdispInit(GDISPDriver *gdisp);
+ void gdispSetPowerMode(gdisp_powermode_t powerMode);
+ void gdispSetOrientation(gdisp_orientation_t newOrientation);
+
+ /* Drawing Functions */
+ void gdispClear(color_t color);
+ void gdispDrawPixel(coord_t x, coord_t y, color_t color);
+ void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
+ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+ void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+ void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer);
+
+ /* Circle Functions */
+ #if GDISP_NEED_CIRCLE
+ void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);
+ void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);
+ #endif
+
+ /* Ellipse Functions */
+ #if GDISP_NEED_ELLIPSE
+ void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+ void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+ #endif
+
+ /* Basic Text Rendering Functions */
+ #if GDISP_NEED_TEXT
+ void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);
+ void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
+ #endif
+
+ /* Read a pixel Function */
+ #if GDISP_NEED_PIXELREAD
+ color_t gdispGetPixelColor(coord_t x, coord_t y);
+ #endif
+
+ /* Scrolling Function - clears the area scrolled out */
+ #if GDISP_NEED_SCROLL
+ void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
+ #endif
+
+#else
+
+ /* The same as above but use the low level driver directly if no multi-thread support is needed */
+ #define gdispInit(gdisp) gdisp_lld_init()
+ #define gdispSetPowerMode(powerMode) gdisp_lld_setpowermode(powerMode)
+ #define gdispSetOrientation(newOrientation) gdisp_lld_setorientation(newOrientation)
+ #define gdispClear(color) gdisp_lld_clear(color)
+ #define gdispDrawPixel(x, y, color) gdisp_lld_drawpixel(x, y, color)
+ #define gdispDrawLine(x0, y0, x1, y1, color) gdisp_lld_drawline(x0, y0, x1, y1, color)
+ #define gdispDrawBox(x, y, cx, cy, color) gdisp_lld_drawbox(x, y, cx, cy, color)
+ #define gdispFillArea(x, y, cx, cy, color) gdisp_lld_fillarea(x, y, cx, cy, color)
+ #define gdispBlitArea(x, y, cx, cy, buffer) gdisp_lld_blitarea(x, y, cx, cy, buffer)
+ #define gdispDrawCircle(x, y, radius, color) gdisp_lld_drawcircle(x, y, radius, color)
+ #define gdispFillCircle(x, y, radius, color) gdisp_lld_fillcircle(x, y, radius, color)
+ #define gdispDrawEllipse(x, y, a, b, color) gdisp_lld_drawellipse(x, y, a, b, color)
+ #define gdispFillEllipse(x, y, a, b, color) gdisp_lld_fillellipse(x, y, a, b, color)
+ #define gdispDrawChar(x, y, c, font, color) gdisp_lld_drawchar(x, y, c, font, color)
+ #define gdispFillChar(x, y, c, font, color, bgcolor) gdisp_lld_fillchar(x, y, c, font, color, bgcolor)
+ #define gdispGetPixelColor(x, y) gdisp_lld_getpixelcolor(x, y)
+ #define gdispVerticalScroll(x, y, cx, cy, lines, bgcolor) gdisp_lld_verticalscroll(x, y, cx, cy, lines, bgcolor)
+
+#endif
+
+ /* Extra Text Functions */
+ #if GDISP_NEED_TEXT
+ void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);
+ void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);
+ void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);
+ coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);
+ coord_t gdispGetCharWidth(char c, font_t font);
+ coord_t gdispGetStringWidth(const char* str, font_t font);
+ #endif
+
+ /* Support routine for packed pixel formats */
+ #ifndef gdispPackPixels
+ void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
+ #endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_USE_GDISP */
+
+#endif /* _GDISP_H */
+/** @} */
diff --git a/gdisp/include/glcd.h b/gdisp/include/glcd.h
new file mode 100644
index 00000000..974fa839
--- /dev/null
+++ b/gdisp/include/glcd.h
@@ -0,0 +1,112 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> Framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/*
+ This file is an emulation of the GLCD interface using the
+ new GDISP interface. It is probably not a perfect replica,
+ some code changes may be necessary.
+ Note it does not replicate the GLCD low level driver, just
+ the high level interface.
+*/
+
+#ifndef GLCD_H
+#define GLCD_H
+
+#include "ch.h"
+#include "hal.h"
+#include "gdisp.h"
+
+#define PORTRAIT (lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv)
+#define LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)
+
+#define RGB565CONVERT(r, g, b) RGB2COLOR(r,g,b)
+
+enum orientation {portrait, landscape, portraitInv, landscapeInv};
+enum filled {frame, filled};
+enum transparency {solid, transparent};
+enum powermode {powerOff, powerOn, sleepOn, sleepOff};
+#define sleepOn powerSleep
+#define sleepOff powerOn
+
+#define lcdGetFontHeight(font) gdispGetFontMetric(font, fontHeight)
+
+#define GLCDDriver GDISPDriver
+#define GLCDD1 GDISP1
+
+enum glcd_result { GLCD_DONE,
+ GLCD_FAILED,
+ GLCD_PROGRESS,
+ };
+
+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 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))
+
+/* Drawing functions */
+#define lcdDrawPixel(x,y,c) (gdispDrawPixel((x),(y),(c)), GLCD_DONE)
+#define lcdDrawLine(x0,y0,x1,y1,c) gdispDrawLine((x0),(y0),(x1),(y1),(c))
+#define lcdDrawRect(x0,y0,x1,y1,f,c) {if(f) gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)); else gdispDrawBox((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c));}
+#define lcdDrawRectString(x0,y0,x1,y1,s,f,c,b) gdispFillStringBox((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(s),(f),(c),(b),justifyLeft)
+#define lcdDrawCircle(x,y,r,f,c) {if(f) gdispFillCircle((x),(y),(r),(c)); else gdispDrawCircle((x),(y),(r),(c));}
+#define lcdDrawEllipse(x,y,a,b,f,c) {if(f) gdispFillEllipse((x),(y),(a),(b),(c)); else gdispDrawEllipse((x),(y),(a),(b),(c));}
+
+/* Text Rendering Functions */
+#define lcdDrawChar(x,y,h,f,c,b,t) ({if(t) gdispDrawChar((x),(y),(h),(f),(c)); else gdispFillChar((x),(y),(h),(f),(c),(b));}, (gdispGetCharWidth((h),(f))+(f)->charPadding))
+#define lcdDrawString(x,y,s,f,c,b,t) ({if(t) gdispDrawString((x),(y),(s),(f),(c)); else gdispFillString((x),(y),(s),(f),(c),(b));}, (gdispGetStringWidth((s),(f))+(f)->charPadding))
+
+/* Character measuring functions */
+#define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(f))+(f)->charPadding)
+#define lcdMeasureString(s,f) (gdispGetStringWidth((s),(f))+(f)->charPadding)
+
+/* Size and orientation related */
+#define lcdGetHeight() (GDISP1.Height)
+#define lcdGetWidth() (GDISP1.Width)
+#define lcdGetOrientation() (GDISP1.Orientation)
+
+/* BGR->RGB and pixel readback */
+#define lcdBGR2RGB(c) RGB2COLOR(BLUE_OF(c),GREEN_OF(c),RED_OF(c))
+#define lcdGetPixelColor(x,y) gdispGetPixelColor((x),(y))
+
+/* Scrolling function */
+#define lcdVerticalScroll(x0,y0,x1,y1,l) gdispVerticalScroll((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,l,Black)
+
+#endif
diff --git a/gdisp/src/gdisp.c b/gdisp/src/gdisp.c
new file mode 100644
index 00000000..c676c333
--- /dev/null
+++ b/gdisp/src/gdisp.c
@@ -0,0 +1,760 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/**
+ * @file gdisp.c
+ * @brief GDISP Driver code.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+#if GDISP_NEED_MULTITHREAD
+ #error "GDISP: Multithread support not complete"
+ #define MUTEX_ENTER /* Not defined yet */
+ #define MUTEX_EXIT /* Not defined yet */
+#endif
+
+/*===========================================================================*/
+/* Driver local definitions. */
+/*===========================================================================*/
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief The size of a font column.
+ * @note If you font heights > 16 you would need to redefine this
+ * as a uint32_t instead of a uint16_t. Fonts would then take
+ * twice the internal program memory.
+ */
+ typedef uint16_t fontcolumn_t
+
+ /**
+ * @brief Internal font structure.
+ * @note This structure is followed by:
+ * An array of column data offsets (relative to the font structure)
+ * An array of character widths (uint8_t)
+ * Each characters array of column data (fontcolumn_t)
+ */
+ typedef struct font {
+ uint8_t height;
+ uint8_t charPadding;
+ uint8_t lineSpacing;
+ uint8_t descenderHeight;
+ uint8_t minWidth;
+ uint8_t maxWidth;
+ char minChar;
+ char maxChar;
+ uint16_t widthTableOffset;
+ uint16_t offsetTableOffset;
+ };
+
+ /**
+ * @brief Macro's to get to the complex parts of the font structure.
+ */
+ #define _getFontPart(f,o,t) ((t)((const uint8_t *)(f)+(o)))
+ #define _getCharWidth(f,c) (((c) < (f)->minChar || (c) > (f)->maxChar) ? 0 : _getFontPart((f), (f)->widthTableOffset, const uint8_t *)[c - (f)->minChar])
+ #define _getCharOffset(f,c) (_getFontPart((f), (f)->offsetTableOffset, const uint16_t *)[c - (f)->minChar])
+ #define _getCharData(f,c) _getFontPart((f), _getCharOffset(c, (f)), const fontcolumn_t *)
+#endif
+
+/*===========================================================================*/
+/* Driver exported variables. */
+/*===========================================================================*/
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ #include "gdisp_inc_fonts.c"
+#endif
+
+/*===========================================================================*/
+/* Driver local variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions. */
+/*===========================================================================*/
+
+/* Include the software emulation routines */
+#include "gdisp_inc_emulation.c"
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief GDISP Driver initialization.
+ * @note This function is NOT currently implicitly invoked by @p halInit().
+ * It must be called manually.
+ *
+ * @init
+ */
+ void gdispInit(GDISPDriver *gdisp) {
+ /* No mutex required as nothing should happen until the init is complete */
+ gdisp_lld_init();
+
+ /* ToDo - Initialise Mutex */
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Set the power mode for the display.
+ * @pre The GDISP unit must have been initialised using @p gdispInit().
+ * @note Depending on the hardware implementation this function may not
+ * support powerSleep. If not powerSleep is treated the same as powerOn.
+ * (sleep allows drawing to the display without the display updating).
+ *
+ * @param[in] powerMode The power mode to use
+ *
+ * @api
+ */
+ void gdispSetPowerMode(gdisp_powermode_t powerMode) {
+ MUTEX_ENTER
+ gdisp_lld_setpowermode(powerMode);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Set the orientation of the display.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ * @note Depending on the hardware implementation this function may clear
+ * the display when changing its orientation.
+ *
+ * @param[in] newOrientation The new orientation to use
+ *
+ * @api
+ */
+ void gdispSetOrientation(gdisp_orientation_t newOrientation) {
+ MUTEX_ENTER
+ gdisp_lld_setorientation(newOrientation);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Clear the display to the specified color.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] color The color to use when clearing the screen
+ *
+ * @api
+ */
+ void gdispClear(color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_clear(color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Set a pixel in the specified color.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x,y The position to set the pixel.
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_drawpixel(x, y, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a line.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The start position
+ * @param[in] x1,y1 The end position
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_drawline(x0, y0, x1, y1, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a rectangular box.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] color The color to use
+ * @param[in] filled Should the box should be filled
+ *
+ * @api
+ */
+ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_drawbox(x, y, cx, cy, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Fill an area with a color.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_fillarea(x, y, cx, cy, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
+ /**
+ * @brief Fill an area using the supplied bitmap.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ * @details The bitmap is in the pixel format specified by the low level driver
+ * @note If a packed pixel format is used and the width doesn't
+ * match a whole number of bytes, the next line will start on a
+ * non-byte boundary (no end-of-line padding).
+ *
+ * @param[in] x0,y0 The start position
+ * @param[in] cx,cy The size of the filled area
+ * @param[in] buffer The bitmap in the driver's pixel format.
+ *
+ * @api
+ */
+ void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {
+ MUTEX_ENTER
+ gdisp_lld_blitarea(x, y, cx, cy, buffer);
+ MUTEX_EXIT
+ }
+#endif
+
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a circle.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The center of the circle
+ * @param[in] radius The radius of the circle
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_drawcircle(x, y, radius, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a filled circle.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The center of the circle
+ * @param[in] radius The radius of the circle
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_fillcircle(x, y, radius, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw an ellipse.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The center of the ellipse
+ * @param[in] a,b The dimensions of the ellipse
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_drawellipse(x, y, a, b, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a filled ellipse.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The center of the ellipse
+ * @param[in] a,b The dimensions of the ellipse
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_fillellipse(x, y, a, b, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text character.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] c The character to draw
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
+ MUTEX_ENTER
+ gdisp_lld_drawchar(x, y, c, font, color);
+ MUTEX_EXIT
+ }
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text character with a filled background.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] c The character to draw
+ * @param[in] color The color to use
+ * @param[in] bgcolor The background color to use
+ *
+ * @api
+ */
+ void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+ MUTEX_ENTER
+ gdisp_lld_fillchar(x, y, c, font, color, bgcolor);
+ MUTEX_EXIT
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] str The string to draw
+ * @param[in] color The color to use
+ *
+ * @api
+ */
+ void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w;
+ char c;
+ int first;
+
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(c);
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (font->charPadding) {
+ if (!first)
+ x += font->charPadding;
+ else
+ first = 0;
+ }
+
+ /* Print the character */
+ gdispDrawChar(x, y, c, font, color);
+ x += w;
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x,y The position for the text
+ * @param[in] str The string to draw
+ * @param[in] color The color to use
+ * @param[in] bgcolor The background color to use
+ *
+ * @api
+ */
+ void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w;
+ char c;
+ int first;
+
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(c);
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (font->charPadding) {
+ if (!first) {
+ gdispFillArea(x, y, font->charPadding, font->height, bgcolor);
+ x += font->charPadding;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ gdispFillChar(x, y, c, font, color, bgcolor);
+ x += w;
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a text string verticly centered within the specified box.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ * @note The entire box is filled
+ *
+ * @param[in] x,y The position for the text (need to define top-right or base-line - check code)
+ * @param[in] str The string to draw
+ * @param[in] color The color to use
+ * @param[in] bgcolor The background color to use
+ * @param[in] justify Justify the text left, center or right within the box
+ *
+ * @api
+ */
+ void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgcolor, justify_t justify) {
+ /* No mutex required as we only call high level functions which have their own mutex */
+ coord_t w, ypos, xpos;
+ char c;
+ int first;
+ const char *rstr;
+
+ /* Oops - font too large for the area */
+ if (font->height > cy) return;
+
+ /* See if we need to fill above the font */
+ ypos = (cy - font->height)/2;
+ if (ypos > 0) {
+ gdispFillArea(x, y, cx, ypos, bgcolor);
+ y += ypos;
+ cy -= ypos;
+ }
+
+ /* See if we need to fill below the font */
+ ypos = cy - font->height;
+ if (ypos > 0) {
+ gdispFillArea(x, y+cy-ypos, cx, ypos, bgcolor);
+ cy -= ypos;
+ }
+
+ /* get the start of the printable string and the xpos */
+ switch(justify) {
+ case justifyCenter:
+ /* Get the length of the entire string */
+ w = gdispStringWidth(str, font);
+ if (w <= cx)
+ xpos = x + (cx - w)/2;
+ else {
+ /* Calculate how much of the string we need to get rid of */
+ ypos = (w - cx)/2;
+ xpos = 0;
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(c);
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (font->charPadding) {
+ if (!first) {
+ xpos += font->charPadding;
+ if (xpos > ypos) break;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ xpos += w;
+ if (xpos > ypos) break;
+ }
+ xpos = ypos - xpos + x;
+ }
+ break;
+ case justifyRight:
+ /* Find the end of the string */
+ for(rpos = str; *str; str++);
+ xpos = x+cx - 2;
+ first = 1;
+ for(str--; str >= rpos; str--) {
+ /* Get the next printable character */
+ c = *str;
+ w = _getCharWidth(c);
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (font->charPadding) {
+ if (!first) {
+ if (xpos - font->charPadding < x) break;
+ xpos -= font->charPadding;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ if (xpos - w < x) break;
+ xpos -= w;
+ }
+ str++;
+ break;
+ case justifyLeft:
+ /* Fall through */
+ xpos = x+1;
+ default:
+ break;
+ }
+
+ /* Fill any space to the left */
+ if (x < xpos)
+ gdispFillArea(x, y, xpos-x, cy, bgcolor);
+
+ /* Print characters until we run out of room */
+ first = 1;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(c);
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (font->charPadding) {
+ if (!first) {
+ if (xpos + font->charPadding > x+cx) break;
+ gdispFillArea(xpos, y, font->charPadding, cy, bgcolor);
+ xpos += font->charPadding;
+ } else
+ first = 0;
+ }
+
+ /* Print the character */
+ if (xpos + w > x+cx) break;
+ gdispFillChar(xpos, y, c, font, color, bgcolor);
+ xpos += w;
+ }
+
+ /* Fill any space to the right */
+ if (xpos < x+cx)
+ gdispFillArea(xpos, y, x+cx-xpos, cy, bgcolor);
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Get a metric of a font.
+ * @return The metric requested in pixels.
+ *
+ * @param[in] font The font to test
+ * @param[in] metric The metric to measure
+ *
+ * @api
+ */
+ coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {
+ /* No mutex required as we only read static data */
+ switch(metric) {
+ case fontHeight: return font->height;
+ case fontDescendersHeight: return font->descenderHeight;
+ case fontLineSpacing: return font->lineSpacing;
+ case fontCharPadding: return font->charPadding;
+ case fontMinWidth: return font->minWidth;
+ case fontMaxWidth: return font->maxWidth;
+ }
+ return 0;
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Get the pixel width of a character.
+ * @return The width of the character in pixels. Does not include any between character padding.
+ *
+ * @param[in] c The character to draw
+ * @param[in] font The font to use
+ *
+ * @api
+ */
+ coord_t gdispGetCharWidth(char c, font_t font) {
+ /* No mutex required as we only read static data */
+ return _getCharWidth(font, c);
+ }
+#endif
+
+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
+ /**
+ * @brief Get the pixel width of a string.
+ * @return The width of the string in pixels.
+ *
+ * @param[in] str The string to measure
+ * @param[in] font The font to use
+ *
+ * @api
+ */
+ coord_t gdispStringWidth(const char* str, font_t font) {
+ /* No mutex required as we only read static data */
+ coord_t w, x;
+ char c;
+ int first;
+
+ first = 1;
+ x = 0;
+ while(*str) {
+ /* Get the next printable character */
+ c = *str++;
+ w = _getCharWidth(c);
+ if (!w) continue;
+
+ /* Handle inter-character padding */
+ if (font->charPadding) {
+ if (!first)
+ x += font->charPadding;
+ else
+ first = 0;
+ }
+
+ /* Add the character width */
+ x += w;
+ }
+ return x;
+ }
+#endif
+
+#if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM)) || defined(__DOXYGEN__)
+ /**
+ * @brief Pack a pixel into a pixel buffer.
+ * @note This function performs no buffer boundary checking
+ * regardless of whether GDISP_NEED_CLIPPING has been specified.
+ *
+ * @param[in] buf The buffer to put the pixel in
+ * @param[in] cx The width of a pixel line
+ * @param[in] x, y The location of the pixel to place
+ * @param[in] color The color to put into the buffer
+ *
+ * @api
+ */
+ void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) {
+ /* No mutex required as we only read static data */
+ #if defined(GDISP_PIXELFORMAT_RGB888)
+ #error "GDISP: Packed pixels not supported yet"
+ #elif defined(GDISP_PIXELFORMAT_RGB444)
+ #error "GDISP: Packed pixels not supported yet"
+ #elif defined(GDISP_PIXELFORMAT_RGB666)
+ #error "GDISP: Packed pixels not supported yet"
+ #elif
+ #error "GDISP: Unsupported packed pixel format"
+ #endif
+ }
+#endif
+
+#if (GDISP_NEED_PIXELREAD && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Get the color of a pixel.
+ * @return The color of the pixel.
+ *
+ * @param[in] x,y The position of the pixel
+ *
+ * @api
+ */
+ color_t gdispGetPixelColor(coord_t x, coord_t y) {
+ color_t c;
+
+ MUTEX_ENTER
+ c = gdisp_lld_getpixelcolor(x, y);
+ MUTEX_EXIT
+
+ return c;
+ }
+#endif
+
+#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Scroll vertically a section of the screen.
+ * @note Optional.
+ * @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
+ *
+ * @param[in] x, y The start of the area to be scrolled
+ * @param[in] cx, cy The size of the area to be scrolled
+ * @param[in] lines The number of lines to scroll (Can be positive or negative)
+ * @param[in] bgcolor The color to fill the newly exposed area.
+ *
+ * @api
+ */
+ void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+ MUTEX_ENTER
+ gdisp_lld_verticalscroll(x, y, cx, cy, lines, bgcolor);
+ MUTEX_EXIT
+ }
+#endif
+
+#endif /* HAL_USE_GDISP */
+/** @} */
diff --git a/gdisp/src/gdisp_inc_emulation.c b/gdisp/src/gdisp_inc_emulation.c
new file mode 100644
index 00000000..402d7f62
--- /dev/null
+++ b/gdisp/src/gdisp_inc_emulation.c
@@ -0,0 +1,422 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> Framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/*
+ Emulation routines included into gdisp.c
+*/
+
+/*
+ Even though this is a software emulation of a low level driver
+ most validation doesn't need to happen here as eventually
+ we call a real low level driver routine and if validation is
+ required - it will do it.
+*/
+
+#if !GDISP_HARDWARE_CLEARS
+ void gdisp_lld_clear(color_t color) {
+ gdisp_lld_fillarea(0, 0, GDISP1.Width, GDISP1.Height, color);
+ }
+#endif
+
+#if !GDISP_HARDWARE_LINES
+ void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+ int16_t dy, dx;
+ int16_t addx, addy;
+ int16_t P, diff, i;
+
+ #if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL
+ // speed improvement if vertical or horizontal
+ if (x0 == x1) {
+ if (y1 > y0)
+ gdisp_lld_fillarea(x0, y0, 1, y1-y0+1, color);
+ else
+ gdisp_lld_fillarea(x0, y1, 1, y0-y1+1, color);
+ return;
+ }
+ if (y0 == y1) {
+ if (x1 > x0)
+ gdisp_lld_fillarea(x0, y0, x1-x0+1, 1, color);
+ else
+ gdisp_lld_fillarea(x0, y1, x0-x1+1, 1, color);
+ return;
+ }
+ #endif
+
+ if (x1 >= x0) {
+ dx = x1 - x0;
+ addx = 1;
+ } else {
+ dx = x0 - x1;
+ addx = -1;
+ }
+ if (y1 >= y0) {
+ dy = y1 - y0;
+ addy = 1;
+ } else {
+ dy = y0 - y1;
+ addy = -1;
+ }
+
+ if (dx >= dy) {
+ dy *= 2;
+ P = dy - dx;
+ diff = P - dx;
+
+ for(i=0; i<=dx; ++i) {
+ gdisp_lld_drawpixel(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=0; i<=dy; ++i) {
+ gdisp_lld_drawpixel(x0, y0, color);
+ if (P < 0) {
+ P += dx;
+ y0 += addy;
+ } else {
+ P += diff;
+ x0 += addx;
+ y0 += addy;
+ }
+ }
+ }
+ }
+#endif
+
+#if !GDISP_HARDWARE_BOX
+ void gdisp_lld_drawbox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ coord x1, y1;
+
+ x1 = x+cx-1;
+ y1 = y+cy-1;
+
+ if (cx > 2) {
+ if (cy >= 1) {
+ gdisp_lld_drawline(x, y, x1, y, color);
+ if (cy >= 2) {
+ gdisp_lld_drawline(x, y1, x1, y1, color);
+ if (cy > 2) {
+ gdisp_lld_drawline(x, y+1, x, y1-1, color);
+ gdisp_lld_drawline(x1, y+1, x1, y1-1, color);
+ }
+ }
+ }
+ } else if (cx == 2) {
+ gdisp_lld_drawline(x, y, x, y1, color);
+ gdisp_lld_drawline(x1, y, x1, y1, color);
+ } else if (cx == 1) {
+ gdisp_lld_drawline(x, y, x, y1, color);
+ }
+ }
+#endif
+
+#if !GDISP_HARDWARE_FILLS
+ void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ #if GDISP_HARDWARE_SCROLL
+ gdisp_lld_verticalscroll(x, y, cx, cy, cy, color);
+ #elif GDISP_HARDWARE_LINES
+ coord_t x1, y1;
+
+ x1 = x + cx - 1;
+ y1 = y + cy;
+ for(; y < y1; y++)
+ gdisp_lld_drawline(x, y, x1, y, color);
+ #else
+ coord_t x0, x1, y1;
+
+ x0 = x;
+ x1 = x + cx;
+ y1 = y + cy;
+ for(; y < y1; y++)
+ for(x = x0; x < x1; x++)
+ gdisp_lld_drawpixel(x, y, color);
+ #endif
+ }
+#endif
+
+#if !GDISP_HARDWARE_BITFILLS
+ void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {
+ coord_t x0, x1, y1;
+
+ x0 = x;
+ x1 = x + cx;
+ y1 = y + cy;
+ for(; y < y1; y++)
+ for(x = x0; x < x1; x++)
+ gdisp_lld_drawpixel(x, y, *buffer++);
+ }
+#endif
+
+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES
+ void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ int16_t a, b, P;
+
+ a = 0;
+ b = radius;
+ P = 1 - radius;
+
+ do {
+ gdisp_lld_drawpixel(a+x, b+y, color);
+ gdisp_lld_drawpixel(b+x, a+y, color);
+ gdisp_lld_drawpixel(x-a, b+y, color);
+ gdisp_lld_drawpixel(x-b, a+y, color);
+ gdisp_lld_drawpixel(b+x, y-a, color);
+ gdisp_lld_drawpixel(a+x, y-b, color);
+ gdisp_lld_drawpixel(x-a, y-b, color);
+ gdisp_lld_drawpixel(x-b, y-a, color);
+ if (P < 0)
+ P += 3 + 2*a++;
+ else
+ P += 5 + 2*(a++ - b--);
+ } while(a <= b);
+ }
+#endif
+
+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS
+ void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ int16_t a, b, P;
+
+ a = 0;
+ b = radius;
+ P = 1 - radius;
+
+ do {
+ gdisp_lld_drawline(x-a, y+b, x+a, y+b, color);
+ gdisp_lld_drawline(x-a, y-b, x+a, y-b, color);
+ gdisp_lld_drawline(x-b, y+a, x+b, y+a, color);
+ gdisp_lld_drawline(x-b, y-a, x+b, y-a, color);
+ if (P < 0)
+ P += 3 + 2*a++;
+ else
+ P += 5 + 2*(a++ - b--);
+ } while(a <= b);
+ }
+#endif
+
+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES
+ void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_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 {
+ gdisp_lld_drawpixel(x+dx, y+dy, color); /* I. Quadrant */
+ gdisp_lld_drawpixel(x-dx, y+dy, color); /* II. Quadrant */
+ gdisp_lld_drawpixel(x-dx, y-dy, color); /* III. Quadrant */
+ gdisp_lld_drawpixel(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) */
+ gdisp_lld_drawpixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
+ gdisp_lld_drawpixel(x-dx, y, color);
+ }
+ }
+#endif
+
+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS
+ void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_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 {
+ gdisp_lld_drawline(x-dx,y+dy,x+dx,y+dy, color);
+ gdisp_lld_drawline(x-dx,y-dy,x+dx,y-dy, color);
+
+ 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) */
+ gdisp_lld_drawpixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */
+ gdisp_lld_drawpixel(x-dx, y, color);
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT
+ void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color) {
+ const fontcolumn_t *ptr;
+ fontcolumn_t column;
+ coord_t width, i, j;
+
+ /* Check we actually have something to print */
+ width = _getCharWidth(font, c);
+ if (!width) return;
+
+ ptr = _getCharData(font, c);
+
+ /* Loop through the data and display. The font data is LSBit first, down the column */
+ for(i = 0; i < width; i++) {
+ /* Get the font bitmap data for the column */
+ column = *ptr++;
+
+ /* Draw each pixel */
+ for(j = 0; j < font->height; j++, column >>= 1) {
+ if (column & 0x01)
+ gdisp_lld_drawpixel(x+i, y+j, color);
+ }
+ }
+ }
+#endif
+
+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS
+ void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+ coord_t width;
+
+ /* Check we actually have something to print */
+ width = _getCharWidth(font, c);
+ if (!width) return;
+
+ /* Method 1: Use background fill and then draw the text */
+ #if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW
+
+ /* Fill the area */
+ gdisp_lld_fillarea(x, y, width, font->height, bgcolor);
+
+ /* Draw the text */
+ gdisp_lld_drawchar(x, y, c, font, color);
+
+ /* Method 2: Create a single column bitmap and then blit it */
+ #elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN
+ {
+ const fontcolumn_t *ptr;
+ fontcolumn_t column;
+ coord_t i, j;
+
+ /* Working buffer for fast non-transparent text rendering [patch by Badger] */
+ static pixel_t buf[sizeof(fontcolumn_t)*8];
+
+ ptr = _getCharData(font, c);
+
+ /* Loop through the data and display. The font data is LSBit first, down the column */
+ for(i = 0; i < width; i++) {
+ /* Get the font bitmap data for the column */
+ column = *ptr++;
+
+ /* Draw each pixel */
+ for(j = 0; j < font->height; j++, column >>= 1) {
+ gdispPackPixels(buf, 1, i, 0, (column & 0x01) ? color : bgcolor);
+ }
+
+ gdisp_lld_blitarea(x+i, y, 1, font->height, buf);
+ }
+ }
+
+ /* Method 3: Create a character bitmap and then blit it */
+ #elif GDISP_HARDWARE_BITFILLS
+ {
+ const fontcolumn_t *ptr;
+ fontcolumn_t column;
+ coord_t i, j;
+
+ /* Working buffer for fast non-transparent text rendering [patch by Badger]
+ This needs to be larger than the largest character we can print.
+ */
+ static pixel_t buf[20*(sizeof(fontcolumn_t)*8)];
+
+ #if GDISP_NEED_VALIDATION
+ /* Check our buffer is big enough */
+ if (width * font->height > sizeof(buf)/sizeof(buf[0])) return;
+ #endif
+
+ ptr = _getCharData(font, c);
+
+ /* Loop through the data and display. The font data is LSBit first, down the column */
+ for(i = 0; i < width; i++) {
+ /* Get the font bitmap data for the column */
+ column = *ptr++;
+
+ /* Draw each pixel */
+ for(j = 0; j < font->height; j++, column >>= 1) {
+ gdispPackPixels(buf, width, i, j, (column & 0x01) ? color : bgcolor);
+ }
+ }
+
+ /* [Patch by Badger] Write all in one stroke */
+ gdisp_lld_blitarea(x, y, width, font->height, buf);
+ }
+
+ /* Method 4: Draw pixel by pixel */
+ #else
+ {
+ const fontcolumn_t *ptr;
+ fontcolumn_t column;
+ coord_t width, i, j;
+
+ ptr = _getCharData(font, c);
+
+ /* Loop through the data and display. The font data is LSBit first, down the column */
+ for(i = 0; i < width; i++) {
+ /* Get the font bitmap data for the column */
+ column = *ptr++;
+
+ /* Draw each pixel */
+ for(j = 0; j < font->height; j++, column >>= 1) {
+ gdisp_lld_drawpixel(x+i, y+j, (column & 0x01) ? color : bgcolor);
+ }
+ }
+ }
+ #endif
+ }
+#endif
diff --git a/gdisp/src/gdisp_inc_fonts.c b/gdisp/src/gdisp_inc_fonts.c
new file mode 100644
index 00000000..b8ade615
--- /dev/null
+++ b/gdisp/src/gdisp_inc_fonts.c
@@ -0,0 +1,631 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/*
+ Font tables included into gdisp.c
+*/
+
+/* Offset building macros */
+#define OFFSETOF(b,a) (((uint8_t*)(b)) - ((uint8_t*)(a)))
+#define FOD(f,nn) OFFSETOF(&f, f##_Data##nn)
+#define FOD_0T3(f,n) FOD(f,n##0),FOD(f,n##1),FOD(f,n##2),FOD(f,n##3)
+#define FOD_4T7(f,n) FOD(f,n##4),FOD(f,n##5),FOD(f,n##6),FOD(f,n##7)
+#define FOD_8TB(f,n) FOD(f,n##8),FOD(f,n##9),FOD(f,n##A),FOD(f,n##B)
+#define FOD_CTF(f,n) FOD(f,n##C),FOD(f,n##D),FOD(f,n##E),FOD(f,n##F)
+#define FOD_0T7(f,n) FOD_0T3(f,n),FOD_4T7(f,n)
+#define FOD_8TF(f,n) FOD_0T3(f,n),FOD_4T7(f,n)
+#define FOD_0TF(f,n) FOD_0T7(f,n),FOD_8TF(f,n)
+#define FOD_0TE(f,n) FOD_0T7(f,n),FOD_8TB(f,n),FOD(f,n##C),FOD(f,n##D),FOD(f,n##E)
+
+/* fontSmall - for side buttons */
+#if 1
+ const struct font fontSmall = {
+ 11, 0, 14, 2, 2, 12, ' ', '~',
+ OFFSETOF(fontSmall_Widths, &fontSmall), OFFSETOF(fontSmall_Offsets, &fontSmall)
+ }
+ static const uint16_t fontSmall_Offsets[] = {
+ FOD_0TF(fontSmall,2), FOD_0TF(fontSmall,3), FOD_0TF(fontSmall,4),
+ FOD_0TF(fontSmall,5), FOD_0TF(fontSmall,6), FOD_0TE(fontSmall,7)
+ }
+ static const uint8_t fontSmall_Widths[] = {
+ 2, 3, 6, 8, 7, 9, 7, 3, 4, 4, 5, 7, 4, 4, 3, 6,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 4, 6, 7, 6, 7,
+ 12, 8, 7, 8, 8, 7, 7, 8, 8, 3, 5, 8, 7, 9, 8, 8,
+ 8, 8, 8, 7, 7, 8, 8, 12, 8, 8, 8, 4, 6, 4, 7, 7,
+ 4, 7, 7, 7, 7, 7, 4, 7, 7, 3, 3, 7, 3, 9, 7, 7,
+ 7, 7, 4, 6, 4, 7, 7, 9, 6, 6, 6, 5, 3, 5, 8
+ }
+ static const fontcolumn_t fontSmall_Data20[] = {0x0000, 0x0000}
+ static const fontcolumn_t fontSmall_Data21[] = {0x0000, 0x017F, 0x017F}
+ static const fontcolumn_t fontSmall_Data22[] = {0x0000, 0x0007, 0x0007, 0x0000, 0x0007, 0x0007}
+ static const fontcolumn_t fontSmall_Data23[] = {0x0000, 0x0044, 0x01FF, 0x01FF, 0x0044, 0x01FF, 0x01FF, 0x0044}
+ static const fontcolumn_t fontSmall_Data24[] = {0x0000, 0x008C, 0x019E, 0x03FF, 0x03FF, 0x01E6, 0x00C4}
+ static const fontcolumn_t fontSmall_Data25[] = {
+ 0x0000, 0x0082, 0x00C7, 0x0065, 0x00B7, 0x01DA, 0x014C, 0x01C6,
+ 0x0082}
+ static const fontcolumn_t fontSmall_Data26[] = {0x0000, 0x00E6, 0x01FF, 0x013F, 0x01E6, 0x01E0, 0x0120}
+ static const fontcolumn_t fontSmall_Data27[] = {0x0000, 0x0007, 0x0007}
+ static const fontcolumn_t fontSmall_Data28[] = {0x0000, 0x03FE, 0x07FF, 0x0401}
+ static const fontcolumn_t fontSmall_Data29[] = {0x0000, 0x0401, 0x07FF, 0x03FE}
+ static const fontcolumn_t fontSmall_Data2A[] = {0x0000, 0x000A, 0x000E, 0x000E, 0x000A}
+ static const fontcolumn_t fontSmall_Data2B[] = {0x0000, 0x0020, 0x0020, 0x00F8, 0x00F8, 0x0020, 0x0020}
+ static const fontcolumn_t fontSmall_Data2C[] = {0x0000, 0x0200, 0x0300, 0x0100}
+ static const fontcolumn_t fontSmall_Data2D[] = {0x0000, 0x0020, 0x0020, 0x0020}
+ static const fontcolumn_t fontSmall_Data2E[] = {0x0000, 0x0100, 0x0100}
+ static const fontcolumn_t fontSmall_Data2F[] = {0x0000, 0x0180, 0x01E0, 0x0078, 0x001F, 0x0007}
+ static const fontcolumn_t fontSmall_Data30[] = {0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x01FF, 0x00FE}
+ static const fontcolumn_t fontSmall_Data31[] = {0x0000, 0x0002, 0x0002, 0x01FF, 0x01FF, 0x0000, 0x0000}
+ static const fontcolumn_t fontSmall_Data32[] = {0x0000, 0x0182, 0x01C3, 0x0161, 0x0131, 0x011F, 0x010E}
+ static const fontcolumn_t fontSmall_Data33[] = {0x0000, 0x0082, 0x0183, 0x0111, 0x0111, 0x01FF, 0x00EE}
+ static const fontcolumn_t fontSmall_Data34[] = {0x0000, 0x0060, 0x0078, 0x005E, 0x01FF, 0x01FF, 0x0040}
+ static const fontcolumn_t fontSmall_Data35[] = {0x0000, 0x009F, 0x019F, 0x0109, 0x0109, 0x01F9, 0x00F1}
+ static const fontcolumn_t fontSmall_Data36[] = {0x0000, 0x00FE, 0x01FF, 0x0111, 0x0111, 0x01F3, 0x00E2}
+ static const fontcolumn_t fontSmall_Data37[] = {0x0000, 0x0001, 0x01C1, 0x01F1, 0x003D, 0x000F, 0x0003}
+ static const fontcolumn_t fontSmall_Data38[] = {0x0000, 0x00EE, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE}
+ static const fontcolumn_t fontSmall_Data39[] = {0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01FF, 0x00FE}
+ static const fontcolumn_t fontSmall_Data3A[] = {0x0000, 0x0108, 0x0108}
+ static const fontcolumn_t fontSmall_Data3B[] = {0x0000, 0x0200, 0x0308, 0x0108}
+ static const fontcolumn_t fontSmall_Data3C[] = {0x0000, 0x0020, 0x0070, 0x00D8, 0x018C, 0x0104}
+ static const fontcolumn_t fontSmall_Data3D[] = {0x0000, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050}
+ static const fontcolumn_t fontSmall_Data3E[] = {0x0000, 0x0104, 0x018C, 0x00D8, 0x0070, 0x0020}
+ static const fontcolumn_t fontSmall_Data3F[] = {0x0000, 0x0002, 0x0003, 0x0161, 0x0171, 0x001F, 0x000E}
+ static const fontcolumn_t fontSmall_Data40[] = {
+ 0x0000, 0x0078, 0x01FE, 0x0186, 0x0333, 0x0279, 0x0249, 0x0279,
+ 0x027B, 0x0246, 0x007E, 0x0078}
+ static const fontcolumn_t fontSmall_Data41[] = {0x0180, 0x01F0, 0x007C, 0x004F, 0x004F, 0x007C, 0x01F0, 0x0180}
+ static const fontcolumn_t fontSmall_Data42[] = {0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE}
+ static const fontcolumn_t fontSmall_Data43[] = {0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x0183, 0x0082}
+ static const fontcolumn_t fontSmall_Data44[] = {0x0000, 0x01FF, 0x01FF, 0x0101, 0x0101, 0x0183, 0x00FE, 0x007C}
+ static const fontcolumn_t fontSmall_Data45[] = {0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x0111, 0x0101}
+ static const fontcolumn_t fontSmall_Data46[] = {0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x0001}
+ static const fontcolumn_t fontSmall_Data47[] = {0x0000, 0x00FE, 0x01FF, 0x0101, 0x0111, 0x0191, 0x01F3, 0x01F2}
+ static const fontcolumn_t fontSmall_Data48[] = {0x0000, 0x01FF, 0x01FF, 0x0010, 0x0010, 0x0010, 0x01FF, 0x01FF}
+ static const fontcolumn_t fontSmall_Data49[] = {0x0000, 0x01FF, 0x01FF}
+ static const fontcolumn_t fontSmall_Data4A[] = {0x00C0, 0x01C0, 0x0100, 0x01FF, 0x00FF}
+ static const fontcolumn_t fontSmall_Data4B[] = {0x0000, 0x01FF, 0x01FF, 0x003C, 0x0066, 0x00C3, 0x0181, 0x0100}
+ static const fontcolumn_t fontSmall_Data4C[] = {0x0000, 0x01FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x0100}
+ static const fontcolumn_t fontSmall_Data4D[] = {
+ 0x0000, 0x01FF, 0x01FF, 0x003C, 0x00F0, 0x00F0, 0x003C, 0x01FF,
+ 0x01FF}
+ static const fontcolumn_t fontSmall_Data4E[] = {0x0000, 0x01FF, 0x01FF, 0x001E, 0x0038, 0x00E0, 0x01FF, 0x01FF}
+ static const fontcolumn_t fontSmall_Data4F[] = {0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x01FF, 0x00FE}
+ static const fontcolumn_t fontSmall_Data50[] = {0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x001F, 0x000E}
+ static const fontcolumn_t fontSmall_Data51[] = {0x0000, 0x00FE, 0x01FF, 0x0101, 0x0141, 0x01C1, 0x03FF, 0x02FE}
+ static const fontcolumn_t fontSmall_Data52[] = {0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x01FF, 0x01EE}
+ static const fontcolumn_t fontSmall_Data53[] = {0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01F3, 0x00E2}
+ static const fontcolumn_t fontSmall_Data54[] = {0x0000, 0x0001, 0x0001, 0x01FF, 0x01FF, 0x0001, 0x0001}
+ static const fontcolumn_t fontSmall_Data55[] = {0x0000, 0x00FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x01FF, 0x00FF}
+ static const fontcolumn_t fontSmall_Data56[] = {0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003}
+ static const fontcolumn_t fontSmall_Data57[] = {
+ 0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x007C, 0x01E0,
+ 0x01E0, 0x007C, 0x001F, 0x0003}
+ static const fontcolumn_t fontSmall_Data58[] = {0x0183, 0x01C7, 0x006C, 0x0038, 0x0038, 0x006C, 0x01C7, 0x0183}
+ static const fontcolumn_t fontSmall_Data59[] = {0x0003, 0x0007, 0x000C, 0x01F8, 0x01F8, 0x000C, 0x0007, 0x0003}
+ static const fontcolumn_t fontSmall_Data5A[] = {0x0181, 0x01C1, 0x0161, 0x0131, 0x0119, 0x010D, 0x0107, 0x0103}
+ static const fontcolumn_t fontSmall_Data5B[] = {0x0000, 0x07FF, 0x07FF, 0x0401}
+ static const fontcolumn_t fontSmall_Data5C[] = {0x0000, 0x0007, 0x001F, 0x0078, 0x01E0, 0x0180}
+ static const fontcolumn_t fontSmall_Data5D[] = {0x0000, 0x0401, 0x07FF, 0x07FF}
+ static const fontcolumn_t fontSmall_Data5E[] = {0x0000, 0x0002, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002}
+ static const fontcolumn_t fontSmall_Data5F[] = {0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400}
+ static const fontcolumn_t fontSmall_Data60[] = {0x0000, 0x0001, 0x0003, 0x0002}
+ static const fontcolumn_t fontSmall_Data61[] = {0x0000, 0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0}
+ static const fontcolumn_t fontSmall_Data62[] = {0x0000, 0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontSmall_Data63[] = {0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x0198, 0x0090}
+ static const fontcolumn_t fontSmall_Data64[] = {0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF}
+ static const fontcolumn_t fontSmall_Data65[] = {0x0000, 0x00F0, 0x01F8, 0x0128, 0x0128, 0x01B8, 0x00B0}
+ static const fontcolumn_t fontSmall_Data66[] = {0x0000, 0x01FE, 0x01FF, 0x0009}
+ static const fontcolumn_t fontSmall_Data67[] = {0x0000, 0x04F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8}
+ static const fontcolumn_t fontSmall_Data68[] = {0x0000, 0x01FF, 0x01FF, 0x0018, 0x0008, 0x01F8, 0x01F0}
+ static const fontcolumn_t fontSmall_Data69[] = {0x0000, 0x01F9, 0x01F9}
+ static const fontcolumn_t fontSmall_Data6A[] = {0x0000, 0x07F9, 0x07F9}
+ static const fontcolumn_t fontSmall_Data6B[] = {0x0000, 0x01FF, 0x01FF, 0x0070, 0x00D8, 0x0188, 0x0100}
+ static const fontcolumn_t fontSmall_Data6C[] = {0x0000, 0x01FF, 0x01FF}
+ static const fontcolumn_t fontSmall_Data6D[] = {
+ 0x0000, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F8, 0x0008, 0x01F8,
+ 0x01F0}
+ static const fontcolumn_t fontSmall_Data6E[] = {0x0000, 0x01F8, 0x01F8, 0x0018, 0x0008, 0x01F8, 0x01F0}
+ static const fontcolumn_t fontSmall_Data6F[] = {0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontSmall_Data70[] = {0x0000, 0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontSmall_Data71[] = {0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8}
+ static const fontcolumn_t fontSmall_Data72[] = {0x0000, 0x01F8, 0x01F8, 0x0008}
+ static const fontcolumn_t fontSmall_Data73[] = {0x0000, 0x0090, 0x01B8, 0x0168, 0x01D8, 0x0090}
+ static const fontcolumn_t fontSmall_Data74[] = {0x0000, 0x00FE, 0x01FE, 0x0108}
+ static const fontcolumn_t fontSmall_Data75[] = {0x0000, 0x00F8, 0x01F8, 0x0100, 0x0180, 0x01F8, 0x01F8}
+ static const fontcolumn_t fontSmall_Data76[] = {0x0000, 0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018}
+ static const fontcolumn_t fontSmall_Data77[] = {
+ 0x0000, 0x0078, 0x01F8, 0x01E0, 0x0078, 0x0078, 0x01E0, 0x01F8,
+ 0x0078}
+ static const fontcolumn_t fontSmall_Data78[] = {0x0000, 0x0198, 0x01F8, 0x0060, 0x01F8, 0x0198}
+ static const fontcolumn_t fontSmall_Data79[] = {0x0400, 0x0478, 0x07F8, 0x0380, 0x00F8, 0x0078}
+ static const fontcolumn_t fontSmall_Data7A[] = {0x0000, 0x0188, 0x01C8, 0x0168, 0x0138, 0x0118}
+ static const fontcolumn_t fontSmall_Data7B[] = {0x0000, 0x0010, 0x01FF, 0x03EF, 0x0200}
+ static const fontcolumn_t fontSmall_Data7C[] = {0x0000, 0x03FF, 0x03FF}
+ static const fontcolumn_t fontSmall_Data7D[] = {0x0000, 0x0200, 0x03EF, 0x01FF, 0x0010}
+ static const fontcolumn_t fontSmall_Data7E[] = {0x0000, 0x0004, 0x0006, 0x0002, 0x0006, 0x0004, 0x0006, 0x0002}
+#endif
+
+/* fontLarger - Tahoma, 11, Bold */
+#if 1
+ const struct font fontLarger = {
+ 12, 1, 13, 2, 2, 13, ' ', '~',
+ OFFSETOF(fontLarger_Widths, &fontLarger), OFFSETOF(fontLarger_Offsets, &fontLarger)
+ }
+ static const uint16_t fontLarger_Offsets[] = {
+ FOD_0TF(fontLarger,2), FOD_0TF(fontLarger,3), FOD_0TF(fontLarger,4),
+ FOD_0TF(fontLarger,5), FOD_0TF(fontLarger,6), FOD_0TE(fontLarger,7)
+ }
+ static const uint8_t fontLarger_Widths[] = {
+ 2, 3, 5, 8, 7, 13, 8, 2, 4, 4, 7, 8, 3, 4, 3, 5,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 9, 8, 9, 6,
+ 9, 8, 7, 7, 8, 6, 5, 7, 8, 4, 5, 7, 6, 10, 7, 8,
+ 7, 8, 8, 7, 6, 7, 7, 11, 7, 6, 6, 4, 5, 4, 9, 8,
+ 5, 6, 7, 5, 7, 6, 5, 7, 7, 2, 3, 6, 2, 10, 7, 7,
+ 7, 7, 4, 5, 5, 7, 6, 10, 6, 6, 5, 6, 4, 6, 9
+ }
+ static const fontcolumn_t fontLarger_Data20[] = {0x0000, 0x0000}
+ static const fontcolumn_t fontLarger_Data21[] = {0x0000, 0x037E, 0x037E}
+ static const fontcolumn_t fontLarger_Data22[] = {0x0007, 0x0007, 0x0000, 0x0007, 0x0007}
+ static const fontcolumn_t fontLarger_Data23[] = {0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018}
+ static const fontcolumn_t fontLarger_Data24[] = {0x0118, 0x023C, 0x0264, 0x0FFF, 0x0264, 0x03C4, 0x0188}
+ static const fontcolumn_t fontLarger_Data25[] = {
+ 0x001C, 0x003E, 0x0022, 0x023E, 0x011C, 0x00C0, 0x0020, 0x0018,
+ 0x01C4, 0x03E2, 0x0220, 0x03E0, 0x01C0}
+ static const fontcolumn_t fontLarger_Data26[] = {0x01CC, 0x03FE, 0x0232, 0x0272, 0x03DE, 0x018C, 0x03E0, 0x0260}
+ static const fontcolumn_t fontLarger_Data27[] = {0x0007, 0x0007}
+ static const fontcolumn_t fontLarger_Data28[] = {0x01F8, 0x07FE, 0x0E07, 0x0801}
+ static const fontcolumn_t fontLarger_Data29[] = {0x0801, 0x0E07, 0x07FE, 0x01F8}
+ static const fontcolumn_t fontLarger_Data2A[] = {0x0000, 0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A}
+ static const fontcolumn_t fontLarger_Data2B[] = {0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020}
+ static const fontcolumn_t fontLarger_Data2C[] = {0x0000, 0x0F00, 0x0700}
+ static const fontcolumn_t fontLarger_Data2D[] = {0x0020, 0x0020, 0x0020, 0x0020}
+ static const fontcolumn_t fontLarger_Data2E[] = {0x0000, 0x0300, 0x0300}
+ static const fontcolumn_t fontLarger_Data2F[] = {0x0C00, 0x0380, 0x0060, 0x001C, 0x0003}
+ static const fontcolumn_t fontLarger_Data30[] = {0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC}
+ static const fontcolumn_t fontLarger_Data31[] = {0x0000, 0x0204, 0x0204, 0x03FE, 0x03FE, 0x0200, 0x0200}
+ static const fontcolumn_t fontLarger_Data32[] = {0x0204, 0x0302, 0x0382, 0x02C2, 0x0262, 0x023E, 0x021C}
+ static const fontcolumn_t fontLarger_Data33[] = {0x0104, 0x0202, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC}
+ static const fontcolumn_t fontLarger_Data34[] = {0x0060, 0x0050, 0x0048, 0x0044, 0x03FE, 0x03FE, 0x0040}
+ static const fontcolumn_t fontLarger_Data35[] = {0x0100, 0x021E, 0x021E, 0x0212, 0x0212, 0x03F2, 0x01E2}
+ static const fontcolumn_t fontLarger_Data36[] = {0x01F8, 0x03FC, 0x0216, 0x0212, 0x0212, 0x03F2, 0x01E0}
+ static const fontcolumn_t fontLarger_Data37[] = {0x0002, 0x0002, 0x0382, 0x03E2, 0x007A, 0x001E, 0x0006}
+ static const fontcolumn_t fontLarger_Data38[] = {0x01DC, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC}
+ static const fontcolumn_t fontLarger_Data39[] = {0x003C, 0x027E, 0x0242, 0x0242, 0x0342, 0x01FE, 0x00FC}
+ static const fontcolumn_t fontLarger_Data3A[] = {0x0000, 0x0318, 0x0318}
+ static const fontcolumn_t fontLarger_Data3B[] = {0x0000, 0x0F18, 0x0718}
+ static const fontcolumn_t fontLarger_Data3C[] = {
+ 0x0000, 0x0060, 0x0060, 0x0090, 0x0090, 0x0108, 0x0108, 0x0204,
+ 0x0204}
+ static const fontcolumn_t fontLarger_Data3D[] = {0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090}
+ static const fontcolumn_t fontLarger_Data3E[] = {
+ 0x0000, 0x0204, 0x0204, 0x0108, 0x0108, 0x0090, 0x0090, 0x0060,
+ 0x0060}
+ static const fontcolumn_t fontLarger_Data3F[] = {0x0004, 0x0002, 0x0362, 0x0372, 0x001E, 0x000C}
+ static const fontcolumn_t fontLarger_Data40[] = {
+ 0x01F8, 0x0204, 0x04F2, 0x05FA, 0x050A, 0x04FA, 0x05FA, 0x0104,
+ 0x00F8}
+ static const fontcolumn_t fontLarger_Data41[] = {0x0380, 0x03F0, 0x00FC, 0x008E, 0x008E, 0x00FC, 0x03F0, 0x0380}
+ static const fontcolumn_t fontLarger_Data42[] = {0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC}
+ static const fontcolumn_t fontLarger_Data43[] = {0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x018C}
+ static const fontcolumn_t fontLarger_Data44[] = {0x03FE, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0306, 0x01FC, 0x00F8}
+ static const fontcolumn_t fontLarger_Data45[] = {0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x0222}
+ static const fontcolumn_t fontLarger_Data46[] = {0x03FE, 0x03FE, 0x0022, 0x0022, 0x0022}
+ static const fontcolumn_t fontLarger_Data47[] = {0x01FC, 0x03FE, 0x0202, 0x0202, 0x0222, 0x03E2, 0x03EC}
+ static const fontcolumn_t fontLarger_Data48[] = {0x03FE, 0x03FE, 0x0020, 0x0020, 0x0020, 0x0020, 0x03FE, 0x03FE}
+ static const fontcolumn_t fontLarger_Data49[] = {0x0202, 0x03FE, 0x03FE, 0x0202}
+ static const fontcolumn_t fontLarger_Data4A[] = {0x0200, 0x0202, 0x0202, 0x03FE, 0x01FE}
+ static const fontcolumn_t fontLarger_Data4B[] = {0x03FE, 0x03FE, 0x0070, 0x00D8, 0x018C, 0x0306, 0x0202}
+ static const fontcolumn_t fontLarger_Data4C[] = {0x03FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x0200}
+ static const fontcolumn_t fontLarger_Data4D[] = {
+ 0x03FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x0030, 0x0018, 0x000C,
+ 0x03FE, 0x03FE}
+ static const fontcolumn_t fontLarger_Data4E[] = {0x03FE, 0x000E, 0x001C, 0x0070, 0x01E0, 0x0380, 0x03FE}
+ static const fontcolumn_t fontLarger_Data4F[] = {0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC}
+ static const fontcolumn_t fontLarger_Data50[] = {0x03FE, 0x03FE, 0x0042, 0x0042, 0x0042, 0x007E, 0x003C}
+ static const fontcolumn_t fontLarger_Data51[] = {0x01FC, 0x03FE, 0x0202, 0x0202, 0x0602, 0x0E02, 0x0BFE, 0x09FC}
+ static const fontcolumn_t fontLarger_Data52[] = {0x03FE, 0x03FE, 0x0022, 0x0062, 0x00E2, 0x01BE, 0x031C, 0x0200}
+ static const fontcolumn_t fontLarger_Data53[] = {0x019C, 0x023E, 0x0222, 0x0222, 0x0222, 0x03E2, 0x01CC}
+ static const fontcolumn_t fontLarger_Data54[] = {0x0002, 0x0002, 0x03FE, 0x03FE, 0x0002, 0x0002}
+ static const fontcolumn_t fontLarger_Data55[] = {0x01FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x03FE, 0x01FE}
+ static const fontcolumn_t fontLarger_Data56[] = {0x000E, 0x007E, 0x03F0, 0x0380, 0x03F0, 0x007E, 0x000E}
+ static const fontcolumn_t fontLarger_Data57[] = {
+ 0x001E, 0x00FE, 0x03E0, 0x03E0, 0x00FC, 0x000E, 0x00FC, 0x03E0,
+ 0x03E0, 0x00FE, 0x001E}
+ static const fontcolumn_t fontLarger_Data58[] = {0x0306, 0x038E, 0x00F8, 0x0070, 0x00F8, 0x038E, 0x0306}
+ static const fontcolumn_t fontLarger_Data59[] = {0x000E, 0x003E, 0x03F0, 0x03F0, 0x003E, 0x000E}
+ static const fontcolumn_t fontLarger_Data5A[] = {0x0382, 0x03C2, 0x0262, 0x0232, 0x021E, 0x020E}
+ static const fontcolumn_t fontLarger_Data5B[] = {0x0FFF, 0x0FFF, 0x0801, 0x0801}
+ static const fontcolumn_t fontLarger_Data5C[] = {0x0003, 0x001C, 0x0060, 0x0380, 0x0C00}
+ static const fontcolumn_t fontLarger_Data5D[] = {0x0801, 0x0801, 0x0FFF, 0x0FFF}
+ static const fontcolumn_t fontLarger_Data5E[] = {
+ 0x0000, 0x0010, 0x0008, 0x0004, 0x0002, 0x0002, 0x0004, 0x0008,
+ 0x0010}
+ static const fontcolumn_t fontLarger_Data5F[] = {0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800}
+ static const fontcolumn_t fontLarger_Data60[] = {0x0000, 0x0000, 0x0001, 0x0003, 0x0002}
+ static const fontcolumn_t fontLarger_Data61[] = {0x0180, 0x03D0, 0x0248, 0x0248, 0x03F8, 0x03F0}
+ static const fontcolumn_t fontLarger_Data62[] = {0x03FF, 0x03FF, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0}
+ static const fontcolumn_t fontLarger_Data63[] = {0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208}
+ static const fontcolumn_t fontLarger_Data64[] = {0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x03FF, 0x03FF}
+ static const fontcolumn_t fontLarger_Data65[] = {0x01F0, 0x03F8, 0x0248, 0x0248, 0x0278, 0x0170}
+ static const fontcolumn_t fontLarger_Data66[] = {0x0008, 0x03FE, 0x03FF, 0x0009, 0x0001}
+ static const fontcolumn_t fontLarger_Data67[] = {0x01F0, 0x0BF8, 0x0A08, 0x0A08, 0x0908, 0x0FF8, 0x07F8}
+ static const fontcolumn_t fontLarger_Data68[] = {0x03FF, 0x03FF, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0}
+ static const fontcolumn_t fontLarger_Data69[] = {0x03FA, 0x03FA}
+ static const fontcolumn_t fontLarger_Data6A[] = {0x0808, 0x0FFA, 0x07FA}
+ static const fontcolumn_t fontLarger_Data6B[] = {0x03FF, 0x03FF, 0x00E0, 0x01B0, 0x0318, 0x0208}
+ static const fontcolumn_t fontLarger_Data6C[] = {0x03FF, 0x03FF}
+ static const fontcolumn_t fontLarger_Data6D[] = {
+ 0x03F8, 0x03F8, 0x0008, 0x0008, 0x03F8, 0x03F0, 0x0008, 0x0008,
+ 0x03F8, 0x03F0}
+ static const fontcolumn_t fontLarger_Data6E[] = {0x03F8, 0x03F8, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0}
+ static const fontcolumn_t fontLarger_Data6F[] = {0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208, 0x03F8, 0x01F0}
+ static const fontcolumn_t fontLarger_Data70[] = {0x0FF8, 0x0FF8, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0}
+ static const fontcolumn_t fontLarger_Data71[] = {0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x0FF8, 0x0FF8}
+ static const fontcolumn_t fontLarger_Data72[] = {0x03F8, 0x03F8, 0x0010, 0x0018}
+ static const fontcolumn_t fontLarger_Data73[] = {0x0130, 0x0278, 0x0248, 0x03C8, 0x0190}
+ static const fontcolumn_t fontLarger_Data74[] = {0x0008, 0x01FE, 0x03FE, 0x0208, 0x0208}
+ static const fontcolumn_t fontLarger_Data75[] = {0x01F8, 0x03F8, 0x0200, 0x0200, 0x0100, 0x03F8, 0x03F8}
+ static const fontcolumn_t fontLarger_Data76[] = {0x0038, 0x00F8, 0x03C0, 0x03C0, 0x00F8, 0x0038}
+ static const fontcolumn_t fontLarger_Data77[] = {
+ 0x0018, 0x00F8, 0x03E0, 0x0380, 0x00F8, 0x00F8, 0x0380, 0x03E0,
+ 0x00F8, 0x0018}
+ static const fontcolumn_t fontLarger_Data78[] = {0x0318, 0x03B8, 0x00E0, 0x00E0, 0x03B8, 0x0318}
+ static const fontcolumn_t fontLarger_Data79[] = {0x0038, 0x0CF8, 0x0FC0, 0x03C0, 0x00F8, 0x0038}
+ static const fontcolumn_t fontLarger_Data7A[] = {0x0388, 0x03C8, 0x0268, 0x0238, 0x0218}
+ static const fontcolumn_t fontLarger_Data7B[] = {0x0020, 0x0020, 0x07FE, 0x0FDF, 0x0801, 0x0801}
+ static const fontcolumn_t fontLarger_Data7C[] = {0x0000, 0x0000, 0x0FFF, 0x0FFF}
+ static const fontcolumn_t fontLarger_Data7D[] = {0x0801, 0x0801, 0x0FDF, 0x07FE, 0x0020, 0x0020}
+ static const fontcolumn_t fontLarger_Data7E[] = {
+ 0x00E0, 0x0030, 0x0030, 0x0030, 0x0060, 0x00C0, 0x00C0, 0x00C0,
+ 0x0070}
+#endif
+
+/* fontUI1 - UI Font 1 Medium Bold */
+#if 1
+ const struct font fontUI1 = {
+ 13, 0, 15, 2, 3, 13, ' ', '~',
+ OFFSETOF(fontUI1_Widths, &fontUI1), OFFSETOF(fontUI1_Offsets, &fontName)
+ }
+ static const uint16_t fontUI1_Offsets[] = {
+ FOD_0TF(fontUI1,2), FOD_0TF(fontUI1,3), FOD_0TF(fontUI1,4),
+ FOD_0TF(fontUI1,5), FOD_0TF(fontUI1,6), FOD_0TE(fontUI1,7)
+ }
+ static const uint8_t fontUI1_Widths[] = {
+ 3, 3, 6, 8, 7, 13, 9, 3, 5, 5, 6, 8, 3, 5, 3, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 8, 8, 8, 6,
+ 10, 8, 7, 7, 8, 7, 7, 8, 8, 5, 5, 7, 7, 9, 8, 8,
+ 7, 8, 8, 7, 8, 8, 7, 11, 7, 7, 7, 5, 7, 5, 9, 8,
+ 5, 7, 7, 6, 7, 7, 5, 7, 7, 3, 4, 7, 3, 11, 7, 7,
+ 7, 7, 6, 6, 5, 7, 7, 9, 7, 7, 6, 7, 4, 7, 8
+ }
+ static const fontcolumn_t fontUI1_Data20[] = {0x0000, 0x0000, 0x0000}
+ static const fontcolumn_t fontUI1_Data21[] = {0x0000, 0x02FC, 0x02FC}
+ static const fontcolumn_t fontUI1_Data22[] = {0x0000, 0x000E, 0x000E, 0x0000, 0x000E, 0x000E}
+ static const fontcolumn_t fontUI1_Data23[] = {0x0000, 0x0080, 0x0390, 0x00F0, 0x039C, 0x00F0, 0x009C, 0x0010}
+ static const fontcolumn_t fontUI1_Data24[] = {0x0000, 0x0130, 0x0278, 0x0FC8, 0x027E, 0x03C8, 0x0190}
+ static const fontcolumn_t fontUI1_Data25[] = {
+ 0x0000, 0x0038, 0x007C, 0x0044, 0x007C, 0x0338, 0x00C0, 0x0030,
+ 0x01CC, 0x03E0, 0x0220, 0x03E0, 0x01C0}
+ static const fontcolumn_t fontUI1_Data26[] = {
+ 0x0000, 0x01D8, 0x03FC, 0x0224, 0x027C, 0x02D8, 0x0180, 0x0360,
+ 0x0220}
+ static const fontcolumn_t fontUI1_Data27[] = {0x0000, 0x000E, 0x000E}
+ static const fontcolumn_t fontUI1_Data28[] = {0x0000, 0x01F0, 0x07FC, 0x0E0E, 0x0802}
+ static const fontcolumn_t fontUI1_Data29[] = {0x0000, 0x0802, 0x0E0E, 0x07FC, 0x01F0}
+ static const fontcolumn_t fontUI1_Data2A[] = {0x0000, 0x0014, 0x0008, 0x003E, 0x0008, 0x0014}
+ static const fontcolumn_t fontUI1_Data2B[] = {0x0000, 0x0040, 0x0040, 0x0040, 0x03F8, 0x0040, 0x0040, 0x0040}
+ static const fontcolumn_t fontUI1_Data2C[] = {0x0000, 0x0F00, 0x0700}
+ static const fontcolumn_t fontUI1_Data2D[] = {0x0000, 0x0040, 0x0040, 0x0040, 0x0040}
+ static const fontcolumn_t fontUI1_Data2E[] = {0x0000, 0x0300, 0x0300}
+ static const fontcolumn_t fontUI1_Data2F[] = {0x0000, 0x0C00, 0x0F00, 0x03E0, 0x00F8, 0x001E, 0x0006}
+ static const fontcolumn_t fontUI1_Data30[] = {0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x03FC, 0x01F8}
+ static const fontcolumn_t fontUI1_Data31[] = {0x0000, 0x0000, 0x0208, 0x03FC, 0x03FC, 0x0200, 0x0000}
+ static const fontcolumn_t fontUI1_Data32[] = {0x0000, 0x0308, 0x038C, 0x02C4, 0x0264, 0x023C, 0x0218}
+ static const fontcolumn_t fontUI1_Data33[] = {0x0000, 0x0108, 0x030C, 0x0224, 0x0224, 0x03FC, 0x01D8}
+ static const fontcolumn_t fontUI1_Data34[] = {0x0000, 0x00C0, 0x00A0, 0x0090, 0x03F8, 0x03FC, 0x0080}
+ static const fontcolumn_t fontUI1_Data35[] = {0x0000, 0x0100, 0x033C, 0x023C, 0x0224, 0x03E4, 0x01C4}
+ static const fontcolumn_t fontUI1_Data36[] = {0x0000, 0x01F0, 0x03F8, 0x022C, 0x0224, 0x03E4, 0x01C0}
+ static const fontcolumn_t fontUI1_Data37[] = {0x0000, 0x0004, 0x0304, 0x03C4, 0x00F4, 0x003C, 0x000C}
+ static const fontcolumn_t fontUI1_Data38[] = {0x0000, 0x01D8, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8}
+ static const fontcolumn_t fontUI1_Data39[] = {0x0000, 0x0038, 0x027C, 0x0244, 0x0344, 0x01FC, 0x00F8}
+ static const fontcolumn_t fontUI1_Data3A[] = {0x0000, 0x0330, 0x0330}
+ static const fontcolumn_t fontUI1_Data3B[] = {0x0000, 0x0F30, 0x0730}
+ static const fontcolumn_t fontUI1_Data3C[] = {0x0000, 0x0040, 0x00A0, 0x00A0, 0x0110, 0x0110, 0x0208, 0x0208}
+ static const fontcolumn_t fontUI1_Data3D[] = {0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090}
+ static const fontcolumn_t fontUI1_Data3E[] = {0x0000, 0x0208, 0x0208, 0x0110, 0x0110, 0x00A0, 0x00A0, 0x0040}
+ static const fontcolumn_t fontUI1_Data3F[] = {0x0000, 0x0008, 0x02C4, 0x02E4, 0x003C, 0x0018}
+ static const fontcolumn_t fontUI1_Data40[] = {
+ 0x0000, 0x01F0, 0x0208, 0x04E4, 0x05F4, 0x0514, 0x05F4, 0x05F4,
+ 0x0104, 0x00F8}
+ static const fontcolumn_t fontUI1_Data41[] = {0x0000, 0x0380, 0x03F0, 0x00FC, 0x008C, 0x00FC, 0x03F0, 0x0380}
+ static const fontcolumn_t fontUI1_Data42[] = {0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8}
+ static const fontcolumn_t fontUI1_Data43[] = {0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x0108}
+ static const fontcolumn_t fontUI1_Data44[] = {0x0000, 0x03FC, 0x03FC, 0x0204, 0x0204, 0x030C, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontUI1_Data45[] = {0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x0224, 0x0224}
+ static const fontcolumn_t fontUI1_Data46[] = {0x0000, 0x03FC, 0x03FC, 0x0024, 0x0024, 0x0024, 0x0024}
+ static const fontcolumn_t fontUI1_Data47[] = {0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0244, 0x03C4, 0x03C8}
+ static const fontcolumn_t fontUI1_Data48[] = {0x0000, 0x03FC, 0x03FC, 0x0020, 0x0020, 0x0020, 0x03FC, 0x03FC}
+ static const fontcolumn_t fontUI1_Data49[] = {0x0000, 0x0204, 0x03FC, 0x03FC, 0x0204}
+ static const fontcolumn_t fontUI1_Data4A[] = {0x0200, 0x0204, 0x0204, 0x03FC, 0x01FC}
+ static const fontcolumn_t fontUI1_Data4B[] = {0x0000, 0x03FC, 0x03FC, 0x00F0, 0x0198, 0x030C, 0x0204}
+ static const fontcolumn_t fontUI1_Data4C[] = {0x0000, 0x03FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x0200}
+ static const fontcolumn_t fontUI1_Data4D[] = {
+ 0x0000, 0x03FC, 0x001C, 0x0038, 0x0070, 0x0020, 0x0010, 0x03F8,
+ 0x03FC}
+ static const fontcolumn_t fontUI1_Data4E[] = {0x0000, 0x03FC, 0x0018, 0x0030, 0x0060, 0x00C0, 0x0180, 0x03FC}
+ static const fontcolumn_t fontUI1_Data4F[] = {0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x03FC, 0x01F8}
+ static const fontcolumn_t fontUI1_Data50[] = {0x0000, 0x03FC, 0x03FC, 0x0044, 0x0044, 0x007C, 0x0038}
+ static const fontcolumn_t fontUI1_Data51[] = {0x0000, 0x01F8, 0x03FC, 0x0204, 0x0604, 0x0E04, 0x0BFC, 0x09F8}
+ static const fontcolumn_t fontUI1_Data52[] = {0x0000, 0x03FC, 0x03FC, 0x0044, 0x00C4, 0x01FC, 0x0338, 0x0200}
+ static const fontcolumn_t fontUI1_Data53[] = {0x0000, 0x0138, 0x027C, 0x0264, 0x0264, 0x03E4, 0x01C8}
+ static const fontcolumn_t fontUI1_Data54[] = {0x0004, 0x0004, 0x0004, 0x03FC, 0x03FC, 0x0004, 0x0004, 0x0004}
+ static const fontcolumn_t fontUI1_Data55[] = {0x0000, 0x01FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x03FC, 0x01FC}
+ static const fontcolumn_t fontUI1_Data56[] = {0x0000, 0x001C, 0x00FC, 0x03E0, 0x03E0, 0x00FC, 0x001C}
+ static const fontcolumn_t fontUI1_Data57[] = {
+ 0x0000, 0x001C, 0x00FC, 0x03E0, 0x03C0, 0x007C, 0x007C, 0x03C0,
+ 0x03E0, 0x00FC, 0x001C}
+ static const fontcolumn_t fontUI1_Data58[] = {0x0000, 0x030C, 0x039C, 0x00F0, 0x00F0, 0x039C, 0x030C}
+ static const fontcolumn_t fontUI1_Data59[] = {0x0000, 0x000C, 0x003C, 0x03F0, 0x03F0, 0x003C, 0x000C}
+ static const fontcolumn_t fontUI1_Data5A[] = {0x0000, 0x0384, 0x03C4, 0x02E4, 0x0274, 0x023C, 0x021C}
+ static const fontcolumn_t fontUI1_Data5B[] = {0x0000, 0x0FFE, 0x0FFE, 0x0802, 0x0802}
+ static const fontcolumn_t fontUI1_Data5C[] = {0x0000, 0x0006, 0x001E, 0x00F8, 0x03E0, 0x0F00, 0x0C00}
+ static const fontcolumn_t fontUI1_Data5D[] = {0x0000, 0x0802, 0x0802, 0x0FFE, 0x0FFE}
+ static const fontcolumn_t fontUI1_Data5E[] = {
+ 0x0000, 0x0020, 0x0030, 0x0018, 0x000C, 0x000C, 0x0018, 0x0030,
+ 0x0020}
+ static const fontcolumn_t fontUI1_Data5F[] = {0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800}
+ static const fontcolumn_t fontUI1_Data60[] = {0x0000, 0x0000, 0x0002, 0x0006, 0x0004}
+ static const fontcolumn_t fontUI1_Data61[] = {0x0000, 0x0180, 0x03D0, 0x0250, 0x0250, 0x03F0, 0x03E0}
+ static const fontcolumn_t fontUI1_Data62[] = {0x0000, 0x03FE, 0x03FE, 0x0210, 0x0210, 0x03F0, 0x01E0}
+ static const fontcolumn_t fontUI1_Data63[] = {0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0210}
+ static const fontcolumn_t fontUI1_Data64[] = {0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03FE, 0x03FE}
+ static const fontcolumn_t fontUI1_Data65[] = {0x0000, 0x01E0, 0x03F0, 0x0250, 0x0250, 0x0270, 0x0160}
+ static const fontcolumn_t fontUI1_Data66[] = {0x0010, 0x03FC, 0x03FE, 0x0012, 0x0012}
+ static const fontcolumn_t fontUI1_Data67[] = {0x0000, 0x01E0, 0x0BF0, 0x0A10, 0x0A10, 0x0FF0, 0x07F0}
+ static const fontcolumn_t fontUI1_Data68[] = {0x0000, 0x03FE, 0x03FE, 0x0010, 0x0010, 0x03F0, 0x03E0}
+ static const fontcolumn_t fontUI1_Data69[] = {0x0000, 0x03F4, 0x03F4}
+ static const fontcolumn_t fontUI1_Data6A[] = {0x0800, 0x0810, 0x0FF4, 0x07F4}
+ static const fontcolumn_t fontUI1_Data6B[] = {0x0000, 0x03FE, 0x03FE, 0x00C0, 0x01E0, 0x0330, 0x0210}
+ static const fontcolumn_t fontUI1_Data6C[] = {0x0000, 0x03FE, 0x03FE}
+ static const fontcolumn_t fontUI1_Data6D[] = {
+ 0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0, 0x0010,
+ 0x0010, 0x03F0, 0x03E0}
+ static const fontcolumn_t fontUI1_Data6E[] = {0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0}
+ static const fontcolumn_t fontUI1_Data6F[] = {0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03F0, 0x01E0}
+ static const fontcolumn_t fontUI1_Data70[] = {0x0000, 0x0FF0, 0x0FF0, 0x0210, 0x0210, 0x03F0, 0x01E0}
+ static const fontcolumn_t fontUI1_Data71[] = {0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0FF0, 0x0FF0}
+ static const fontcolumn_t fontUI1_Data72[] = {0x0000, 0x03F0, 0x03F0, 0x0020, 0x0030, 0x0030}
+ static const fontcolumn_t fontUI1_Data73[] = {0x0000, 0x0260, 0x02F0, 0x02D0, 0x03D0, 0x0190}
+ static const fontcolumn_t fontUI1_Data74[] = {0x0010, 0x01FC, 0x03FC, 0x0210, 0x0210}
+ static const fontcolumn_t fontUI1_Data75[] = {0x0000, 0x01F0, 0x03F0, 0x0200, 0x0200, 0x03F0, 0x03F0}
+ static const fontcolumn_t fontUI1_Data76[] = {0x0000, 0x0070, 0x01F0, 0x0380, 0x0380, 0x01F0, 0x0070}
+ static const fontcolumn_t fontUI1_Data77[] = {
+ 0x0000, 0x00F0, 0x03F0, 0x0300, 0x00F0, 0x00F0, 0x0300, 0x03F0,
+ 0x00F0}
+ static const fontcolumn_t fontUI1_Data78[] = {0x0000, 0x0330, 0x03F0, 0x00C0, 0x00C0, 0x03F0, 0x0330}
+ static const fontcolumn_t fontUI1_Data79[] = {0x0000, 0x0030, 0x0CF0, 0x0FC0, 0x03C0, 0x00F0, 0x0030}
+ static const fontcolumn_t fontUI1_Data7A[] = {0x0000, 0x0310, 0x0390, 0x02D0, 0x0270, 0x0230}
+ static const fontcolumn_t fontUI1_Data7B[] = {0x0000, 0x0040, 0x0040, 0x07FC, 0x0FBE, 0x0802, 0x0802}
+ static const fontcolumn_t fontUI1_Data7C[] = {0x0000, 0x0000, 0x0FFE, 0x0FFE}
+ static const fontcolumn_t fontUI1_Data7D[] = {0x0000, 0x0802, 0x0802, 0x0FBE, 0x07FC, 0x0040, 0x0040}
+ static const fontcolumn_t fontUI1_Data7E[] = {0x0000, 0x01C0, 0x0020, 0x0020, 0x00C0, 0x0100, 0x0100, 0x00E0}
+#endif
+
+/* fontUI1 - UI Font 2 Medium Bold */
+#if 1
+ const struct font fontUI2 = {
+ 11, 1, 13, 2, 2, 12, ' ', '~',
+ OFFSETOF(fontUI2_Widths, &fontUI2), OFFSETOF(fontUI2_Offsets, &fontUI2)
+ }
+ static const uint16_t fontUI2_Offsets[] = {
+ FOD_0TF(fontUI2,2), FOD_0TF(fontUI2,3), FOD_0TF(fontUI2,4),
+ FOD_0TF(fontUI2,5), FOD_0TF(fontUI2,6), FOD_0TE(fontUI2,7)
+ }
+ static const uint8_t fontUI2_Widths[] = {
+ 2, 2, 5, 8, 6, 12, 8, 2, 4, 4, 6, 8, 2, 4, 2, 5,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 8, 8, 8, 5,
+ 9, 7, 6, 6, 7, 5, 5, 7, 7, 4, 5, 6, 5, 9, 6, 7,
+ 6, 7, 7, 6, 6, 7, 6, 10, 6, 6, 6, 4, 5, 4, 7, 7,
+ 4, 6, 6, 5, 6, 6, 4, 6, 6, 2, 3, 6, 2, 10, 6, 6,
+ 6, 6, 4, 5, 4, 6, 6, 8, 6, 6, 5, 6, 4, 6, 8
+ }
+ static const fontcolumn_t fontUI2_Data20[] = {0x0000, 0x0000}
+ static const fontcolumn_t fontUI2_Data21[] = {0x017E, 0x017E}
+ static const fontcolumn_t fontUI2_Data22[] = {0x0007, 0x0007, 0x0000, 0x0007, 0x0007}
+ static const fontcolumn_t fontUI2_Data23[] = {0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018}
+ static const fontcolumn_t fontUI2_Data24[] = {0x0098, 0x013C, 0x07E4, 0x013F, 0x01E4, 0x00C8}
+ static const fontcolumn_t fontUI2_Data25[] = {
+ 0x001C, 0x003E, 0x0022, 0x003E, 0x019C, 0x0060, 0x0018, 0x00E6,
+ 0x01F0, 0x0110, 0x01F0, 0x00E0}
+ static const fontcolumn_t fontUI2_Data26[] = {0x00EC, 0x01FE, 0x0112, 0x013E, 0x016C, 0x00C0, 0x01B0, 0x0110}
+ static const fontcolumn_t fontUI2_Data27[] = {0x0007, 0x0007}
+ static const fontcolumn_t fontUI2_Data28[] = {0x00F8, 0x03FE, 0x0707, 0x0401}
+ static const fontcolumn_t fontUI2_Data29[] = {0x0401, 0x0707, 0x03FE, 0x00F8}
+ static const fontcolumn_t fontUI2_Data2A[] = {0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A}
+ static const fontcolumn_t fontUI2_Data2B[] = {0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020}
+ static const fontcolumn_t fontUI2_Data2C[] = {0x0780, 0x0380}
+ static const fontcolumn_t fontUI2_Data2D[] = {0x0020, 0x0020, 0x0020, 0x0020}
+ static const fontcolumn_t fontUI2_Data2E[] = {0x0180, 0x0180}
+ static const fontcolumn_t fontUI2_Data2F[] = {0x0600, 0x0180, 0x0070, 0x000C, 0x0003}
+ static const fontcolumn_t fontUI2_Data30[] = {0x00FC, 0x01FE, 0x0102, 0x0102, 0x01FE, 0x00FC}
+ static const fontcolumn_t fontUI2_Data31[] = {0x0000, 0x0104, 0x01FE, 0x01FE, 0x0100, 0x0000}
+ static const fontcolumn_t fontUI2_Data32[] = {0x0184, 0x01C6, 0x0162, 0x0132, 0x011E, 0x010C}
+ static const fontcolumn_t fontUI2_Data33[] = {0x0084, 0x0186, 0x0112, 0x0112, 0x01FE, 0x00EC}
+ static const fontcolumn_t fontUI2_Data34[] = {0x0060, 0x0050, 0x0048, 0x01FC, 0x01FE, 0x0040}
+ static const fontcolumn_t fontUI2_Data35[] = {0x0080, 0x019E, 0x011E, 0x0112, 0x01F2, 0x00E2}
+ static const fontcolumn_t fontUI2_Data36[] = {0x00FC, 0x01FE, 0x0112, 0x0112, 0x01F2, 0x00E0}
+ static const fontcolumn_t fontUI2_Data37[] = {0x0002, 0x0002, 0x01C2, 0x01FA, 0x003E, 0x0006}
+ static const fontcolumn_t fontUI2_Data38[] = {0x00EC, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC}
+ static const fontcolumn_t fontUI2_Data39[] = {0x001C, 0x013E, 0x0122, 0x0122, 0x01FE, 0x00FC}
+ static const fontcolumn_t fontUI2_Data3A[] = {0x0198, 0x0198}
+ static const fontcolumn_t fontUI2_Data3B[] = {0x0798, 0x0398}
+ static const fontcolumn_t fontUI2_Data3C[] = {0x0000, 0x0020, 0x0050, 0x0050, 0x0088, 0x0088, 0x0104, 0x0104}
+ static const fontcolumn_t fontUI2_Data3D[] = {0x0000, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048}
+ static const fontcolumn_t fontUI2_Data3E[] = {0x0000, 0x0104, 0x0104, 0x0088, 0x0088, 0x0050, 0x0050, 0x0020}
+ static const fontcolumn_t fontUI2_Data3F[] = {0x0004, 0x0162, 0x0172, 0x001E, 0x000C}
+ static const fontcolumn_t fontUI2_Data40[] = {
+ 0x00F8, 0x0104, 0x0272, 0x02FA, 0x028A, 0x027A, 0x02FA, 0x0084,
+ 0x0078}
+ static const fontcolumn_t fontUI2_Data41[] = {0x01C0, 0x01F8, 0x007E, 0x0046, 0x007E, 0x01F8, 0x01C0}
+ static const fontcolumn_t fontUI2_Data42[] = {0x01FE, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC}
+ static const fontcolumn_t fontUI2_Data43[] = {0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x0102}
+ static const fontcolumn_t fontUI2_Data44[] = {0x01FE, 0x01FE, 0x0102, 0x0102, 0x0186, 0x00FC, 0x0078}
+ static const fontcolumn_t fontUI2_Data45[] = {0x01FE, 0x01FE, 0x0112, 0x0112, 0x0112}
+ static const fontcolumn_t fontUI2_Data46[] = {0x01FE, 0x01FE, 0x0012, 0x0012, 0x0012}
+ static const fontcolumn_t fontUI2_Data47[] = {0x00FC, 0x01FE, 0x0102, 0x0102, 0x0122, 0x01E2, 0x01E2}
+ static const fontcolumn_t fontUI2_Data48[] = {0x01FE, 0x01FE, 0x0010, 0x0010, 0x0010, 0x01FE, 0x01FE}
+ static const fontcolumn_t fontUI2_Data49[] = {0x0102, 0x01FE, 0x01FE, 0x0102}
+ static const fontcolumn_t fontUI2_Data4A[] = {0x0100, 0x0102, 0x0102, 0x01FE, 0x00FE}
+ static const fontcolumn_t fontUI2_Data4B[] = {0x01FE, 0x01FE, 0x0078, 0x00CC, 0x0186, 0x0102}
+ static const fontcolumn_t fontUI2_Data4C[] = {0x01FE, 0x01FE, 0x0100, 0x0100, 0x0100}
+ static const fontcolumn_t fontUI2_Data4D[] = {
+ 0x01FE, 0x000E, 0x001C, 0x0038, 0x0030, 0x0018, 0x000C, 0x01FE,
+ 0x01FE}
+ static const fontcolumn_t fontUI2_Data4E[] = {0x01FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x01FE}
+ static const fontcolumn_t fontUI2_Data4F[] = {0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x01FE, 0x00FC}
+ static const fontcolumn_t fontUI2_Data50[] = {0x01FE, 0x01FE, 0x0022, 0x0022, 0x003E, 0x001C}
+ static const fontcolumn_t fontUI2_Data51[] = {0x00FC, 0x01FE, 0x0102, 0x0302, 0x0702, 0x05FE, 0x04FC}
+ static const fontcolumn_t fontUI2_Data52[] = {0x01FE, 0x01FE, 0x0022, 0x0062, 0x00FE, 0x019C, 0x0100}
+ static const fontcolumn_t fontUI2_Data53[] = {0x011C, 0x013E, 0x0132, 0x0132, 0x01F2, 0x00E2}
+ static const fontcolumn_t fontUI2_Data54[] = {0x0002, 0x0002, 0x01FE, 0x01FE, 0x0002, 0x0002}
+ static const fontcolumn_t fontUI2_Data55[] = {0x00FE, 0x01FE, 0x0100, 0x0100, 0x0100, 0x01FE, 0x00FE}
+ static const fontcolumn_t fontUI2_Data56[] = {0x000E, 0x007E, 0x01F0, 0x01F0, 0x007E, 0x000E}
+ static const fontcolumn_t fontUI2_Data57[] = {
+ 0x000E, 0x007E, 0x01F0, 0x01E0, 0x003E, 0x003E, 0x01E0, 0x01F0,
+ 0x007E, 0x000E}
+ static const fontcolumn_t fontUI2_Data58[] = {0x0186, 0x01CE, 0x0078, 0x0078, 0x01CE, 0x0186}
+ static const fontcolumn_t fontUI2_Data59[] = {0x0006, 0x001E, 0x01F8, 0x01F8, 0x001E, 0x0006}
+ static const fontcolumn_t fontUI2_Data5A[] = {0x01C2, 0x01E2, 0x0172, 0x013A, 0x011E, 0x010E}
+ static const fontcolumn_t fontUI2_Data5B[] = {0x07FF, 0x07FF, 0x0401, 0x0401}
+ static const fontcolumn_t fontUI2_Data5C[] = {0x0003, 0x000C, 0x0070, 0x0180, 0x0600}
+ static const fontcolumn_t fontUI2_Data5D[] = {0x0401, 0x0401, 0x07FF, 0x07FF}
+ static const fontcolumn_t fontUI2_Data5E[] = {0x0010, 0x0008, 0x0004, 0x0002, 0x0004, 0x0008, 0x0010}
+ static const fontcolumn_t fontUI2_Data5F[] = {0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400}
+ static const fontcolumn_t fontUI2_Data60[] = {0x0000, 0x0001, 0x0003, 0x0002}
+ static const fontcolumn_t fontUI2_Data61[] = {0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0}
+ static const fontcolumn_t fontUI2_Data62[] = {0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontUI2_Data63[] = {0x00F0, 0x01F8, 0x0108, 0x0108, 0x0108}
+ static const fontcolumn_t fontUI2_Data64[] = {0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF}
+ static const fontcolumn_t fontUI2_Data65[] = {0x00F0, 0x01F8, 0x0128, 0x0128, 0x0138, 0x0130}
+ static const fontcolumn_t fontUI2_Data66[] = {0x01FE, 0x01FF, 0x0009, 0x0001}
+ static const fontcolumn_t fontUI2_Data67[] = {0x00F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8}
+ static const fontcolumn_t fontUI2_Data68[] = {0x01FF, 0x01FF, 0x0008, 0x0008, 0x01F8, 0x01F0}
+ static const fontcolumn_t fontUI2_Data69[] = {0x01FA, 0x01FA}
+ static const fontcolumn_t fontUI2_Data6A[] = {0x0408, 0x07FA, 0x03FA}
+ static const fontcolumn_t fontUI2_Data6B[] = {0x01FF, 0x01FF, 0x0060, 0x00F0, 0x0198, 0x0108}
+ static const fontcolumn_t fontUI2_Data6C[] = {0x01FF, 0x01FF}
+ static const fontcolumn_t fontUI2_Data6D[] = {
+ 0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0, 0x0008, 0x0008,
+ 0x01F8, 0x01F0}
+ static const fontcolumn_t fontUI2_Data6E[] = {0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0}
+ static const fontcolumn_t fontUI2_Data6F[] = {0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontUI2_Data70[] = {0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0}
+ static const fontcolumn_t fontUI2_Data71[] = {0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8}
+ static const fontcolumn_t fontUI2_Data72[] = {0x01F8, 0x01F8, 0x0010, 0x0018}
+ static const fontcolumn_t fontUI2_Data73[] = {0x0130, 0x0178, 0x0168, 0x01E8, 0x00C8}
+ static const fontcolumn_t fontUI2_Data74[] = {0x00FE, 0x01FE, 0x0108, 0x0108}
+ static const fontcolumn_t fontUI2_Data75[] = {0x00F8, 0x01F8, 0x0100, 0x0100, 0x01F8, 0x01F8}
+ static const fontcolumn_t fontUI2_Data76[] = {0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018}
+ static const fontcolumn_t fontUI2_Data77[] = {0x0078, 0x01F8, 0x01C0, 0x0078, 0x0078, 0x01C0, 0x01F8, 0x0078}
+ static const fontcolumn_t fontUI2_Data78[] = {0x0198, 0x01F8, 0x0060, 0x0060, 0x01F8, 0x0198}
+ static const fontcolumn_t fontUI2_Data79[] = {0x0018, 0x0678, 0x07E0, 0x01E0, 0x0078, 0x0018}
+ static const fontcolumn_t fontUI2_Data7A[] = {0x0188, 0x01C8, 0x0168, 0x0138, 0x0118}
+ static const fontcolumn_t fontUI2_Data7B[] = {0x0020, 0x0020, 0x03FE, 0x07DF, 0x0401, 0x0401}
+ static const fontcolumn_t fontUI2_Data7C[] = {0x0000, 0x0000, 0x07FF, 0x07FF}
+ static const fontcolumn_t fontUI2_Data7D[] = {0x0401, 0x0401, 0x07DF, 0x03FE, 0x0020, 0x0020}
+ static const fontcolumn_t fontUI2_Data7E[] = {0x0060, 0x0010, 0x0010, 0x0030, 0x0060, 0x0040, 0x0040, 0x0030}
+#endif
+
+/*
+ fontLargeNumbers:
+ Large numbers font, height = 16 (including the decenders)
+ Characters include: 0 - 9, -, +, ., %, :, Space, Comma
+*/
+#if 1
+ const struct font fontLargeNumbers = {
+ 16, 2, 21, 1, 3, 15, 0x25, 0x3A,
+ OFFSETOF(fontLargeNumbers_Widths, &fontLargeNumbers), OFFSETOF(fontLargeNumbers_Offsets, &fontLargeNumbers)
+ }
+ static const uint16_t fontLargeNumbers_Offsets[] = {
+ FOD(f,25), FOD(f,ZW), FOD(f,ZW), FOD(f,ZW), FOD(f,ZW), FOD(f,ZW), FOD(f,2B), FOD(f,2C),
+ FOD(f,2D), FOD(f,2E), FOD(f,ZW), FOD(f,30), FOD(f,31), FOD(f,32), FOD(f,33), FOD(f,34),
+ FOD(f,35), FOD(f,36), FOD(f,37), FOD(f,38), FOD(f,39), FOD(f,3A)
+ }
+ static const uint8_t fontLargeNumbers_Widths[] = {
+ 15, 0, 0, 0, 0, 0, 11, 3, 6, 3, 0, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 4
+ }
+ static const fontcolumn_t fontLargeNumbers_DataZW[] = {0}
+ static const fontcolumn_t fontLargeNumbers_Data25[] = {
+ 0x007E, 0x00FF, 0x00C3, 0x80C3, 0xE0FF, 0x7C7E, 0x1F00, 0x07C0,
+ 0x00F0, 0x7E3E, 0xFF0F, 0xC303, 0xC300, 0xFF00, 0x7E00}
+ static const fontcolumn_t fontLargeNumbers_Data2B[] = {
+ 0x01C0, 0x01C0, 0x01C0, 0x01C0, 0x1FFC, 0x1FFC, 0x1FFC, 0x01C0,
+ 0x01C0, 0x01C0, 0x01C0}
+ static const fontcolumn_t fontLargeNumbers_Data2C[] = {0x7000, 0x7000, 0xF000}
+ static const fontcolumn_t fontLargeNumbers_Data2D[] = {0x0700, 0x0700, 0x0700, 0x0700, 0x0700, 0x0700}
+ static const fontcolumn_t fontLargeNumbers_Data2E[] = {0x7000, 0x7000, 0x7000}
+ static const fontcolumn_t fontLargeNumbers_Data30[] = {
+ 0x0FF8, 0x3FFE, 0x3FFE, 0x7007, 0x6003, 0x6003, 0x7007, 0x3FFE,
+ 0x3FFE, 0x0FF8}
+ static const fontcolumn_t fontLargeNumbers_Data31[] = {
+ 0x0000, 0x0070, 0x0038, 0x0038, 0x001C, 0x7FFF, 0x7FFF, 0x7FFF,
+ 0x0000, 0x0000}
+ static const fontcolumn_t fontLargeNumbers_Data32[] = {
+ 0x600C, 0x700E, 0x7C0F, 0x7E07, 0x6F03, 0x6783, 0x63C7, 0x61FF,
+ 0x60FE, 0x603C}
+ static const fontcolumn_t fontLargeNumbers_Data33[] = {
+ 0x180C, 0x380E, 0x780F, 0x70C3, 0x60C3, 0x60E3, 0x71FF, 0x3FFE,
+ 0x3F3C, 0x0E00}
+ static const fontcolumn_t fontLargeNumbers_Data34[] = {
+ 0x0F00, 0x0DC0, 0x0CE0, 0x0C38, 0x0C1E, 0x7FFF, 0x7FFF, 0x7FFF,
+ 0x0C00, 0x0C00}
+ static const fontcolumn_t fontLargeNumbers_Data35[] = {
+ 0x18C0, 0x38FC, 0x78FF, 0x707F, 0x6063, 0x6063, 0x70E3, 0x3FE3,
+ 0x3FC3, 0x0F80}
+ static const fontcolumn_t fontLargeNumbers_Data36[] = {
+ 0x0FF8, 0x3FFE, 0x3FFE, 0x70C7, 0x6063, 0x6063, 0x70E7, 0x3FEF,
+ 0x3FC6, 0x0F04}
+ static const fontcolumn_t fontLargeNumbers_Data37[] = {
+ 0x0003, 0x0003, 0x7803, 0x7F03, 0x7FC3, 0x07F3, 0x00FB, 0x003F,
+ 0x000F, 0x0007}
+ static const fontcolumn_t fontLargeNumbers_Data38[] = {
+ 0x1E1C, 0x3F3E, 0x7FFF, 0x71E7, 0x60C3, 0x60C3, 0x71E7, 0x7FFF,
+ 0x3F3E, 0x1E1C}
+ static const fontcolumn_t fontLargeNumbers_Data39[] = {
+ 0x1078, 0x39FE, 0x7BFE, 0x7387, 0x6303, 0x6303, 0x7187, 0x3FFE,
+ 0x3FFE, 0x0FF8}
+ static const fontcolumn_t fontLargeNumbers_Data3A[] = {0x0000, 0x0E38, 0x0E38, 0x0E38}
+ #endif
diff --git a/gdisp/template/gdisp_lld.c b/gdisp/template/gdisp_lld.c
new file mode 100644
index 00000000..f25b1843
--- /dev/null
+++ b/gdisp/template/gdisp_lld.c
@@ -0,0 +1,425 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/**
+ * @file templates/gdisp_lld.c
+ * @brief GDISP Graphics Driver subsystem low level driver source template.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver local definitions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported variables. */
+/*===========================================================================*/
+
+#if !defined(__DOXYGEN__)
+ GDISPDriver GDISP1;
+#endif
+
+/*===========================================================================*/
+/* Driver local variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver interrupt handlers. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions. */
+/*===========================================================================*/
+
+/* ---- Required Routines ---- */
+/*
+ The following 4 routines are required.
+ All other routines are optional.
+*/
+
+/**
+ * @brief Low level GDISP driver initialization.
+ *
+ * @notapi
+ */
+void gdisp_lld_init(void) {
+ /* Initialise the GDISP structure with the defaults for your display */
+ GDISP1.Width = 128;
+ GDISP1.Height = 128;
+ GDISP1.Orientation = portrait;
+ GDISP1.Powermode = powerOff;
+
+ /* Now initialise your display to match */
+ /* Code here */
+}
+
+/**
+ * @brief Sets the power mode for the graphic device.
+ * @note The power modes are powerOn, powerSleep and powerOff.
+ * If powerSleep is not supported it is equivelent to powerOn.
+ *
+ * @param[in] powerMode The new power mode
+ *
+ * @notapi
+ */
+void gdisp_lld_setpowermode(gdisp_powermode_t powerMode) {
+ /* Code here */
+ /* if successful
+ GDISP1.Powermode = powerMode;
+ */
+}
+
+/**
+ * @brief Sets the orientation of the display.
+ * @note This may be ignored if not supported by the device.
+ *
+ * @param[in] newOrientation The new orientation
+ *
+ * @notapi
+ */
+void gdisp_lld_setorientation(gdisp_orientation_t newOrientation) {
+ /* Code here */
+ /* if successful
+ GDISP1.Orientation = newOrientation;
+ */
+}
+
+/**
+ * @brief Draws a pixel on the display.
+ *
+ * @param[in] x X location of the pixel
+ * @param[in] y Y location of the pixel
+ * @param[in] color The color of the pixel
+ *
+ * @notapi
+ */
+void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ if (x >= GDISP1.Width || y >= GDISP1.Height) return;
+ #endif
+ /* Code here */
+}
+
+/* ---- Optional Routines ---- */
+/*
+ All the below routines are optional.
+ Defining them will increase speed but everything
+ will work if they are not defined.
+ If you are not using a routine - turn it off using
+ the appropriate GDISP_HARDWARE_XXXX macro.
+ Don't bother coding for obvious similar routines if
+ there is no performance penalty as the emulation software
+ makes a good job of using similar routines.
+ eg. If gdisp_lld_fillarea() is defined there is little
+ point in defining gdisp_lld_clear() unless the
+ performance bonus is significant.
+ For good performance it is suggested to implement
+ gdisp_lld_fillarea() and gdisp_lld_blitarea().
+*/
+
+#if GDISP_HARDWARE_CLEARS || defined(__DOXYGEN__)
+ /**
+ * @brief Clear the display.
+ * @note Optional - The high level driver can emulate using software.
+ *
+ * @param[in] color The color of the pixel
+ *
+ * @notapi
+ */
+ void gdisp_lld_clear(color_t color) {
+ /* Code here */
+ }
+#endif
+
+#if GDISP_HARDWARE_LINES || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a line.
+ * @note Optional - The high level driver can emulate using software.
+ *
+ * @param[in] x0, y0 The start of the line
+ * @param[in] x1, y1 The end of the line
+ * @param[in] color The color of the line
+ *
+ * @notapi
+ */
+ void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Need to clip to screen */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if GDISP_HARDWARE_BOX || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a box.
+ * @pre The GDISP unit must be in powerOn or powerSleep mode.
+ *
+ * @param[in] x0,y0 The start position
+ * @param[in] cx,cy The size of the box (outside dimensions)
+ * @param[in] color The color to use
+ * @param[in] filled Should the box should be filled
+ *
+ * @notapi
+ */
+ void gdisp_lld_drawbox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Need to clip to screen */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if GDISP_HARDWARE_FILLS || defined(__DOXYGEN__)
+ /**
+ * @brief Fill an area with a color.
+ * @note Optional - The high level driver can emulate using software.
+ *
+ * @param[in] x, y The start filled area
+ * @param[in] cx, cy The width and height to be filled
+ * @param[in] color The color of the fill
+ *
+ * @notapi
+ */
+ void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+ if (x+cx > GDISP1.Width) cx = GDISP1.Width - x;
+ if (y+cy > GDISP1.Height) cy = GDISP1.Height - y;
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if GDISP_HARDWARE_BITFILLS || defined(__DOXYGEN__)
+ /**
+ * @brief Fill an area with a bitmap.
+ * @note Optional - The high level driver can emulate using software.
+ *
+ * @param[in] x, y The start filled area
+ * @param[in] cx, cy The width and height to be filled
+ * @param[in] buffer The pixels to use to fill the area.
+ *
+ * @notapi
+ */
+ void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {
+ #if GDISP_NEED_VALIDATION
+ if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+ if (x+cx > GDISP1.Width || y+cy > GDISP1.Height) return;
+ #endif
+ /* Code here */
+ }
+#endif
+
+/* Circular Drawing Functions */
+#if (GDISP_NEED_CIRCLE && GDISP_HARDWARE_CIRCLES) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a circle.
+ * @note Optional - The high level driver can emulate using software.
+ * @note If GDISP_NEED_CLIPPING is defined this routine MUST behave
+ * correctly if the circle is over the edges of the screen.
+ *
+ * @param[in] x, y The centre of the circle
+ * @param[in] radius The radius of the circle
+ * @param[in] color The color of the circle
+ *
+ * @notapi
+ */
+ void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Code here */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_CIRCLE && GDISP_HARDWARE_CIRCLEFILLS) || defined(__DOXYGEN__)
+ /**
+ * @brief Create a filled circle.
+ * @note Optional - The high level driver can emulate using software.
+ * @note If GDISP_NEED_CLIPPING is defined this routine MUST behave
+ * correctly if the circle is over the edges of the screen.
+ *
+ * @param[in] x, y The centre of the circle
+ * @param[in] radius The radius of the circle
+ * @param[in] color The color of the circle
+ *
+ * @notapi
+ */
+ void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Code here */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_HARDWARE_ELLIPSES) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw an ellipse.
+ * @note Optional - The high level driver can emulate using software.
+ * @note If GDISP_NEED_CLIPPING is defined this routine MUST behave
+ * correctly if the ellipse is over the edges of the screen.
+ *
+ * @param[in] x, y The centre of the ellipse
+ * @param[in] a, b The dimensions of the ellipse
+ * @param[in] color The color of the ellipse
+ *
+ * @notapi
+ */
+ void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Code here */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_ELLIPSE && GDISP_HARDWARE_ELLIPSEFILLS) || defined(__DOXYGEN__)
+ /**
+ * @brief Create a filled ellipse.
+ * @note Optional - The high level driver can emulate using software.
+ * @note If GDISP_NEED_CLIPPING is defined this routine MUST behave
+ * correctly if the ellipse is over the edges of the screen.
+ *
+ * @param[in] x, y The centre of the ellipse
+ * @param[in] a, b The dimensions of the ellipse
+ * @param[in] color The color of the ellipse
+ *
+ * @notapi
+ */
+ void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Code here */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a character using a transparent background.
+ * @note Optional - The high level driver can emulate using software.
+ *
+ * @param[in] x, y The top-left corner of the text
+ * @param[in] c The character to print
+ * @param[in] color The color of the character
+ *
+ * @notapi
+ */
+ void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color) {
+ #if GDISP_NEED_VALIDATION
+ /* Code here */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXTFILLS) || defined(__DOXYGEN__)
+ /**
+ * @brief Draw a character using a filled background.
+ * @note Optional - The high level driver can emulate using software.
+ *
+ * @param[in] x, y The top-left corner of the text
+ * @param[in] c The character to print
+ * @param[in] color The color of the character
+ * @param[in] bgcolor The background color
+ *
+ * @notapi
+ */
+ void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
+ #if GDISP_NEED_VALIDATION
+ /* Code here */
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_PIXELREAD && GDISP_HARDWARE_PIXELREAD) || defined(__DOXYGEN__)
+ /**
+ * @brief Get the color of a particular pixel.
+ * @note Optional.
+ * @note If x,y is off the screen, the result is undefined.
+ *
+ * @param[in] x, y The start of the text
+ *
+ * @notapi
+ */
+ color_t gdisp_lld_getpixelcolor(coord_t x, coord_t y) {
+ #if GDISP_NEED_VALIDATION
+ if (x >= GDISP1.Width || y >= GDISP1.Height) return 0;
+ #endif
+ /* Code here */
+ }
+#endif
+
+#if (GDISP_NEED_SCROLL && GDISP_HARDWARE_SCROLL) || defined(__DOXYGEN__)
+ /**
+ * @brief Scroll vertically a section of the screen.
+ * @note Optional.
+ * @note If x,y + cx,cy is off the screen, the result is undefined.
+ * @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
+ *
+ * @param[in] x, y The start of the area to be scrolled
+ * @param[in] cx, cy The size of the area to be scrolled
+ * @param[in] lines The number of lines to scroll (Can be positive or negative)
+ * @param[in] bgcolor The color to fill the newly exposed area.
+ *
+ * @notapi
+ */
+ void gdisp_lld_verticalscroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
+ #if GDISP_NEED_VALIDATION
+ if (cx < 1 || cy < 1 || x >= GDISP1.Width || y >= GDISP1.Height) return;
+ if (x+cx > GDISP1.Width) cx = GDISP1.Width - x;
+ if (y+cy > GDISP1.Height) cy = GDISP1.Height - y;
+ #endif
+ /* Code here */
+ }
+#endif
+
+#endif /* HAL_USE_GDISP */
+/** @} */
diff --git a/gdisp/template/gdisp_lld.h b/gdisp/template/gdisp_lld.h
new file mode 100644
index 00000000..5e426bb5
--- /dev/null
+++ b/gdisp/template/gdisp_lld.h
@@ -0,0 +1,322 @@
+/*
+ ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+ 2011,2012 Giovanni Di Sirio.
+
+ This file is part of ChibiOS/RT.
+
+ ChibiOS/RT 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/RT 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 .
+
+ ---
+
+ A special exception to the GPL can be applied should you wish to distribute
+ a combined work that includes ChibiOS/RT, without being obliged to provide
+ the source code for any proprietary components. See the file exception.txt
+ for full details of how and when the exception can be applied.
+*/
+/*
+ Concepts and parts of this file have been contributed by:
+ Joel Bodenmann aka Tectu -> Maintainer
+ Andrew Hannam aka inmarket -> framework
+ Badger -> console implementation and FSMC
+ Abhishek -> font rendering
+ Ben William -> fastMath and lcdDrawEllipse()
+ Dongxu Li aka dxli -> lcdDrawEllipse() filled option
+*/
+
+/**
+ * @file templates/gdisp_lld.h
+ * @brief GDISP Graphic Driver subsystem low level driver header template.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_LLD_H
+#define _GDISP_LLD_H
+
+#if HAL_USE_GDISP || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver constants. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver pre-compile time settings. */
+/*===========================================================================*/
+
+/**
+ * @name GDISP hardware accelerated support
+ * @{
+ */
+ /**
+ * @brief Hardware accelerated line drawing.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_LINES FALSE
+
+ /**
+ * @brief Hardware accelerated box drawing.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_BOX FALSE
+
+ /**
+ * @brief Hardware accelerated screen clears.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_CLEARS FALSE
+
+ /**
+ * @brief Hardware accelerated rectangular fills.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_FILLS FALSE
+
+ /**
+ * @brief Hardware accelerated fills from an image.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_BITFILLS FALSE
+
+ /**
+ * @brief Hardware accelerated circles.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_CIRCLES FALSE
+
+ /**
+ * @brief Hardware accelerated filled circles.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_CIRCLEFILLS FALSE
+
+ /**
+ * @brief Hardware accelerated ellipses.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_ELLIPSES FALSE
+
+ /**
+ * @brief Hardware accelerated filled ellipses.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_ELLIPSEFILLS FALSE
+
+ /**
+ * @brief Hardware accelerated text drawing.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_TEXT FALSE
+
+ /**
+ * @brief Hardware accelerated text drawing with a filled background.
+ * @details If set to @p FALSE software emulation is used.
+ */
+ #define GDISP_HARDWARE_TEXTFILLS FALSE
+
+ /**
+ * @brief Hardware accelerated scrolling.
+ * @details If set to @p FALSE there is no support for scrolling.
+ */
+ #define GDISP_HARDWARE_SCROLL FALSE
+
+ /**
+ * @brief Reading back of pixel values.
+ * @details If set to @p FALSE there is no support for pixel read-back.
+ */
+ #define GDISP_HARDWARE_PIXELREAD FALSE
+/** @} */
+
+/**
+ * @name GDISP software algorithm choices
+ * @{
+ */
+ /**
+ * @brief For filled text drawing, use a background fill and then draw
+ * the text instead of using a blit or direct pixel drawing.
+ * @details If set to @p TRUE background fill and then text draw is used.
+ * @note This is ignored if hardware accelerated text is supported.
+ */
+ #define GDISP_SOFTWARE_TEXTFILLDRAW FALSE
+ /**
+ * @brief For filled text drawing, when using a bitmap blit
+ * use a column by column buffer rather than a full character
+ * buffer to save memory at a small performance cost.
+ * @details If set to @p TRUE background fill one character column at a time.
+ * @note This is ignored if software text using blit is not being used.
+ */
+ #define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE
+/** @} */
+
+/**
+ * @name GDISP pixel format choices
+ * @{
+ */
+ /**
+ * @brief The native pixel format for this device
+ * @note One of the following should be defined:
+ * GDISP_PIXELFORMAT_RGB565
+ * GDISP_PIXELFORMAT_RGB888
+ * GDISP_PIXELFORMAT_RGB444
+ * GDISP_PIXELFORMAT_RGB332
+ * GDISP_PIXELFORMAT_RGB666
+ * GDISP_PIXELFORMAT_CUSTOM
+ * @note If you define GDISP_PIXELFORMAT_CUSTOM you need to also define
+ * color_t, RGB2COLOR(r,g,b), HTML2COLOR(h),
+ * RED_OF(c), GREEN_OF(c), BLUE_OF(c),
+ * COLOR(c) and MASKCOLOR.
+ */
+ #define GDISP_PIXELFORMAT_RGB565
+
+ /**
+ * @brief Do pixels require packing for a blit
+ * @note Is only valid for a pixel format that doesn't fill it's datatype. ie formats:
+ * GDISP_PIXELFORMAT_RGB888
+ * GDISP_PIXELFORMAT_RGB444
+ * GDISP_PIXELFORMAT_RGB666
+ * GDISP_PIXELFORMAT_CUSTOM
+ * @note If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills
+ * you need to also define @P gdispPackPixels(buf,cx,x,y,c)
+ * @note If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel
+ * format must not be a packed format as the software blit does
+ * not support packed pixels
+ * @note Very few cases should actually require packed pixels as the low
+ * level driver can also pack on the fly as it is sending it
+ * to the graphics device.
+ */
+ #define GDISP_PACKED_PIXELS FALSE
+
+ /**
+ * @brief Do lines of pixels require packing for a blit
+ * @note Ignored if GDISP_PACKED_PIXELS is FALSE
+ */
+ #define GDISP_PACKED_LINES FALSE
+
+ /**
+ * @brief Do lines of pixels require packing for a blit
+ * @note Ignored if GDISP_PACKED_PIXELS is FALSE
+ */
+ #define GDISP_PACKED_LINES FALSE
+/** @} */
+
+/*===========================================================================*/
+/* Derived constants and error checks. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver data structures and types. */
+/*===========================================================================*/
+
+/**
+ * @brief Structure representing a GDISP driver.
+ * @note Implementations may extend this structure to contain more,
+ * architecture dependent, fields.
+ */
+struct GDISPDriver {
+ /**
+ * @brief Width of the screen.
+ * @note Read-only.
+ */
+ coord_t Width;
+ /**
+ * @brief Height of the screen.
+ * @note Read-only.
+ */
+ coord_t Height;
+ /**
+ * @brief Current orientation of the screen.
+ * @note Read-only.
+ */
+ gdisp_orientation_t Orientation;
+ /**
+ * @brief Current power mode of the screen.
+ * @note Read-only.
+ */
+ gdisp_powermode_t Powermode;
+
+ #if defined(GDISP_DRIVER_EXT_FIELDS)
+ GDISP_DRIVER_EXT_FIELDS
+ #endif
+
+ /* End of mandatory fields */
+};
+
+/*===========================================================================*/
+/* Driver macros. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* External declarations. */
+/*===========================================================================*/
+
+#if !defined(__DOXYGEN__)
+ extern GDISPDriver GDISP1;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ /* Core functions */
+ void gdisp_lld_init(void);
+ void gdisp_lld_setpowermode(gdisp_powermode_t powerMode);
+ void gdisp_lld_setorientation(gdisp_orientation_t newOrientation);
+
+ /* Some of these functions will be implemented in software by the high level driver
+ depending on the GDISP_HARDWARE_XXX macros defined above.
+ */
+
+ /* Drawing functions */
+ void gdisp_lld_clear(color_t color);
+ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color);
+ void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
+ void gdisp_lld_drawbox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+ void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
+ void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer);
+
+ /* Circular Drawing Functions */
+ #if GDISP_NEED_CIRCLE
+ void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color);
+ void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color);
+ #endif
+
+ #if GDISP_NEED_ELLIPSE
+ void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+ void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
+ #endif
+
+ /* Text Rendering Functions */
+ #if GDISP_NEED_TEXT
+ void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color);
+ void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
+ #endif
+
+ /* Pixel readback */
+ #if GDISP_NEED_PIXELREAD
+ color_t gdisp_lld_getpixelcolor(coord_t x, coord_t y);
+ #endif
+
+ /* Scrolling Function - clears the area scrolled out */
+ #if GDISP_NEED_SCROLL
+ void gdisp_lld_verticalscroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
+ #endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAL_USE_GDISP */
+
+#endif /* _GDISP_LLD_H */
+/** @} */
diff --git a/readme b/readme
index 5213a311..ba8db7de 100644
--- a/readme
+++ b/readme
@@ -1,18 +1,19 @@
-## Wiki
-please read the wiki pages to this project carefully, before you ask any questions:
-
-http://chibios.org/dokuwiki/doku.php?id=chibios:community
-
-
-
-## Maintainer & Contributors
-Contributors:
- - Badger -> console implementation and FSMC
- - Abhishek -> font rendering
- - Ben William -> fastMath and lcdDrawEllipse()
- - dxli (Dongxu Li) -> lcdDrawEllipse() filled option
-
-Maintainer:
- - Joel Bodenmann aka Tectu
-
-
+## Wiki
+please read the wiki pages to this project carefully, before you ask any questions:
+
+http://chibios.org/dokuwiki/doku.php?id=chibios:community
+
+
+
+## Maintainer & Contributors
+Contributors:
+ - Badger -> console implementation and FSMC
+ - Abhishek -> font rendering
+ - Ben William -> fastMath and lcdDrawEllipse()
+ - dxli (Dongxu Li) -> lcdDrawEllipse() filled option
+ - inmarket -> ChibiOS'ify and retructure
+
+Maintainer:
+ - Joel Bodenmann aka Tectu
+
+