WG240128B TOSHIBA T6963C 240x128 GLCD ÇALIŞAN PROJE

[mustisal]

@KONYALI
Vee ucu negatif voltaj çıkış ucu. Isis dosyasındaki bağlantıyı yapacaksınız.
Vee ucu 10k lık potun bir ucuna, diğer ucu gnd ye, orta ucu ise Glcd nin Vo pinine bağlanacak.

[Phenomen]

mustisal arkadaşın dediği doğru bağlantıları Isis şemasına göre yapın. Ekranı bir süre önce geliştirdiğim üründe aktif olarak bu şekilde kullandım.

[musti463]

18F46K22 de çalıştırmak istiyorsak kod da nereleri değiştirmeliyiz?

[Phenomen]

Hotfile dosyaları silmiş nedense. Yeni link https://rapidshare.com/share/A8D6787734BE9A9B4AC8448F94D165FF

[Phenomen]

GDrive linkleri:

https://drive.google.com/file/d/0By7sRf0RIWttbFFWbmlGYjA0S1U/edit?usp=sharing

https://drive.google.com/file/d/0By7sRf0RIWttT1ljcXM4UzBlVDA/edit?usp=sharing

Dosya menüsünü seçip indire tıklayın.

[gokgokhan]

s.a ısis dosyalarını bulamadım resimde yok

[gokgokhan]

glcd_init(240,128) diyorum program T6963C dosyasındaki aşağıdaki while da sonsuz döngüye giriyo çıkamıyor nerde hata yapıyorum acaba

while (status != 0x03) {  // is LCD busy?
       LCD.r_bar= 0;
       temp = LCD_Data;
       LCD.r_bar = 1;
       status = temp & 0x03;
    }

[Kabil ATICI]

O kodu parçası, LCD ekranın meşgul olup olmadığını kontrol eder. Eğer orada kalıyorsa, ya bağlantılarda bir sorun var, yada programda. Yoksa ekranın çalışması çok kolaydır.

T6963C kontroller veri gönderiminde her veride o mesgul kontrolunu yapar. Hatta  o kontrollerden 2 tane daha var. Bazı komutlarda devreye giriyor.

[gokgokhan]

kodu herkez kullanmış sıkıntı yok birde farklı kodalar da denedim hepsinde bu kontrol yapılıyor ve değişik kodalarda olsa yine o wihle da takılıyor yani benim anladığım donanımsal herhalde diyecem ama isis de deniyorum..kodun iç yapısını bilen biri varsa  o döngüden çıkartan işlem ne dir acaba
mesaj birleştirme:: 27 Şubat 2015, 15:13:22




/////////////////////////////////////////////////////////////////////////
////    T6963C.c     -      T6963C driver                            ////
////   Not for comercial Use                                         ////
////      Driver by treitmey Graphic functions and Resolution Select ////   
////                                    by mcdoganay(mcdoganay@gmail.com) ////
////                                                                 ////
//// This file contains drivers for using a Tosiba T6963C controller ////
//// in parallel/8080(intel) mode.  The T6963C is 256 pixels across  ////
////  and 256 pixels down. The driver treats the upper left pixel 0,0 ////
////                                                                 ////
////  Connections are as follows:                                    ////
////  /WR - - C4                                                     ////
////  /RD - - C5                                                     ////
////  C//D- - C6                                                     ////
////  /RST- - C7                                                     ////
////  DATA0-7 PORTD0-7                                               ////
////  LCD's FS is tied low (FS = 0 is 8x8 font)                      ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////

// 256 x 256 in the 8x8 font mode means that 30 characters across by
// 32 rows of characters may be displayed

#define set_tris_lcd(x) set_tris_d(x) // Data hattı hangi portta ise o tanımlanacak örneğin "set_tris_c(x)"
#define LCDColorBlack 0b1
#define LCDColorWhite 0b0

#use fast_io(D) // Yukarıda tanımlanan data portu girilecek örneğin fast_io(C)

const int16 TextHome = 3968;
const int8  TextArea = 30; // how many bytes before a new line
const int16 GraphicsHome = 0;
const int8  GraphicsArea = 30; // how many bytes before a new line

const int8 AutoModeWrite = 0xB0;
const int8 AutoModeRead  = 0xB1;
const int8 AutoModeReset = 0xB2;

const int8 LCDModeSet  = 0x80;   // send this OR'd with the following
const int8 LCDMode_OR  = 0b0000;
const int8 LCDMode_XOR = 0b0001;
const int8 LCDMode_AND = 0b0010;
const int8 LCDMode_TA  = 0b0100; // TEXT ATTRIBUTE mode.
const int8 LCDMode_RAM = 0b1000; // 1=CG RAM, 0=internal CG ROM

const int8 LCDSetCursorPtr  = 0x21;  // cursor address
const int8 LCDSetCursorSize = 0xA0;  // 1 line cursor

