CCS C Software and Maintenance Offers
FAQFAQ   FAQForum Help   FAQOfficial CCS Support   SearchSearch  RegisterRegister 

ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

CCS does not monitor this forum on a regular basis.

Please do not post bug Reports on this forum. Send them to support@ccsinfo.com

Nokia 1100 lcd driver with graphics functions, big font size

 
Post new topic   Reply to topic    CCS Forum Index -> Code Library
View previous topic :: View next topic  
Author Message
lazuribicci



Joined: 06 Feb 2010
Posts: 10

View user's profile Send private message

Nokia 1100 lcd driver with graphics functions, big font size
PostPosted: Thu May 05, 2011 6:46 am     Reply with quote

This driver is for nokia lcd with PCF8814 controller for example 1100, 1110i... etc.

As you can see on picture, you can plot a line, circle, rectangle
and fill in these graphics.
you can also use different font size

one of the advantages of the driver is very similar with 128*64 GLCD with HDM64GS12 controller

besides, the disadvantage of this, the driver file uses a lot of ram about 775 bytes
enjoy it Smile

Best Regards,

Fatih GENC



Code:
//////////////////////
///    lcd1100.c
///
///    by Fatih GENC
///    fatihgenc81@hotmail.com
///    5/5/2011
//////////////////////

#define sclk   PIN_B4
#define sda    PIN_B5
#define cs     PIN_B6
#define rst    PIN_B7

#define CMD      0
#define DATA   1

#define lcd_WIDTH   96

#ifndef ON
#define ON           1
#endif

#ifndef OFF
#define OFF          0
#endif

void Lcd_Clear(void);
void Lcd_Init(void);
void Lcd_Write(int1 cd,unsigned char c);
void Gotoxy(char x,char y);
void lcd_pixel(unsigned char x,unsigned char y, int1 color);
void lcd_line(int8 x1, int8 y1, int8 x2, int8 y2, int1 color);
void lcd_circle(int8 x, int8 y, int8 radius, int1 fill, int1 color);
void lcd_text57(int8 x, int8 y, char* textptr, int8 size, int1 color);
void lcd_rect(int8 x1, int8 y1, int8 x2, int8 y2, int1 fill, int1 color);


static int8 memory[96][8]; //LCD memory data
static int8 XX,YY;


