t6963c -- wg240x128b sorun

erhans · 17 Temmuz 2016, 23:39:34

Herkese kolay gelsin arkadaşlar;

Yeni aldığım wg240x128 glcd ile ilgili yazdırma işlemleri kontrolüm dışında oluyor. x,y koordinatlarını tam çözemedim. Bilgisi olan arkadaşların tecrübelerinden yararlanmak isterim.

#include <18F452.h>
#Device PASS_STRINGS=IN_RAM
#fuses HS, BROWNOUT, BORV27, PUT, STVREN, NOLVP
#use delay(clock=1000000)
#include <T6963C.c>

void main()
{
   setup_psp(PSP_DISABLED);
   setup_wdt(WDT_OFF);
   setup_adc_ports(NO_ANALOGS); 

   glcd_init(240,128); 
   glcd_WriteByte(1, (LCDModeSet|LCDMode_XOR)); 
   glcd_WriteByte(1, (LCDDispMode|LCDDisp_TXT|LCDDisp_GRH)); 
   glcd_gotoxy(0,0,1);  // 1 = text area of memory; note that there are only 
   glcd_putc("1");
   glcd_gotoxy(0,15,1); 
   glcd_putc("2");
   glcd_gotoxy(39,0,1);
   glcd_putc("3");
   glcd_gotoxy(39,15,1);   
   glcd_putc("4");
   glcd_pixel(3,9,1);
   glcd_pixel(3,9,1);
   glcd_line(40,50,200,50,1,1); 
   glcd_box (60,30,100,60,1);    
}

sorun resim link : http://imgur.com/Tv4CS75

internetten bulduğum kulandığım kütüphane dasyam

/////////////////////////////////////////////////////////////////////////
////    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 ce;        // Kontrol hattynyn 0. pini
   BOOLEAN unused1; // w_bar;     Kontrol hattynyn 1. pini Write bar ba?ly (dü?ükte aktif)
   BOOLEAN cd;  // Kontrol hattynyn 2. pini
   BOOLEAN w_bar;  // Kontrol hattynyn 3. pini
   BOOLEAN r_bar;  // Kontrol hattynyn 4. pini
   BOOLEAN reset_bar;    // Kontrol hattynyn 5. pini Read bar ba?ly (dü?ükte aktif)
   BOOLEAN unused5;       // Kontrol hattynyn 6. pini Command/Data bar ba?ly (1=command 0=data)
   BOOLEAN unused6;// Kontrol hattynyn 7. pini Reset ba?ly (dü?ükte aktif)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
                  }
               }
            }
         }
      }
   }
}

erhans · 26 Temmuz 2016, 14:58:46

Merhaba arkadaşlar;
Sorunun bir kısmı donanımsal olarak çözüldü. Glcd'yi biraz inceledikten sonra ( Font selection: FS = "H", 6 x 8 character font, FS = "L", 8 x 8 character font ) olduğunu gördüm.

FS=L 8*8 iken nokta,çizgi,yuvarlak,kare ,yazı vs kontrollü oluyor. (yazıların araları açık)

