19 Ekim 2021, 12:22:57

Haberler:

Eposta uyarılarını yanıtlamayınız ( ! ) https://bit.ly/2J7yi0d


STM32F103 ve GLCD problemi

Başlatan hypercupe, 13 Ekim 2021, 20:01:48

hypercupe

Merhabalar,
Elimde stm32f103 ile bir adet GLCD (128x64 Grafik Lcd Ekran Yeşil - WG12864B-YYH-V#N) modeli mevcut ben SPI mevcut diye almıştım ama içerisinde NT7108 IC'si mevcutmuş yani SPI ile süremiyorum DataBusları ile sürmem gerekiyor ama internette yakınından geçen bir örneğe rastlayamadım datasheetinde bir komut seti göremedim. U8Glib librarysine rastladım fakat bu cihazı desteklemediği için onu da kullanamıyorum tavsiyelerinizi bekliyorum.

gevv

13 Ekim 2021, 21:51:41 #1 Son düzenlenme: 13 Ekim 2021, 22:12:40 gevv
Merhaba,

NT7108 arm, NT7108 library c, NT7108 stm32   anahtarları veya benzerleri ile arama yapın

https://os.mbed.com/forum/mbed/topic/3418/?page=1#comment-17325

AlıntıHepinize merhaba,

KS0108B yerine NT7108 çipli bir Raystar RG12864B-BIW-V satın aldım. "DisplayTest" programını denedim ama başarılı olamadım. KS0108.cpp koduna baktığımda KS0108::SelectSide'da CS1 ve CS2'nin yanlış değerlere sahip olduğunu buldum. Orada "0"daki tüm "1"leri ve "1"deki tüm "0"ları değiştirdim. Ve şimdi her şey çalışıyor!


https://www.electro-tech-online.com/threads/glcd-wayton-mg1206e-cs1-cs2-polarity.150917/


http://ardupiclab.blogspot.com/2015/08/a-128x64-glcd-for-teensy-3x.html

http://we.easyelectronics.ru/attachments/get/1127

anladığım kadarı ile mevcut kütüphaneler ile çalışıyor ama CS1 ve CS2 farkı varmış

 

hypercupe

Cevabınız için teşekkür ederim GLCD bir kaç gün içerisinde elimde olacak deneyeceğim ama bayağı eski bir lcd galiba piyasada kullanımı da yok

gevv

çözersiniz büyük ihtimal daha önce forumda konusu geçmiş

Alıntı yapılan: salih18200 - 10 Haziran 2012, 22:55:21Hocam kiti arkadaştan çalışmak için aldım, glcd üzerinde verdi. NT7108 ve KS0108 datasheet'lerini karşılaştırdım. Registerlardan tutunda hepsi birebir aynı büyük ihtimal bağlantılarda hata olabilir.

Alıntı yapılan: Burak B - 23 Ağustos 2013, 01:30:23Ben aşağıdaki LCD' yi kullanıyorum sürücüsü KS0108' dir.
WG12864B KS0108

Ayrıca S6B0108 aslında KS0108' in yeni adından başka birşey değil. İkiside Samsung zaten. Samsung yeni bir isimlendirmeye gidip eski KS0108' lerin teknolojisini küçülttüğünden yeni kontrolcülere S6B0108 gibi bir isim vermiştir.

NT7108 ' de novatek firmasının KS0108 klonudur.

Bu tıpkı T6963C ile SAP1024 kontrolcülerinin işlevsel olarak aynı cihp olmaları gibi bir durum.

Biraz ipucu vermek gerekirse.
KS0108 uyumlu kontrolcülerde 8bit veri dikey bir şekilde haritalanmıştır.
Buna karşın T6963C serisi kontrolcülerde ise bu 8 bitlik veri yatay olarak adreslenir. Yani T6963 kontrolcüler bitmap basmaya çok daha uygundur. KS0108 serisi kontrolcülerde bitmap basabilmek için bitmap verisini önceden işlemek veya transpose etmek gerekir buda zaman kaybına yolaçar.

Yine FT1505, ILI9325 v.s. aslında Renesas R61505 kontrolcüsünün klonundan başka bir şey değil.
 

hypercupe

Yardımlarınız için teşekkürler şimdi clon meselesini okuyunca içim biraz daha rahatladı KS ile alakalı daha fazla örnek ve bilgi mevcut tekrardan teşekkürler.

kimlenbu

Gözünü korkutmak istemem ama öncden 8051 ile çalıştırdığım grafik lcd'yi STM32F103 ile çalıştıramadım. Zamanım çok kısıtlıydı bir kaç gün uğraşıp başka ekrana geçtim.

İnternetteki örneklerin hepsi 8 bitlik işlemciden apartma kodlar, hepsi pin değil, direkt olarak port sürmeye yönelik, zaman gecikmeleri "yavaş" işlemcilere göre döngülerle yapıldığı için sıkıntılar çıkıyor.

Hal library uyumlu çalışan bir kütüphane bulamamıştım. Kendim eski kodlarıma baka baka düzenlemeye çalıştım, 3-4 tane hazır kütüphaneyi port etmeye çalıştım olmadı.

3.3V-5V uyumsuzluğundan kaynaklanabileceğini düşünüyorum ama test etmeye vaktim olmadı.

hypercupe

Ben ekranı harici bir power supply ile beslemeyi düşünüyorum ama pcb üzerine geçirince tabi deneme amaçlı stm ile besleyecektim uyarınızı dikkate alırım teşekkürler.

izturk

Ben ccs c nin glcd kütüphanesini ile çalıştırmıştım. şimdi düzenlediğim kütüphaneyi bulamadım. halihazırda 240*128 kullanıyorum. yine pic için yapılmış bi kütüphaneden derledim.

/////////////////////////////////////////////////////////////////////////
////                          GLCD.C                                ////
////                                                                ////
//// This file contains drivers for using a Hantronix HDM64GS12 with ////
//// an LED backlight. The HDM64GS12 is 128 pixles across and 64    ////
//// pixels down. The driver treats the upper left pixel as (0,0).  ////
////                                                                ////
//// LCD Pin connections:                                            ////
//// (These can be changed as needed in the following defines).      ////
////  * 1: VSS is connected to GND                                  ////
////  * 2: VDD is connected to +5V                                  ////
////  * 3: V0 - LCD operating voltage is connected from a 20k Ohm POT////
////  * 4: D/I - Data or Instruction is connected to B2              ////
////  * 5: R/W - Read or Write is connected to B4                    ////
////  * 6: Enable is connected to B5                                ////
////  *7-14: Data Bus 0 to 7 is connected to port d                  ////
////  *15: Chip Select 1 is connected to B0                          ////
////  *16: Chip Select 2 is connected to B1                          ////
////  *17: Reset is connected to C0                                  ////
////  *18: Negative voltage is also connected to the 20k Ohm POT    ////
////  *19: Positive voltage for LED backlight is connected to +5V    ////
////  *20: Negavtive voltage for LED backlight is connected to GND  ////
////                                                                ////
////  glcd_init(mode)                                                ////
////    * Must be called before any other function.                ////
////      - mode can be ON or OFF to turn the LCD on or off        ////
////                                                                ////
////  glcd_pixel(x,y,color)                                          ////
////    * Sets the pixel to the given color.                        ////
////      - color can be ON or OFF                                  ////
////                                                                ////
////  glcd_line(x1,y1,x2,y2,color)                                  ////
////    * Draws a line from the first point to the second point    ////
////      with the given color.                                    ////
////      - color can be ON or OFF                                  ////
////                                                                ////
////  glcd_rect(x1,y1,x2,y2,fill,color)                              ////
////    * Draws a rectangle with upper left point (x1,y1) and lower ////
////      right point (x2,y2).                                      ////
////      - fill can be YES or NO                                  ////
////      - color can be ON or OFF                                  ////
////                                                                ////
////  glcd_bar(x1,y1,x2,y2,width,color)                              ////
////    * Draws a bar (wide line) from the first point to the      ////
////      second point.                                            ////
////      - width is the number of pixels wide                      ////
////      - color is ON or OFF                                      ////
////                                                                ////
////  glcd_circle(x,y,radius,fill,color)                            ////
////    * Draws a circle with center at (x,y)                      ////
////      - fill can be YES or NO                                  ////
////      - color can be ON or OFF                                  ////
////                                                                ////
////  glcd_text57(x,y,textptr,size,color)                            ////
////    * Write the null terminated text pointed to by textptr with ////
////      the upper left coordinate of the first character at (x,y).////
////      Characters are 5 pixels wide and 7 pixels tall.          ////
////      - size is an integer that scales the size of the text    ////
////      - color is ON or OFF                                      ////
////    * Note - The given text is character wrapped. If this      ////
////      function is used on a different size display, then change ////
////      the GLCD_WIDTH define appropriately.                      ////
////                                                                ////
////  glcd_fillScreen(color)                                        ////
////    * Fills the entire LCD with the given color.                ////
////      - color can be ON or OFF                                  ////
////                                                                ////
/////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2003 Custom Computer Services        ////
//// This source code may only be used by licensed users of the CCS  ////
//// C compiler.  This source code may only be distributed to other  ////
//// licensed users of the CCS C compiler.  No other use,            ////
//// reproduction or distribution is permitted without written      ////
//// permission.  Derivative programs created using this software    ////
//// in object code form are not restricted in any way.              ////
/////////////////////////////////////////////////////////////////////////



#ifndef GLCD_C
#define GLCD_C

#ifndef GLCD_WIDTH
#define GLCD_WIDTH 128    // Used for text wrapping by glcd_text57 function
#endif

#define ON  1
#define OFF 0

#define YES 1
#define NO  0

#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



BYTE glcd_readByte(BYTE chip);
void glcd_writeByte(BYTE chipBYTE data);
void glcd_fillScreen(int1 color);

const 
BYTE TEXT[51][5] ={0x000x000x000x000x00// SPACE
                        
0x000x000x5F0x000x00// !
                        
0x000x030x000x030x00// "
                        
0x140x3E0x140x3E0x14// #
                        
0x240x2A0x7F0x2A0x12// $
                        
0x430x330x080x660x61// %
                        
0x360x490x550x220x50// &
                        
0x000x050x030x000x00// '
                        
0x000x1C0x220x410x00// (
                        
0x000x410x220x1C0x00// )
                        
0x140x080x3E0x080x14// *
                        
0x080x080x3E0x080x08// +
                        
0x000x500x300x000x00// ,
                        
0x080x080x080x080x08// -
                        
0x000x600x600x000x00// .
                        
0x200x100x080x040x02// /
                        
0x3E0x510x490x450x3E// 0
                        
0x040x020x7F0x000x00// 1
                        
0x420x610x510x490x46// 2
                        
0x220x410x490x490x36// 3
                        
0x180x140x120x7F0x10// 4
                        
0x270x450x450x450x39// 5
                        
0x3E0x490x490x490x32// 6
                        
0x010x010x710x090x07// 7
                        
0x360x490x490x490x36// 8
                        
0x260x490x490x490x3E// 9
                        
0x000x360x360x000x00// :
                        
0x000x560x360x000x00// ;
                        
0x080x140x220x410x00// <
                        
0x140x140x140x140x14// =
                        
0x000x410x220x140x08// >
                        
0x020x010x510x090x06// ?
                        
0x3E0x410x590x550x5E// @
                        
0x7E0x090x090x090x7E// A
                        
0x7F0x490x490x490x36// B
                        
0x3E0x410x410x410x22// C
                        
0x7F0x410x410x410x3E// D
                        
0x7F0x490x490x490x41// E
                        
0x7F0x090x090x090x01// F
                        
0x3E0x410x410x490x3A// G
                        
0x7F0x080x080x080x7F// H
                        
0x000x410x7F0x410x00// I
                        
0x300x400x400x400x3F// J
                        
0x7F0x080x140x220x41// K
                        
0x7F0x400x400x400x40// L
                        
0x7F0x020x0C0x020x7F// M
                        
0x7F0x020x040x080x7F// N
                        
0x3E0x410x410x410x3E// O
                        
0x7F0x090x090x090x06// P
                        
0x1E0x210x210x210x5E// Q
                        
0x7F0x090x090x090x76};// R

const BYTE TEXT2[44][5]={0x260x490x490x490x32// S
                        
0x010x010x7F0x010x01// T
                        
0x3F0x400x400x400x3F// U
                        
0x1F0x200x400x200x1F// V
                        
0x7F0x200x100x200x7F// W
                        
0x410x220x1C0x220x41// X
                        
0x070x080x700x080x07// Y
                        
0x610x510x490x450x43// Z
                        
0x000x7F0x410x000x00// [
                        
0x020x040x080x100x20// \
                        
0x000x000x410x7F0x00// ]
                        
0x040x020x010x020x04// ^
                        
0x400x400x400x400x40// _
                        
0x000x010x020x040x00// `
                        
0x200x540x540x540x78// a
                        
0x7F0x440x440x440x38// b
                        
0x380x440x440x440x44// c
                        
0x380x440x440x440x7F// d
                        
0x380x540x540x540x18// e
                        
0x040x040x7E0x050x05// f
                        
0x080x540x540x540x3C// g
                        
0x7F0x080x040x040x78// h
                        
0x000x440x7D0x400x00// i
                        
0x200x400x440x3D0x00// j
                        
0x7F0x100x280x440x00// k
                        
0x000x410x7F0x400x00// l
                        
0x7C0x040x780x040x78// m
                        
0x7C0x080x040x040x78// n
                        
0x380x440x440x440x38// o
                        
0x7C0x140x140x140x08// p
                        
0x080x140x140x140x7C// q
                        
0x000x7C0x080x040x04// r
                        
0x480x540x540x540x20// s
                        
0x040x040x3F0x440x44// t
                        
0x3C0x400x400x200x7C// u
                        
0x1C0x200x400x200x1C// v
                        
0x3C0x400x300x400x3C// w
                        
0x440x280x100x280x44// x
                        
0x0C0x500x500x500x3C// y
                        
0x440x640x540x4C0x44// z
                        
0x000x080x360x410x41// {
                        
0x000x000x7F0x000x00// |
                        
0x410x410x360x080x00// }
                        
0x020x010x020x040x02};// ~


// Purpose:      Initialize a graphic LCD. This must be called before any
//                other glcd function is used.
// Inputs:        The initialization mode
//                OFF - Turns the LCD off
//                ON  - Turns the LCD on
// Date:          5/28/2003
void glcd_init(int1 mode)
{
  
// Initialze some pins
  
output_high(GLCD_RST);
  
output_low(GLCD_E);
  
output_low(GLCD_CS1);
  
output_low(GLCD_CS2);

  
output_low(GLCD_DI);                // Set for instruction
  
glcd_writeByte(GLCD_CS10xC0);    // Specify first RAM line at the top
  
glcd_writeByte(GLCD_CS20xC0);    //  of the screen
  
glcd_writeByte(GLCD_CS10x40);    // Set the column address to 0
  
glcd_writeByte(GLCD_CS20x40);
  
glcd_writeByte(GLCD_CS10xB8);    // Set the page address to 0
  
glcd_writeByte(GLCD_CS20xB8);
  if(
mode == ON)
  {
      
glcd_writeByte(GLCD_CS10x3F);  // Turn the display on
      
glcd_writeByte(GLCD_CS20x3F);
  }
  else
  {
      
glcd_writeByte(GLCD_CS10x3E);  // Turn the display off
      
glcd_writeByte(GLCD_CS20x3E);
  }

  
glcd_fillScreen(OFF);              // Clear the display
}


// Purpose:      Turn a pixel on a graphic LCD on or off
// Inputs:        x - the x coordinate of the pixel
//                y - the y coordinate of the pixel
//                color - ON or OFF
// Output:        1 if coordinate out of range, 0 if in range
void glcd_pixel(int xint yint1 color)
{
  
BYTE data;
  
BYTE chip GLCD_CS1;  // Stores which chip to use on the LCD

  
if(63)  // Check for first or second display area
  
{
      
-= 64;
      
chip GLCD_CS2;
  }

  
output_low(GLCD_DI);                                    // Set for instruction
  
bit_clear(x,7);                                          // Clear the MSB. Part of an instruction code
  
bit_set(x,6);                                            // Set bit 6. Also part of an instruction code
  
glcd_writeByte(chipx);                                // Set the horizontal address
  
glcd_writeByte(chip, (y/0b10111111) | 0b10111000);  // Set the vertical page address
  
output_high(GLCD_DI);                                    // Set for data
  
data glcd_readByte(chip);

  if(
color == ON)
      
bit_set(datay%8);        // Turn the pixel on
  
else                          // or
      
bit_clear(datay%8);      // turn the pixel off
  
output_low(GLCD_DI);          // Set for instruction
  
glcd_writeByte(chipx);      // Set the horizontal address
  
output_high(GLCD_DI);        // Set for data
  
glcd_writeByte(chipdata);  // Write the pixel data
}


// Purpose:      Draw a line on a graphic LCD using Bresenham's
//                line drawing algorithm
// Inputs:        (x1, y1) - the start coordinate
//                (x2, y2) - the end coordinate
//                color - ON or OFF
// Dependencies:  glcd_pixel()
void glcd_line(int x1int y1int x2int y2int1 color)
{
  
signed int  xyaddxaddydxdy;
  
signed long P;
  
int i;
  
dx abs((signed int)(x2 x1));
  
dy abs((signed int)(y2 y1));
  
x1;
  
y1;

  if(
x1 x2)
      
addx = -1;
  else
      
addx 1;
  if(
y1 y2)
      
addy = -1;
  else
      
addy 1;

  if(
dx >= dy)
  {
      
2*dy dx;

      for(
i=0i<=dx; ++i)
      {
        
glcd_pixel(xycolor);

        if(
0)
        {
            
+= 2*dy;
            
+= addx;
        }
        else
        {
            
+= 2*dy 2*dx;
            
+= addx;
            
+= addy;
        }
      }
  }
  else
  {
      
2*dx dy;

      for(
i=0i<=dy; ++i)
      {
        
glcd_pixel(xycolor);

        if(
0)
        {
            
+= 2*dx;
            
+= addy;
        }
        else
        {
            
+= 2*dx 2*dy;
            
+= addx;
            
+= addy;
        }
      }
  }
}


// Purpose:      Draw a rectangle on a graphic LCD
// Inputs:        (x1, y1) - the start coordinate
//                (x2, y2) - the end coordinate
//                fill  - YES or NO
//                color - ON or OFF
// Dependencies:  glcd_pixel(), glcd_line()
void glcd_rect(int x1int y1int x2int y2int fillint1 color)
{
  if(
fill)
  {
      
int yymax;                          // Find the y min and max
      
if(y1 y2)
      {
        
y1;
        
ymax y2;
      }
      else
      {
        
y2;
        
ymax y1;
      }

      for(; 
y<=ymax; ++y)                    // Draw lines to fill the rectangle
        
glcd_line(x1yx2ycolor);
  }
  else
  {
      
glcd_line(x1y1x2y1color);      // Draw the 4 sides
      
glcd_line(x1y2x2y2color);
      
glcd_line(x1y1x1y2color);
      
glcd_line(x2y1x2y2color);
  }
}


// Purpose:      Draw a bar (wide line) on a graphic LCD
// Inputs:        (x1, y1) - the start coordinate
//                (x2, y2) - the end coordinate
//                width  - The number of pixels wide
//                color - ON or OFF
void glcd_bar(int x1int y1int x2int y2int widthint1 color)
{
  
signed int  xyaddxaddyj;
  
signed long Pdxdyc1c2;
  
int i;
  
dx abs((signed int)(x2 x1));
  
dy abs((signed int)(y2 y1));
  
x1;
  
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)
  {
      
2*dy dx;

      for(
i=0i<=dx; ++i)
      {
        for(
j=-(width/2); j<width/2+width%2; ++j)
        {
            if(
dx*x+dy*(y+j)+c1 >= && dx*x+dy*(y+j)+c2 <=0)
              
glcd_pixel(xy+jcolor);
        }
        if(
0)
        {
            
+= 2*dy;
            
+= addx;
        }
        else
        {
            
+= 2*dy 2*dx;
            
+= addx;
            
+= addy;
        }
      }
  }
  else
  {
      
2*dx dy;

      for(
i=0i<=dy; ++i)
      {
        if(
0)
        {
            
+= 2*dx;
            
+= addy;
        }
        else
        {
            
+= 2*dx 2*dy;
            
+= addx;
            
+= addy;
        }
        for(
j=-(width/2); j<width/2+width%2; ++j)
        {
            if(
dx*x+dy*(y+j)+c1 >= && dx*x+dy*(y+j)+c2 <=0)
              
glcd_pixel(x+jycolor);
        }
      }
  }
}


