KS0108 entegreli glcd yi 3.3 v ile sürme.

[yamak]

GLCD PGM12864A
Kodlar da:
main.c

include <lpc17xx.h>
#include <lpc_glcd.h>
#include <stdio.h>
void pll_hazirla(void)
{
	LPC_SC->SCS=0x20;
	LPC_SC->CLKSRCSEL=0x01;
	LPC_SC->CCLKCFG=0x71;
	LPC_SC->PLL0CON=0x01;
	LPC_SC->PLL0CFG=0xb;
	LPC_SC->PLL0FEED=0xAA;
        LPC_SC->PLL0FEED=0x55;
	while(!(LPC_SC->PLL0STAT&(1<<26)));
	LPC_SC->PLL0CON=0x07;
	LPC_SC->PLL0FEED=0xAA;
        LPC_SC->PLL0FEED=0x55;
	LPC_SC->PCLKSEL0=0;
}
int main(void)
{
	  int i=1;
	  pll_hazirla();
	  LPC_GPIO2->FIODIR=0xFF;
	  LPC_GPIO2->FIOCLR=0xFF;
	  LPC_GPIO1->FIODIR=1<<19|1<<20|1<<21|1<<22|1<<23|1<<24;
	  LPC_GPIO1->FIOCLR=1<<19|1<<20|1<<21|1<<22|1<<23|1<<24;	
	  glcd_init();
          glcd_circle(20,20,10,1,1);
	  while(1)
	  {

		
	  }
}
 }

glcd.c:

#include <lpc17xx.h>
#include <delay.h>
#include <lpc_glcd.h>
#include <string.h>

const unsigned char 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 unsigned char 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};// ~

void glcd_init(void)
{

   GLCD_RST(1);
   GLCD_EC(1);
   GLCD_CS1C(1);
   GLCD_CS2C(1);

   GLCD_DIC(1);                     
   glcd_writeByte(1, 0xC0);   
   glcd_writeByte(0, 0xC0);   
   glcd_writeByte(1, 0x40);   
   glcd_writeByte(0, 0x40);
   glcd_writeByte(1, 0xB8); 
   glcd_writeByte(0, 0xB8);
   
   glcd_writeByte(1, 0x3F);
   glcd_writeByte(0, 0x3F);

   glcd_fillScreen(0);         
}

void glcd_pixel(int x, int y, int color)
{
   int data;
   int chip = 1; 

   if(x > 63) 
   {
      x -= 64;
      chip = 0;
   }

   GLCD_DIC(1);                               
   x= x&0x7F;                                          
   x= x|0x40;                                          
   glcd_writeByte(chip, x);                             
   glcd_writeByte(chip, (y/8 & 0xBF) | 0xB8);   
   GLCD_DI(1); 
   glcd_readByte(chip);                                 
   data = glcd_readByte(chip);

   if(color == 1)
     data=data|(1<<(y%8));      
   else                     
      data= data&(~(1<<(y%8)));    
   GLCD_DIC(1);    
   glcd_writeByte(chip, x);     
   GLCD_DI(1);       
   glcd_writeByte(chip, data); 
}

void glcd_line(int x1, int y1, int x2, int y2, int color)
{
   signed int  x, y, addx, addy, dx, dy;
   signed long P;
   int i;
   if(x2>x1)
     dx=x2-x1;
   else
      dx=x1-x2;
   if(y2>y1)
      dy=y2-y1;
   else
      dy=y1-y2;
   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;
         }
      }
   }
}
void glcd_rect(int x1, int y1, int x2, int y2, int fill, int color)
{
   if(fill)
   {
      int ymin, ymax;
      int xmin,xmax,i,j;
      if(x1<x2)
      {
	xmin=x1;
        xmax=x2;
      }                         
      else
      {
	xmin=x2;
        xmax=x1;
      }
      if(y1 < y2)
      {
         ymin = y1;
         ymax = y2;
      }
      else
      {
         ymin = y2;
         ymax = y1;
      }
      for(j=xmin;j<=xmax;++j)
      {
      for(i=ymin;i<=ymax;++i) 
         {              
         glcd_pixel(j,i,color);
         }
       }
    }
   else
   {
      glcd_line(x1, y1, x2, y1, color);   
      glcd_line(x1, y2, x2, y2, color);
      glcd_line(x1, y1, x1, y2, color);
      glcd_line(x2, y1, x2, y2, color);
   }
}

void glcd_bar(int x1, int y1, int x2, int y2, int width, int color)
{
   signed int  x, y, addx, addy, j;
   signed long P, dx, dy, c1, c2;
   int i;
   if(x2>x1)
   dx=x2-x1;
   else
   dx=x1-x2;
   if(y2>y1)
   dy=y2-y1;
   else
   dy=y1-y2;
   
   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);
         }
      }
   }
}

