lcd159a.c

lpc2478+ucosII+ucgui源码

/*
*********************************************************************************************************
*                                                uC/GUI
*                        Universal graphic software for embedded applications
*
*                       (c) Copyright 2002, Micrium Inc., Weston, FL
*                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
*
*              礐/GUI is protected by international copyright laws. Knowledge of the
*              source code may not be used to write a similar product. This file may
*              only be used in accordance with a license and should not be redistributed
*              in any way. We appreciate your understanding and fairness.
*
----------------------------------------------------------------------
File        : LCD159A.C
Purpose     : Driver for LCDs using a Seiko Epson SED159A controller
----------------------------------------------------------------------   
Version-Date---Author-Explanation                                        
----------------------------------------------------------------------   
1.00b   020204 JE     a) Hardwareinterface routines renamed:
                         ...DATA -> ...A1, ...CMD -> ...A0
1.00a   010926 JE     a) Support for LCD_SWAPXY added
1.00.00 010710 JE     a) Speed optimizations added
0.90.00 010709 JE     a) First release
---------------------------LIST OF CONFIG SWITCHES--------------------
The following is a list of additional configuration switches for this
driver. These switches might not be listed in the manual, because
the manual mainly covers the general config switches which are
supported by all drivers.
----------------------------------------------------------------------
define ----------------------Explanation------------------------------
LCD_OPTIMIZE                 Controls the use of optimized routines.
                             If 1, several (speed) optimizations are used.
                             Default: ON (1)
----------------------------------------------------------------------
Known problems or limitations with current version
----------------------------------------------------------------------
a) Cache not supported yet, becuse RAM requirement would be 
   to large. LCD_CACHE must be set to 0
----------------------------------------------------------------------
Open issues
----------------------------------------------------------------------
none
---------------------------END-OF-HEADER------------------------------
*/

#include <string.h>             /* for memset */
#include <stddef.h>           /* needed for definition of NULL */
#include "LCD_Private.h"      /* private modul definitions & config */
#include "GUI_Private.h"
#include "GUIDebug.h"
#include "LCD_0.h"            /* Defines for first display */

#if      (LCD_CONTROLLER == 0x159A) \
      && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))


/*
        *********************************************************
        *
        *           Defaults for config switches
        *
        *********************************************************

*/

#ifndef LCD_OPTIMIZE
  #define LCD_OPTIMIZE                (1)
#endif

#ifndef LCD_CACHE
  #define  LCD_CACHE                  (0)
#endif

/*
        *********************************************************
        *
        *           Defines for simulation
        *
        *********************************************************
*/

#ifdef WIN32
  #undef LCD_WRITE_A0
  #undef LCD_WRITE_A1
  #undef LCD_READ_A0
  #undef LCD_READ_A1
  void SIM_WriteA1C0(U8 Byte);
  void SIM_WriteA0C0(U8 Byte);
  U8   SIM_ReadA1C0(void);
  U8   SIM_ReadA0C0(void);
  #define LCD_WRITE_A1(Byte) SIM_WriteA1C0(Byte) 
  #define LCD_WRITE_A0(Byte) SIM_WriteA0C0(Byte)
  #define LCD_READ_A1(Byte)  Byte = SIM_ReadA1C0()
  #define LCD_READ_A0(Byte)  Byte = SIM_ReadA0C0()
#endif

/*
        *********************************************************
        *
        *          Remap ...A0, ...A1 -> ...CMD, ...DATA
        *
        *********************************************************
*/

#define LCD_READCMD0    LCD_READ_A0
#define LCD_READDATA0   LCD_READ_A1
#define LCD_WRITECMD0   LCD_WRITE_A0
#define LCD_WRITEDATA0  LCD_WRITE_A1

/*
        *********************************************************
        *
        *           Macro calculations
        *
        *********************************************************
*/

/*
        *********************************************************
        *
        *           Configuration switch checking
        *
        *********************************************************
*/

#if (LCD_BITSPERPIXEL != 8)
  #error This controller can handle only 8bpp displays
#endif

/*
        *********************************************************
        *
        *           Macros, standard
        *
        *********************************************************

These macros can be found in any LCD-driver as they serve purposes
that can be found in any class of LCD-driver (Like clipping).

*/