// 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(int xint yint radiusint1 fillint1 color)
{
  
signed int abP;
  
0;
  
radius;
  
radius;

  do
  {
      if(
fill)
      {
        
glcd_line(x-ay+bx+ay+bcolor);
        
glcd_line(x-ay-bx+ay-bcolor);
        
glcd_line(x-by+ax+by+acolor);
        
glcd_line(x-by-ax+by-acolor);
      }
      else
      {
        
glcd_pixel(a+xb+ycolor);
        
glcd_pixel(b+xa+ycolor);
        
glcd_pixel(x-ab+ycolor);
        
glcd_pixel(x-ba+ycolor);
        
glcd_pixel(b+xy-acolor);
        
glcd_pixel(a+xy-bcolor);
        
glcd_pixel(x-ay-bcolor);
        
glcd_pixel(x-by-acolor);
      }

      if(
0)
        
P+= 2*a++;
      else
        
P+= 2*(a++ - b--);
    } while(
<= b);
}

// Purpose:      Write text on a graphic LCD
// Inputs:        (x,y) - The upper left coordinate of the first letter
//                textptr - A pointer to an array of text to display
//                size - The size of the text: 1 = 5x7, 2 = 10x14, ...
//                color - ON or OFF
void glcd_text57(int xint ychartextptrint sizeint1 color)
{
  
int ijklm;                    // Loop counters
  
BYTE pixelData[5];                    // Stores character data

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

      
if(x+5*size >= GLCD_WIDTH)          // Performs character wrapping
      
{
        
0;                          // Set x at far left position
        
+= 7*size 1;                // Set y at next position down
      
}
      for(
j=0j<5; ++jx+=size)        // Loop through character byte data
      
{
        for(
k=0k<7*size; ++k)          // Loop through the vertical pixels
        
{
            if(
bit_test(pixelData[j], k)) // Check if the pixel should be set
            
{
              for(
l=0l<size; ++l)      // The next two loops change the
              
{                          // character's size
                  
for(m=0m<size; ++m)
                  {
                    
glcd_pixel(x+my+k*size+lcolor); // Draws the pixel
                  
}
              }
            }
        }
      }
  }
}