const int8 LCDDispMode = 0x90;   // send this OR'd with the following
const int8 LCDDisp_BLK = 0b0001;
const int8 LCDDisp_CUR = 0b0010;
const int8 LCDDisp_TXT = 0b0100;
const int8 LCDDisp_GRH = 0b1000;

const int8 LCDBitSet   = 0xF8;
const int8 LCDBitReset = 0xF0;
const int8 LCDBit0 = 0b000;
const int8 LCDBit1 = 0b001;
const int8 LCDBit2 = 0b010;
const int8 LCDBit3 = 0b011;
const int8 LCDBit4 = 0b100;
const int8 LCDBit5 = 0b101;
const int8 LCDBit6 = 0b110;
const int8 LCDBit7 = 0b111;

const int8 LCDSetPtr = 0xE0;


struct lcd_pin_def
{
   BOOLEAN unused1;  // Kontrol hattının 0. pini
   BOOLEAN w_bar;    // Kontrol hattının 1. pini Write bar bağlı (düşükte aktif)
   BOOLEAN unused2;  // Kontrol hattının 2. pini
   BOOLEAN unused3;  // Kontrol hattının 3. pini
   BOOLEAN unused4;  // Kontrol hattının 4. pini
   BOOLEAN r_bar;    // Kontrol hattının 5. pini Read bar bağlı (düşükte aktif)
   BOOLEAN cd;       // Kontrol hattının 6. pini Command/Data bar bağlı (1=command 0=data)
   BOOLEAN reset_bar;// Kontrol hattının 7. pini Reset bağlı (düşükte aktif)
};
struct lcd_pin_def  LCD;

  #byte LCD = 0xf81        // Kontrol portunun işlemcideki adresi (18f452 için B port adresi 0xf81)
  #byte LCD_Data = 0xf83   // Data portunun işlemcideki adresi (18f452 için D port adresi 0xf83)
 
int   glcd_ReadByte(void);
void  glcd_WriteByte(int1 cd, int data);
void  glcd_WriteByteAuto(int data);
void  glcd_WriteCmd2(int16 data, int cmd);
void  glcd_WriteCmd1(int data, int cmd);
void  glcd_gotoxy(int x, int y, int1 text);
/////////////////////////////////////////////////////////////////////////
//// Defines a 5x7 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, // ]
                         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};// ~
/////////////////////////////////////////////////////////////////////////

#inline
void glcd_init(unsigned int16 res_x, unsigned int16 res_y) {
   
  int16 counter;

  set_tris_b(0b00000000);  // Kontrol portunun yönlendirilmesi
  set_tris_lcd(0xff);      // Data portunun yönlendirilmesi

  LCD.w_bar = 1;      // INITIAL STATES OF CONTROL PINS
  LCD.r_bar = 1;      //
  LCD.cd = 1;         // command

  LCD.reset_bar = 0;  // perform a reset
  LCD.reset_bar = 1;  // run

  // Set up the graphics and text areas
  glcd_WriteCmd2(TextHome, 0x40);
  glcd_WriteCmd2(TextArea, 0x41);
  glcd_WriteCmd2(GraphicsHome, 0x42);
  glcd_WriteCmd2(GraphicsArea, 0x43);

  // set address to 0
  glcd_WriteCmd2(0x0000, 0x24);
  glcd_WriteCmd2(0x0000, 0x24);

  // Clear all RAM of LCD (8k)
  glcd_WriteByte(1, AutoModeWrite);
  for (counter = 0; counter < 0x1fff; counter++)
  {
    glcd_WriteByteAuto(0);    // fill everything with zeros
  }
  glcd_WriteByte(1, AutoModeReset);
}

void glcd_WriteByte(int1 cd, int data)
{
    int status = 0, temp = 0;
    set_tris_lcd(0xff);
    LCD.w_bar = 1;
    LCD.r_bar= 1;
    LCD.cd = 1;//defaults

    while (status != 0x03) {  // is LCD busy?
       LCD.r_bar= 0;
       temp = LCD_Data;
       LCD.r_bar = 1;
       status = temp & 0x03;
    }

    set_tris_lcd(0x00);    // All outputs
    LCD.cd = cd;           // Command/Data bar
    LCD_Data = data;
    LCD.r_bar = 1;         // not read
    LCD.w_bar = 0;         // write
    LCD.w_bar = 1;         // release
}


void glcd_WriteByteAuto(int data)
{
   int status = 0, temp = 0; // status bits ARE DIFFERENT BITS THAN NORMAL
   set_tris_lcd(0xff);
   LCD.w_bar = 1;
   LCD.r_bar = 1;
   LCD.cd = 1; // defaults

   while (status != 0x08) {  // is LCD busy?
     LCD.r_bar = 0;
     temp = LCD_Data;
     LCD.r_bar = 1;
     status = temp & 0x08;
   }

   set_tris_lcd(0x00);     // All outputs
   LCD.cd = 0;             // This is always data, cd=0
   LCD_Data = data;        // Put data on data bus
   LCD.w_bar = 0;          // write
   LCD.w_bar = 1;          // release
}