#if (!LCD_SWAP_XY) && (!LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) x, y
#elif (!LCD_SWAP_XY) && (!LCD_MIRROR_X) && (LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) x, LCD_YSIZE_PHYS - 1 - (y)
#elif (!LCD_SWAP_XY) && (LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) LCD_XSIZE_PHYS - 1 - (x), y
#elif (!LCD_SWAP_XY) && (LCD_MIRROR_X) && (LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) LCD_XSIZE_PHYS - 1 - (x), LCD_YSIZE_PHYS - 1 - (y)
#elif (LCD_SWAP_XY) && (!LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) y, x
#elif (LCD_SWAP_XY) && (LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) y, LCD_XSIZE - 1 - (x)
#elif (LCD_SWAP_XY) && (!LCD_MIRROR_X) && (LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) LCD_YSIZE - 1 - (y), x
#elif (LCD_SWAP_XY) && (LCD_MIRROR_X) && (LCD_MIRROR_Y)
  #define LOG2PHYS(x, y) LCD_YSIZE - 1 - (y), LCD_XSIZE - 1 - (x)
#else
  #error unsupported configuration
#endif

#define BKCOLOR LCD_BKCOLORINDEX
#define   COLOR LCD_COLORINDEX

/*
        *********************************************************
        *
        *           Static variables for driver
        *
        *********************************************************
*/

#if LCD_CACHE
  static U8 VRam[LCD_YSIZE_PHYS][LCD_XSIZE_PHYS];
#endif

static int CurrentX, CurrentY, StartPage, StartColumn, RAM_Mode;

/*
        *********************************************************
        *
        *           Hardware access
        *
        *********************************************************
*/

/*
        *****************************************
        *
        *           Low level macros
        *
        *****************************************
*/

#define RAM_WRITE (0x5c)
#define RAM_READ  (0x5d)

#define INCREMENT_CURSOR() \
  CurrentX++; \
  if (CurrentX >= LCD_XSIZE_PHYS) { \
    CurrentX = StartColumn; \
    CurrentY++; \
    if (CurrentY >= LCD_YSIZE_PHYS) \
      CurrentY = StartPage; \
  }

#define RESET_CURSOR() \
  CurrentX = StartColumn; \
  CurrentY = StartPage

#define SET_RAMMODE(Mode) \
  RAM_Mode = Mode; \
  LCD_WRITECMD0 (Mode); \
  RESET_CURSOR()

#define PASET(y) \
  RAM_Mode = 0; \
  LCD_WRITECMD0 (0x75); \
  LCD_WRITEDATA0(y); \
  LCD_WRITEDATA0(LCD_YSIZE_PHYS - 1); \
  StartPage = y
  
#define CASET(x) \
  RAM_Mode = 0; \
  LCD_WRITECMD0 (0x15); \
  LCD_WRITEDATA0(x); \
  LCD_WRITEDATA0(LCD_XSIZE_PHYS - 1); \
  StartColumn = x

#define LCD_ON() \
  LCD_WRITECMD0 (0xaf); \
  SET_RAMMODE(RAM_WRITE)

#define LCD_OFF() \
  LCD_WRITECMD0 (0xae); \
  SET_RAMMODE(RAM_WRITE)

#define DUMMYREAD(Data) \
  LCD_READDATA0(Data)

#if (LCD_OPTIMIZE)
  
  #define SET_RECT(x1, y1, x2, y2) \
    CurrentX = CurrentY = 0xfff; \
    LCD_WRITECMD0 (0x15); \
    LCD_WRITEDATA0(x1); \
    LCD_WRITEDATA0(x2); \
    LCD_WRITECMD0 (0x75); \
    LCD_WRITEDATA0(y1); \
    LCD_WRITEDATA0(y2); \
    LCD_WRITECMD0 (0x5c)

  #define WRITEDATA_DIRECT(Data) \
    LCD_WRITEDATA0(Data)

#endif

#if LCD_CACHE

  #define WRITEDATA(Data) \
    if (VRam[CurrentX][CurrentY] != Data) { \
      VRam[CurrentX][CurrentY] = Data; \
      LCD_WRITEDATA0(Data); \
    } \
    INCREMENT_CURSOR()

  #define READDATA(Data) \
    Data = VRam[CurrentX][CurrentY]