// Purpose:      Fill the LCD screen with the passed in color.
//                Works much faster than drawing a rectangle to fill the screen.
// Inputs:        ON - turn all the pixels on
//                OFF - turn all the pixels off
// Dependencies:  glcd_writeByte()
void glcd_fillScreen(int1 color)
{
  
int ij;

  
// Loop through the vertical pages
  
for(08; ++i)
  {
      
output_low(GLCD_DI);                      // Set for instruction
      
glcd_writeByte(GLCD_CS10b01000000);    // Set horizontal address to 0
      
glcd_writeByte(GLCD_CS20b01000000);
      
glcd_writeByte(GLCD_CS10b10111000); // Set page address
      
glcd_writeByte(GLCD_CS20b10111000);
      
output_high(GLCD_DI);                    // Set for data

      // Loop through the horizontal sections
      
for(064; ++j)
      {
        
glcd_writeByte(GLCD_CS10xFF*color);  // Turn pixels on or off
        
glcd_writeByte(GLCD_CS20xFF*color);  // Turn pixels on or off
      
}
  }
}

// Purpose:      Write a byte of data to the specified chip
// Inputs:        chipSelect - which chip to write the data to
//                data - the byte of data to write

void glcd_writeByte(char chipBYTE data)
{
  if(
chip == GLCD_CS1)      // Choose which chip to write to
      
output_high(GLCD_CS1);
  else
      
output_high(GLCD_CS2);

  
output_low(GLCD_RW);      // Set for writing
  
output_d(data);            // Put the data on the port
  
output_high(GLCD_E);      // Pulse the enable pin
  
delay_us(2);
  
output_low(GLCD_E);

  
output_low(GLCD_CS1);      // Reset the chip select lines
  
output_low(GLCD_CS2);
}


