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

Merge pull request #5 from abhishek-kakkar/master

Browse Source 
Changes in Text Rendering API
This commit is contained in:
Tectu 2012-06-13 08:44:42 -07:00
commit 25ff65d207
6 changed files with 1161 additions and 713 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/s6d1121_lld.c
View File

@ -40,7 +40,7 @@ inline void lld_lcdwrite(uint16_t db)
}
static __inline uint16_t lcdReadData(void) {
uint16_t value;
uint16_t value=0;
LCD_RS_HIGH;
LCD_WR_HIGH;
@ -83,21 +83,15 @@ static __inline uint16_t lcdReadReg(uint16_t lcdReg) {
}
void lcdWriteIndex(uint16_t lcdReg) {
LCD_CS_LOW;
LCD_RS_LOW;
lld_lcdwrite(lcdReg);
LCD_RS_HIGH;
LCD_CS_HIGH;
}
void lcdWriteData(uint16_t lcdData) {
LCD_CS_LOW;
lld_lcdwrite(lcdData);
LCD_CS_HIGH;
}
void lcdWriteReg(uint16_t lcdReg, uint16_t lcdRegValue) {

1146
fonts.c
View File

File diff suppressed because it is too large Load Diff

39
fonts.h
View File

@ -1,12 +1,27 @@
#ifndef ASCIILIB_H
#define ASCIILIB_H
#include <string.h>
//#define ASCII_8X16_MS_Gothic
#define ASCII_8X16_System
void GetASCIICode(unsigned char* pBuffer,unsigned char ASCII);
#endif
/*
* fonts.h
*
* File containing prototype of the fonts for display
*
*
*/
#include <stdint.h>
#ifndef _FONT_
#define _FONT_
#define FONT_TABLE_HEIGHT_IDX 0
#define FONT_TABLE_PAD_AFTER_CHAR_IDX 1
#define FONT_TABLE_LINE_SPACING_IDX 2
#define FONT_TABLE_DECENDERS_HEIGHT_IDX 3
#define FONT_TABLE_UNUSED_IDX 4
#define FONT_TABLE_CHAR_LOOKUP_IDX 5
extern const uint8_t font_Small[];
extern const uint8_t font_Larger[];
//extern const uint8_t font_Medium[];
extern const uint8_t font_MediumBold[];
extern const uint8_t font_LargeNumbers[];
#endif

557
glcd.c
View File

@ -1,244 +1,313 @@
#include "glcd.h"
#include "fonts.h"
#include <math.h>
uint8_t font_width = 8, font_height = 16;
uint16_t lcd_width, lcd_height;
void lcdInit(void) {
lld_lcdInit();
lcd_width = SCREEN_WIDTH;
lcd_height = SCREEN_HEIGHT;
}
uint16_t lcdGetHeight(void) {
return lld_lcdGetHeight();
}
uint16_t lcdGetWidth(void) {
return lld_lcdGetWidth();
}
uint16_t lcdGetOrientation(void) {
return lld_lcdGetOrientation();
}
static void lcdSetCursor(uint16_t x, uint16_t y) {
lld_lcdSetCursor(x, y);
}
void lcdSetOrientation(uint8_t newOrientation) {
lld_lcdSetOrientation(newOrientation);
}
void lcdSetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
lld_lcdSetWindow(x0, y0, x1, y1);
}
void lcdClear(uint16_t color) {
lld_lcdClear(color);
}
uint16_t lcdGetPixelColor(uint16_t x, uint16_t y) {
return lld_lcdGetPixelColor(x, y);
}
void lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color) {
lld_lcdDrawPixel(x, y, color);
}
void lcdDrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
int16_t dy, dx;
int16_t addx=1, addy=1;
int16_t P, diff;
int16_t i=0;
dx = abs((int16_t)(x2 - x1));
dy = abs((int16_t)(y2 - y1));
if(x1 > x2)
addx = -1;
if(y1 > y2)
addy = -1;
if(dx >= dy)
{
dy *= 2;
P = dy - dx;
diff = P - dx;
for(; i<=dx; ++i)
{
lcdDrawPixel(x1, y1, color);
if(P < 0)
{
P += dy;
x1 += addx;
}
else
{
P += diff;
x1 += addx;
y1 += addy;
}
}
}
else
{
dx *= 2;
P = dx - dy;
diff = P - dy;
for(; i<=dy; ++i)
{
lcdDrawPixel(x1, y1, color);
if(P < 0)
{
P += dx;
y1 += addy;
}
else
{
P += diff;
x1 += addx;
y1 += addy;
}
}
}
}
void lcdDrawChar(uint16_t x, uint16_t y, const char c, uint16_t charcolor, uint16_t bkcolor) {
uint16_t i = 0;
uint16_t j = 0;
unsigned char buffer[16];
unsigned char tmp_char=0;
GetASCIICode(buffer,c);
for (i=0;i<16;i++) {
tmp_char=buffer[i];
for (j=0;j<8;j++) {
if (((tmp_char >> (7-j)) & 0x01) == 0x01)
lcdDrawPixel(x+j,y+i,charcolor);
else
lcdDrawPixel(x+j,y+i,bkcolor);
}
}
}
void lcdDrawString(uint16_t x, uint16_t y, const char *str, uint16_t color, uint16_t bkcolor) {
uint8_t TempChar;
do {
TempChar = *str++;
lcdDrawChar(x, y, TempChar, color, bkcolor);
if(x<232) {
x+=8;
} else if(y<304) {
x=0;
y+=16;
} else {
x=0;
y=0;
}
} while(*str != 0);
}
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 lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
lcdDrawRect(x0, y0, x1, y1, filled, color);
/*
uint32_t index = 0, area;
area = ((x1-x0)*(y1-y0));
lcdSetWindow(x0, y0, x1, y1);
Clr_CS;
lcdWriteIndex(0x0022);
for(index = 0; index < area; index++)
lcdWriteData(color);
Set_CS;
*/
}
void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color) {
uint16_t i, TempX;
uint16_t j, TempY;
if (x0 > x1) {
TempX = x1;
x1 = x0;
x0 = TempX;
}
if (y0 > y1) {
TempY = y1;
y1 = y0;
y0 = TempY;
}
if(filled) {
for(i=x0; i<x1; i++)
for(j=y0; j<y1; j++)
lcdDrawPixel(i , j , 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, color);
}
}
void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t *str, uint16_t fontColor, uint16_t bkColor) {
if(((strlen(str)*8) < (x1-x0)) && ((y1-y0) > font_height)) {
uint16_t off_left, off_up;
off_left = ((x1-x0) - (strlen(str) * font_width)) / 2;
off_up = ((y1-y0) - font_height) / 2;
lcdDrawRect(x0, y0, x1, y1, 1, bkColor);
lcdDrawString(x0 + off_left, y0 + off_up, str, fontColor, bkColor);
}
}
void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color) {
int16_t a, b, P;
a = 0;
b = radius;
P = 1 - radius;
do {
if(filled) {
lcdDrawLine(x-a, y+b, x+a, y+b, color);
lcdDrawLine(x-a, y-b, x+a, y-b, color);
lcdDrawLine(x-b, y+a, x+b, y+a, color);
lcdDrawLine(x-b, y-a, x+b, y-a, color);
} else {
lcdDrawPixel(a+x, b+y, color);
lcdDrawPixel(b+x, a+y, color);
lcdDrawPixel(x-a, b+y, color);
lcdDrawPixel(x-b, a+y, color);
lcdDrawPixel(b+x, y-a, color);
lcdDrawPixel(a+x, y-b, color);
lcdDrawPixel(x-a, y-b, color);
lcdDrawPixel(x-b, y-a, color);
}
if(P < 0)
P += 3 + 2*a++;
else
P += 5 + 2*(a++ - b--);
} while(a <= b);
}
#include "glcd.h"
#include "fonts.h"
#include <stdlib.h>
#include <math.h>
uint16_t lcd_width, lcd_height;
uint16_t bgcolor=White, fgcolor=Black;
uint16_t cx, cy;
static uint8_t tpText=0;
const uint8_t* font;
void lcdInit(void) {
lld_lcdInit();
lcd_width = SCREEN_WIDTH;
lcd_height = SCREEN_HEIGHT;
lcdSetFont(font_MediumBold);
}
uint16_t lcdGetHeight(void) {
return lld_lcdGetHeight();
}
uint16_t lcdGetWidth(void) {
return lld_lcdGetWidth();
}
uint16_t lcdGetOrientation(void) {
return lld_lcdGetOrientation();
}
static void lcdSetCursor(uint16_t x, uint16_t y) {
lld_lcdSetCursor(x, y);
}
void lcdSetOrientation(uint8_t newOrientation) {
lld_lcdSetOrientation(newOrientation);
}
void lcdSetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
lld_lcdSetWindow(x0, y0, x1, y1);
}
void lcdClear(uint16_t color) {
lld_lcdClear(color);
}
uint16_t lcdGetPixelColor(uint16_t x, uint16_t y) {
return lld_lcdGetPixelColor(x, y);
}
void lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color) {
lld_lcdDrawPixel(x, y, color);
}
void lcdDrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
int16_t dy, dx;
int16_t addx=1, addy=1;
int16_t P, diff;
int16_t i=0;
dx = abs((int16_t)(x2 - x1));
dy = abs((int16_t)(y2 - y1));
if(x1 > x2)
addx = -1;
if(y1 > y2)
addy = -1;
if(dx >= dy)
{
dy *= 2;
P = dy - dx;
diff = P - dx;
for(; i<=dx; ++i)
{
lcdDrawPixel(x1, y1, color);
if(P < 0)
{
P += dy;
x1 += addx;
}
else
{
P += diff;
x1 += addx;
y1 += addy;
}
}
}
else
{
dx *= 2;
P = dx - dy;
diff = P - dy;
for(; i<=dy; ++i)
{
lcdDrawPixel(x1, y1, color);
if(P < 0)
{
P += dx;
y1 += addy;
}
else
{
P += diff;
x1 += addx;
y1 += addy;
}
}
}
}
void lcdEnableTransparentText(uint8_t en) {
tpText=en;
}
void lcdDrawChar(char c) {
const uint8_t* ptr;
uint8_t fontHeight=lcdGetCurFontHeight();
uint8_t sps=font[FONT_TABLE_PAD_AFTER_CHAR_IDX];
uint16_t chi;
uint16_t x,y;
// No support for nongraphic characters, so just ignore them
if (c<0x20||c>0x7F) {
if (c=='\n') lcdLineBreak();
return;
}
chi=*(uint16_t*)(&font[FONT_TABLE_CHAR_LOOKUP_IDX+ (c-0x20)*2]);
ptr=font+chi;
uint8_t fontWidth=*(ptr++);
if (cx+fontWidth>lcdGetWidth()) lcdLineBreak();
for (x=0;x<fontWidth;x++) {
chi=*(uint16_t*)ptr;
for (y=0;y<fontHeight;y++) {
if (chi&0x01)
lcdDrawPixel(cx+x, cy+y, fgcolor);
else if (!tpText)
lcdDrawPixel(cx+x, cy+y, bgcolor);
chi>>=1;
}
ptr+=2;
}
cx+=fontWidth;
if (sps!=0) {
if (!tpText) lcdFillArea(cx,cy,sps,fontHeight,fgcolor);
cx+=sps;
}
}
void lcdPutString(const char *str) {
while (*str) lcdDrawChar(*str++);
}
void lcdDrawString(uint16_t x, uint16_t y, const char *str, uint16_t color, uint16_t bkcolor) {
uint16_t _bg=bgcolor, _fg=fgcolor;
cx=x;
cy=y;
bgcolor=bkcolor;
fgcolor=color;
lcdPutString(str);
bgcolor=_bg;
fgcolor=_fg;
}
uint16_t lcdMeasureChar(char c) {
const uint8_t* ptr;
// First get spaces after each character, usually 0 but can change
uint8_t sps=font[FONT_TABLE_PAD_AFTER_CHAR_IDX];
uint16_t chi;
if (c<0x20||c>0x7F) {
return 0;
}
chi=*(uint16_t*)(&font[FONT_TABLE_CHAR_LOOKUP_IDX+ (c-0x20)*2]);
ptr=font+chi;
uint8_t fontWidth=*(ptr++);
return fontWidth+sps;
}
uint16_t lcdMeasureString(const char* str) {
uint16_t result=0;
while (*str) result+=lcdMeasureChar(*str++);
return result;
}
void lcdLineBreak() {
// x=0 seems too much on the edge. So I keep it at 3
cx=3;
cy+=lcdGetCurFontHeight();
}
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 lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color) {
lcdDrawRect(x0, y0, x1, y1, filled, color);
/*
uint32_t index = 0, area;
area = ((x1-x0)*(y1-y0));
lcdSetWindow(x0, y0, x1, y1);
Clr_CS;
lcdWriteIndex(0x0022);
for(index = 0; index < area; index++)
lcdWriteData(color);
Set_CS;
*/
}
void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color) {
uint16_t i, TempX;
uint16_t j, TempY;
if (x0 > x1) {
TempX = x1;
x1 = x0;
x0 = TempX;
}
if (y0 > y1) {
TempY = y1;
y1 = y0;
y0 = TempY;
}
if(filled) {
for(i=x0; i<x1; i++)
for(j=y0; j<y1; j++)
lcdDrawPixel(i , j , 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, color);
}
}
void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char *str, uint16_t fontColor, uint16_t bkColor) {
uint16_t off_left, off_up;
off_left = ((x1-x0)-lcdMeasureString(str))/2;
off_up = ((y1-y0) - lcdGetCurFontHeight()) / 2;
lcdDrawRect(x0, y0, x1, y1, 1, bkColor);
lcdDrawString(x0+off_left, y0+off_up, str, fontColor, bkColor);
}
void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color) {
int16_t a, b, P;
a = 0;
b = radius;
P = 1 - radius;
do {
if(filled) {
lcdDrawLine(x-a, y+b, x+a, y+b, color);
lcdDrawLine(x-a, y-b, x+a, y-b, color);
lcdDrawLine(x-b, y+a, x+b, y+a, color);
lcdDrawLine(x-b, y-a, x+b, y-a, color);
} else {
lcdDrawPixel(a+x, b+y, color);
lcdDrawPixel(b+x, a+y, color);
lcdDrawPixel(x-a, b+y, color);
lcdDrawPixel(x-b, a+y, color);
lcdDrawPixel(b+x, y-a, color);
lcdDrawPixel(a+x, y-b, color);
lcdDrawPixel(x-a, y-b, color);
lcdDrawPixel(x-b, y-a, color);
}
if(P < 0)
P += 3 + 2*a++;
else
P += 5 + 2*(a++ - b--);
} while(a <= b);
}