#else

  #define WRITEDATA(Data) \
    LCD_WRITEDATA0(Data); \
    INCREMENT_CURSOR()

  #define READDATA(Data) \
    LCD_READDATA0(Data); \
    INCREMENT_CURSOR()

#endif

/*
        *****************************************
        *
        *           GotoXY
        *
        *****************************************
*/

void GotoXY(int x, int y, int Mode) {
  if ((CurrentX != x) || (CurrentY != y)) {
    CASET(x);
    PASET(y);
  }
  if (RAM_Mode != Mode) {
    SET_RAMMODE(Mode);
  }
}

#define GOTOXY(x, y, Mode) GotoXY(x, y, Mode)

/*
        *********************************************************
        *
        *           Drawing routines, internal
        *
        *********************************************************
*/

/*
        *****************************************
        *
        *           SET pixel
        *
        *****************************************
*/

static void SetPixel(int x, int y, U8 Color) {
  GOTOXY(x, y, RAM_WRITE);
  WRITEDATA(Color);
}

/*
        *****************************************
        *
        *           GET pixel
        *
        *****************************************
*/

static U8 GetPixel(int x, int y) {
  U8 Color;
  CASET(x);
  PASET(y);
  SET_RAMMODE(RAM_READ);
  DUMMYREAD(Color);
  READDATA(Color);
  return Color;
}

/*
        *****************************************
        *
        *           XOR pixel
        *
        *****************************************
*/

static void XorPixel(int x, int y) {
  U8 Color = GetPixel(x, y);
  Color ^= 0xff;
  SET_RAMMODE(RAM_WRITE);
  WRITEDATA(Color);
}

/*
        *********************************************************
        *
        *           Access macros for pixel access
        *
        *********************************************************

Use only this macros for pixel access

*/

#define XORPIXEL(x, y) \
  XorPixel(LOG2PHYS(x, y));

#define SETPIXEL(x, y, Color) \
  SetPixel(LOG2PHYS(x, y), Color);

#define GETPIXEL(x, y, Color) \
  Color = GetPixel(LOG2PHYS(x, y));

/*
        *********************************************************
        *
        *           Exported routines
        *
        *********************************************************
*/

/*
        *****************************************
        *
        *           LCD_L0_XorPixel
        *
        *****************************************

Purpose:  This routine is called by emWin. It writes 1 pixel into the
          display.

*/

void LCD_L0_XorPixel(int x, int y) {
  XORPIXEL(x, y);
}

/*
        *****************************************
        *
        *           LCD_L0_SetPixelIndex
        *
        *****************************************

Purpose:  This routine is called by emWin. It writes 1 pixel into the
          display.

*/

void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  SETPIXEL(x, y, ColorIndex);
}

/*
        *****************************************
        *
        *           LCD_L0_GetPixelIndex
        *
        *****************************************
*/

unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  U8 ColorIndex;
  GETPIXEL(x, y, ColorIndex);
  return ColorIndex;
}

/*
        *****************************************
        *
        *           LCD_L0_DrawPixel
        *
        *****************************************
*/

void LCD_L0_DrawPixel(int x, int y) {
  SETPIXEL(x, y, COLOR);
}

/*
        ****************************************
        *
        *           LCD_DrawHLine
        *
        ****************************************
*/

#if  (LCD_OPTIMIZE)  \
  && (!LCD_MIRROR_X) \
  && (!LCD_MIRROR_Y) \
  && (!LCD_SWAP_XY)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (x0 <= x1) {
      XORPIXEL(x0, y);
      x0++;
    }
  } else {
    SET_RECT(x0, y, x1, y);
    while (x0++ <= x1) {
      WRITEDATA_DIRECT(COLOR);
    }
  }
}

#else

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (x0 <= x1) {
      XORPIXEL(x0, y);
      x0++;
    }
  } else {
    while (x0 <= x1) {
      SETPIXEL(x0, y, COLOR);
      x0++;
    }
  }
}

#endif

/*
        ****************************************
        *
        *           LCD_DrawVLine
        *
        ****************************************
*/

#if  (LCD_OPTIMIZE)  \
  && (!LCD_MIRROR_X) \
  && (!LCD_MIRROR_Y) \
  && (!LCD_SWAP_XY)

void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (y0 <= y1) {
      XORPIXEL(x, y0);
      y0++;
    }
  } else {
    SET_RECT(x, y0, x, y1);