// Purpose:      Reads a byte of data from the specified chip
// Ouputs:        A byte of data read from the chip
BYTE glcd_readByte(BYTE chip)
{
  
BYTE data;                // Stores the data read from the LCD
  
if(chip == GLCD_CS1)      // Choose which chip to read from
      
output_high(GLCD_CS1);
  else
      
output_high(GLCD_CS2);

  
input_d();                // Set port d to input
  
output_high(GLCD_RW);      // Set for reading
  
output_high(GLCD_E);      // Pulse the enable pin
  
delay_us(2);
  
output_low(GLCD_E);
  
delay_us(2);
  
output_high(GLCD_E);      // Pulse the enable pin
  
delay_us(2);
  
data input_d();          // Get the data from the display's output register
  
output_low(GLCD_E);

  
output_low(GLCD_CS1);      // Reset the chip select lines
  
output_low(GLCD_CS2);
  return 
data;              // Return the read data
}

#endif

fonksiyonları düzenleyin. zaten pin aç pin kapat. direk çalışır. problem yaşayacağınızı zannetmem.

bymrz

Hocam GLCD'nin bir noktasını/bitini kendi yazdığın kod ile kontrol edebiliyorsan, U8Glib ile gerisini halledersin, çok kolay...

hypercupe

Alıntı yapılan: bymrz - 16 Ekim 2021, 15:36:40Hocam GLCD'nin bir noktasını/bitini kendi yazdığın kod ile kontrol edebiliyorsan, U8Glib ile gerisini halledersin, çok kolay...

