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

Added UC1601s driver

remotes/origin_old/release/v2.9
inmarket 6 years ago
parent
864210b764
commit
eaa704c765
7 changed files with 451 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      changelog.txt
  2. 87
      drivers/gdisp/UC1601s/UC1601s.h
  3. 45
      drivers/gdisp/UC1601s/board_UC1601s_template.h
  4. 2
      drivers/gdisp/UC1601s/driver.mk
  5. 283
      drivers/gdisp/UC1601s/gdisp_lld_UC1601s.c
  6. 31
      drivers/gdisp/UC1601s/gdisp_lld_config.h
  7. 1
      drivers/gdisp/readme.txt

2
changelog.txt
View File

@ -31,6 +31,8 @@ FEATURE: Added justifyWordWrap, justifyNoWordWrap text justification to GDISP (r
FEATURE: Added justifyPad, justifyNoPad text justification to GDISP
FEATURE: Added GDISP_NEED_TEXT_BOXPADLR and GDISP_NEED_TEXT_BOXPADTB configuration options
FIX: Fixed an issue on FreeRTOS where thread stacks were being created too large
FEATURE: Added UC1601s driver
FIX: Fixed issues with the STM746-Discovery board with ChibiOS
*** Release 2.7 ***

87
drivers/gdisp/UC1601s/UC1601s.h
View File

@ -0,0 +1,87 @@
/*
* 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:
*
* https://ugfx.io/license.html
*
* Author: pashamray
* e-mail: pashamray@gmail.com
* github: https://github.com/pashamray
*
* this driver based on code:
* http://caxapa.ru/thumbs/316734/rdx0154gc.zip
* http://leoniv.livejournal.com/124005.html
* Author: leoniv
* Web site: http://leoniv.livejournal.com
*
*/
#ifndef _UC1601s_H
#define _UC1601s_H
// UC1601s Address:
#define UC1601s_ADDR_C 0x70 // control address
#define UC1601s_ADDR_D 0x72 // data address
#define UC1601s_SET_COL_L 0x00 // set column address LSB, CA[3:0]
#define UC1601s_SET_COL_H 0x10 // set column address MSB, CA[7:4]
#define UC1601s_SET_TC 0x24 // set temperature compensation, TC[1:0]
#define UC1601s_SET_POWER 0x28 // set power control, PC[2:0]
#define UC1601s_SET_ADV 0x30 // set advanced program control, APC[R][7:0]
#define UC1601s_SET_SL 0x40 // set scroll line, SL[5:0]
#define UC1601s_SET_PAGE 0xB0 // set page address, PA[3:0]
#define UC1601s_SET_BIAS 0x81 // set Vbias, PM[7:0]
#define UC1601s_SET_PART 0x84 // set partial display control, LC[4]
#define UC1601s_SET_RAMA 0x88 // set RAM address control, AC[2:0]
#define UC1601s_SET_FR 0xA0 // set frame rate, LC[3]
#define UC1601s_SET_PON 0xA4 // set all pixel on, DC[1]
#define UC1601s_SET_INV 0xA6 // set inverse display, DC[0]
#define UC1601s_SET_EN 0xAE // set display enable, DC[2]
#define UC1601s_SET_MAP 0xC0 // set LCD mapping control, LC[2:1]
#define UC1601s_RESET 0xE2 // system reset
#define UC1601s_NOP 0xE3 // NOP
#define UC1601s_SET_TEST 0xE4 // set test control
#define UC1601s_SET_BR 0xE8 // set LCD bias ratio, BR[1:0]
#define UC1601s_SET_CEN 0xF1 // set COM end, CEN[6:0]
#define UC1601s_SET_DST 0xF2 // set partial display start, DST[6:0]
#define UC1601s_SET_DEN 0xF3 // set partial display end, DEN[6:0]
// TC[1:0]:
#define UC1601s_TC0 0x00 // TC[1:0] = 0: temp. coeff. -0.05%/°C (default)
#define UC1601s_TC1 0x01 // TC[1:0] = 1: temp. coeff. -0.10%/°C
#define UC1601s_TC2 0x02 // TC[1:0] = 2: temp. coeff. -0.15%/°C
#define UC1601s_TC3 0x03 // TC[1:0] = 3: temp. coeff. -0.00%/°C
// PC[2:0]
#define UC1601s_15N 0x00 // PC[0] = 0, panel loading < 15 nF (default)
#define UC1601s_24N 0x01 // PC[0] = 1, panel loading 15 - 24 nF
#define UC1601s_EXT_VLCD 0x00 // PC[2:1] = 00, external Vlcd
#define UC1601s_INT_VLCD 0x06 // PC[2:1] = 11, internal Vlcd (x7) (default)
// LC[4:1]:
#define UC1601s_MX 0x02 // LC[1] = 1, X mirror
#define UC1601s_MY 0x04 // LC[2] = 1, Y mirror
#define UC1601s_80FPS 0x00 // LC[3] = 0, 80 frames per second (default)
#define UC1601s_100FPS 0x01 // LC[3] = 1, 100 frames per second
#define UC1601s_DIS_PD 0x00 // LC[4] = 0, disable partial display,
// mux rate = CEN + 1 (DST, DEN not used)
#define UC1601s_ENA_PD 0x01 // LC[4] = 1, enable partial display,
// mux rate = DEN - DST + 1
// AC[2:0]:
#define UC1601s_WA 0x01 // AC[0] = 1, wrap around
#define UC1601s_AINC 0x02 // AC[1] = 1, auto increment
#define UC1601s_PID 0x04 // AC[2] = 1, page auto increment direction
// DC[2:0]:
#define UC1601s_INVERSE 0x01 // DC[0] = 1, inverse display
#define UC1601s_ALL_ON 0x01 // DC[1] = 1, all pixels on
#define UC1601s_ENABLE 0x01 // DC[2] = 1, enable display
//BR[1:0]:
#define UC1601s_BR_6 0x00 // BR[1:0] = 0: bias ratio = 6
#define UC1601s_BR_7 0x01 // BR[1:0] = 1: bias ratio = 7
#define UC1601s_BR_8 0x02 // BR[1:0] = 2: bias ratio = 8
#define UC1601s_BR_9 0x03 // BR[1:0] = 3: bias ratio = 9 (default)
#endif /* _UC1601s_H */

45
drivers/gdisp/UC1601s/board_UC1601s_template.h
View File

@ -0,0 +1,45 @@
/*
* 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_BOARD_H
#define _GDISP_LLD_BOARD_H
//#define SSD1306_PAGE_PREFIX 0x40
static GFXINLINE void init_board(GDisplay *g) {
(void) g;
}
static GFXINLINE void post_init_board(GDisplay *g) {
(void) g;
}
static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) {
(void) g;
(void) state;
}
static GFXINLINE void acquire_bus(GDisplay *g) {
(void) g;
}
static GFXINLINE void release_bus(GDisplay *g) {
(void) g;
}
static GFXINLINE void write_cmd(GDisplay *g, uint8_t cmd) {
(void) g;
(void) cmd;
}
static GFXINLINE void write_data(GDisplay *g, uint8_t* data, uint16_t length) {
(void) g;
(void) data;
(void) length;
}
#endif /* _GDISP_LLD_BOARD_H */

2
drivers/gdisp/UC1601s/driver.mk
View File

@ -0,0 +1,2 @@
GFXINC += $(GFXLIB)/drivers/gdisp/UC1601s
GFXSRC += $(GFXLIB)/drivers/gdisp/UC1601s/gdisp_lld_UC1601s.c

283
drivers/gdisp/UC1601s/gdisp_lld_UC1601s.c
View File

@ -0,0 +1,283 @@
/*
* 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:
*
* https://ugfx.io/license.html
*
* Author: pashamray
* e-mail: pashamray@gmail.com
* github: https://github.com/pashamray
*
* this driver based on code:
* http://caxapa.ru/thumbs/316734/rdx0154gc.zip
* http://leoniv.livejournal.com/124005.html
* Author: leoniv
* Web site: http://leoniv.livejournal.com
*
*/
#include "gfx.h"
#if GFX_USE_GDISP
#define GDISP_DRIVER_VMT GDISPVMT_UC1601s
#include "gdisp_lld_config.h"
#include "../../../src/gdisp/gdisp_driver.h"
#include "board_UC1601s.h"
#include <string.h> // for memset
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
#ifndef GDISP_SCREEN_HEIGHT
#define GDISP_SCREEN_HEIGHT 64
#endif
#ifndef GDISP_SCREEN_WIDTH
#define GDISP_SCREEN_WIDTH 132
#endif
#ifndef GDISP_INITIAL_CONTRAST
#define GDISP_INITIAL_CONTRAST 47
#endif
#ifndef GDISP_INITIAL_BACKLIGHT
#define GDISP_INITIAL_BACKLIGHT 100
#endif
#define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER << 0)
#include "UC1601s.h"
/*===========================================================================*/
/* Driver local functions. */
/*===========================================================================*/
// Some common routines and macros
#define RAM(g) ((uint8_t *)g->priv)
#define xyaddr(x, y) ((x) + ((y) >> 3) * GDISP_SCREEN_WIDTH)
#define xybit(y) (1 << ((y) & 7))
/**
* As this controller can't update on a pixel boundary we need to maintain the
* the entire display surface in memory so that we can do the necessary bit
* operations. Fortunately it is a small display in monochrome.
* 64 * 132 / 8 = 1056 bytes.
*/
#define GDISP_SCREEN_BYTES ((GDISP_SCREEN_WIDTH * GDISP_SCREEN_HEIGHT) / 8)
#define GDISP_SCREEN_PAGE_SIZE 8
#define GDISP_SCREEN_PAGES GDISP_SCREEN_HEIGHT / GDISP_SCREEN_PAGE_SIZE
/*===========================================================================*/
/* Driver exported functions. */
/*===========================================================================*/
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
// The private area is the display surface.
if (!(g->priv = gfxAlloc(GDISP_SCREEN_BYTES)))
{
gfxHalt("GDISP UC1601s: Failed to allocate private memory");
}
memset(RAM(g), 0, GDISP_SCREEN_BYTES);
// Initialise the board interface
init_board(g);
// Hardware reset
setpin_reset(g, TRUE);
gfxSleepMilliseconds(5);
setpin_reset(g, FALSE);
acquire_bus(g);
write_cmd(g, UC1601s_RESET);
gfxSleepMilliseconds(10);
write_cmd2(g, UC1601s_SET_BIAS, (uint8_t)(((GDISP_INITIAL_CONTRAST << 8) - 1) / 100));
write_cmd(g, UC1601s_SET_EN | UC1601s_ENABLE);
// Finish Init
post_init_board(g);
// Release the bus
release_bus(g);
/* 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;
}
#if GDISP_HARDWARE_FLUSH
LLDSPEC void gdisp_lld_flush(GDisplay *g) {
// Don't flush if we don't need it.
if (!(g->flags & GDISP_FLG_NEEDFLUSH)) {
return;
}
acquire_bus(g);
for (int i = 0; i < GDISP_SCREEN_PAGES; ++i)
{
write_cmd3(g, UC1601s_SET_PAGE | i, UC1601s_SET_COL_L | (0 & 0x0f), UC1601s_SET_COL_H | ((0 >> 4) & 0x0f)); // Y, XL, XH
write_data(g, RAM(g) + (i * GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH);
}
release_bus(g);
g->flags &= ~GDISP_FLG_NEEDFLUSH;
}
#endif
#if GDISP_HARDWARE_DRAWPIXEL
LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
coord_t x, y;
#if GDISP_NEED_CONTROL
switch(g->g.Orientation) {
default:
case GDISP_ROTATE_0:
x = g->p.x;
y = g->p.y;
break;
case GDISP_ROTATE_90:
x = g->p.y;
y = g->g.Width - g->p.x - 1;
break;
case GDISP_ROTATE_180:
x = g->g.Width - g->p.x - 1;
y = g->g.Height - g->p.y - 1;
break;
case GDISP_ROTATE_270:
x = g->g.Height - g->p.y - 1;
y = g->p.x;
break;
}
#else
x = g->p.x;
y = g->p.y;
#endif
if (gdispColor2Native(g->p.color) != Black) {
RAM(g)[xyaddr(x, y)] |= xybit(y);
} else {
RAM(g)[xyaddr(x, y)] &= ~xybit(y);
}
g->flags |= GDISP_FLG_NEEDFLUSH;
}
#endif
#if GDISP_HARDWARE_PIXELREAD
LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
coord_t x, y;
switch(g->g.Orientation) {
default:
case GDISP_ROTATE_0:
x = g->p.x;
y = g->p.y;
break;
case GDISP_ROTATE_90:
x = g->p.y;
y = GDISP_SCREEN_HEIGHT-1 - g->p.x;
break;
case GDISP_ROTATE_180:
x = GDISP_SCREEN_WIDTH-1 - g->p.x;
y = GDISP_SCREEN_HEIGHT-1 - g->p.y;
break;
case GDISP_ROTATE_270:
x = GDISP_SCREEN_WIDTH-1 - g->p.y;
y = g->p.x;
break;
}
return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black;
}
#endif
#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:
case powerSleep:
case powerDeepSleep:
acquire_bus(g);
write_cmd(g, UC1601s_SET_EN);
release_bus(g);
break;
case powerOn:
acquire_bus(g);
write_cmd(g, UC1601s_SET_EN | UC1601s_ENABLE);
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:
case GDISP_ROTATE_180:
if (g->g.Orientation == GDISP_ROTATE_90 || g->g.Orientation == GDISP_ROTATE_270) {
coord_t tmp;
tmp = g->g.Width;
g->g.Width = g->g.Height;
g->g.Height = tmp;
}
break;
case GDISP_ROTATE_90:
case GDISP_ROTATE_270:
if (g->g.Orientation == GDISP_ROTATE_0 || g->g.Orientation == GDISP_ROTATE_180) {
coord_t tmp;
tmp = g->g.Width;
g->g.Width = g->g.Height;
g->g.Height = tmp;
}
break;
default:
return;
}
g->g.Orientation = (orientation_t)g->p.ptr;
return;
case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
set_backlight(g, (unsigned)g->p.ptr);
g->g.Backlight = (unsigned)g->p.ptr;
return;
case GDISP_CONTROL_CONTRAST:
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
acquire_bus(g);
write_cmd2(g, UC1601s_SET_BIAS, (uint8_t)(((((unsigned)g->p.ptr) << 8) - 1) / 100));
release_bus(g);
g->g.Contrast = (unsigned)g->p.ptr;
return;
}
}
#endif
#if GDISP_HARDWARE_FILLS
LLDSPEC void gdisp_lld_fill_area(GDisplay *g) {
g->flags |= GDISP_FLG_NEEDFLUSH;
}
#endif
#endif // GFX_USE_GDISP

31
drivers/gdisp/UC1601s/gdisp_lld_config.h
View File

@ -0,0 +1,31 @@
/*
* 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
#if GFX_USE_GDISP
/*===========================================================================*/
/* Driver hardware support. */
/*===========================================================================*/
#define GDISP_HARDWARE_FLUSH TRUE // This controller requires flushing
#define GDISP_HARDWARE_DRAWPIXEL TRUE
#define GDISP_HARDWARE_PIXELREAD TRUE
#define GDISP_HARDWARE_CONTROL TRUE
#define GDISP_HARDWARE_FILLS FALSE
#define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_MONO
// This controller supports a special gdispControl() to inverse the display.
// Pass a parameter of 1 for inverse and 0 for normal.
#define GDISP_CONTROL_INVERSE (GDISP_CONTROL_LLD+0)
#endif /* GFX_USE_GDISP */
#endif /* _GDISP_LLD_CONFIG_H */

1
drivers/gdisp/readme.txt
View File

@ -32,6 +32,7 @@ STM32LTDC - STM32 ART graphics STM32F4 and STM32F7 series CPU's
TestStub - NULL driver just to test compile
TLS8204 - Small monochrome LCD
UC8173 - E-Ink display driver
UC1601s - Small (64x132) monochrome LCD
QImage - Driver that allows rendering into a QImage object (of the Qt framework)
uGFXnet - Remote Network display (in drivers/multiple/uGFXnet directory)
Win32 - Microsoft Windows (in drivers/multiple/Win32 directory)

Write Preview
Loading…
Cancel
Save