// lookup table, here you can modify the font
const int8 FONT[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
                         0x00, 0x04, 0x02, 0x7F, 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 int8 FONT2[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, // ]
                         0x00, 0x07, 0x05, 0x07, 0x00, // ° (degree)
                         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};// ~
/////////////////////////////////////////////////////////////////////////


// clear LCD
void Lcd_Clear(void){
unsigned int i;
Lcd_Write(CMD,0x40); // Y = 0
Lcd_Write(CMD,0xb0);
Lcd_Write(CMD,0x10); // X = 0
Lcd_Write(CMD,0x0);
Lcd_Write(CMD,0xae); // disable display;
for(i=0;i<255;i++)
Lcd_Write(DATA,0x00);
for(i=0;i<255;i++)
Lcd_Write(DATA,0x00);
for(i=0;i<255;i++)
Lcd_Write(DATA,0x00);
for(i=0;i<99;i++)
Lcd_Write(DATA,0x00);
Lcd_Write(CMD,0xaf); // enable display;
}

// Purpose:       Initialize the LCD.
//                Call before using any other LCD function.
void Lcd_Init(void){
output_low(cs);
output_low(rst);
delay_ms(5);         // 5mS so says the stop watch(less than 5ms will not work)
output_high(rst);
Lcd_Write(CMD,0x20); // write VOP register
Lcd_Write(CMD,0x90);
Lcd_Write(CMD,0xA4); // all on/normal display
Lcd_Write(CMD,0x2F); // Power control set(charge pump on/off)
Lcd_Write(CMD,0x40); // set start row address = 0
Lcd_Write(CMD,0xb0); // set Y-address = 0
Lcd_Write(CMD,0x10); // set X-address, upper 3 bits
Lcd_Write(CMD,0x0);  // set X-address, lower 4 bits
Lcd_Write(CMD,0xC8); // mirror Y axis (about X axis)
Lcd_Write(CMD,0xa1); // Invert screen in horizontal axis
Lcd_Write(CMD,0xac); // set initial row (R0) of the display
Lcd_Write(CMD,0x07);
//Lcd_Write(CMD,0xF9); //
Lcd_Write(CMD,0xaf); // display ON/OFF

Lcd_Clear(); // clear LCD
Lcd_Write(CMD,0xa7); // invert display
delay_ms(100);       
Lcd_Write(CMD,0xa6); // normal display (non inverted)
delay_ms(100);           
}

// Purpose:    Write a byte of data to lcd
// Inputs:     c - the byte of data to write
void Lcd_Write(int1 cd,unsigned char c){
int i;
   output_low(cs);
   output_low(sclk);
   output_bit(sda,cd);
   output_high(sclk);

if(cd==DATA)
   {
   memory[XX][YY]= c; //write data to memory
   XX++;
   }

for(i=0;i<8;i++){
      output_low(sclk);
         if((c & 0x80))
            output_high(sda);
         else
            output_low(sda);
      output_high(sclk);
      c <<= 1;
     delay_us(10);
            }
     output_high(cs);
     

 }

void Gotoxy(char x,char y){
      Lcd_Write(CMD,(0xB0|(y&0x0F)));       // Y axis initialisation: 0100 yyyy         
      Lcd_Write(CMD,(0x00|(x&0x0F)));       // X axis initialisation: 0000 xxxx ( x3 x2 x1 x0)
      Lcd_Write(CMD,(0x10|((x>>4)&0x07))); // X axis initialisation: 0010 0xxx  ( x6 x5 x4)

}

// Purpose:    Turn a pixel on a graphic LCD on or off
// Inputs:     1) x - the x coordinate of the pixel
//             2) y - the y coordinate of the pixel
//             3) color - ON or OFF
void lcd_pixel(unsigned char x,unsigned char y, int1 color){
   char aux[8];
   char i,o;
   char c=1;
   char index;
   int8 temp;
   
   XX=x;
   YY=y/8;

      Gotoxy(x,YY);           
      temp=memory[x][YY];
     
      if(color == ON)
         bit_set(temp, y%8);        // Turn the pixel on
         else                          // or
         bit_clear(temp, y%8);      // turn the pixel off
     
      Lcd_Write(DATA,temp);   
}

/////////////////////////////////////////////////////////////////////////
// Purpose:       Draw a line on a nokia 1100 LCD
//                line drawing algorithm
// Inputs:        (x1, y1) - the start coordinate
//                (x2, y2) - the end coordinate
//                color - ON or OFF
// Dependencies:  glcd_pixel()
/////////////////////////////////////////////////////////////////////////
void lcd_line(int8 x1, int8 y1, int8 x2, int8 y2, int1 color)
{
   int16        dy, dx;
   signed int8  addx=1, addy=1;
   signed int16 P, diff;

   int8 i=0;
   dx = abs((signed int8)(x2 - x1));
   dy = abs((signed int8)(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)
      {
         lcd_pixel(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)
      {
         lcd_pixel(x1, y1, color);

         if(P < 0)
         {
            P  += dx;
            y1 += addy;
         }
         else
         {
            P  += diff;
            x1 += addx;
            y1 += addy;
         }
      }
   }
}

/////////////////////////////////////////////////////////////////////////
// Purpose:       Draw a circle on a nokia 1100 LCD
// Inputs:        (x,y) - the center of the circle
//                radius - the radius of the circle
//                fill - YES or NO
//                color - ON or OFF
/////////////////////////////////////////////////////////////////////////
void lcd_circle(int8 x, int8 y, int8 radius, int1 fill, int1 color)
{
signed int8  a, b, P;

   a = 0;
   b = radius;
   P = 1 - radius;

   do
   {
      if(fill)
      {
         lcd_line(x-a, y+b, x+a, y+b, color);
         lcd_line(x-a, y-b, x+a, y-b, color);
         lcd_line(x-b, y+a, x+b, y+a, color);
         lcd_line(x-b, y-a, x+b, y-a, color);
      }
      else
      {
         lcd_pixel(a+x, b+y, color);
         lcd_pixel(b+x, a+y, color);
         lcd_pixel(x-a, b+y, color);
         lcd_pixel(x-b, a+y, color);
         lcd_pixel(b+x, y-a, color);
         lcd_pixel(a+x, y-b, color);
         lcd_pixel(x-a, y-b, color);
         lcd_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 nokia 1100 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 lcd_text57(int8 x, int8 y, char* textptr, int8 size, int1 color)
{
   int8 j, k, l, m;                       // Loop counters
   int8 pixelData[5];                     // Stores character data

   for(; *textptr != '\0'; ++textptr, ++x)// Loop through the passed string
   {
      if(*textptr < 'S') // Checks if the letter is in the first font array
         memcpy(pixelData, FONT[*textptr - ' '], 5);
      else if(*textptr <= '~') // Check if the letter is in the second font array
         memcpy(pixelData, FONT2[*textptr - 'S'], 5);
      else
         memcpy(pixelData, FONT[0], 5);   // Default to space

      // Handles newline and carriage returns
      switch(*textptr)
      {
         case '\n':
            y += 7*size + 1;
            continue;
         case '\r':
            x = 0;
            continue;
      }

      if(x+5*size >= lcd_WIDTH)          // 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)         // Loop through character byte data
      {
         for(k=0; k < 7; ++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)    // These two loops change the
               {                          // character's size
                  for(m=0; m < size; ++m)
                  {
                     lcd_pixel(x+m, y+k*size+l, color); // Draws the pixel
                  }
               }
            }
         }
      }
   }
}

/////////////////////////////////////////////////////////////////////////
// Purpose:       Draw a rectangle on a nokia 1100 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 lcd_rect(int8 x1, int8 y1, int8 x2, int8 y2, int1 fill, int1 color)
{
   if(fill)
   {
     
      int8  i, xmin, xmax, ymin, ymax;

      if(x1 < x2)                            //  Find x min and max
      {
         xmin = x1;
         xmax = x2;
      }
      else
      {
         xmin = x2;
         xmax = x1;
      }

      if(y1 < y2)                            // Find the y min and max
      {
         ymin = y1;
         ymax = y2;
      }
      else
      {
         ymin = y2;
         ymax = y1;
      }

      for(; xmin <= xmax; ++xmin)
      {
         for(i=ymin; i<=ymax; ++i)
         {
            lcd_pixel(xmin, i, color);
         }
      }
   }
   else
   {
      lcd_line(x1, y1, x2, y1, color);      // Draw the 4 sides
      lcd_line(x1, y2, x2, y2, color);
      lcd_line(x1, y1, x1, y2, color);
      lcd_line(x2, y1, x2, y2, color);
   }
}


test file

Code:


//test.c

#include <18f2620.h>
#fuses H4,NOWDT,NOLVP,NOPROTECT
#use delay(clock=40000000)

#include "lcd1100.c"

int8 i;
char c[]="TEST";

void main (void) {
   

    Lcd_Init();
   
 lcd_circle(76, 38, 10, 0, 1);

 lcd_line(95, 0, 0, 64, 1);
 
 lcd_text57(10, 15, c, 1, 1);
 
 lcd_text57(10, 25, c, 2, 1);
 
 lcd_rect(60, 50, 92, 60, 1, 1);
 
 lcd_text57(65, 52, c, 1, 0);
 
while(1);
 }
Display posts from previous:   
Post new topic   Reply to topic    CCS Forum Index -> Code Library All times are GMT - 6 Hours
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2005 phpBB Group