From e27d04d002a40f3b514eeeb60d374df6a8a1280c Mon Sep 17 00:00:00 2001 From: Tectu Date: Mon, 13 Aug 2012 04:12:42 +0200 Subject: restructure --- include/gdisp.h | 266 ++++++++++++++++++++ include/gdisp_emulation.c | 549 ++++++++++++++++++++++++++++++++++++++++++ include/gdisp_fonts.h | 90 +++++++ include/gdisp_lld.h | 599 ++++++++++++++++++++++++++++++++++++++++++++++ include/gdisp_lld_msgs.h | 165 +++++++++++++ include/glcd.h | 136 +++++++++++ include/touchpad.h | 93 +++++++ include/touchpad_lld.h | 106 ++++++++ 8 files changed, 2004 insertions(+) create mode 100644 include/gdisp.h create mode 100644 include/gdisp_emulation.c create mode 100644 include/gdisp_fonts.h create mode 100644 include/gdisp_lld.h create mode 100644 include/gdisp_lld_msgs.h create mode 100644 include/glcd.h create mode 100644 include/touchpad.h create mode 100644 include/touchpad_lld.h (limited to 'include') diff --git a/include/gdisp.h b/include/gdisp.h new file mode 100644 index 00000000..b5a59cf9 --- /dev/null +++ b/include/gdisp.h @@ -0,0 +1,266 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/** + * @file gdisp.h + * @brief GDISP Graphic Driver subsystem header file. + * + * @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 Do the drawing functions need to be thread-safe. + * @details Defaults to FALSE + * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make + * the gdisp API thread-safe. + * @note This is more efficient than GDISP_NEED_ASYNC as it only + * requires a context switch if something else is already + * drawing. + */ + #ifndef GDISP_NEED_MULTITHREAD + #define GDISP_NEED_MULTITHREAD FALSE + #endif + + /** + * @brief Use asynchronous calls (multi-thread safe). + * @details Defaults to FALSE + * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make + * the gdisp API thread-safe. + * @note Turning this on adds two context switches per transaction + * so it can significantly slow graphics drawing. + */ + #ifndef GDISP_NEED_ASYNC + #define GDISP_NEED_ASYNC FALSE + #endif +/** @} */ + +#if GDISP_NEED_MULTITHREAD && GDISP_NEED_ASYNC + #error "GDISP: Only one of GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC should be defined." +#endif + +#if GDISP_NEED_ASYNC + /* Messaging API is required for Async Multi-Thread */ + #undef GDISP_NEED_MSGAPI + #define GDISP_NEED_MSGAPI TRUE +#endif + +/*===========================================================================*/ +/* Low Level Driver details and error checks. */ +/*===========================================================================*/ + +/* Include the low level driver information */ +#include "gdisp_lld.h" + +/*===========================================================================*/ +/* Type definitions */ +/*===========================================================================*/ + +/** + * @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 fontSmallDouble; +extern const struct font fontSmallNarrow; +extern const struct font fontLarger; +extern const struct font fontLargerDouble; +extern const struct font fontLargerNarrow; +extern const struct font fontUI1; +extern const struct font fontUI1Double; +extern const struct font fontUI1Narrow; +extern const struct font fontUI2; +extern const struct font fontUI2Double; +extern const struct font fontUI2Narrow; +extern const struct font fontLargeNumbers; +extern const struct font fontLargeNumbersDouble; +extern const struct font fontLargeNumbersNarrow; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC + + /* Base Functions */ + bool_t gdispInit(void); + bool_t gdispIsBusy(void); + + /* 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 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, const 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 + + /* Set driver specific control */ + #if GDISP_NEED_CONTROL + void gdispControl(unsigned what, void *value); + #endif + + /* Query driver specific data */ + #if GDISP_NEED_CONTROL + void *gdispQuery(unsigned what); + #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 gdispIsBusy() FALSE + #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 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) + #define gdispControl(what, value) GDISP_LLD(control)(what, value) + #define gdispQuery(what) GDISP_LLD(query)(what) + +#endif + +void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); + +/* 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(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color); +#endif + +/* Macro definitions for common gets and sets */ +#define gdispSetPowerMode(powerMode) gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode)) +#define gdispSetOrientation(newOrientation) gdispControl(GDISP_CONTROL_ORITENTATION, (void *)(unsigned)(newOrientation)) +#define gdispSetBacklight(percent) gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent)) +#define gdispSetContrast(percent) gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent)) + +#define gdispGetWidth() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH)) +#define gdispGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT)) +#define gdispGetPowerMode() ((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER)) +#define gdispGetOrientation() ((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) +#define gdispGetBacklight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT)) +#define gdispGetContrast() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST)) + +#ifdef __cplusplus +} +#endif + +#endif /* HAL_USE_GDISP */ + +#endif /* _GDISP_H */ +/** @} */ diff --git a/include/gdisp_emulation.c b/include/gdisp_emulation.c new file mode 100644 index 00000000..cb3773a7 --- /dev/null +++ b/include/gdisp_emulation.c @@ -0,0 +1,549 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + Emulation routines included into gdisp_lld.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. +*/ +#ifndef GDISP_EMULATION_C +#define GDISP_EMULATION_C + +#if HAL_USE_GDISP || defined(__DOXYGEN__) + +#ifdef UNUSED +#elif defined(__GNUC__) +# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) +#elif defined(__LCLINT__) +# define UNUSED(x) /*@unused@*/ x +#else +# define UNUSED(x) x +#endif + +#ifndef GDISP_LLD_NO_STRUCT + static struct GDISPDriver { + coord_t Width; + coord_t Height; + gdisp_orientation_t Orientation; + gdisp_powermode_t Powermode; + coord_t Backlight; + coord_t Contrast; + } GDISP; +#endif + +#if !GDISP_HARDWARE_CLEARS + void GDISP_LLD(clear)(color_t color) { + GDISP_LLD(fillarea)(0, 0, GDISP.Width, GDISP.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_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, const 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 + #include "gdisp_fonts.h" +#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, height, xscale, yscale; + coord_t i, j, xs, ys; + + /* Check we actually have something to print */ + width = _getCharWidth(font, c); + if (!width) return; + + xscale = font->xscale; + yscale = font->yscale; + height = font->height * yscale; + width *= xscale; + + 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+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j=0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + GDISP_LLD(drawpixel)(x+i+xs, y+j+ys, 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, height; + coord_t xscale, yscale; + + /* Check we actually have something to print */ + width = _getCharWidth(font, c); + if (!width) return; + + xscale = font->xscale; + yscale = font->yscale; + height = font->height * yscale; + width *= xscale; + + /* 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, 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, xs, ys; + + /* Working buffer for fast non-transparent text rendering [patch by Badger] + This needs to be larger than the largest character we can print. + Assume the max is double sized by one column. + */ + static pixel_t buf[sizeof(fontcolumn_t)*8*2]; + + #if GDISP_NEED_VALIDATION + /* Check our buffer is big enough */ + if (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+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j = 0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, 1, j+ys, 0, color); + } else { + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, 1, j+ys, 0, bgcolor); + } + } + + for(xs=0; xs < xscale; xs++) + GDISP_LLD(blitarea)(x+i+xs, y, 1, 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, xs, ys; + + /* Working buffer for fast non-transparent text rendering [patch by Badger] + This needs to be larger than the largest character we can print. + Assume the max is double sized. + */ + static pixel_t buf[20*(sizeof(fontcolumn_t)*8)*2]; + + #if GDISP_NEED_VALIDATION + /* Check our buffer is big enough */ + if ((unsigned)(width * 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+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j = 0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, width, i+xs, j+ys, color); + } else { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + gdispPackPixels(buf, width, i+xs, j+ys, bgcolor); + } + } + } + + /* [Patch by Badger] Write all in one stroke */ + GDISP_LLD(blitarea)(x, y, width, height, buf); + } + + /* Method 4: Draw pixel by pixel */ + #else + { + const fontcolumn_t *ptr; + fontcolumn_t column; + coord_t i, j, xs, ys; + + 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+=xscale) { + /* Get the font bitmap data for the column */ + column = *ptr++; + + /* Draw each pixel */ + for(j = 0; j < height; j+=yscale, column >>= 1) { + if (column & 0x01) { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + GDISP_LLD(drawpixel)(x+i, y+j, color); + } else { + for(xs=0; xs < xscale; xs++) + for(ys=0; ys < yscale; ys++) + GDISP_LLD(drawpixel)(x+i, y+j, bgcolor); + } + } + } + } + #endif + } +#endif + + +#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL + void GDISP_LLD(control)(unsigned UNUSED(what), void *UNUSED(value)) { + /* Ignore everything */ + } +#endif + +#if GDISP_NEED_QUERY && !GDISP_HARDWARE_QUERY +void *GDISP_LLD(query)(unsigned what) { + switch(what) { + case GDISP_QUERY_WIDTH: return (void *)(unsigned)GDISP.Width; + case GDISP_QUERY_HEIGHT: return (void *)(unsigned)GDISP.Height; + case GDISP_QUERY_POWER: return (void *)(unsigned)GDISP.Powermode; + case GDISP_QUERY_ORIENTATION: return (void *)(unsigned)GDISP.Orientation; + case GDISP_QUERY_BACKLIGHT: return (void *)(unsigned)GDISP.Backlight; + case GDISP_QUERY_CONTRAST: return (void *)(unsigned)GDISP.Contrast; + default: return (void *)-1; + } +} +#endif + +#if GDISP_NEED_MSGAPI + void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg) { + switch(msg->action) { + case GDISP_LLD_MSG_NOP: + break; + case GDISP_LLD_MSG_INIT: + GDISP_LLD(init)(); + break; + case GDISP_LLD_MSG_CLEAR: + GDISP_LLD(clear)(msg->clear.color); + break; + case GDISP_LLD_MSG_DRAWPIXEL: + GDISP_LLD(drawpixel)(msg->drawpixel.x, msg->drawpixel.y, msg->drawpixel.color); + break; + case GDISP_LLD_MSG_FILLAREA: + GDISP_LLD(fillarea)(msg->fillarea.x, msg->fillarea.y, msg->fillarea.cx, msg->fillarea.cy, msg->fillarea.color); + break; + case GDISP_LLD_MSG_BLITAREA: + GDISP_LLD(blitarea)(msg->blitarea.x, msg->blitarea.y, msg->blitarea.cx, msg->blitarea.cy, msg->blitarea.buffer); + break; + case GDISP_LLD_MSG_DRAWLINE: + GDISP_LLD(drawline)(msg->drawline.x0, msg->drawline.y0, msg->drawline.x1, msg->drawline.y1, msg->drawline.color); + break; + #if GDISP_NEED_CIRCLE + case GDISP_LLD_MSG_DRAWCIRCLE: + GDISP_LLD(drawcircle)(msg->drawcircle.x, msg->drawcircle.y, msg->drawcircle.radius, msg->drawcircle.color); + break; + case GDISP_LLD_MSG_FILLCIRCLE: + GDISP_LLD(fillcircle)(msg->fillcircle.x, msg->fillcircle.y, msg->fillcircle.radius, msg->fillcircle.color); + break; + #endif + #if GDISP_NEED_ELLIPSE + case GDISP_LLD_MSG_DRAWELLIPSE: + GDISP_LLD(drawellipse)(msg->drawellipse.x, msg->drawellipse.y, msg->drawellipse.a, msg->drawellipse.b, msg->drawellipse.color); + break; + case GDISP_LLD_MSG_FILLELLIPSE: + GDISP_LLD(fillellipse)(msg->fillellipse.x, msg->fillellipse.y, msg->fillellipse.a, msg->fillellipse.b, msg->fillellipse.color); + break; + #endif + #if GDISP_NEED_TEXT + case GDISP_LLD_MSG_DRAWCHAR: + GDISP_LLD(drawchar)(msg->drawchar.x, msg->drawchar.y, msg->drawchar.c, msg->drawchar.font, msg->drawchar.color); + break; + case GDISP_LLD_MSG_FILLCHAR: + GDISP_LLD(fillchar)(msg->fillchar.x, msg->fillchar.y, msg->fillchar.c, msg->fillchar.font, msg->fillchar.color, msg->fillchar.bgcolor); + break; + #endif + #if GDISP_NEED_PIXELREAD + case GDISP_LLD_MSG_GETPIXELCOLOR: + msg->getpixelcolor.result = GDISP_LLD(getpixelcolor)(msg->getpixelcolor.x, msg->getpixelcolor.y); + break; + #endif + #if GDISP_NEED_SCROLL + case GDISP_LLD_MSG_VERTICALSCROLL: + GDISP_LLD(verticalscroll)(msg->verticalscroll.x, msg->verticalscroll.y, msg->verticalscroll.cx, msg->verticalscroll.cy, msg->verticalscroll.lines, msg->verticalscroll.bgcolor); + break; + #endif + #if GDISP_NEED_CONTROL + case GDISP_LLD_MSG_CONTROL: + GDISP_LLD(control)(msg->control.what, msg->control.value); + break; + #endif + #if GDISP_NEED_QUERY + case GDISP_LLD_MSG_QUERY: + msg->query.result = GDISP_LLD(query)(msg->query.what); + break; + #endif + } + } +#endif + +#endif /* HAL_USE_GDISP */ +#endif /* GDISP_EMULATION_C */ diff --git a/include/gdisp_fonts.h b/include/gdisp_fonts.h new file mode 100644 index 00000000..a1a4c3cb --- /dev/null +++ b/include/gdisp_fonts.h @@ -0,0 +1,90 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/** + * @file gdisp_fonts.h + * @brief GDISP internal font definitions. + * @details This is not generally needed by an application. It is used + * by the low level drivers that need to understand a font. + * + * @addtogroup GDISP + * @{ + */ + +#ifndef _GDISP_FONTS_H +#define _GDISP_FONTS_H + +/* Don't test against HAL_USE_GDISP as we may want to use this in other non-GDISP utilities. */ + +/** + * @brief The maximum height of a font. + * @details Either 16 or 32. Defaults to 16 + * @note Setting this to 32 causes the font tables to take + * twice the internal program memory. + */ +#ifndef GDISP_MAX_FONT_HEIGHT + #define GDISP_MAX_FONT_HEIGHT 16 +#endif + +/** + * @brief The type of a font column. + * @note Set by defining @p GDISP_MAX_FNT_HEIGHT appropriately. + */ +#if GDISP_MAX_FONT_HEIGHT == 16 + typedef uint16_t fontcolumn_t; +#elif GDISP_MAX_FONT_HEIGHT == 32 + typedef uint32_t fontcolumn_t; +#else + #error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32" +#endif + +/** + * @brief Internal font structure. + * @note This structure is followed by: + * 1. An array of character widths (uint8_t) + * 2. An array of column data offsets (relative to the font structure) + * 3. Each characters array of column data (fontcolumn_t) + * Each sub-structure must be padded to a multiple of 8 bytes + * to allow the tables to work across many different compilers. + */ +struct font { + uint8_t height; + uint8_t charPadding; + uint8_t lineSpacing; + uint8_t descenderHeight; + uint8_t minWidth; + uint8_t maxWidth; + char minChar; + char maxChar; + uint8_t xscale; + uint8_t yscale; + const uint8_t *widthTable; + const uint16_t *offsetTable; + const fontcolumn_t *dataTable; + }; + +/** + * @brief Macros to get to the complex parts of the font structure. + */ +#define _getCharWidth(f,c) (((c) < (f)->minChar || (c) > (f)->maxChar) ? 0 : (f)->widthTable[(c) - (f)->minChar]) +#define _getCharOffset(f,c) ((f)->offsetTable[(c) - (f)->minChar]) +#define _getCharData(f,c) (&(f)->dataTable[_getCharOffset(f, c)]) + +#endif /* _GDISP_FONTS_H */ +/** @} */ diff --git a/include/gdisp_lld.h b/include/gdisp_lld.h new file mode 100644 index 00000000..99865a9f --- /dev/null +++ b/include/gdisp_lld.h @@ -0,0 +1,599 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/** + * @file gdisp_lld.h + * @brief GDISP Graphic Driver subsystem low level driver header. + * + * @addtogroup GDISP + * @{ + */ + +#ifndef _GDISP_LLD_H +#define _GDISP_LLD_H + +#if HAL_USE_GDISP || defined(__DOXYGEN__) + +/*===========================================================================*/ +/* Low level driver configuration needs */ +/*===========================================================================*/ + +/** + * @name GDISP low level driver 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 Control some aspect of the drivers operation. + * @details Defaults to FALSE + */ + #ifndef GDISP_NEED_CONTROL + #define GDISP_NEED_CONTROL FALSE + #endif + + /** + * @brief Query some aspect of the drivers operation. + * @details Defaults to TRUE + */ + #ifndef GDISP_NEED_QUERY + #define GDISP_NEED_QUERY TRUE + #endif + + /** + * @brief Is the messaging api interface required. + * @details Defaults to FALSE + */ + #ifndef GDISP_NEED_MSGAPI + #define GDISP_NEED_MSGAPI FALSE + #endif +/** @} */ + +/*===========================================================================*/ +/* Include the low level driver configuration information */ +/*===========================================================================*/ + +#include "gdisp_lld_config.h" + +/*===========================================================================*/ +/* Constants. */ +/*===========================================================================*/ + +/** + * @brief Driver Control Constants + * @detail Unsupported control codes are ignored. + * @note The value parameter should always be typecast to (void *). + * @note There are some predefined and some specific to the low level driver. + * @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t + * GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t + * GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver + * that only supports off/on anything other + * than zero is on. + * GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100. + * GDISP_CONTROL_LLD - Low level driver control constants start at + * this value. + */ +#define GDISP_CONTROL_POWER 0 +#define GDISP_CONTROL_ORIENTATION 1 +#define GDISP_CONTROL_BACKLIGHT 2 +#define GDISP_CONTROL_CONTRAST 3 +#define GDISP_CONTROL_LLD 1000 + +/** + * @brief Driver Query Constants + * @detail Unsupported query codes return (void *)-1. + * @note There are some predefined and some specific to the low level driver. + * @note The result should be typecast the required type. + * @note GDISP_QUERY_WIDTH - Gets the width of the screen + * GDISP_QUERY_HEIGHT - Gets the height of the screen + * GDISP_QUERY_POWER - Get the current powermode + * GDISP_QUERY_ORIENTATION - Get the current orientation + * GDISP_QUERY_BACKLIGHT - Get the backlight state (0 to 100) + * GDISP_QUERY_CONTRAST - Get the contrast. + * GDISP_QUERY_LLD - Low level driver control constants start at + * this value. + */ +#define GDISP_QUERY_WIDTH 0 +#define GDISP_QUERY_HEIGHT 1 +#define GDISP_QUERY_POWER 2 +#define GDISP_QUERY_ORIENTATION 3 +#define GDISP_QUERY_BACKLIGHT 4 +#define GDISP_QUERY_CONTRAST 5 +#define GDISP_QUERY_LLD 1000 + +/** + * @brief Driver Pixel Format Constants + */ +#define GDISP_PIXELFORMAT_RGB565 565 +#define GDISP_PIXELFORMAT_RGB888 888 +#define GDISP_PIXELFORMAT_RGB444 444 +#define GDISP_PIXELFORMAT_RGB332 332 +#define GDISP_PIXELFORMAT_RGB666 666 +#define GDISP_PIXELFORMAT_CUSTOM 99999 +#define GDISP_PIXELFORMAT_ERROR 88888 + +/*===========================================================================*/ +/* Error checks. */ +/*===========================================================================*/ + +/** + * @name GDISP hardware accelerated support + * @{ + */ + /** + * @brief Hardware accelerated line drawing. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_LINES + #define GDISP_HARDWARE_LINES FALSE + #endif + + /** + * @brief Hardware accelerated screen clears. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_CLEARS + #define GDISP_HARDWARE_CLEARS FALSE + #endif + + /** + * @brief Hardware accelerated rectangular fills. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_FILLS + #define GDISP_HARDWARE_FILLS FALSE + #endif + + /** + * @brief Hardware accelerated fills from an image. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_BITFILLS + #define GDISP_HARDWARE_BITFILLS FALSE + #endif + + /** + * @brief Hardware accelerated circles. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_CIRCLES + #define GDISP_HARDWARE_CIRCLES FALSE + #endif + + /** + * @brief Hardware accelerated filled circles. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_CIRCLEFILLS + #define GDISP_HARDWARE_CIRCLEFILLS FALSE + #endif + + /** + * @brief Hardware accelerated ellipses. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_ELLIPSES + #define GDISP_HARDWARE_ELLIPSES FALSE + #endif + + /** + * @brief Hardware accelerated filled ellipses. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_ELLIPSEFILLS + #define GDISP_HARDWARE_ELLIPSEFILLS FALSE + #endif + + /** + * @brief Hardware accelerated text drawing. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_TEXT + #define GDISP_HARDWARE_TEXT FALSE + #endif + + /** + * @brief Hardware accelerated text drawing with a filled background. + * @details If set to @p FALSE software emulation is used. + */ + #ifndef GDISP_HARDWARE_TEXTFILLS + #define GDISP_HARDWARE_TEXTFILLS FALSE + #endif + + /** + * @brief Hardware accelerated scrolling. + * @details If set to @p FALSE there is no support for scrolling. + */ + #ifndef GDISP_HARDWARE_SCROLL + #define GDISP_HARDWARE_SCROLL FALSE + #endif + + /** + * @brief Reading back of pixel values. + * @details If set to @p FALSE there is no support for pixel read-back. + */ + #ifndef GDISP_HARDWARE_PIXELREAD + #define GDISP_HARDWARE_PIXELREAD FALSE + #endif + + /** + * @brief The driver supports one or more control commands. + * @details If set to @p FALSE there is no support for control commands. + */ + #ifndef GDISP_HARDWARE_CONTROL + #define GDISP_HARDWARE_CONTROL FALSE + #endif + + /** + * @brief The driver supports a non-standard query. + * @details If set to @p FALSE there is no support for non-standard queries. + */ + #ifndef GDISP_HARDWARE_QUERY + #define GDISP_HARDWARE_QUERY FALSE + #endif +/** @} */ + +/** + * @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. + */ + #ifndef GDISP_SOFTWARE_TEXTFILLDRAW + #define GDISP_SOFTWARE_TEXTFILLDRAW FALSE + #endif + + /** + * @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. + */ + #ifndef GDISP_SOFTWARE_TEXTBLITCOLUMN + #define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE + #endif +/** @} */ + +/** + * @name GDISP pixel format choices + * @{ + */ + /** + * @brief The native pixel format for this device + * @note Should be set to one of the following: + * GDISP_PIXELFORMAT_RGB565 + * GDISP_PIXELFORMAT_RGB888 + * GDISP_PIXELFORMAT_RGB444 + * GDISP_PIXELFORMAT_RGB332 + * GDISP_PIXELFORMAT_RGB666 + * GDISP_PIXELFORMAT_CUSTOM + * @note If you set 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. + */ + #ifndef GDISP_PIXELFORMAT + #define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_ERROR + #endif + + /** + * @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. + */ + #ifndef GDISP_PACKED_PIXELS + #define GDISP_PACKED_PIXELS FALSE + #endif + + /** + * @brief Do lines of pixels require packing for a blit + * @note Ignored if GDISP_PACKED_PIXELS is FALSE + */ + #ifndef GDISP_PACKED_LINES + #define GDISP_PACKED_LINES FALSE + #endif +/** @} */ + +/*===========================================================================*/ +/* Define the macro's for the various pixel formats */ +/*===========================================================================*/ + +#if 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 GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565 + typedef uint16_t color_t; + #define COLOR(c) ((color_t)(c)) + #define MASKCOLOR FALSE + #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3))) + #define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3))) + #define RED_OF(c) (((c) & 0xF800)>>8) + #define GREEN_OF(c) (((c)&0x007E)>>3) + #define BLUE_OF(c) (((c)&0x001F)<<3) + #define RGB565CONVERT(red, green, blue) (uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 )) + + +#elif GDISP_PIXELFORMAT == 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 GDISP_PIXELFORMAT == 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 GDISP_PIXELFORMAT == 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 GDISP_PIXELFORMAT == 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 GDISP_PIXELFORMAT != 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 GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \ + && GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \ + && GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \ + && GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM + #error "GDISP: A packed pixel format has been specified for an unsupported pixel format." +#endif + +#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 types. */ +/*===========================================================================*/ + +/** + * @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 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; + +/*===========================================================================*/ +/* External declarations. */ +/*===========================================================================*/ + +#ifndef GDISP_LLD_VMT + /* Special magic stuff for the VMT driver */ + #define GDISP_LLD_VMT(x) GDISP_LLD(x) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + /* Core functions */ + extern bool_t GDISP_LLD(init)(void); + + /* Some of these functions will be implemented in software by the high level driver + depending on the GDISP_HARDWARE_XXX macros defined in gdisp_lld_config.h. + */ + + /* Drawing functions */ + extern void GDISP_LLD_VMT(clear)(color_t color); + extern void GDISP_LLD_VMT(drawpixel)(coord_t x, coord_t y, color_t color); + extern void GDISP_LLD_VMT(fillarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); + extern void GDISP_LLD_VMT(blitarea)(coord_t x, coord_t y, coord_t cx, coord_t cy, const pixel_t *buffer); + extern void GDISP_LLD_VMT(drawline)(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color); + + /* Circular Drawing Functions */ + #if GDISP_NEED_CIRCLE + extern void GDISP_LLD_VMT(drawcircle)(coord_t x, coord_t y, coord_t radius, color_t color); + extern void GDISP_LLD_VMT(fillcircle)(coord_t x, coord_t y, coord_t radius, color_t color); + #endif + + #if GDISP_NEED_ELLIPSE + extern void GDISP_LLD_VMT(drawellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); + extern void GDISP_LLD_VMT(fillellipse)(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); + #endif + + /* Text Rendering Functions */ + #if GDISP_NEED_TEXT + extern void GDISP_LLD_VMT(drawchar)(coord_t x, coord_t y, char c, font_t font, color_t color); + extern void GDISP_LLD_VMT(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 + extern color_t GDISP_LLD_VMT(getpixelcolor)(coord_t x, coord_t y); + #endif + + /* Scrolling Function - clears the area scrolled out */ + #if GDISP_NEED_SCROLL + extern void GDISP_LLD_VMT(verticalscroll)(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor); + #endif + + /* Set driver specific control */ + #if GDISP_NEED_CONTROL + extern void GDISP_LLD_VMT(control)(unsigned what, void *value); + #endif + + /* Query driver specific data */ + #if GDISP_NEED_QUERY + extern void *GDISP_LLD_VMT(query)(unsigned what); + #endif + + /* Messaging API */ + #if GDISP_NEED_MSGAPI + #include "gdisp_lld_msgs.h" + extern void GDISP_LLD(msgdispatch)(gdisp_lld_msg_t *msg); + #endif + +#ifdef __cplusplus +} +#endif + +#endif /* HAL_USE_GDISP */ + +#endif /* _GDISP_LLD_H */ +/** @} */ diff --git a/include/gdisp_lld_msgs.h b/include/gdisp_lld_msgs.h new file mode 100644 index 00000000..28a6707e --- /dev/null +++ b/include/gdisp_lld_msgs.h @@ -0,0 +1,165 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/** + * @file gdisp_lld_msgs.h + * @brief GDISP Graphic Driver subsystem low level driver message structures. + * + * @addtogroup GDISP + * @{ + */ + +#ifndef _GDISP_LLD_MSGS_H +#define _GDISP_LLD_MSGS_H + +/* This file describes the message API for gdisp_lld */ +#if HAL_USE_GDISP && GDISP_NEED_MSGAPI + +typedef enum gdisp_msgaction { + GDISP_LLD_MSG_NOP, + GDISP_LLD_MSG_INIT, + GDISP_LLD_MSG_CLEAR, + GDISP_LLD_MSG_DRAWPIXEL, + GDISP_LLD_MSG_FILLAREA, + GDISP_LLD_MSG_BLITAREA, + GDISP_LLD_MSG_DRAWLINE, + #if GDISP_NEED_CIRCLE + GDISP_LLD_MSG_DRAWCIRCLE, + GDISP_LLD_MSG_FILLCIRCLE, + #endif + #if GDISP_NEED_ELLIPSE + GDISP_LLD_MSG_DRAWELLIPSE, + GDISP_LLD_MSG_FILLELLIPSE, + #endif + #if GDISP_NEED_TEXT + GDISP_LLD_MSG_DRAWCHAR, + GDISP_LLD_MSG_FILLCHAR, + #endif + #if GDISP_NEED_PIXELREAD + GDISP_LLD_MSG_GETPIXELCOLOR, + #endif + #if GDISP_NEED_SCROLL + GDISP_LLD_MSG_VERTICALSCROLL, + #endif + #if GDISP_NEED_CONTROL + GDISP_LLD_MSG_CONTROL, + #endif + #if GDISP_NEED_QUERY + GDISP_LLD_MSG_QUERY, + #endif +} gdisp_msgaction_t; + +typedef union gdisp_lld_msg { + gdisp_msgaction_t action; + struct gdisp_lld_msg_init { + gdisp_msgaction_t action; // GDISP_LLD_MSG_INIT + } init; + struct gdisp_lld_msg_clear { + gdisp_msgaction_t action; // GDISP_LLD_MSG_CLEAR + color_t color; + } clear; + struct gdisp_lld_msg_drawpixel { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWPIXEL + coord_t x, y; + color_t color; + } drawpixel; + struct gdisp_lld_msg_fillarea { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLAREA + coord_t x, y; + coord_t cx, cy; + color_t color; + } fillarea; + struct gdisp_lld_msg_blitarea { + gdisp_msgaction_t action; // GDISP_LLD_MSG_BLITAREA + coord_t x, y; + coord_t cx, cy; + const pixel_t *buffer; + } blitarea; + struct gdisp_lld_msg_drawline { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWLINE + coord_t x0, y0; + coord_t x1, y1; + color_t color; + } drawline; + struct gdisp_lld_msg_drawcircle { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCIRCLE + coord_t x, y; + coord_t radius; + color_t color; + } drawcircle; + struct gdisp_lld_msg_fillcircle { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCIRCLE + coord_t x, y; + coord_t radius; + color_t color; + } fillcircle; + struct gdisp_lld_msg_drawellipse { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWELLIPSE + coord_t x, y; + coord_t a, b; + color_t color; + } drawellipse; + struct gdisp_lld_msg_fillellipse { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLELLIPSE + coord_t x, y; + coord_t a, b; + color_t color; + } fillellipse; + struct gdisp_lld_msg_drawchar { + gdisp_msgaction_t action; // GDISP_LLD_MSG_DRAWCHAR + coord_t x, y; + char c; + font_t font; + color_t color; + } drawchar; + struct gdisp_lld_msg_fillchar { + gdisp_msgaction_t action; // GDISP_LLD_MSG_FILLCHAR + coord_t x, y; + char c; + font_t font; + color_t color; + color_t bgcolor; + } fillchar; + struct gdisp_lld_msg_getpixelcolor { + gdisp_msgaction_t action; // GDISP_LLD_MSG_GETPIXELCOLOR + coord_t x, y; + color_t result; + } getpixelcolor; + struct gdisp_lld_msg_verticalscroll { + gdisp_msgaction_t action; // GDISP_LLD_MSG_VERTICALSCROLL + coord_t x, y; + coord_t cx, cy; + int lines; + color_t bgcolor; + } verticalscroll; + struct gdisp_lld_msg_control { + gdisp_msgaction_t action; // GDISP_LLD_MSG_CONTROL + int what; + void * value; + } control; + struct gdisp_lld_msg_query { + gdisp_msgaction_t action; // GDISP_LLD_MSG_QUERY + int what; + void * result; + } query; +} gdisp_lld_msg_t; + +#endif /* HAL_USE_GDISP */ +#endif /* _GDISP_LLD_MSGS_H */ +/** @} */ diff --git a/include/glcd.h b/include/glcd.h new file mode 100644 index 00000000..ab2f6be2 --- /dev/null +++ b/include/glcd.h @@ -0,0 +1,136 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/* + 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. + You may also need to define the various GDISP_NEED_XXX in your + halconf.h in order to turn on the functionality you need. +*/ + +#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 filled {frame, filled}; +enum transparency {solid, transparent}; +#define sleepOn powerSleep +#define sleepOff powerOn + +#define font_Small (&fontSmall) +#define font_SmallDouble (&fontSmallDouble) +#define font_SmallNarrow (&fontSmall) +#define font_Larger (&fontLarger) +#define font_LargerDouble (&fontLargerDouble) +#define font_LargerNarrow (&fontLargerNarrow) +#define font_MediumBold (&fontUI1) +#define font_MediumBoldDouble (&fontUI1Double) +#define font_MediumBoldNarrow (&fontUI1Narrow) +#define font_LargeNumbers (&fontLargeNumbers) +#define font_LargeNumbersDouble (&fontLargeNumbersDouble) +#define font_LargeNumbersNarrow (&fontLargeNumbersNarrow) + +enum glcd_result { GLCD_DONE, + GLCD_FAILED, + GLCD_PROGRESS, + }; + +typedef enum glcd_result glcd_result_t; + +/* Core functions */ +#define lcdInit(dvr) gdispInit(dvr) +static __inline glcd_result_t lcdClear(color_t color) { + gdispClear(color); + return GLCD_DONE; +} +static __inline glcd_result_t lcdSetOrientation(enum orientation newO) { + gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(int)newO); + return ((enum orientation)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) == (newO) ? GLCD_DONE : GLCD_FAILED; +} +static __inline glcd_result_t lcdFillArea(coord_t x0, coord_t y0, coord_t x1, coord_t y1,color_t c) { + gdispFillArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(c)); + return GLCD_DONE; +} +static __inline glcd_result_t lcdWriteArea(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const pixel_t *b, coord_t n) { + (void)n; + gdispBlitArea((x0),(y0),(x1)-(x0)+1,(y1)-(y0)+1,(b)); + return GLCD_DONE; +} +static __inline glcd_result_t lcdSetPowerMode(enum powermode pm) { + gdispControl(GDISP_CONTROL_POWER, (void *)(int)pm); + return ((enum powermode)(unsigned)gdispQuery(GDISP_QUERY_POWER)) == (pm) ? GLCD_DONE : GLCD_FAILED; +} + +/* Drawing functions */ +static __inline glcd_result_t lcdDrawPixel(coord_t x, coord_t y, color_t c) { + gdispDrawPixel((x),(y),(c)); + return 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 */ +static __inline coord_t lcdDrawChar(coord_t x, coord_t y, char h, font_t f, color_t c, color_t b, bool_t t) { + if (t) + gdispDrawChar((x),(y),(h),(f),(c)); + else + gdispFillChar((x),(y),(h),(f),(c),(b)); + return gdispGetCharWidth((h),(f))+gdispGetFontMetric((f), fontCharPadding); +} +static __inline coord_t lcdDrawString(coord_t x, coord_t y, const char *s, font_t f, color_t c, color_t b, bool_t t) { + if (t) + gdispDrawString((x),(y),(s),(f),(c)); + else + gdispFillString((x),(y),(s),(f),(c),(b)); + return gdispGetStringWidth((s),(f))+gdispGetFontMetric((f), fontCharPadding); +} + +/* Character measuring functions */ +#define lcdMeasureChar(h,f) (gdispGetCharWidth((h),(f))+gdispGetFontMetric((f), fontCharPadding)) +#define lcdMeasureString(s,f) (gdispGetStringWidth((s),(f))+gdispGetFontMetric((f), fontCharPadding)) +#define lcdGetFontHeight(f) gdispGetFontMetric((f), fontHeight) + +/* Size and orientation related */ +#define lcdGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT)) +#define lcdGetWidth() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH)) +#define lcdGetOrientation() ((enum orientation)(unsigned)gdispQuery(GDISP_QUERY_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/include/touchpad.h b/include/touchpad.h new file mode 100644 index 00000000..445d3202 --- /dev/null +++ b/include/touchpad.h @@ -0,0 +1,93 @@ +/* + ChibiOS-LCD-Driver/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/** + * @file touchpad.h + * @brief TOUCHPAD Touchpad Driver subsystem header file. + * + * @addgroup TOUCHPAD + * @{ + */ +#ifndef _TOUCHPAD_H +#define _TOUCHPAD_H + +#if HAL_USE_TOUCHPAD || defined(__DOXYGEN__) + +/** + * @brief specifies how many conversions are made for a readout. + * + * @note higher is more accurate, but takes more time + */ +#define CONVERSIONS 3 + +/*===========================================================================*/ +/* Driver constants. */ +/*===========================================================================*/ + +/*===========================================================================*/ +/* Low Level Driver details and error checks. */ +/*===========================================================================*/ + +/* Include the low level driver information */ +#include "touchpad_lld.h" + +/*===========================================================================*/ +/* Type definitions */ +/*===========================================================================*/ + +/** + * @brief Struct used for calibration + */ +struct cal { + float xm; + float ym; + float xn; + float yn; +}; + +/*===========================================================================*/ +/* External declarations. */ +/*===========================================================================*/ + +#ifdef __cplusplus +extern "C" { +#endif + +void tpInit(TOUCHPADDriver *tp); +uint16_t tpReadX(void); +uint16_t tpReadY(void); + +#if TOUCHPAD_HAS_IRQ + uint8_t tpIRQ(void); +#endif + +#if TOUCHPAD_HAS_PRESSURE + uint16_t tpReadZ(void); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* HAL_USE_TOUCHPAD */ + +#endif /* _TOUCHPAD_H */ +/** @} */ + diff --git a/include/touchpad_lld.h b/include/touchpad_lld.h new file mode 100644 index 00000000..45a561d3 --- /dev/null +++ b/include/touchpad_lld.h @@ -0,0 +1,106 @@ +/* + ChibiOS-LCD-Driver/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/** + * @file touchpad_lld.h + * @brief TOUCHPAD Driver subsystem low level driver header. + * + * @addgroup TOUCHPAD + * @{ + */ + +#ifndef _TOUCHPAD_LLD_H +#define _TOUCHPAD_LLD_H + +#if HAL_USE_TOUCHPAD || defined(__DOXYGEN__) + +/*===========================================================================*/ +/* Include the low level driver configuration information */ +/*===========================================================================*/ + +#include "touchpad_lld_config.h" + +/*===========================================================================*/ +/* Error checks. */ +/*===========================================================================*/ + +#ifndef TOUCHPAD_HAS_IRQ + #define TOUCHPAD_HAS_IRQ FALSE +#endif + +#ifndef TOUCHPAD_HAS_PRESSURE + #define TOUCHPAD_HAS_PRESSURE FALSE +#endif + +/*===========================================================================*/ +/* Driver types. */ +/*===========================================================================*/ + +typedef struct TOUCHPADDriver TOUCHPADDriver; + +/** + * @brief Structure representing a Touchpad driver. + */ +struct TOUCHPADDriver { + /* + * @brief Pointer to SPI driver. + */ + SPIDriver *spid; + + /* + * @brief SPI configuration. + */ + SPIConfig *spicfg; +}; + +/*===========================================================================*/ +/* External declarations. */ +/*===========================================================================*/ + +#if !defined(__DOXYGEN__) + extern TOUCHPADDriver Touchpad; +#endif + +#ifdef __cplusplus +extern "C" { +#endif + + /* Core functions */ + void tp_lld_init(TOUCHPADDriver *tp); + uint16_t tp_lld_read_x(void); + uint16_t tp_lld_read_y(void); + + #if TOUCHPAD_HAS_IRQ + uint8_t tp_lld_irq(void); + #endif + + #if TOUCHPAD_HAS_PRESSURE + uint16_t tp_lld_read_z(void); + #endif + +#ifdef __cplusplus +} +#endif + +#endif /* HAL_USE_TOUCHPAD */ + +#endif /* _TOUCHPAD_LLD_H */ +/** @} */ + -- cgit v1.2.3 From 6982d7d076ac480fa46bb1c69ef49963c7bebb18 Mon Sep 17 00:00:00 2001 From: Tectu Date: Mon, 13 Aug 2012 13:44:43 +0200 Subject: moved console to src/ and include/ --- include/console.h | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 include/console.h (limited to 'include') diff --git a/include/console.h b/include/console.h new file mode 100644 index 00000000..edd8498e --- /dev/null +++ b/include/console.h @@ -0,0 +1,87 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + This file is part of ChibiOS-LCD-Driver. + + ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS-LCD-Driver is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#ifndef CONSOLE_H +#define CONSOLE_H + +#include "ch.h" +#include "hal.h" + +#include "gdisp.h" + +/** + * @brief Structure representing a GLCD driver. + */ +typedef struct GLCDConsole GLCDConsole; + +/** + * @brief @p GLCDConsole specific methods. + */ +#define _glcd_driver_methods \ + _base_asynchronous_channel_methods + +/** + * @extends BaseAsynchronousChannelVMT + * + * @brief @p GLCDConsole virtual methods table. + */ +struct GLCDConsoleVMT { + _glcd_driver_methods +}; + +/** + * @extends BaseAsynchronousChannel + * + * @brief GLCD Console class. + * @details This class extends @p BaseAsynchronousChannel by adding physical + * I/O queues. + */ +struct GLCDConsole { + /** @brief Virtual Methods Table.*/ + const struct GLCDConsoleVMT *vmt; + _base_asynchronous_channel_data + /* WARNING: Do not add any data to this struct above this comment, only below */ + /* font */ + font_t font; + /* lcd area to use */ + coord_t x0,y0; + /* current cursor position, in pixels */ + coord_t cx,cy; + /* console size in pixels */ + coord_t sx,sy; + /* foreground and background colour */ + pixel_t bkcolor, color; + /* font size in pixels */ + uint8_t fy; +}; + +#ifdef __cplusplus +extern "C" { +#endif + +msg_t lcdConsoleInit(GLCDConsole *console, coord_t x0, coord_t y0, coord_t width, coord_t height, font_t font, pixel_t bkcolor, pixel_t color); +msg_t lcdConsolePut(GLCDConsole *console, char c); +msg_t lcdConsoleWrite(GLCDConsole *console, char *bp, size_t n); + +#ifdef __cplusplus +} +#endif + +#endif /* CONSOLE_H */ -- cgit v1.2.3 From a9beec902da2348e858dcd54550d99a40c1fbe87 Mon Sep 17 00:00:00 2001 From: Kumar Abhishek Date: Thu, 16 Aug 2012 15:14:16 +0530 Subject: XPT2046 LLD Major Update Added 7 point median filtering to reduce noise TOUCHPADDriver structure now encapsulates the IRQ pin, so removed the TP_CS_ and TP_IRQ_ macros Added generic tp_lld_read_value method to read any ADC channel from the XPT2046, this includes on-chip temperature sensor and VBAT input Improved SPI bus sharing, with the optional TOUCHPAD_SPI_PROLOGUE and TOUCHPAD_SPI_EPILOGUE macros --- include/touchpad_lld.h | 65 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 50 insertions(+), 15 deletions(-) (limited to 'include') diff --git a/include/touchpad_lld.h b/include/touchpad_lld.h index 45a561d3..a3a7489c 100644 --- a/include/touchpad_lld.h +++ b/include/touchpad_lld.h @@ -49,41 +49,76 @@ #define TOUCHPAD_HAS_PRESSURE FALSE #endif +#ifndef TOUCHPAD_SPI_PROLOGUE + #define TOUCHPAD_SPI_PROLOGUE() +#endif + +#ifndef TOUCHPAD_SPI_EPILOGUE + #define TOUCHPAD_SPI_EPILOGUE() +#endif + /*===========================================================================*/ /* Driver types. */ /*===========================================================================*/ -typedef struct TOUCHPADDriver TOUCHPADDriver; +typedef struct _TOUCHPADDriver TOUCHPADDriver; /** * @brief Structure representing a Touchpad driver. */ -struct TOUCHPADDriver { - /* - * @brief Pointer to SPI driver. - */ - SPIDriver *spid; - - /* - * @brief SPI configuration. - */ - SPIConfig *spicfg; +struct _TOUCHPADDriver { + /* + * @brief Pointer to SPI driver. + * @note SPI driver must be enabled in mcuconf.h and halconf.h + */ + SPIDriver *spip; + + /* + * @brief Pointer to the SPI configuration structure. + * @note The lowest possible speed ~ 1-2MHz is to be used, otherwise + * will result in a lot of noise + */ + const SPIConfig *spicfg; + + /* + * @brief Touchscreen controller TPIRQ pin GPIO port + */ + ioportid_t tpIRQPort; + + /* + * @brief Touchscreen controller TPIRQ GPIO pin + * @note The interface is polled as of now, interrupt support is + * to be implemented in the future. + */ + ioportmask_t tpIRQPin; + + /* + * @brief Initialize the SPI with the configuration struct given or not + * If TRUE, spiStart is called by the init, otherwise not + * @note This is provided in such a case when SPI port is being shared + * across multiple peripherals, so not to disturb the SPI bus. + * You can use TOUCHPAD_SPI_PROLOGUE() and TOUCHPAD_SPI_EPILOGUE() + * macros to change the SPI configuration or speed before and + * after using the touchpad. An example case would be sharing the + * bus with a fast flash memory chip. + */ + bool_t direct_init; }; + /*===========================================================================*/ /* External declarations. */ /*===========================================================================*/ -#if !defined(__DOXYGEN__) - extern TOUCHPADDriver Touchpad; -#endif #ifdef __cplusplus extern "C" { #endif /* Core functions */ - void tp_lld_init(TOUCHPADDriver *tp); + void tp_lld_init(const TOUCHPADDriver *tp); + + uint16_t tp_lld_read_value(uint8_t cmd); uint16_t tp_lld_read_x(void); uint16_t tp_lld_read_y(void); -- cgit v1.2.3 From a41a5911e54a2b9683d88d35c01c58d0349cd804 Mon Sep 17 00:00:00 2001 From: Kumar Abhishek Date: Thu, 16 Aug 2012 15:26:03 +0530 Subject: Fix compiler warnings Removed redundant dummy read from high level functions --- include/touchpad.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'include') diff --git a/include/touchpad.h b/include/touchpad.h index 445d3202..55a83a9d 100644 --- a/include/touchpad.h +++ b/include/touchpad.h @@ -70,7 +70,7 @@ struct cal { extern "C" { #endif -void tpInit(TOUCHPADDriver *tp); +void tpInit(const TOUCHPADDriver *tp); uint16_t tpReadX(void); uint16_t tpReadY(void); -- cgit v1.2.3