5 changed files with 742 additions and 0 deletions
@ -0,0 +1,394 @@ |
|||
/*
|
|||
* This file is subject to the terms of the GFX License. If a copy of |
|||
* the license was not distributed with this file, you can obtain one at: |
|||
* |
|||
* http://ugfx.org/license.html
|
|||
*/ |
|||
/* KS0107/0108 Driver
|
|||
* Pinout: There are at least two different Pinouts! |
|||
* Version 1: |
|||
* 1 - CS1 High Active |
|||
* 2 - CS2 High Active |
|||
* 3 - GND |
|||
* 4 - 5V |
|||
* 5 - CONTRAST |
|||
* 6 - RS(=DC) High = Data, Low = Command |
|||
* 7 - R/W High = Read, Low = Write |
|||
* 8 - E Data is KS0108_latched at the falling Edge |
|||
* 9..16 - D0..7 |
|||
* Version 2: |
|||
* 1 - GND |
|||
* 2 - 5V |
|||
* 3 - Vo (Operating Voltage for LCD) |
|||
* 4 - RS High = Data, Low = Command |
|||
* 5 - R/W High = Read, Low = Write |
|||
* 6 - E Data is KS0108_latched at the falling Edge |
|||
* 7..14 - D0..7 |
|||
* 15 - CS1 High Active |
|||
* 16 - CS2 High Active |
|||
* 17 - /RST Low Active |
|||
* 18 - Vout (Output voltage for LCD) |
|||
* 19 - LEDA |
|||
* 20 - LEDK |
|||
* |
|||
*/ |
|||
#ifndef _GDISP_LLD_BOARD_H |
|||
#define _GDISP_LLD_BOARD_H |
|||
|
|||
// My Settings
|
|||
#define GDISP_SCREEN_HEIGHT 64 |
|||
#define GDISP_SCREEN_WIDTH 128 |
|||
#define KS0108_NEED_READ FALSE |
|||
#define KS0108_HAS_RESET FALSE |
|||
#define KS0108_NEED_BACKLIGHT FALSE |
|||
#define KS0108_NEED_PWMBACKLIGHT FALSE |
|||
#define KS0108_NOP_DLY TRUE //doesn't work for me without!
|
|||
|
|||
#define LINE_D0 PAL_LINE(GPIOB, 0U) |
|||
#define LINE_D1 PAL_LINE(GPIOB, 1U) |
|||
#define LINE_D2 PAL_LINE(GPIOB, 2U) |
|||
#define LINE_D3 PAL_LINE(GPIOB, 3U) |
|||
#define LINE_D4 PAL_LINE(GPIOB, 4U) |
|||
#define LINE_D5 PAL_LINE(GPIOB, 5U) |
|||
#define LINE_D6 PAL_LINE(GPIOB, 6U) |
|||
#define LINE_D7 PAL_LINE(GPIOB, 7U) |
|||
#define LINE_BUSY PAL_LINE(GPIOB, 7U) |
|||
#define LINE_CS1 PAL_LINE(GPIOB, 8U) |
|||
#define LINE_CS2 PAL_LINE(GPIOB, 9U) |
|||
#define LINE_E PAL_LINE(GPIOB, 10U) |
|||
#define LINE_DC PAL_LINE(GPIOB, 11U) |
|||
#if KS0108_NEED_READ |
|||
#define LINE_RW PAL_LINE(GPIOB, 12U) |
|||
#endif |
|||
#if KS0108_NEED_BACKLIGHT |
|||
#define LINE_BL PAL_LINE(GPIOB, 13U) |
|||
#endif |
|||
#if KS0108_HAS_RESET |
|||
#define LINE_RESET PAL_LINE(GPIOB, 13U) |
|||
#endif |
|||
|
|||
typedef struct { |
|||
ioline_t CS1; // Chip Select1 PIN
|
|||
ioline_t CS2; // Chip Select2 PIN
|
|||
ioline_t DC; // Register selector PIN
|
|||
ioline_t E; // Enable PIN
|
|||
ioline_t BUSY; // Busy PIN (Same as D[7])
|
|||
#if KS0108_NEED_READ |
|||
ioline_t RW; // Read/Write PIN
|
|||
#endif |
|||
#if KS0108_HAS_RESET |
|||
ioline_t RST; // Reset PIN
|
|||
#endif |
|||
#if KS0108_NEED_BACKLIGHT |
|||
ioline_t BL; // Backlight PIN
|
|||
#endif |
|||
ioline_t D[8]; |
|||
ioline_t CS[CHIPS]; |
|||
} lcd_pins_t; |
|||
|
|||
/*===========================================================================*/ |
|||
/* Driver local variables. */ |
|||
/*===========================================================================*/ |
|||
static const lcd_pins_t lcdpins = { |
|||
LINE_CS1, |
|||
LINE_CS2, |
|||
LINE_DC, |
|||
LINE_E, |
|||
LINE_BUSY, |
|||
#if KS0108_NEED_READ |
|||
LINE_RW, |
|||
#endif |
|||
#if KS0108_HAS_RESET |
|||
LINE_RST, |
|||
#endif |
|||
#if KS0108_NEED_BACKLIGHT |
|||
LINE_BL, |
|||
#endif |
|||
{ |
|||
LINE_D0, |
|||
LINE_D1, |
|||
LINE_D2, |
|||
LINE_D3, |
|||
LINE_D4, |
|||
LINE_D5, |
|||
LINE_D6, |
|||
LINE_D7 |
|||
}, |
|||
{ |
|||
LINE_CS1, |
|||
LINE_CS2 |
|||
} |
|||
}; |
|||
|
|||
static GFXINLINE void init_board(GDisplay* g){ |
|||
(void) g; |
|||
g->board = 0; |
|||
int ii; |
|||
|
|||
for (ii = 0; ii < CHIPS; ii++){ |
|||
palSetLineMode(lcdpins.CS[ii], PAL_MODE_OUTPUT_PUSHPULL); |
|||
palClearLine(lcdpins.CS[ii]); |
|||
} |
|||
palSetLineMode(lcdpins.DC, PAL_MODE_OUTPUT_PUSHPULL); |
|||
palClearLine(lcdpins.DC); |
|||
palSetLineMode(lcdpins.E, PAL_MODE_OUTPUT_PUSHPULL); |
|||
palSetLine(lcdpins.E); |
|||
#if KS0108_NEED_READ |
|||
palSetLineMode(lcdpins.RW, PAL_MODE_OUTPUT_PUSHPULL); |
|||
palClearLine(lcdpins.RW); |
|||
#endif |
|||
#if KS0108_HAS_RESET |
|||
palSetLineMode(lcdpins.RST, PAL_MODE_OUTPUT_PUSHPULL); |
|||
palSetLine(lcdpins.RST); |
|||
#endif |
|||
for(ii = 0; ii < 8; ii++) { |
|||
palSetLineMode(lcdpins.D[ii], PAL_MODE_OUTPUT_PUSHPULL); |
|||
palClearLine(lcdpins.D[ii]); |
|||
} |
|||
#if KS0108_NEED_BACKLIGHT |
|||
#if KS0108_NEED_PWMBACKLIGHT |
|||
palSetLineMode(lcdpins.BL, PAL_MODE_ALTERNATE(1)); |
|||
#else |
|||
palSetLineMode(lcdpins.BL, PAL_MODE_OUTPUT_PUSHPULL); |
|||
#endif |
|||
#endif |
|||
} |
|||
|
|||
static GFXINLINE void post_init_board(GDisplay *g) { |
|||
(void) g; |
|||
} |
|||
|
|||
static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) { |
|||
(void) g; |
|||
(void) state; |
|||
|
|||
#if KS0108_HAS_RESET //Make Hardware Reset
|
|||
if (state) |
|||
palClearLine(lcdpins.RST); |
|||
else |
|||
palSetLine(lcdpins.RST); |
|||
#endif |
|||
} |
|||
|
|||
static GFXINLINE void set_backlight(GDisplay *g, uint8_t percent) { |
|||
(void) g; |
|||
(void) percent; |
|||
} |
|||
|
|||
static GFXINLINE void acquire_bus(GDisplay *g) { |
|||
(void) g; |
|||
} |
|||
|
|||
static GFXINLINE void release_bus(GDisplay *g) { |
|||
(void) g; |
|||
} |
|||
|
|||
void KS0108_delay(uint16_t microsec){ |
|||
#if KS0108_NOP_DLY |
|||
uint16_t cn; |
|||
for (cn=0;cn< microsec;cn++){ |
|||
|
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
|
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
|
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
|
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
asm("nop");asm("nop");asm("nop");asm("nop"); |
|||
|
|||
//asm("nop");asm("nop");asm("nop");asm("nop");
|
|||
//asm("nop");asm("nop");asm("nop");asm("nop");
|
|||
//1us
|
|||
} |
|||
#else |
|||
gfxSleepMicroseconds(microsec); |
|||
#endif |
|||
} |
|||
|
|||
static GFXINLINE void KS0108_latch(void){ |
|||
palClearLine(lcdpins.E); |
|||
KS0108_delay(1); |
|||
palSetLine(lcdpins.E); |
|||
} |
|||
|
|||
static GFXINLINE void KS0108_write(uint8_t value){ |
|||
int ii; |
|||
|
|||
for(ii = 0; ii < 8; ii++){ |
|||
if(value & (1 << ii)) |
|||
palSetLine(lcdpins.D[ii]); |
|||
else |
|||
palClearLine(lcdpins.D[ii]); |
|||
} |
|||
KS0108_delay(1); |
|||
} |
|||
|
|||
static GFXINLINE void KS0108_select(uint8_t chip){ |
|||
uint8_t ii; |
|||
KS0108_delay(1); |
|||
for (ii = 0; ii < CHIPS; ii++){ |
|||
if (ii == chip) |
|||
palSetLine(lcdpins.CS[ii]); |
|||
} |
|||
KS0108_delay(1); |
|||
} |
|||
|
|||
static GFXINLINE void KS0108_unselect(void){ |
|||
uint8_t ii; |
|||
|
|||
KS0108_delay(1); |
|||
for (ii = 0; ii < CHIPS; ii++){ |
|||
palClearLine(lcdpins.CS[ii]); |
|||
} |
|||
} |
|||
|
|||
/*
|
|||
#if KS0108_NEED_READ //Hardware Read ############## WORKS more or less
|
|||
static GFXINLINE uint8_t read_KS0108(void) { |
|||
uint8_t ii, data=0; |
|||
|
|||
for(ii = 0; ii < 8; ii++) |
|||
palSetLineMode(lcdpins.D[ii], PAL_MODE_INPUT); //Set pads to input
|
|||
palSetLine(lcdpins.RW); |
|||
KS0108_delay(1); |
|||
palClearLine(lcdpins.E); |
|||
KS0108_delay(1); |
|||
palSetLine(lcdpins.E); |
|||
KS0108_delay(1); |
|||
// palClearLine(lcdpins.RW);
|
|||
// KS0108_delay(1);
|
|||
// palSetLine(lcdpins.RW);
|
|||
// KS0108_delay(1);
|
|||
for(ii = 0; ii < 8; ii++){ |
|||
if (palReadLine(lcdpins.D[ii]) == PAL_HIGH){ //Read output
|
|||
data |= (1<<ii); |
|||
} |
|||
} |
|||
// palClearLine(lcdpins.E);
|
|||
palClearLine(lcdpins.RW); //Write again
|
|||
for(ii = 0; ii < 8; ii++) { |
|||
palSetLineMode(lcdpins.D[ii], PAL_MODE_OUTPUT_PUSHPULL); //Set pads to output
|
|||
} |
|||
return data; |
|||
} |
|||
#endif |
|||
*/ |
|||
#if KS0108_NEED_READ //Hardware Read ########### needs more testing but my display is broken
|
|||
static GFXINLINE uint8_t read_KS0108(void) { |
|||
uint8_t ii, data=0; |
|||
|
|||
for(ii = 0; ii < 8; ii++) |
|||
palSetLineMode(lcdpins.D[ii], PAL_MODE_INPUT); //Set pads to input
|
|||
palSetLine(lcdpins.RW); |
|||
KS0108_delay(1); |
|||
|
|||
palClearLine(lcdpins.DC); |
|||
KS0108_delay(1); |
|||
|
|||
|
|||
while (palReadLine(lcdpins.BUSY)); //Wait for busy flag
|
|||
palSetLine(lcdpins.DC); |
|||
/*
|
|||
KS0108_delay(2); |
|||
KS0108_latch(); |
|||
KS0108_delay(2); |
|||
//KS0108_latch();
|
|||
//KS0108_delay(1);
|
|||
*/ |
|||
palClearLine(lcdpins.RW); |
|||
KS0108_delay(2); |
|||
palSetLine(lcdpins.RW); |
|||
KS0108_delay(1); |
|||
palClearLine(lcdpins.DC); |
|||
KS0108_delay(1); |
|||
while (palReadLine(lcdpins.BUSY)); //Wait for busy flag
|
|||
//KS0108_delay(7);
|
|||
palSetLine(lcdpins.DC); |
|||
|
|||
//KS0108_delay(1);
|
|||
//KS0108_latch();
|
|||
//KS0108_delay(3);
|
|||
|
|||
KS0108_delay(1); |
|||
for(ii = 0; ii < 8; ii++){ |
|||
if (palReadLine(lcdpins.D[ii]) == PAL_HIGH) //Read output
|
|||
data |= (1<<ii); |
|||
} |
|||
// palClearLine(lcdpins.E);
|
|||
palSetLine(lcdpins.DC); |
|||
palClearLine(lcdpins.RW); //Write again
|
|||
for(ii = 0; ii < 8; ii++) { |
|||
palSetLineMode(lcdpins.D[ii], PAL_MODE_OUTPUT_PUSHPULL); //Set pads to output
|
|||
} |
|||
return data; |
|||
} |
|||
#endif |
|||
|
|||
static GFXINLINE void write_data(GDisplay* g, uint16_t data){ |
|||
(void)g; |
|||
uint8_t bit, displayData; |
|||
#if !KS0108_NEED_READ |
|||
uint8_t *p; |
|||
#endif |
|||
|
|||
palSetLine(lcdpins.DC); |
|||
KS0108_select((uint8_t)(data>>8)); |
|||
#if KS0108_NEED_READ |
|||
displayData=read_KS0108(); |
|||
#else |
|||
p = RAM(g) + (GDISP_SCREEN_WIDTH*(g->p.y >> 3)) + g->p.x; |
|||
displayData = *p; |
|||
#endif |
|||
bit = 1 << (g->p.y & 7); //Get Page bit
|
|||
|
|||
if ((uint8_t)data){ //set bit
|
|||
KS0108_write(displayData | bit); |
|||
#if !KS0108_NEED_READ |
|||
*p = (displayData | bit); |
|||
#endif |
|||
KS0108_latch(); |
|||
} else { |
|||
KS0108_write(displayData & ~bit); |
|||
#if !KS0108_NEED_READ |
|||
*p = (displayData & ~bit); |
|||
#endif |
|||
KS0108_latch(); |
|||
} |
|||
KS0108_delay(2); //one is too short!
|
|||
KS0108_unselect(); //Important
|
|||
} |
|||
|
|||
static GFXINLINE void write_cmd(GDisplay* g, uint16_t cmd){ |
|||
(void)g; |
|||
palClearLine(lcdpins.DC); |
|||
KS0108_select((uint8_t)(cmd>>8)); |
|||
KS0108_write((uint8_t)cmd); |
|||
KS0108_latch(); |
|||
KS0108_unselect(); //Important
|
|||
} |
|||
|
|||
static GFXINLINE void setreadmode(GDisplay *g) { |
|||
(void) g; |
|||
} |
|||
|
|||
static GFXINLINE void setwritemode(GDisplay *g) { |
|||
(void) g; |
|||
} |
|||
|
|||
static GFXINLINE uint16_t read_data(GDisplay *g) { |
|||
(void) g; |
|||
return 0; |
|||
} |
|||
#endif /* _GDISP_LLD_BOARD_H */ |
@ -0,0 +1,2 @@ |
|||
GFXINC += $(GFXLIB)/drivers/gdisp/KS0108 |
|||
GFXSRC += $(GFXLIB)/drivers/gdisp/KS0108/gdisp_lld_KS0108.c |
@ -0,0 +1,327 @@ |
|||
/*
|
|||
* This file is subject to the terms of the GFX License. If a copy of |
|||
* the license was not distributed with this file, you can obtain one at: |
|||
* |
|||
* http://ugfx.org/license.html
|
|||
*/ |
|||
|
|||
#include "gfx.h" |
|||
|
|||
#if GFX_USE_GDISP |
|||
|
|||
/* Robert Offner 2017
|
|||
* This is a driver for the KS0107 Displays. |
|||
* It should work with displays up to 240 pixel in width and 64 pixel in height |
|||
* ATTENTION some newer displays on ebay look like KS0107 Type but they're not! |
|||
* They use a new controller: ST7920. These are easy to identify: NO CS pin but |
|||
* a PSB Pin which switches from parallel to serial communication mode. |
|||
* If it cost less than 10.- it is probably a ST7920. |
|||
* Features: Well not much. For now write pixel to display and |
|||
* Read from Display / Buffer in RAM. Buffer in Ram is much faster than |
|||
* readback! |
|||
* I am trying to get the auto increment feature somehow implemented. It |
|||
* basically means if you start at x=0 and continue with x=1, x=2,... you don't |
|||
* have to write the address just data. |
|||
* |
|||
* Version: 0.3 |
|||
* |
|||
* History: |
|||
* v0.4 |
|||
* .) Cleanup by uGFX team. Code needs a lot of work. |
|||
* |
|||
* v0.3 |
|||
* .) Removed initialization of g->priv because it is already done by uGFX. |
|||
* |
|||
* v0.2 |
|||
* .) Cleanup, |
|||
* .) changed osalThreadSleep to gfxSleepMicroseconds(x) |
|||
* ATTENTION: for gfxSleepMicroseconds to work on chibios you have to |
|||
* increase CH_CFG_ST_FREQUENCY to 1000000 and probably CH_CFG_ST_RESOLUTION |
|||
* to 32 bit (not tested because STM32F103 doesn't have a 32 bit timer |
|||
* .) changed lcdbuf to g->priv |
|||
* |
|||
* v0.1 Initial Release |
|||
*/ |
|||
|
|||
#define GDISP_DRIVER_VMT GDISPVMT_KS0108 |
|||
#include "gdisp_lld_config.h" |
|||
#include "../../../src/gdisp/gdisp_driver.h" |
|||
|
|||
#include "board_KS0108.h" |
|||
|
|||
/*===========================================================================*/ |
|||
/* Driver local definitions. */ |
|||
/*===========================================================================*/ |
|||
|
|||
#ifndef GDISP_SCREEN_HEIGHT |
|||
#define GDISP_SCREEN_HEIGHT 64 |
|||
#endif |
|||
#ifndef GDISP_SCREEN_WIDTH |
|||
#define GDISP_SCREEN_WIDTH 128 |
|||
#endif |
|||
|
|||
#define CHIPS (GDISP_SCREEN_WIDTH/64) |
|||
|
|||
#if !KS0108_NEED_READ |
|||
#define BUFFSZ (GDISP_SCREEN_HEIGHT/8 * GDISP_SCREEN_WIDTH) |
|||
#define RAM(g) ((uint8_t *)g->priv) |
|||
#endif |
|||
#ifndef GDISP_INITIAL_CONTRAST |
|||
#define GDISP_INITIAL_CONTRAST 50 |
|||
#endif |
|||
#ifndef GDISP_INITIAL_BACKLIGHT |
|||
#define GDISP_INITIAL_BACKLIGHT 100 |
|||
#endif |
|||
|
|||
// KS0108 Commands
|
|||
#define KS0108_CHIP1_ON 0x003F |
|||
#define KS0108_CHIP2_ON 0x013F |
|||
#define KS0108_DISP1START 0x00C0 |
|||
#define KS0108_DISP2START 0x01C0 |
|||
#define KS0108_DISP1OFF 0x003E |
|||
#define KS0108_DISP2OFF 0x013E |
|||
#define KS0108_SET_ADDR 0x0040 |
|||
#define KS0108_SET_PAGE 0x00B8 |
|||
|
|||
/*===========================================================================*/ |
|||
/* Driver local functions. */ |
|||
/*===========================================================================*/ |
|||
#ifndef write_data_repeat |
|||
#define write_data_repeat(g, data, count) { int i; for (i = 0; i < count; ++i) write_data (g, data); } |
|||
#endif |
|||
|
|||
/*===========================================================================*/ |
|||
/* Driver exported functions. */ |
|||
/*===========================================================================*/ |
|||
|
|||
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) { |
|||
#if !KS0108_NEED_READ |
|||
// The private area is the display surface.
|
|||
g->priv = gfxAlloc(BUFFSZ); |
|||
#else |
|||
g->priv = 0; |
|||
#endif |
|||
// Initialise the board interface
|
|||
init_board(g); |
|||
|
|||
#if KS0108_HAS_RESET //Make Hardware Reset
|
|||
setpin_reset(g, TRUE); |
|||
gfxSleepMilliseconds(120); |
|||
setpin_reset(g, FALSE); |
|||
#endif |
|||
gfxSleepMilliseconds(120); |
|||
write_cmd(g, KS0108_DISP1OFF); |
|||
gfxSleepMilliseconds(1); |
|||
write_cmd(g, KS0108_DISP2OFF); |
|||
gfxSleepMilliseconds(1); |
|||
write_cmd(g, KS0108_CHIP1_ON); //0x3F Chip1
|
|||
gfxSleepMilliseconds(1); |
|||
write_cmd(g, KS0108_CHIP2_ON); //0x3F Chip2
|
|||
gfxSleepMilliseconds(1); |
|||
write_cmd(g, KS0108_DISP1START); //0xC0 Chip1
|
|||
gfxSleepMilliseconds(1); |
|||
write_cmd(g, KS0108_DISP2START); //0xC0 Chip2
|
|||
gfxSleepMilliseconds(1); |
|||
|
|||
// Finish Init
|
|||
post_init_board(g); |
|||
|
|||
#if KS0108_NEED_BACKLIGHT |
|||
// Turn on the back-light
|
|||
set_backlight(g, GDISP_INITIAL_BACKLIGHT); |
|||
#endif |
|||
|
|||
// Initialise the GDISP structure
|
|||
g->g.Width = GDISP_SCREEN_WIDTH; |
|||
g->g.Height = GDISP_SCREEN_HEIGHT; |
|||
g->g.Orientation = GDISP_ROTATE_0; |
|||
g->g.Powermode = powerOn; |
|||
g->g.Backlight = GDISP_INITIAL_BACKLIGHT; |
|||
g->g.Contrast = GDISP_INITIAL_CONTRAST; |
|||
|
|||
return TRUE; |
|||
} |
|||
|
|||
GFXINLINE void KS0108_goto(GDisplay* g, ) { |
|||
} |
|||
|
|||
static void set_viewport(GDisplay *g) { |
|||
uint16_t pg; |
|||
uint16_t chip; |
|||
|
|||
pg = g->p.y >> 3; |
|||
chip = (g->p.x >> 6) << 8; |
|||
write_cmd(g, KS0108_SET_PAGE | chip | pg); // (0xB8) - Set page
|
|||
write_cmd(g, KS0108_SET_ADDR | chip | g->p.x); // (0x40) - Set x Address
|
|||
} |
|||
|
|||
LLDSPEC void gdisp_lld_write_color(GDisplay *g) { |
|||
uint16_t data; |
|||
|
|||
data = (g->p.x >> 6) << 8; // Set the chip
|
|||
if (g->p.color != White) |
|||
data |= 0x01; // set dot
|
|||
write_data(g, data); |
|||
} |
|||
|
|||
LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) { |
|||
set_viewport(g); |
|||
gdisp_lld_write_color(g); |
|||
} |
|||
|
|||
#if GDISP_HARDWARE_STREAM_WRITE |
|||
LLDSPEC void gdisp_lld_write_start(GDisplay *g) { |
|||
acquire_bus(g); |
|||
set_viewport(g); |
|||
} |
|||
|
|||
LLDSPEC void gdisp_lld_write_stop(GDisplay *g) { |
|||
release_bus(g); |
|||
} |
|||
#endif |
|||
|
|||
#if GDISP_HARDWARE_STREAM_READ |
|||
LLDSPEC void gdisp_lld_read_start(GDisplay *g) { |
|||
acquire_bus(g); |
|||
set_viewport(g); |
|||
setreadmode(g); |
|||
dummy_read(g); |
|||
} |
|||
|
|||
LLDSPEC color_t gdisp_lld_read_color(GDisplay *g) { |
|||
uint16_t data; |
|||
|
|||
data = read_data(g); |
|||
return gdispNative2Color(data); |
|||
} |
|||
|
|||
LLDSPEC void gdisp_lld_read_stop(GDisplay *g) { |
|||
setwritemode(g); |
|||
release_bus(g); |
|||
} |
|||
#endif |
|||
|
|||
#if GDISP_HARDWARE_FILLS |
|||
LLDSPEC void gdisp_lld_fill_area(GDisplay *g) { |
|||
uint8_t data, j; |
|||
set_viewport(g); |
|||
|
|||
if (g->p.color != White) { |
|||
data = 0xFF; // set dot
|
|||
} |
|||
else { |
|||
data = 0; // clr dot
|
|||
} |
|||
for (j=0; j < (g->p.cy)/8; j++) { |
|||
write_data_repeat(g, data, (g->p.cx)); |
|||
(g->p.cy) +=8; |
|||
set_viewport(g); |
|||
} |
|||
|
|||
} |
|||
#endif // GDISP_HARDWARE_FILLS
|
|||
|
|||
#if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL |
|||
LLDSPEC void gdisp_lld_control(GDisplay *g) { |
|||
switch(g->p.x) { |
|||
case GDISP_CONTROL_POWER: |
|||
if (g->g.Powermode == (powermode_t)g->p.ptr) |
|||
return; |
|||
|
|||
switch((powermode_t)g->p.ptr) { |
|||
case powerOff: |
|||
acquire_bus(g); |
|||
write_index(g, 0x28); |
|||
gfxSleepMilliseconds(10); |
|||
write_index(g, 0x10); |
|||
release_bus(g); |
|||
break; |
|||
|
|||
case powerOn: |
|||
acquire_bus(g); |
|||
write_index(g, 0x11); |
|||
gfxSleepMilliseconds(120); |
|||
write_index(g, 0x29); |
|||
release_bus(g); |
|||
if (g->g.Powermode != powerSleep) |
|||
gdisp_lld_init(g); |
|||
break; |
|||
|
|||
case powerSleep: |
|||
acquire_bus(g); |
|||
write_index(g, 0x28); |
|||
gfxSleepMilliseconds(10); |
|||
write_index(g, 0x10); |
|||
release_bus(g); |
|||
break; |
|||
|
|||
default: |
|||
return; |
|||
} |
|||
|
|||
g->g.Powermode = (powermode_t)g->p.ptr; |
|||
return; |
|||
|
|||
case GDISP_CONTROL_ORIENTATION: |
|||
if (g->g.Orientation == (orientation_t)g->p.ptr) |
|||
return; |
|||
|
|||
switch((orientation_t)g->p.ptr) { |
|||
case GDISP_ROTATE_0: |
|||
acquire_bus(g); |
|||
|
|||
write_index(g, 0x36); |
|||
write_data(g, 0x08); |
|||
|
|||
release_bus(g); |
|||
g->g.Height = GDISP_SCREEN_HEIGHT; |
|||
g->g.Width = GDISP_SCREEN_WIDTH; |
|||
break; |
|||
|
|||
case GDISP_ROTATE_90: |
|||
acquire_bus(g); |
|||
|
|||
write_index(g, 0x36); |
|||
write_data(g, 0x68); |
|||
|
|||
release_bus(g); |
|||
g->g.Height = GDISP_SCREEN_WIDTH; |
|||
g->g.Width = GDISP_SCREEN_HEIGHT; |
|||
break; |
|||
|
|||
case GDISP_ROTATE_180: |
|||
acquire_bus(g); |
|||
|
|||
write_index(g, 0x36); |
|||
write_data(g, 0xC8); |
|||
|
|||
release_bus(g); |
|||
g->g.Height = GDISP_SCREEN_HEIGHT; |
|||
g->g.Width = GDISP_SCREEN_WIDTH; |
|||
break; |
|||
|
|||
case GDISP_ROTATE_270: |
|||
acquire_bus(g); |
|||
|
|||
write_index(g, 0x36); |
|||
write_data(g, 0xA8); |
|||
|
|||
release_bus(g); |
|||
g->g.Height = GDISP_SCREEN_WIDTH; |
|||
g->g.Width = GDISP_SCREEN_HEIGHT; |
|||
break; |
|||
|
|||
default: |
|||
return; |
|||
} |
|||
|
|||
g->g.Orientation = (orientation_t)g->p.ptr; |
|||
return; |
|||
|
|||
default: |
|||
return; |
|||
} |
|||
} |
|||
#endif |
|||
|
|||
#endif /* GFX_USE_GDISP */ |
@ -0,0 +1,18 @@ |
|||
/*
|
|||
* This file is subject to the terms of the GFX License. If a copy of |
|||
* the license was not distributed with this file, you can obtain one at: |
|||
* |
|||
* http://ugfx.org/license.html
|
|||
*/ |
|||
|
|||
#ifndef _GDISP_LLD_CONFIG_H |
|||
#define _GDISP_LLD_CONFIG_H |
|||
|
|||
/*===========================================================================*/ |
|||
/* Driver hardware support. */ |
|||
/*===========================================================================*/ |
|||
|
|||
#define GDISP_HARDWARE_DRAWPIXEL TRUE |
|||
#define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_MONO |
|||
|
|||
#endif /* _GDISP_LLD_CONFIG_H */ |
Loading…
Reference in new issue