void glcd_circle(int x, int y, int radius, int fill, int 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);
}

void glcd_fillScreen(unsigned char color)
{
   unsigned char i, j;
   for(i = 0; i < 8; i++)
   {
      GLCD_DIC(1);                   
      glcd_writeByte(1, 0x40);   
      glcd_writeByte(0, 0x40);
      glcd_writeByte(1, i | 0xB8); 
      glcd_writeByte(0, i | 0xB8);
      GLCD_DI(1);                   
      for(j = 0; j < 64; j++)
      {
         glcd_writeByte(1, 0xFF*color);
         glcd_writeByte(0, 0xFF*color);
      }
   }
}
void glcd_text57(int x, int y, char* textptr, int size, int color)
{
   int i, j, k, l, m;                   
   unsigned char pixelData[5];              

   for(i=0; textptr[i] != '\0'; ++i, ++x)
   {
      if(textptr[i] < 'S') 
         memcpy(pixelData, TEXT[textptr[i]-' '], 5);
      else if(textptr[i] <= '~') 
         memcpy(pixelData, TEXT2[textptr[i]-'S'], 5);
      else
         memcpy(pixelData, TEXT[0], 5);  

      if(x+5*size >= GLCD_WIDTH)       
      {
         x = 0;                         
         y += 7*size + 1;                
      }
      for(j=0; j<5; ++j, x+=size)        
      {
         for(k=0; k<7*size; ++k)      
         {
            if((pixelData[j]&(1<<k))>>k==1)
            {
               for(l=0; l<size; ++l)     
               {                       
                  for(m=0; m<size; ++m)
                  {
                     glcd_pixel(x+m, y+k*size+l, color); 
                  }
               }
            }
         }
      }
   }
}

void glcd_writeByte(int chip, unsigned char data)
{
   if(chip == 1)   
     { 
      GLCD_CS1(1);
      GLCD_CS2C(1);
     }
   else
      {
      GLCD_CS2(1);
      GLCD_CS1C(1);
      }
   //DelayUs(10);//****
   GLCD_RWC(1);
   //DelayUs(10);//****
   LPC_GPIO2->FIOMASK=0x0000;      
   LPC_GPIO2->FIOPIN=data;          
   DelayUs(10);
   GLCD_E(1);     
   DelayUs(10);
   GLCD_EC(1);
   GLCD_CS1C(1);      
   GLCD_CS2C(1);
}
unsigned char glcd_readByte(int chip)
{
   unsigned char data; 
   LPC_GPIO2->FIODIR=0x00;
   LPC_GPIO2->FIOMASK=0x00;
   //DelayUs(10);//*****
   GLCD_RW(1);
  // DelayUs(10);//*****
   if(chip == 1)       
     { 
      GLCD_CS1(1);
      GLCD_CS2C(1);
     }
   else
      {
      GLCD_CS2(1);
      GLCD_CS1C(1);
      }
   DelayUs(10);
   GLCD_E(1);      
   DelayUs(10);
   data = LPC_GPIO2->FIOPIN;
   GLCD_EC(1);
  // DelayUs(10);//***
   LPC_GPIO2->FIODIR=255;
   GLCD_CS1C(1);     
   GLCD_CS2C(1);
   return data;         
}

lpc_glcd.h:

#define ON  1
#define OFF 0

#define YES 1
#define NO  0

#define GLCD_CS1(a) (LPC_GPIO1->FIOSET=a<<19)   // Chip Selection 1
#define GLCD_CS1C(a) (LPC_GPIO1->FIOCLR=a<<19)

#define GLCD_CS2(a) (LPC_GPIO1->FIOSET=a<<20)   // Chip Selection 2
#define GLCD_CS2C(a) (LPC_GPIO1->FIOCLR=a<<20)

#define GLCD_DI(a)  (LPC_GPIO1->FIOSET=a<<21)   // Data or Instruction input
#define GLCD_DIC(a)  (LPC_GPIO1->FIOCLR=a<<21)

#define GLCD_RW(a)  (LPC_GPIO1->FIOSET=a<<22)  // Read/Write
#define GLCD_RWC(a)  (LPC_GPIO1->FIOCLR=a<<22)

#define GLCD_E(a)   (LPC_GPIO1->FIOSET=a<<23)   // Enable
#define GLCD_EC(a)   (LPC_GPIO1->FIOCLR=a<<23)

#define GLCD_RST(a) (LPC_GPIO1->FIOSET=a<<24)
#define GLCD_RSTC(a) (LPC_GPIO1->FIOCLR=a<<24)   // Reset	

