treitmey
Joined: 23 Jan 2004
Posts: 1094
Location: Appleton,WI USA
|
| Epson SED1335 SED 1335 |
 Posted: Mon Nov 26, 2007 9:56 am |
 |
|
Found this grep'ing through my library. Use it if you wish. I am not supporting it tho. I don't know where it came from.
You may also want to try/test the generic graphics lcd driver found.
C:\Program Files\PICC\Drivers\GLCD.C
| Code: |
/////////////////////////////////////////////////////////////////////////
//// c:\program files\PICC\drivers\LCD_epson1335.c ////
//// This file contains drivers for using a Epson SED1335 controller ////
//// in parallel/8080(intel) mode. The SED1335 is 320 pixles across ////
//// and 240 pixels down. The driver treats the upper left pixel 0,0////
//// ////
//// glcd_init(mode) ////
//// * Must be called before any other function. ////
//// - mode can be ON or OFF to turn the LCD on or off ////
//// ////
//// glcd_pixel(x,y,color) ////
//// * Sets the pixel to the given color. ////
//// - color can be ON or OFF ////
//// ////
//// glcd_line(x1,y1,x2,y2,color) ////
//// * Draws a line from the first point to the second point ////
//// with the given color. ////
//// - color can be ON or OFF ////
//// ////
//// glcd_rect(x1,y1,x2,y2,fill,color) ////
//// * Draws a rectangle with upper left point (x1,y1) and lower ////
//// right point (x2,y2). ////
//// - fill can be YES or NO ////
//// - color can be ON or OFF ////
//// ////
//// glcd_bar(x1,y1,x2,y2,width,color) ////
//// * Draws a bar (wide line) from the first point to the ////
//// second point. ////
//// - width is the number of pixels wide ////
//// - color is ON or OFF ////
//// ////
//// glcd_circle(x,y,radius,fill,color) ////
//// * Draws a circle with center at (x,y) ////
//// - fill can be YES or NO ////
//// - color can be ON or OFF ////
//// ////
//// glcd_text57(x,y,textptr,size,color) ////
//// * Write the null terminated text pointed to by textptr with ////
//// the upper left coordinate of the first character at (x,y).////
//// Characters are 5 pixels wide and 7 pixels tall. ////
//// - size is an integer that scales the size of the text ////
//// - color is ON or OFF ////
//// * Note - The given text is character wrapped. If this ////
//// function is used on a different size display, then change ////
//// the GLCD_COL define appropriately. ////
//// ////
//// glcd_fillScreen(color) ////
//// * Fills the entire LCD with the given color. ////
//// - color can be ON or OFF ////
//// ////
/////////////////////////////////////////////////////////////////////////
#ifndef GLCD_COL
#define GLCD_COL 128 // Used for text wrapping by glcd_text57 function and sanity check
#endif
#ifndef GLCD_ROW
#define GLCD_ROW 64 // Used for text wrapping by glcd_text57 function and sanity check
#endif
#define ON 1
#define OFF 0
#define YES 1
#define NO 0
//LCD_CS VAR PORTA.1 'Chip select BAR
//LCD_RST VAR PORTA.2 'Reset BAR
//LCD_A0 VAR PORTA.3 '1=Data 0=Command
//LCD_WR VAR PORTA.4 '1=Read 0=Write
//LCD_RD VAR PORTA.5 'Enable
//LCD_DAT VAR PORTD 'Data Pin
struct lcd_pin_def
{
BOOLEAN unused0; // A0 unused
BOOLEAN cs_bar; // A1 Chip select active low
BOOLEAN reset_bar; // A2 Reset active low
BOOLEAN A0; // A3 Data/Instruction 1=data 0=Instruction
BOOLEAN w_bar; // A4 Write bar active low
BOOLEAN r_bar; // A5 Read bar active low
BOOLEAN unused1; // A6 Unused
BOOLEAN unused2; // A7 Unused
int unused3 : 8; // PortB... waisted some bits/bytes for clarity
int unused4 : 8; // PortC... waisted some bits/bytes for clarity
int data : 8; // PortD=Data bus
};
#define set_tris_lcd(x) set_tris_a(0);set_tris_B(0);set_tris_d(x)
struct lcd_pin_def LCD;
#byte LCD = 5 //note: no semicolin 5=A0 on a 16F877A
BYTE glcd_readByte();
BYTE glcd_readStat();
BOOLEAN glcd_pixel(unsigned int x,unsigned int y, int1 color);
void glcd_writeByte(BYTE chip, BYTE data);
void glcd_fillScreen(int1 color);
const BYTE TEXT[51][5] ={ 0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
0x00, 0x00, 0x5F, 0x00, 0x00, // !
0x00, 0x03, 0x00, 0x03, 0x00, // "
0x14, 0x3E, 0x14, 0x3E, 0x14, // #
0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
0x43, 0x33, 0x08, 0x66, 0x61, // %
0x36, 0x49, 0x55, 0x22, 0x50, // &
0x00, 0x05, 0x03, 0x00, 0x00, // '
0x00, 0x1C, 0x22, 0x41, 0x00, // (
0x00, 0x41, 0x22, 0x1C, 0x00, // )
0x14, 0x08, 0x3E, 0x08, 0x14, // *
0x08, 0x08, 0x3E, 0x08, 0x08, // +
0x00, 0x50, 0x30, 0x00, 0x00, // ,
0x08, 0x08, 0x08, 0x08, 0x08, // -
0x00, 0x60, 0x60, 0x00, 0x00, // .
0x20, 0x10, 0x08, 0x04, 0x02, // /
0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
0x04, 0x02, 0x7F, 0x00, 0x00, // 1
0x42, 0x61, 0x51, 0x49, 0x46, // 2
0x22, 0x41, 0x49, 0x49, 0x36, // 3
0x18, 0x14, 0x12, 0x7F, 0x10, // 4
0x27, 0x45, 0x45, 0x45, 0x39, // 5
0x3E, 0x49, 0x49, 0x49, 0x32, // 6
0x01, 0x01, 0x71, 0x09, 0x07, // 7
0x36, 0x49, 0x49, 0x49, 0x36, // 8
0x26, 0x49, 0x49, 0x49, 0x3E, // 9
0x00, 0x36, 0x36, 0x00, 0x00, // :
0x00, 0x56, 0x36, 0x00, 0x00, // ;
0x08, 0x14, 0x22, 0x41, 0x00, // <
0x14, 0x14, 0x14, 0x14, 0x14, // =
0x00, 0x41, 0x22, 0x14, 0x08, // >
0x02, 0x01, 0x51, 0x09, 0x06, // ?
0x3E, 0x41, 0x59, 0x55, 0x5E, // @
0x7E, 0x09, 0x09, 0x09, 0x7E, // A
0x7F, 0x49, 0x49, 0x49, 0x36, // B
0x3E, 0x41, 0x41, 0x41, 0x22, // C
0x7F, 0x41, 0x41, 0x41, 0x3E, // D
0x7F, 0x49, 0x49, 0x49, 0x41, // E
0x7F, 0x09, 0x09, 0x09, 0x01, // F
0x3E, 0x41, 0x41, 0x49, 0x3A, // G
0x7F, 0x08, 0x08, 0x08, 0x7F, // H
0x00, 0x41, 0x7F, 0x41, 0x00, // I
0x30, 0x40, 0x40, 0x40, 0x3F, // J
0x7F, 0x08, 0x14, 0x22, 0x41, // K
0x7F, 0x40, 0x40, 0x40, 0x40, // L
0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
0x7F, 0x02, 0x04, 0x08, 0x7F, // N
0x3E, 0x41, 0x41, 0x41, 0x3E, // O
0x7F, 0x09, 0x09, 0x09, 0x06, // P
0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
0x7F, 0x09, 0x09, 0x09, 0x76};// R
const BYTE TEXT2[44][5]={ 0x26, 0x49, 0x49, 0x49, 0x32, // S
0x01, 0x01, 0x7F, 0x01, 0x01, // T
0x3F, 0x40, 0x40, 0x40, 0x3F, // U
0x1F, 0x20, 0x40, 0x20, 0x1F, // V
0x7F, 0x20, 0x10, 0x20, 0x7F, // W
0x41, 0x22, 0x1C, 0x22, 0x41, // X
0x07, 0x08, 0x70, 0x08, 0x07, // Y
0x61, 0x51, 0x49, 0x45, 0x43, // Z
0x00, 0x7F, 0x41, 0x00, 0x00, // [
0x02, 0x04, 0x08, 0x10, 0x20, // \
0x00, 0x00, 0x41, 0x7F, 0x00, // ]
0x04, 0x02, 0x01, 0x02, 0x04, // ^
0x40, 0x40, 0x40, 0x40, 0x40, // _
0x00, 0x01, 0x02, 0x04, 0x00, // `
0x20, 0x54, 0x54, 0x54, 0x78, // a
0x7F, 0x44, 0x44, 0x44, 0x38, // b
0x38, 0x44, 0x44, 0x44, 0x44, // c
0x38, 0x44, 0x44, 0x44, 0x7F, // d
0x38, 0x54, 0x54, 0x54, 0x18, // e
0x04, 0x04, 0x7E, 0x05, 0x05, // f
0x08, 0x54, 0x54, 0x54, 0x3C, // g
0x7F, 0x08, 0x04, 0x04, 0x78, // h
0x00, 0x44, 0x7D, 0x40, 0x00, // i
0x20, 0x40, 0x44, 0x3D, 0x00, // j
0x7F, 0x10, 0x28, 0x44, 0x00, // k
0x00, 0x41, 0x7F, 0x40, 0x00, // l
0x7C, 0x04, 0x78, 0x04, 0x78, // m
0x7C, 0x08, 0x04, 0x04, 0x78, // n
0x38, 0x44, 0x44, 0x44, 0x38, // o
0x7C, 0x14, 0x14, 0x14, 0x08, // p
0x08, 0x14, 0x14, 0x14, 0x7C, // q
0x00, 0x7C, 0x08, 0x04, 0x04, // r
0x48, 0x54, 0x54, 0x54, 0x20, // s
0x04, 0x04, 0x3F, 0x44, 0x44, // t
0x3C, 0x40, 0x40, 0x20, 0x7C, // u
0x1C, 0x20, 0x40, 0x20, 0x1C, // v
0x3C, 0x40, 0x30, 0x40, 0x3C, // w
0x44, 0x28, 0x10, 0x28, 0x44, // x
0x0C, 0x50, 0x50, 0x50, 0x3C, // y
0x44, 0x64, 0x54, 0x4C, 0x44, // z
0x00, 0x08, 0x36, 0x41, 0x41, // {
0x00, 0x00, 0x7F, 0x00, 0x00, // |
0x41, 0x41, 0x36, 0x08, 0x00, // }
0x02, 0x01, 0x02, 0x04, 0x02};// ~
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Initialize a graphic LCD. This must be called before any
// other glcd function is used.
// Inputs: The initialization mode
// OFF - Turns the LCD off
// ON - Turns the LCD on
// Date: 5/28/2003
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_init(int1 mode)
{
char d1;
set_tris_lcd(0x00) ; //All outputs
LCD.cs_bar=1;
LCD.A0=0;LCD.r_bar=1;LCD.w_bar=1;
LCD.reset_bar=0; //reset state
LCD.reset_bar=1; //run state
glcd_writeByte(0, 0xE2 ); // ';reset display
glcd_writeByte(0, 0xA2 ); // ';lcd bias 1_9
glcd_writeByte(0, 0xA1 ); // ';normal
//glcd_writeByte(0, 0x $DI); // ';mirror image
glcd_writeByte(0, 0xC0 ); // ';common_output_normal upside dnw&mirror
glcd_writeByte(0, 0x27 ); // ';v5 resistor ratio 'perhaps $24
glcd_writeByte(0, 0x81 ); // ';electronic volume set
glcd_writeByte(0, 0x10 ); // ';electronic volume init
glcd_writeByte(0, 0x2F ); // ';power control
glcd_writeByte(0, 0x40 ); // ';start line set
glcd_writeByte(0, 0xB0 ); // ';page address set
glcd_writeByte(0, 0x10 ); // ';column address high
glcd_writeByte(0, 0x00 ); // ';column address low
glcd_writeByte(0, 0xAF ); // ';turn on display
glcd_writeByte(0, 0xA4 ); // ';NOT all on display (NORMAL)
glcd_writeByte(0, 0xA6 ); // ';normal video
//glcd_writeByte(0, 0x $A7); // ';reverse video
if (mode)
glcd_writeByte(0, 0xAF); // Turn the display ON
else
glcd_writeByte(0, 0xAE); // Turn the display OFF
d1 = glcd_readStat();
fprintf(debug,"LCD Status after init=%x\n\r",d1);
set_tris_lcd(0xFF) ; //Port D tristate
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Turn a pixel on a graphic LCD on or off
// Inputs: x - the x coordinate of the pixel
// y - the y coordinate of the pixel
// color - ON or OFF
// Output: 1 if coordinate out of range, 0 if in range
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
BOOLEAN glcd_pixel(unsigned int x,unsigned int y, int1 color)
{
BYTE data;
// fprintf(debug,"Pixel at %d,%d\n\r",x ,y);
// fprintf(debug,"Pixel at %U,%U ",x ,y);
if(x > GLCD_COL || x<0){return (1);} // Check for valid x
if(y > GLCD_ROW || y<0){return (1);} // Check for valid y
glcd_writeByte(0,(y>>3)+0xB0); // Set the page that is y/8 + 0xB0
glcd_writeByte(0,((x>>4)|0x10)); // Set the COL address, upper 4 bits
// fprintf(debug,"Upper=%x\n\r",(x>>4)|0x10);
glcd_writeByte(0,(x & 0xF)); // Set the COL address, lower 4 bits
// fprintf(debug," Lower=%x\n\r",(x & 0xF));
glcd_writeByte(0, 0xE0 ); // 'fctn 12 Read/Modify/Write,..ie:don't inc on a read
data = glcd_readByte();
glcd_writeByte(0, 0xEE ); // 'fctn 13 END..ie:Restart inc on a read
if(color == ON)
bit_set(data, y%8); // Turn the pixel data bit on or off
else
bit_clear(data, y%8);
glcd_writeByte(1, data); // Write new data back to LCD (this will inc ptr)
return (0);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Write a byte of data or instruction to LCD
// Inputs: DI - 1=data 0=Instruction
// data - the byte of data to write
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_writeByte(int1 DI, BYTE data)
{
// fprintf(debug,"write byte\n\r");
set_tris_lcd(0x00) ; //All outputs
LCD.A0=DI;//Data/Instruction
LCD.data=data;
LCD.cs_bar=0;//chip select
LCD.w_bar=0;//write
LCD.cs_bar=1;//chip select
LCD.w_bar=1;//write
set_tris_lcd(0xFF) ; //Port D tristate
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Reads a byte of data from the current location
// Ouputs: A byte of data read from the LCD
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
BYTE glcd_readByte()
{
BYTE data; // Stores the data read from the LCD
set_tris_lcd(0xFF) ; //Port D inputs
LCD.cs_bar=0; //Chip select
LCD.A0=1; //Data
LCD.r_bar=0; //Read (FALSE READ)
LCD.r_bar=1; //Release Read
LCD.r_bar=0; //Read Real READ
LCD.w_bar=1; //Read
data=LCD.data;
LCD.r_bar=1; //Release Read
LCD.cs_bar=1; //Chip deselect
set_tris_lcd(0xFF) ; //Port D tristate
return data; //Return the read data
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Reads status of LCD
// Ouputs: A byte of data read from the chip
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
BYTE glcd_readStat()
{
BYTE data; // Stores the data read from the LCD
set_tris_lcd(0xFF) ; // Port D inputs
LCD.cs_bar=0; //Chip select
LCD.A0=0; //Instruction
LCD.r_bar=0; //Read
LCD.w_bar=1; //Read
data=LCD.data;
LCD.r_bar=1; //Release Read
LCD.cs_bar=1; //Chip deselect
set_tris_lcd(0xFF) ; //Port D tristate
return (data>>4); //Return status
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Draw a line on a graphic LCD using Bresenham's
// line drawing algorithm
// Inputs: (x1, y1) - the start coordinate
// (x2, y2) - the end coordinate
// color - ON or OFF
// Dependencies: glcd_pixel()
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_line(int x1, int y1, int x2, int y2, int1 color)
{
signed int x, y, addx, addy, dx, dy;
signed long P;
int i;
dx = abs((signed int)(x2 - x1));
dy = abs((signed int)(y2 - y1));
x = x1;
y = y1;
if(x1 > x2)
addx = -1;
else
addx = 1;
if(y1 > y2)
addy = -1;
else
addy = 1;
if(dx >= dy)
{
P = 2*dy - dx;
for(i=0; i<=dx; ++i)
{
glcd_pixel(x, y, color);
if(P < 0)
{
P += 2*dy;
x += addx;
}
else
{
P += 2*dy - 2*dx;
x += addx;
y += addy;
}
}
}
else
{
P = 2*dx - dy;
for(i=0; i<=dy; ++i)
{
glcd_pixel(x, y, color);
if(P < 0)
{
P += 2*dx;
y += addy;
}
else
{
P += 2*dx - 2*dy;
x += addx;
y += addy;
}
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Draw a rectangle on a graphic LCD
// Inputs: (x1, y1) - the start coordinate
// (x2, y2) - the end coordinate
// fill - YES or NO
// color - ON or OFF
// Dependencies: glcd_pixel(), glcd_line()
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_rect(int x1, int y1, int x2, int y2, int fill, int1 color)
{
if(fill)
{
int y, ymax; // Find the y min and max
if(y1 < y2)
{
y = y1;
ymax = y2;
}
else
{
y = y2;
ymax = y1;
}
for(; y<=ymax; ++y) // Draw lines to fill the rectangle
glcd_line(x1, y, x2, y, color);
}
else
{
glcd_line(x1, y1, x2, y1, color); // Draw the 4 sides
glcd_line(x1, y2, x2, y2, color);
glcd_line(x1, y1, x1, y2, color);
glcd_line(x2, y1, x2, y2, color);
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Draw a bar (wide line) on a graphic LCD
// Inputs: (x1, y1) - the start coordinate
// (x2, y2) - the end coordinate
// width - The number of pixels wide
// color - ON or OFF
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_bar(int x1, int y1, int x2, int y2, int width, int1 color)
{
signed int x, y, addx, addy, j;
signed long P, dx, dy, c1, c2;
int i;
dx = abs((signed int)(x2 - x1));
dy = abs((signed int)(y2 - y1));
x = x1;
y = y1;
c1 = -dx*x1 - dy*y1;
c2 = -dx*x2 - dy*y2;
if(x1 > x2)
{
addx = -1;
c1 = -dx*x2 - dy*y2;
c2 = -dx*x1 - dy*y1;
}
else
addx = 1;
if(y1 > y2)
{
addy = -1;
c1 = -dx*x2 - dy*y2;
c2 = -dx*x1 - dy*y1;
}
else
addy = 1;
if(dx >= dy)
{
P = 2*dy - dx;
for(i=0; i<=dx; ++i)
{
for(j=-(width/2); j<width/2+width%2; ++j)
{
if(dx*x+dy*(y+j)+c1 >= 0 && dx*x+dy*(y+j)+c2 <=0)
glcd_pixel(x, y+j, color);
}
if(P < 0)
{
P += 2*dy;
x += addx;
}
else
{
P += 2*dy - 2*dx;
x += addx;
y += addy;
}
}
}
else
{
P = 2*dx - dy;
for(i=0; i<=dy; ++i)
{
if(P < 0)
{
P += 2*dx;
y += addy;
}
else
{
P += 2*dx - 2*dy;
x += addx;
y += addy;
}
for(j=-(width/2); j<width/2+width%2; ++j)
{
if(dx*x+dy*(y+j)+c1 >= 0 && dx*x+dy*(y+j)+c2 <=0)
glcd_pixel(x+j, y, color);
}
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Draw a circle on a graphic LCD
// Inputs: (x,y) - the center of the circle
// radius - the radius of the circle
// fill - YES or NO
// color - ON or OFF
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_circle(int x, int y, int radius, int1 fill, int1 color)
{
signed int a, b, P;
a = 0;
b = radius;
P = 1 - radius;
do
{
if(fill)
{
glcd_line(x-a, y+b, x+a, y+b, color);
glcd_line(x-a, y-b, x+a, y-b, color);
glcd_line(x-b, y+a, x+b, y+a, color);
glcd_line(x-b, y-a, x+b, y-a, color);
}
else
{
glcd_pixel(a+x, b+y, color);
glcd_pixel(b+x, a+y, color);
glcd_pixel(x-a, b+y, color);
glcd_pixel(x-b, a+y, color);
glcd_pixel(b+x, y-a, color);
glcd_pixel(a+x, y-b, color);
glcd_pixel(x-a, y-b, color);
glcd_pixel(x-b, y-a, color);
}
if(P < 0)
P+= 3 + 2*a++;
else
P+= 5 + 2*(a++ - b--);
} while(a <= b);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Write text on a graphic LCD
// Inputs: (x,y) - The upper left coordinate of the first letter
// textptr - A pointer to an array of text to display
// size - The size of the text: 1 = 5x7, 2 = 10x14, ...
// color - ON or OFF
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_text57(int x, int y, char* textptr, int size, int1 color)
{
int i, j, k, l, m; // Loop counters
BYTE pixelData[5]; // Stores character data
for(i=0; textptr[i] != '\0'; ++i, ++x) // Loop through the passed string
{
if(textptr[i] < 'S') // Checks if the letter is in the first or second array
memcpy(pixelData, TEXT[textptr[i]-' '], 5);
else if(textptr[i] <= '~') // Check if the letter is in the second array
memcpy(pixelData, TEXT2[textptr[i]-'S'], 5);
else
memcpy(pixelData, TEXT[0], 5); // Default to space
if(x+5*size >= GLCD_COL) // Performs character wrapping
{
x = 0; // Set x at far left position
y += 7*size + 1; // Set y at next position down
}
for(j=0; j<5; ++j, x+=size) // 5 bytes per character
{
for(k=0; k<7*size; ++k) // Loop through the vertical pixels
{
if(bit_test(pixelData[j], k)) // Check if the pixel should be set
{
for(l=0; l<size; ++l) // The next two loops change the
{ // character's size
for(m=0; m<size; ++m)
{
glcd_pixel(x+m, y+k*size+l, color); // Draws the pixel
}
}
}
}
}
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose: Fill the LCD screen with the passed in color.
// Works much faster than drawing a rectangle to fill the screen
// Inputs: ON - turn all the pixels on
// OFF - turn all the pixels off
// Dependencies: glcd_writeByte()
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_fillScreen(int1 color)
{
int line_num, column;
// Loop through the lines
fprintf(debug,"Fill screen with %d\n\r",color);
for(line_num = 0; line_num < 8; ++line_num)
{
glcd_writeByte(0, 0xB0+line_num);
glcd_writeByte(0, 0x10);
glcd_writeByte(0, 0x00);
// Loop through the horline_numzontal sectline_numons
for(column = 0; column < 128; ++column)
{
glcd_writeByte(1, 0xFF*color); // Turn all pixels on or off
}
}
}
|
|
|
FAQ 
Search
Register
Profile 
Log in to check your private messages 
Log in
