Grafik LCD'nin data portunu PIC'in D portuna taşıdığımda görüntü gelmiyor!

[musti463]

Merhaba,

Grafik LCD'nin data portunu B'den PIC'in D portuna taşıdığımda ISIS'deki simülasyonda gayet güzel çalışıyor. Fakat devreyi gerçekte kurduğumda grafik lcd de görüntü oluşmuyor? Sebebi ne olabilir?



Kod:

#include <18F46K22.h> 
#device PASS_STRINGS=IN_RAM 
#device ADC=10 

#include <T6963C.c> 
#include <Grafikler.h> 
#include <Animasyonlar.h> 
#include <math.h> 

#FUSES NOWDT                    //No Watch Dog Timer 
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale 
#FUSES NOPLLEN                  //4X HW PLL disabled, 4X PLL enabled in softwar 
#FUSES PUT                      //Power Up Timer 
#FUSES NOBROWNOUT               //No brownout reset 
#FUSES WDT_SW                   //No Watch Dog Timer, enabled in Software 
#FUSES NOPBADEN                 //PORTB pins are configured as digital I/O on RESET 
#FUSES NOMCLR                   //Master Clear pin used for I/O 
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O 
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode) 
#DEFINE fast_glcd 

#use delay(clock=4000000) 

void main() 
{    
   ekran_temizle();  
   Resim_goster(LoadMomentIndicator,240,128,0,0); // "LoadMomentIndicator" ekrana basılıyor 
   delay_ms(500); 
    
   ekran_temizle();  
   Resim_goster(MesaElectronics,240,128,0,0); // "MesaElectronics" ekrana basılıyor  
   delay_ms(500); 
   loading(); 
    
   ekran_temizle(); 
   Resim_goster(AnaGosterge,240,128,0,0); // "AnaGosterge" ekrana basılıyor    

   ekran_temizle(); 
   Resim_goster(Tablolar,240,128,0,0); 
   tablo_secim(); 
    
} 

T6963C.c:

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

  #byte LCD = 0xf82        // 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_C(0b00011000);  // 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 
                  } 
               } 
            } 
         } 
      } 
   } 
}

[baran123]

Kod paylaşırsanız daha çabuk çözebiliriz.

[musti463]

ekledim hocam

[baran123]

Kullandığınız kütüphane flexy değil gördüğüm kadarı ile pic numralarını ayarlayamıyorsunuz değil mi ?

[musti463]

flexy ve pic numarası nedir açıklarmısınız? t6963c içinde port değişimi için gerekli değişiklikleri yaptım

[baran123]

flexy derken pinleri ayarlarnabılır yani pic'in hangi bacagına hangis uc baglı oldugunu

[cripple]

Connections are as follows:                        //// 
////  /WR - - C4                                                     //// 
////  /RD - - C5                                                     //// 
////  C//D- - C6                                                    //// 
////  /RST- - C7                                                   ////

T6963C.c içinde bunlar belirtilmemiş

örnek olarak  C:\Program Files (x86)\PICC\Drivers dosyasındaki GLCD.c ve HDM64GS12.c driverları incelemenizi tavsiye ederim.

#ifndef HDM64GS12
#define HDM64GS12

#ifndef GLCD_WIDTH
#define GLCD_WIDTH   128
#endif

#ifndef GLCD_CS1
#define GLCD_CS1     PIN_B0   // Chip Selection 1
#endif

#ifndef GLCD_CS2
#define GLCD_CS2     PIN_B1   // Chip Selection 2
#endif

#ifndef GLCD_DI
#define GLCD_DI      PIN_B2   // Data or Instruction input
#endif

#ifndef GLCD_RW
#define GLCD_RW      PIN_B4   // Read/Write
#endif

#ifndef GLCD_E
#define GLCD_E       PIN_B5   // Enable
#endif

#ifndef GLCD_RST
#define GLCD_RST     PIN_C0   // Reset
#endif

gibi tanımlamalar var.