void glcd_WriteCmd1(int data, int cmd)
{
  glcd_WriteByte(0, data);
  glcd_WriteByte(1, cmd);
}

void glcd_WriteCmd2(int16 data, int cmd)
{
  glcd_WriteByte(0, data & 0xff);
  glcd_WriteByte(0, data>>8);
  glcd_WriteByte(1, cmd);
}

int glcd_ReadByte(void)
{
  int data = 0, status = 0, temp = 0;
  set_tris_lcd(0xff);
  LCD.w_bar = 1;
  LCD.r_bar = 1;
  LCD.cd = 1;  // defaults

  #asm nop #endasm

  while (status != 0x03) {  // is LCD busy?
    LCD.r_bar = 0;
    temp = LCD_Data;
    LCD.r_bar = 1;
    status = temp & 0x03;
  }

  LCD.cd = 0;          // Command/Data bar
  LCD.r_bar = 0;        // read
  /////////////////////////////////////////////////////////
  #asm nop #endasm    // THIS PAUSE IS VERY NESSESARY !!!//
  /////////////////////////////////////////////////////////
  data = LCD_Data;
  LCD.r_bar = 1;
  LCD.cd = 1;
  return data;        // Return the read data
}

void glcd_putc(char c) {
   glcd_WriteCmd1(c - 0x20, 0xc0);
}