123
glcd.h
View File

@ -1,51 +1,72 @@
#ifndef GLCD_H
#define GLCD_H
#include "ch.h"
#include "hal.h"
#include "drivers/ssd1289_lld.h"
#include "drivers/s6d1121_lld.h"
#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 320
#define PORTRAIT (lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv)
#define LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)
/* LCD color */
#define White 0xFFFF
#define Black 0x0000
#define Grey 0xF7DE
#define Blue 0x001F
#define Blue2 0x051F
#define Red 0xF800
#define Magenta 0xF81F
#define Green 0x07E0
#define Cyan 0x7FFF
#define Yellow 0xFFE0
#define RGB565CONVERT(red, green, blue) \
(uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 ))
enum orientation {portrait, landscape, portraitInv, landscapeInv};
enum filled {frame, filled};
void lcdInit(void);
void lcdClear(uint16_t color);
void lcdSetOrientation(uint8_t newOrientation);
void lcdSetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
void lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
void lcdDrawPixel(uint16_t x, uint16_t y, uint16_t point);
void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color);
void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t* str, uint16_t fontColor, uint16_t bkColor);
void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color);
void lcdDrawString(uint16_t x, uint16_t y, const char *str, uint16_t color, uint16_t bkColor);
void lcdDrawChar(uint16_t x, uint16_t y, const char c, uint16_t charcolor, uint16_t bkColor);
uint16_t lcdGetHeight(void);
uint16_t lcdGetWidth(void);
uint16_t lcdGetOrientation(void);
uint16_t lcdBGR2RGB(uint16_t color);
uint16_t lcdGetPixelColor(uint16_t x, uint16_t y);
#endif
#ifndef GLCD_H
#define GLCD_H
#include "ch.h"
#include "hal.h"
#include "drivers/ssd1289_lld.h"
#include "drivers/s6d1121_lld.h"
#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 320
#define PORTRAIT (lcdGetOrientation() == portrait || lcdGetOrientation() == portraitInv)
#define LANDSCAPE (lcdGetOrientation() == landscape || lcdGetOrientation() == landscapeInv)
/* LCD color */
#define White 0xFFFF
#define Black 0x0000
#define Grey 0xF7DE
#define Blue 0x001F
#define Blue2 0x051F
#define Red 0xF800
#define Magenta 0xF81F
#define Green 0x07E0
#define Cyan 0x7FFF
#define Yellow 0xFFE0
#define RGB565CONVERT(red, green, blue) \
(uint16_t)( (( red >> 3 ) << 11 ) | (( green >> 2 ) << 5 ) | ( blue >> 3 ))
enum orientation {portrait, landscape, portraitInv, landscapeInv};
enum filled {frame, filled};
// For text rendering only
extern uint16_t bgcolor, fgcolor;
extern uint16_t cx, cy;
extern const uint8_t* font;
// A few macros
#define lcdGotoXY(x,y) { cx=x; cy=y; }
#define lcdGetCurFontHeight() (font[FONT_TABLE_HEIGHT_IDX])
#define lcdSetFont(fnt) { font=fnt; }
void lcdInit(void);
void lcdClear(uint16_t color);
void lcdSetOrientation(uint8_t newOrientation);
void lcdSetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
void lcdFillArea(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
void lcdDrawPixel(uint16_t x, uint16_t y, uint16_t point);
void lcdDrawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color);
void lcdDrawRect(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t filled, uint16_t color);
void lcdDrawRectString(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, const char* str, uint16_t fontColor, uint16_t bkColor);
void lcdDrawCircle(uint16_t x, uint16_t y, uint16_t radius, uint8_t filled, uint16_t color);
void lcdEnableTransparentText(uint8_t en);
void lcdDrawChar(char c);
void lcdPutString(const char *str);
void lcdDrawString(uint16_t x, uint16_t y, const char *str, uint16_t color, uint16_t bkcolor);
void lcdLineBreak(void);
uint16_t lcdMeasureChar(char c);
uint16_t lcdMeasureString(const char* str);
uint16_t lcdGetHeight(void);
uint16_t lcdGetWidth(void);
uint16_t lcdGetOrientation(void);
uint16_t lcdBGR2RGB(uint16_t color);
uint16_t lcdGetPixelColor(uint16_t x, uint16_t y);
#endif

1
touchpad.c
View File

@ -122,6 +122,7 @@ void tpCalibrate(void) {
lcdSetOrientation(portrait);
lcdClear(Red);
cx=40; cy=10;
lcdDrawString(40, 10, "Touchpad Calibration", White, Red);
for(i=0; i<2; i++) {