uGFX
/
ugfx
2
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity
ugfx/glcd/glcd.c

432 lines
11 KiB
C
Raw Blame History

/*
ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS-LCD-Driver is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ch.h"
#include "hal.h"
#ifdef UNUSED
#elif defined(__GNUC__)
# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
#elif defined(__LCLINT__)
# define UNUSED(x) /*@unused@*/ x
#else
# define UNUSED(x) x
#endif
/* Hack 1: Manually load the low level driver capabilities first so we can
* control what we implement with hardware scrolling and pixel read.
*/
#include "gdisp_lld_config.h"
/* Hack 2: Force on the bits of functionality that glcd needs. */
#define HAL_USE_GDISP TRUE
#define GDISP_NEED_VALIDATION FALSE /* The original glcd didn't so we don't here either */
#define GDISP_NEED_CIRCLE TRUE
#define GDISP_NEED_ELLIPSE TRUE
#define GDISP_NEED_TEXT TRUE
#define GDISP_NEED_SCROLL GDISP_HARDWARE_SCROLL
#define GDISP_NEED_PIXELREAD GDISP_HARDWARE_PIXELREAD
#define GDISP_NEED_CONTROL TRUE
#define GDISP_NEED_MULTITHREAD FALSE /* We implement multi-thread here */
/* Now load the low level driver and font structure definitions */
#include "gdisp_lld.h"
#include "gdisp_fonts.h"
/* Hack 3: GLCD only supports RGB565. Anything else would require significant API changes. */
#ifndef GDISP_PIXELFORMAT_RGB565
#error "GLCD only support drivers with RGB565 pixel format"
#endif
/* Now load the glcd headers */
#include "glcd.h"
#include "glcdWorker.h"
/* Hack 4: Include the emulation code and font tables.
* We have to include it here rather than compiling
* the files as we need to pass our control defines
* as they are not being defined by the application.
* We need to turn off the inclusion of gdisp.h due
* to conflicting type defines etc.
*/
#define _GDISP_H // Prevent gdisp.h from being included
#include "gdisp_emulation.c"
#include "gdisp_fonts.c"
#define EMSG(a) struct a *emsg = (struct a*)msg
static Thread *workerThread = NULL;
static WORKING_AREA(waGLCDWorkerThread, GLCD_WORKER_SIZE);
static msg_t ThreadGLCDWorker(void *arg) {
(void)arg;
Thread *p;
chRegSetThreadName("GLCDWorker");
while(TRUE) {
/* Wait for msg with work to do. */
p = chMsgWait();
struct glcd_msg_base *msg = (struct glcd_msg_base*)chMsgGet(p);
glcd_result_t result = GLCD_PROGRESS;
/* do work here */
switch(msg->action) {
case GLCD_SET_POWERMODE: {
EMSG(glcd_msg_powermode);
gdisp_lld_control(GDISP_CONTROL_POWER, (void *)(int)emsg->powermode);
result = GLCD_DONE;
break;
}
case GLCD_SET_ORIENTATION: {
EMSG(glcd_msg_orientation);
gdisp_lld_control(GDISP_CONTROL_ORIENTATION, (void *)(int)emsg->newOrientation);
result = GLCD_DONE;
break;
}
case GLCD_FILL_AREA: {
EMSG(glcd_msg_fill_area);
gdisp_lld_fillarea(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1,emsg->y1-emsg->y0+1,emsg->color);
result = GLCD_DONE;
break;
}
case GLCD_WRITE_AREA: {
EMSG(glcd_msg_write_area);
gdisp_lld_blitarea(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1, emsg->y1-emsg->y0+1, emsg->buffer);
result = GLCD_DONE;
break;
}
case GLCD_CLEAR: {
EMSG(glcd_msg_clear);
gdisp_lld_clear(emsg->color);
result = GLCD_DONE;
break;
}
case GLCD_GET_PIXEL_COLOR: {
/* Hack 5: This may now fail if the low level driver doesn't
* support it. Previously this support was required
* in the driver by GLCD
*/
#if GDISP_HARDWARE_READPIXEL
((struct glcd_msg_get_pixel_color *)emsg)->color =
gdisp_lld_getpixelcolor(emsg->x, emsg->y);
result = GLCD_DONE;
#else
EMSG(glcd_msg_get_pixel_color);
((struct glcd_msg_get_pixel_color *)emsg)->color = 0;
result = GLCD_FAILED;
#endif
break;
}
case GLCD_DRAW_PIXEL: {
EMSG(glcd_msg_draw_pixel);
gdisp_lld_drawpixel(emsg->x, emsg->y, emsg->color);
result = GLCD_DONE;
break;
}
case GLCD_VERTICAL_SCROLL: {
/* Hack 6: This may now fail if the low level driver doesn't
* support it. Previously this support was required
* in the driver by GLCD
*/
#if GDISP_HARDWARE_SCROLL
EMSG(glcd_msg_vertical_scroll);
gdisp_lld_verticalscroll(emsg->x0, emsg->y0, emsg->x1-emsg->x0+1, emsg->y1-emsg->y0+1, emsg->lines, 0);
result = GLCD_DONE;
#else
result = GLCD_FAILED;
#endif
break;
}
case GLCD_DRAW_CHAR: {
EMSG(glcd_msg_draw_char);
if (emsg->tpText)
gdisp_lld_drawchar(emsg->cx, emsg->cy, emsg->c, emsg->font, emsg->color);
else
gdisp_lld_fillchar(emsg->cx, emsg->cy, emsg->c, emsg->font, emsg->color, emsg->bkcolor);
/* We can't normally access a high level function here but in this case it is safe
* because the routine only accesses const data members (multi-thread safe).
*/
emsg->ret_width = lcdMeasureChar(emsg->c, emsg->font);
result = GLCD_DONE;
break;
}
default: {
result = GLCD_FAILED;
break;
}
}
/* Done, release msg again. */
chMsgRelease(p, (msg_t)result);
}
return 0;
}
void lcdInit(GLCDDriver *UNUSED(glcdp)) {
workerThread = chThdCreateStatic(waGLCDWorkerThread, sizeof(waGLCDWorkerThread), NORMALPRIO, ThreadGLCDWorker, NULL);
gdisp_lld_init();
}
uint16_t lcdGetHeight(void) {
return GDISP.Height;
}
uint16_t lcdGetWidth(void) {
return GDISP.Width;
}
uint16_t lcdGetOrientation(void) {
return GDISP.Orientation;
}
glcd_result_t lcdSetPowerMode(uint8_t powerMode) {
struct glcd_msg_powermode msg;
msg.action = GLCD_SET_POWERMODE;
msg.powermode = powerMode;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdSetOrientation(uint8_t newOrientation) {
struct glcd_msg_orientation msg;
msg.action = GLCD_SET_ORIENTATION;
msg.newOrientation = newOrientation;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
struct glcd_msg_fill_area msg;
msg.action = GLCD_FILL_AREA;
msg.x0 = x0;
msg.y0 = y0;
msg.x1 = x1;
msg.y1 = y1;
msg.color = color;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdWriteArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t *buffer, size_t n) {
struct glcd_msg_write_area msg;
msg.action = GLCD_WRITE_AREA;
msg.x0 = x0;
msg.y0 = y0;
msg.x1 = x1;
msg.y1 = y1;
msg.buffer = buffer;
msg.size = n;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdClear(uint16_t color) {
struct glcd_msg_clear msg;
msg.action = GLCD_CLEAR;
msg.color = color;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
uint16_t lcdGetPixelColor(uint16_t x, uint16_t y) {
struct glcd_msg_get_pixel_color msg;
msg.action = GLCD_GET_PIXEL_COLOR;
msg.x = x;
msg.y = y;
chMsgSend(workerThread, (msg_t)&msg);
return msg.color;
}
glcd_result_t lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color) {
struct glcd_msg_draw_pixel msg;
msg.action = GLCD_DRAW_PIXEL;
msg.x = x;
msg.y = y;
msg.color = color;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
glcd_result_t lcdVerticalScroll(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, int16_t lines) {
struct glcd_msg_vertical_scroll msg;
msg.action = GLCD_VERTICAL_SCROLL;
msg.x0 = x0;
msg.y0 = y0;
msg.x1 = x1;
msg.y1 = y1;
msg.lines = lines;
return (glcd_result_t)chMsgSend(workerThread, (msg_t)&msg);
}
void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
struct glcd_msg_draw_line msg;
msg.action = GLCD_DRAW_LINE;
msg.x0 = x0;
msg.y0 = y0;
msg.x1 = x1;
msg.y1 = y1;
msg.color = color;
chMsgSend(workerThread, (msg_t)&msg);
}
uint16_t lcdDrawChar(uint16_t cx, uint16_t cy, char c, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) {
struct glcd_msg_draw_char msg;
msg.action = GLCD_DRAW_CHAR;
msg.cx = cx;
msg.cy = cy;
msg.c = c;
msg.font = font;
msg.color = color;
msg.bkcolor = bkcolor;
msg.tpText = tpText;
msg.ret_width = 0;
chMsgSend(workerThread, (msg_t)&msg);
return msg.ret_width;
}
void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color) {
struct glcd_msg_draw_circle msg;
msg.action = GLCD_DRAW_CIRCLE;
msg.x = x;
msg.y = y;
msg.radius = radius;
msg.filled = filled;
msg.color = color;
chMsgSend(workerThread, (msg_t)&msg);
}
void lcdDrawEllipse(uint16_t x, uint16_t y, uint16_t a, uint16_t b, uint8_t filled, uint16_t color) {
struct glcd_msg_draw_ellipse msg;
msg.action = GLCD_DRAW_ELLIPSE;
msg.x = x;
msg.y = y;
msg.a = a;
msg.b = b;
msg.filled = filled;
msg.color = color;
chMsgSend(workerThread, (msg_t)&msg);
}
/* WARNING: No boundary checks! Unpredictable behaviour if text exceeds boundary */
void lcdDrawString(uint16_t x, uint16_t y, const char *str, font_t font, uint16_t color, uint16_t bkcolor, bool_t tpText) {
uint16_t cx = x, cy = y;
while (*str) {
cx += lcdDrawChar(cx, cy, *str++, font, color, bkcolor, tpText);
}
}
uint16_t lcdMeasureChar(char c, font_t font) {
return (_getCharWidth(font, c)+font->charPadding) * font->xscale;
}
uint16_t lcdMeasureString(const char *str, font_t font) {
uint16_t result = 0;
/* Measure each char width, add it, return the result */
while (*str)
result += lcdMeasureChar(*str++, font);
return result;
}
uint16_t lcdGetFontHeight(font_t font) {
return font->height;
}
uint16_t lcdBGR2RGB(uint16_t color) {
uint16_t r, g, b, rgb;
b = ( color>>0 ) & 0x1f;
g = ( color>>5 ) & 0x3f;
r = ( color>>11 ) & 0x1f;
rgb = (b<<11) + (g<<5) + (r<<0);
return( rgb );
}
void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color) {
uint16_t TempX;
uint16_t TempY;
if (x0 > x1) {
TempX = x1;
x1 = x0;
x0 = TempX;
}
if (y0 > y1) {
TempY = y1;
y1 = y0;
y0 = TempY;
}
if(filled) {
lcdFillArea(x0, y0, x1+1, y1+1, color);
} else {
lcdDrawLine(x0, y0, x1, y0, color);
lcdDrawLine(x0, y1, x1, y1, color);
lcdDrawLine(x0, y0, x0, y1, color);
lcdDrawLine(x1, y0, x1, y1+1, color);
}
}
void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char* str, font_t font, uint16_t fontColor, uint16_t bkColor) {
uint16_t off_left, off_up;
off_left = ((x1-x0)-lcdMeasureString(str, font))/2;
off_up = ((y1-y0) - lcdGetFontHeight(font)) / 2;
lcdDrawRect(x0, y0, x1, y1, filled, bkColor);
/* Abhishek: default to solid text for this? */
lcdDrawString(x0+off_left, y0+off_up, str, font, fontColor, bkColor, solid);
}
Reference in New Issue View Git Blame Copy Permalink