Sorun zaten oradan kaynaklanıyor bir pixeli kontrol edebilecek bir instruction seti yok sürücünün sadece datasheeti var orada da hiç bir bilgi yok nasıl süreleceğine dahil. Bu hafta bakacağım umarım çok zorlanmadan sürebilirim.

MC_Skywalker


hypercupe

Alıntı yapılan: MC_Skywalker - 16 Ekim 2021, 20:58:11http://www.hpinfotech.ro/KS0108.pdf
komut açıklamaları son sayfalarda

Sagolun hocam ben ilk NT için araştırıyordum ama onun da en altında varmış sonradan fark ettim. Ama ks ile birebir clon olduğu için ks örnekleri üzerinden yürüyeceğim.

Yasal Uyarı: Picproje.org sitemizde 5651 sayılı kanunun 8. maddesine ve T.C.Knın 125. maddesine göre tüm üyelerimiz yaptıkları paylaşımlardan kendileri sorumludur. Picproje.org hakkında yapılacak tüm hukuksal şikayetleri İletişim sayfamızdan bize bildirdikten en geç 3 (üç) iş günü içerisinde ilgili kanunlar ve yönetmelikler çerçevesinde tarafımızca incelenerek gereken işlemler yapılacak ve site yöneticilerimiz tarafından bilgi verilecektir.