void glcd_gotoxy(int x, int y, int1 text) { // sets memory location to screen location x, y
   // location 1,1 is upper left corner;  text = 1 (text area), text = 0 (graphics area)
   int16 location, home;
   int line;

   if (text==0) {
      home = GraphicsHome;
      line = GraphicsArea;
   } else {
      home = TextHome;
      line = TextArea;
   }

   location = home + (((int16)y) * line) + x;
   glcd_WriteCmd2(location, 0x24);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
// Purpose:       Clears LCD RAM
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
void glcd_clr(int16 location,int16 size)
{
  ////fprintf(DEBUG,"loc=%lu  size=%lu\n\r",location,size);
  // look very simular to the init,... doesn't it. : )
  glcd_WriteCmd2(location,LCDSetPtr);
  glcd_WriteCmd1(1,AutoModeWrite);
  for (;size;size--)
  {
    glcd_WriteByteAuto(0x00);//clear ram
  }
  glcd_WriteCmd1(1,AutoModeReset);
}

/////////////////////////////////////////
// Graphics Controller by mcdoganay (c)2010
//    mcdoganay@gmail.com
//       Not for comercial use
/////////////////////////////////////////

unsigned int8 i;  //General Purpouse variable

// glcd_pixel(x,y,c) sets pixel x,y with c color
void glcd_pixel(unsigned int8 x, unsigned int8 y, int1 c){
   unsigned int8 x_H;
   unsigned int8 x_L=0;
   x_H = (x / 8);//6x8 karaktere göre ayarlandı
   x_L = 7 - (x - 8*x_H);//6x8 karaktere göre ayarlandı
   glcd_gotoxy(x_H,y,0);    //Bug fixed, thanks to etiedon
   if(c){
      glcd_WriteCmd1(1,(LCDBitSet|x_L));
   } else {
      glcd_WriteCmd1(1,(LCDBitReset|x_L));
   }
}

// glcd_pixel8(x,y,px8) sets 8 pixels in line.
void glcd_pixel8(unsigned int8 x, unsigned int8 y, int8 pixel8){
   unsigned int8 x_H;
   x_H = (x / 8); //6x8 karaktere göre ayarlandı
   glcd_gotoxy(x_H,y,0);
   glcd_WriteCmd1(pixel8,0xc0);
}

// glcd_line(x0,y0, x1,y1, c) puts line from (x0, y0) to (x1, y1) with c color
#separate
void glcd_line(int16 x1, int16 y1, int16 x2, int16 y2, int kalilik, int1 color)
{
   
   int16        dy, dx;
   signed int8  addx=1, addy=1;
   signed int16 P, diff;

   int16 i=0;
   int8 j = 0;
   
   dx = abs((signed int16)(x2 - x1));
   dy = abs((signed int16)(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)
      {

         glcd_pixel(x1 + j, 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)
      {

         glcd_pixel(x1, y1 + j, color);

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


// glcd_square(x0,y0,x1,y1, c) sets square
void glcd_square( unsigned int8 x0, unsigned int8 y0,
                  unsigned int8 x1, unsigned int8 y1 , int1 c){
   glcd_line(x0,y0, x1,y0,1, c);
   glcd_line(x1,y0, x1,y1, 1,c);
   glcd_line(x0,y1, x1,y1, 1,c);
   glcd_line(x0,y0, x0,y1, 1, c);
}

// glcd_box(x0,y0,x1,y1, c)
void glcd_box( unsigned int8 x0, unsigned int8 y0,
               unsigned int8 x1, unsigned int8 y1 , int1 c){
   unsigned int8 x;
   unsigned int8 y;
   for(y=y0; y<=y1;y++){
      for(x=x0; x<=x1;x++){
         if((!(x%8)) && ((x1-x)>8)){
            glcd_pixel8(x,y,0xFF*c);  //Same time to write 8 pixel
            x +=7 ;
         } else {
            glcd_pixel(x,y,c);
         }
      }
   }
}

/////////////////////////////////////////////////////////////////////////
// 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(int16 x, int16 y, int16 radius, int1 fill, int1 color)

{
   #ifdef LARGE_LCD
   signed int16 a, b, P;
   #else
   signed int8  a, b, P;
   #endif

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

   do
   {
      if(fill)
      {
         glcd_line(x-a, y+b, x+a, y+b, 1, color);
         glcd_line(x-a, y-b, x+a, y-b, 1, color);
         glcd_line(x-b, y+a, x+b, y+a, 1, color);
         glcd_line(x-b, y-a, x+b, y-a, 1, 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);
}

//glcd_image8 (*Pic, x, y, size_x, size_y)
void glcd_image8(int8 *pic_px, unsigned int8 x, unsigned int8 y,
                 unsigned int8 size_x, unsigned int8 size_y){
   
   unsigned int16 px_y;
   unsigned int16 px_x;
   unsigned int16 px=0;
   
   for(px_y=y; px_y<(y+size_y); px_y++){
      for(px_x=x; px_x<(x+size_x); px_x+=8) //6x8 karaktere göre ayarlandı
      {
         glcd_pixel8(px_x, px_y, *(!pic_px+px));
         px+=1;
      }
   }
}
void glcd_text57(int16 x, int16 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 >= 240)          // 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)
                  {
                     glcd_pixel(x+m, y+k*size+l, color); // Draws the pixel
                  }
               }
            }
         }
      }
   }
}

[gokgokhan]

while (status != 0x03) {  // is LCD busy?
       LCD.r_bar= 0;
       temp = LCD_Data;
       LCD.r_bar = 1;
       status = temp & 0x03;
    }
burda döngüden çıkması için tempin son iki basamağı 11 olması gerekiyor oda LCD_Data ya eşitlenmiş LCD_Data ise oraya gelince değeri ilk değer atanmadığı için 0 gözküyo doğal olarak çıkmıyo döngüden arkadaşlar çok öenmli bi prjem bilen ardakaşlar yardımcı olursa şimdiden teşekkürler

[RaMu]

Kodun o kısmında bir problem yok,
cd ile r bacaklarını ters bağlamışsın, yer değiştir.
mesaj birleştirme:: 27 Şubat 2015, 23:24:54
Ve kodlarınızı kod tag ı içine alın:
https://www.picproje.org/index.php/topic,57135.0.html

[gokgokhan]

Dediğiniz gibi bacakları değiştirdim. Daha önce D portunda hiç değişme yoktu bu sefer d portunda çıkışlar oldu fakat yine o while da takıldı..bende
while (status != 0x03) {  // is LCD busy?
       LCD.r_bar= 0;
       //temp = LCD_Data;
       LCD.r_bar = 1;
       temp = LCD_Data;
       status = temp & 0x03;
    }
temp = LCD_Data; yı bir altı satıra indirdim artık takılmıyor fakat ekrana yine yazı gelmiyor. İlgilendiğiniz için teşekkürler olmadı  128x64 devam etcez napalım 

[kartal0689]

Arkadaşlar,

Büyük karakterlerle yazı yazıyorum. Fakat, Normal LCD kullandığımızda bir yazının üzerine aynı x,y koordinatlarında yazı yazdığımızda üzerine silip yazar.
Fakat burada o yazılan karakterler kalıyor ve üzerine yazıyor. Ekranda salak saçma şeyler oluşuyor. Bunun önüne nasıl geçebilirim.(Winstar T6963C 240x128)

[Murat Mert]

S.A.
İlk yazdığın değişkeni negatif görüntüsü ile tersle ve yeni veriyi yekrar yazdır. Bende 64*128 bu problemi yaşadım böyle çözdümdeğişken ekranda anlık yanıp sönerek değer değiştiriyor. Pic programlamada daha önce proton kullanıyordum onda olmuyordu ccs c de böyle olunca ilk zamanlar şaşırmıştım.

[kartal0689]

Rica etsem örnek kod verebilir misin?