extern void glcd_init(void);
extern void glcd_pixel(int x,int y,int color);
extern void glcd_line(int x1,int y1,int x2,int y2,int color);
extern void glcd_rect(int x1,int y1,int x2,int y2,int fill,int color);
extern void glcd_bar(int x1,int y1,int x2,int y2,int width,int color);
extern void glcd_circle(int x,int y,int radius,int fill,int color);
extern void glcd_text57(int x,int y,char *textptr,int size,int color);
extern void glcd_fillScreen(unsigned char color);
extern void glcd_writeByte(int chip,unsigned char data);
unsigned char glcd_readByte(int chip);

delay.c:

#include "lpc17xx.h"
#include "delay.h"
void DelayMs(int timer_num,int bekle)
{
     if(timer_num==0)
     {
	 				
                     LPC_TIM0->TCR=0x02;//reset timer
                     LPC_TIM0->IR=0xFF;//tüm kesmeleri restle
                     LPC_TIM0->MR0=bekle*1000;
                     LPC_TIM0->MCR=0x04;
                     LPC_TIM0->TCR=0x01;//start timer
		             LPC_TIM0->PR=0x00;//prescalar deger.Örnegin 2 oldugunda her 3 tick de bir sayar.
                     while(LPC_TIM0->TCR&0x01);//tasana kadar bekle
     }
     if(timer_num==1)
     {
                     LPC_TIM1->TCR=0x02;
                     LPC_TIM1->IR=0xFF;
                     LPC_TIM1->MR0=bekle*1000;
                     LPC_TIM1->MCR=0x04;
                     LPC_TIM1->TCR=0x01;
                     while(LPC_TIM1->TCR&0x01);
     }
     return;
}
void DelayUs(int timer_num,int bekle)
{
     if(timer_num==0)
     {
                     LPC_TIM0->TCR=0x02;
                     LPC_TIM0->IR=0xFF;
                     LPC_TIM0->MR0=bekle*1;
                     LPC_TIM0->MCR=0x04;
                     LPC_TIM0->TCR=0x01;
                     while(LPC_TIM0->TCR&0x01);
     }
     if(timer_num==1)
     {
                     LPC_TIM1->TCR=0x02;
                     LPC_TIM1->IR=0xFF;
                     LPC_TIM1->MR0=bekle*1;
                     LPC_TIM1->MCR=0x04;
                     LPC_TIM1->TCR=0x01;
                     while(LPC_TIM1->TCR&0x01);
     }
     return;
}

[fatihkuzucu]

KS0108  değil bu çip. S6B0108B.
LCD yi 4.6V ile beslersen 3.3V data ile sürebilirsin.
İlla 5V la sürecegim dersen çalışmaz. Buffer çip koymak gerekirki onun yerine 3.3V ile çalışan glcd tercih etmek daha mantıklı olur.

[yamak]

KS0108  değil bu çip. S6B0108B.
LCD yi 4.6V ile beslersen 3.3V data ile sürebilirsin.
İlla 5V la sürecegim dersen çalışmaz. Buffer çip koymak gerekirki onun yerine 3.3V ile çalışan glcd tercih etmek daha mantıklı olur.

Tamam teşekkür ederim daha önce forumda ks0108 ile uyumlu olduğunu okumuştum forumda o yüzden bu şekilde oldu.Bir de bu çipin ks0108 den farkı ne ikisinde de input high voltage ın 0,7vdd olduğu yazıyo.

[fatihkuzucu]

Genelde uyumlu dediklerinde bunu yazanlar yazılımcı oluyor ve aynı driverla  sürülebileceğini kastediyorlar. Ancak donanım tarafında bu tip sorunlar ortaya çıkabiliyor.

Öteki başlıktaki LCD PG12864  onun sürücüsü  T6963 . Bu çip VDD-2.2  ile sürülebiliyor. Seninki PGM12864 ve sürücüsü farklı. 2 Lcdnin isim benzerliginden oradada aynı datasheeti incelediğimi düşünerek, KS0108 in 2.8V ta sürülebileceğini yazıp durmuşum kusura bakma, hata bende de var.  Datasheeti başkalarının değilde devreyi yapanın okuması önemli. Okunacak öyle çok karışık bildiler de degil.

KS0108,  S6B0108B datasheetlerine tekrar baktım. Bir kısım netler için 0.7VDD diyor. 3.5V ediyor oda. Onu kurtarmak için VDD biraz aşağı çekmek yeterli gelecektir. LCD beslemesine bir tane diyot yetebilir denemek gerek. 4.5V sınır değer. Diyot takınca voltajın ne kadar olduğunu bir kontrol et. 4.6V civarında bir değere gelmesi gerekiyor.

0.7VDD dedigi netler CL, FRM, M, RSTB, CLK1, CLK2 . Bu pinlerden mcudan sürülen kaç tane var.