FS=H 6*8 iken ( TextArea = 40; // 30) yapıyoruz ve yazılar düzgün ve kontrollü fakat şekiller karışık.

Şimdi ise;
FS=H (6*8 font ) iken şekilleri düzgün çizmenin yolunu öğrenmek gerekiyor. Bu konuda yazılımsal olarak yardıma ihtiyacım var galiba

RaMu · 26 Temmuz 2016, 18:24:07

Öyle detaylı bakmadım ama
denenebilecek çok basit bir şey var,
bundansa piyango olur:

glcd_init(240,128);

yerine,

glcd_init(128,240);

erhans · 26 Temmuz 2016, 23:17:54

Malesef olmadı

Kurcalamaya devam .

8051-ARM · 26 Temmuz 2016, 23:24:26

Alıntı yapılan: erhans - 26 Temmuz 2016, 14:58:46
Merhaba arkadaşlar;
Sorunun bir kısmı donanımsal olarak çözüldü. Glcd'yi biraz inceledikten sonra ( Font selection: FS = "H", 6 x 8 character font, FS = "L", 8 x 8 character font ) olduğunu gördüm.

FS=L 8*8 iken nokta,çizgi,yuvarlak,kare ,yazı vs kontrollü oluyor. (yazıların araları açık)

FS=H 6*8 iken ( TextArea = 40; // 30) yapıyoruz ve yazılar düzgün ve kontrollü fakat şekiller karışık.

Şimdi ise;
FS=H (6*8 font ) iken şekilleri düzgün çizmenin yolunu öğrenmek gerekiyor. Bu konuda yazılımsal olarak yardıma ihtiyacım var galiba

Merhaba hocam hayırlı akşamlar,

Texthome, TextArea, GraphicsHome ve GraphicsArea değerlerni kullanacağın fonta göre ayarlaman gerekiyor.

DSP_SET_6X8:
	   		MOV	   A,#00H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#00H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#40H	       	;TEXT HOME ADRESS
	   		CALL    LCD_KOMUT
	  		MOV	    A,#28H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#00H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#41H	       	;TEXT AREA ADRESS
	   		CALL    LCD_KOMUT
	   		MOV	    A,#00H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#03H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#42H	       	;GRAPHIC HOME ADRESS
	   		CALL    LCD_KOMUT
	   		MOV	    A,#28H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#00H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#43H	       	;GRAPHIC AREA ADRESS
	   		CALL    LCD_KOMUT
	   		MOV	    A,#84H		   	;MODE SET  84
	   		CALL    LCD_KOMUT	   	

	   		MOV	    A,#02H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#0H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#22H		   	;OFFSET ADRESS
	   		CALL    LCD_KOMUT
	   
	   		CALL    SIL
	   		MOV	    A,#9CH		   	;DISPLAY MODE
	   		CALL    LCD_KOMUT	   
	  
			MOV	    A,#0A7H		   	;CURSOR PATTERN
	   		CALL    LCD_KOMUT

	   		RET

;-------------------------------------;

DSP_SET_8X8:
	   		MOV	    A,#00H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#00H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#40H	       	;TEXT HOME ADRESS
	   		CALL    LCD_KOMUT
	  		MOV	    A,#1EH	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#00H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#41H	       	;TEXT AREA ADRESS
	   		CALL    LCD_KOMUT
	   		MOV	    A,#00H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#03H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#42H	       	;GRAPHIC HOME ADRESS
	   		CALL    LCD_KOMUT
	   		MOV	    A,#1EH	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#00H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#43H	       	;GRAPHIC AREA ADRESS
	   		CALL    LCD_KOMUT
	   		MOV	    A,#81H		   	;MODE SET  84
	   		CALL    LCD_KOMUT

	   		MOV	    A,#02H	       	;LOW
	   		CALL    LCD_DATA
	   		MOV	    A,#0H	       	;HIGH
	   		CALL    LCD_DATA
	   		MOV	    A,#22H		   	;OFFSET ADRESS
	   		CALL    LCD_KOMUT
	   
	   		CALL    SIL
	   		MOV	    A,#9CH		   	;DISPLAY MODE 
	   		CALL    LCD_KOMUT	  	

			MOV	    A,#0A7H		   	;CURSOR PATTERN
	   		CALL    LCD_KOMUT

	   		RET

erhans · 27 Temmuz 2016, 12:19:14

Merhabalar arkadaşlar herkese iyi günler ;

" 8051-ARM " vermiş olduğun bilgi ve kodlar için teşekkürler .

kodların ccs icin uygun durumu böylemidir ? ( ccs de daha yeniyim )

const int16 TextHome = 0x0000;
const int8 TextArea = 0x0028;
const int16 GraphicsHome = 0x0300;
const int8 GraphicsArea = 0x0028 ;

8051-ARM · 27 Temmuz 2016, 16:32:10

Alıntı yapılan: erhans - 27 Temmuz 2016, 12:19:14
Merhabalar arkadaşlar herkese iyi günler ;

" 8051-ARM " vermiş olduğun bilgi ve kodlar için teşekkürler .

kodların ccs icin uygun durumu böylemidir ? ( ccs de daha yeniyim )

const int16 TextHome = 0x0000;
const int8 TextArea = 0x0028;
const int16 GraphicsHome = 0x0300;
const int8 GraphicsArea = 0x0028 ;

Hocam ben ccs hiç bilmiyorum ama benim kodlarıma göre şöyle olması gerekir diye düşünüyorum.

8x8 için

const int16 TextHome = 0x0000;
const int16 TextArea = 0x001E;
const int16 GraphicsHome = 0x0300;
const int16 GraphicsArea = 0x001E ;

6x8 için

const int16 TextHome = 0x0000;
const int16 TextArea = 0x0028;
const int16 GraphicsHome = 0x0300;
const int16 GraphicsArea = 0x0028 ;

RaMu · 27 Temmuz 2016, 18:18:34

Hepsini const int16 yazsan daha doğru olur,
ama senin kodda bu değerler sadece sabit sayı anladığım kadarıyla,
yani const işi olmaz gibi.
Const ile ncu program memory de saklanacak sabit değerler tanımlanır.
Bunun yerine, gerekli değerler sadece derleme esnasında lazım olduğu için
bunları:

#define TextHome 0x0000UL
#define TextArea 0x0028UL
#define GraphicsHome 0x0300UL
#define GraphicsArea 0x0028UL

şeklinde yazmalısın.

erhans · 27 Temmuz 2016, 22:43:49

Merhabalar iyi akşamlar ;

   glcd_init(240,128); 
   glcd_WriteByte(1, (LCDModeSet|LCDMode_XOR)); 
   glcd_WriteByte(1, (LCDDispMode|LCDDisp_TXT|LCDDisp_GRH)); 
   glcd_gotoxy(8,8,1);
   glcd_putc("Hi there.");
   glcd_text57(12,12,giris1,1,1);
   glcd_line(1,10,239,10,1,1); 
   glcd_box(10,30,230,32,1);// 1 = text area of memory; note that there are only
                            // 8 rows of text possible

Denemelerimiz olumsuz sonuçlandı

Fs=1 , MD2=0

Fs=0 , MD2=0

Sorun olduğunu düşündüklerim ;

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);
}

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);
}

Picproje Elektronik Sitesi

Haberler:

t6963c -- wg240x128b sorun

erhans

erhans

RaMu

erhans

8051-ARM

erhans

8051-ARM

RaMu

erhans