GLCD' de Pixel tabanlı metin kaydırma

[ete]

Ben programı sana fikir versin diye yazdım. Ama GLCD mantık tamamen farklı olabilir. Başlangıçta bende yalnızca karekter konum adresleri yerine pixel adresleri verilerek çalışır diyordum ama sanırım zor olacak. Hala çalışacağı fikrini taşıyorum ama bazı şeyleri farklı düşünmek gerkeecek.
Yazdığım programda tek tek karekterlerle çalışılıyor. Bir satırı yazdırırken karekterler Lookup tablosundan alınıyor ve ekranda yer olduğu kadar başlangıç adresinden itibaren ekrana basılıyor. Ekran dolunca bu sefer karekter bir atlanarak bütün karekterler teker teker yeniden ekrana veriliyor. Her ekran dolması durumunda bir kayma gecikmesi veriliyor.
Temel mantık budur. Grafik ekran olunca belkide farklı bir mantık düşünmeye gerek yok gibime geliyor. Benzer mantıkla yapılabilir diyorum. Burada tek test etmemiz gereken şey, Print AT komutu karekteri ASCII kodundan yazdırabiliyormu. Yani, PrintAt 1,3,65 deyince ilgili adrese A harfini basabiliyormu. Bunu yapıyor ise (Belki normal LCD de bunu yapar ama GLCD de yapıyormu denemek lazım) o zaman sistemimiz çalışır demektir.

Hatta PBP da dizi değişkeni yok. Yada karekterleri topluca yükleyeceğimiz bir değişken yok maalesef. Olmadığı için karekterleri ekrana verme konusunu biraz uzun yoldan hallettim. Ama protonda bunun olduğunu sanıyorum. Var ise bu sana biraz kolaylık getirecektir. Hele birde bu değişkenden birim birim harf çekebiliyorsan tam süper olur gibime geliyor. O zaman pixel adreslemesi ile yazıyı kaydırmak kolaylaşır. Dediğim gibi protonu genel olarak biliyorum ve özel komutlar hakkında bilgim yok sayılır. Biraz araştır ve string komutlarını bir incele istersen. String komutlarını PC basic den bilirim bu nedenle bulduğun komutları benimle paylaşırsan bir çözüm bulabiliriz belki.

Ete

ilave: epeyce düşündümde sağdan sola kaydırmada sorun yok. Yani ekran sınırlarında kaldığın müddetçe kaydırma çok kolay. Sütun sayısını birer eksilterek ver kayar yazı. Ancak ekranın en soluna geldiğin zaman sorun başlıyor. Bu aşamada sana yazıları oluşturan haflerin sütün bilgileri gerekecek. Bu durumda çözüm sanıırm kendi oluşturduğun karekter tablosu ile bu kaydırmayı yapmak. Başka çare yok gibi.

[Mucit23]

Hocam pek anlayamadım açıkçası..
Dediğiniz gibi harfin ascii değerini lcd ye gönderince aynı karakter lcd lerdeki gibi harf çıkıyor.
Örneğin Print At 1,1,65,66,124,67,68,69,70 = "AB CDEF" Burada space karakteri kendim tanımladığım için "|" değeri yani 124 oluyor. Normalde space nin değeri 32 dir.

Ayrıca protonda dizi değişkenleri de var yani dediğiniz gibi string komutları ile değişkenlere harfleri yükleyebiliyoruz protonun help dosyasından örnek vereyim.

DIM MYARRAY [10] AS BYTE    ' Create a 10-byte array.
STR MYARRAY = "HELLO"       ' Load the first 5 bytes of the array
PRINT STR MYARRAY \5        ' Send 5-byte string.

hocam yukarıda karakter sayısı kadar dizi değişkeni tanımlayıp bu değişkene yukarıdaki komut ile harf yükleyebiliyoruz. Bu komut çok güzel çalışıyor.

Yine hocam protonun help kısmından prınt komutlarından bir alıntı yaptım. İşimize yarayabilecek birçok faydalı özellik olduğunu düşünüyorum

Combining the unique features of the 'self modifying PICmicro's ' with a string format, the compiler is capable of reducing the overhead of printing, or transmitting large amounts of text data. The CSTR modifier may be used in commands that deal with text processing i.e. SerOut, HRSOut and RSOut etc.

The CSTR modifier is used in conjunction with the CData command. The CData command is used for initially creating the string of characters: -

STRING1: CDATA "HELLO WORLD" , 0

The above line of case will create, in flash memory, the values that make up the ASCII text "HELLO WORLD", at address STRING1. Note the NULL terminator after the ASCII text. NULL terminated means that a zero (NULL) is placed at the end of the string of ASCII characters to signal that the string has finished.

To display, or transmit this string of characters, the following command structure could be used: 

 PRINT CSTR STRING1

The label that declared the address where the list of CData values resided, now becomes the string's name. In a large program with lots of text formatting, this type of structure can save quite literally hundreds of bytes of valuable code space. Try both these small programs, and you'll see that using CSTR saves a few bytes of code. First the standard way of displaying text: -

 DEVICE 16F877
 CLS
 PRINT "HELLO WORLD"
 PRINT "HOW ARE YOU?"
 PRINT "I AM FINE!"
 STOP 

Now using the CSTR modifier: -

 CLS
 PRINT CSTR TEXT1
 PRINT CSTR TEXT2
 PRINT CSTR TEXT3
 STOP

TEXT1: CDATA "HELLO WORLD" , 0
TEXT2: CDATA "HOW ARE YOU?" , 0
TEXT3: CDATA "I AM FINE!" , 0

Again, note the NULL terminators after the ASCII text in the CData commands. Without these, the PICmicro will continue to transmit data in an endless loop. The term 'virtual string' relates to the fact that a string formed from the CData command cannot be written too, but only read from.

The STR modifier is used for sending a string of bytes from a byte array variable. A string is a set of bytes sized values that are arranged or accessed in a certain order. The values 1, 2, 3 would be stored in a string with the value 1 first, followed by 2 then followed by the value 3. A byte array is a similar concept to a string; it contains data that is arranged in a certain order. Each of the elements in an array is the same size. The string 1,2,3 would be stored in a byte array containing three bytes (elements). Below is an example that displays four bytes (from a byte array): -

 DIM MYARRAY[10] AS BYTE    ' Create a 10-byte array.
 MYARRAY [0] = "H"          ' Load the first 5 bytes of the array
 MYARRAY [1] = "E"          ' With the data to send
 MYARRAY [2] = "L"
 MYARRAY [3] = "L"
 MYARRAY [4] = "O" 
 PRINT STR MYARRAY \5       ' Display a 5-byte string.

Note that we use the optional \n argument of STR. If we didn't specify this, the PICmicro would try to keep sending characters until all 10 bytes of the array were transmitted. Since we do not wish all 10 bytes to be transmitted, we chose to tell it explicitly to only send the first 5 bytes. The above example may also be written as: -

 DIM MYARRAY [10] AS BYTE    ' Create a 10-byte array.
 STR MYARRAY = "HELLO"       ' Load the first 5 bytes of the array
 PRINT STR MYARRAY \5        ' Send 5-byte string.

The above example, has exactly the same function as the previous one. The only difference is that the string is now constructed using STR as a command instead of a modifier. 

Buda başka bir örnek

DIM STRING1[21] as BYTE      ' Create a Byte array with 21 elements

DELAYMS 200                  ' Wait for PICmicro to stabilise
CLS                          ' Clear the LCD
STRN STRING1 = "HELLO WORLD" ' Load STRING1 with characters and NULL terminate it
PRINT STR STRING1            ' Display the string
STOP

Hocam Sizden ricam Boş bir vaktinizde gönderdiğim help dosyasını incelerseniz belki ne yapmam gerektiğine daha net karar verebiliriz. Özellikle Print komutlarına, STR,STRN ve CDATA komutlarınıza bakmanızı öneririm.

Cdata komutları ile ilgili yine help dosyasından aldığım başka örnekler var

CDATA { alphanumeric data } 
 
Overview

Place information directly into memory for access by CRead and CWrite. 
 
Operators
alphanumeric data - any value, alphabetic character, or string enclosed in quotes (") or numeric data without quotes. 
Example

 DEVICE 16F877                 ' Use a 16F877 PICmicro 
 DIM VAR1 as BYTE 
  VAR1 = CREAD 2000            ' Read the data from address 2000 
 ORG 2000                      ' Set the address of the CDATA command 
 CDATA 120                     ' Place 120 at address 2000 
 
In the above example, the data is located at address 2000 within the PICmicro, then it's read using the CRead command. 
 
Notes

CData is only available on the newer PICmicro types that have self-modifying features, such as the 16F87x range, and offer an excellent, and efficient use of precious code space.

The CRead and CWrite commands can also use a label address as a location variable. For example: -

 DEVICE 16F877                 ' A device with code modifying features
 DIM DByte AS BYTE
 DIM Loop AS BYTE
 FOR Loop = 0 TO 9             ' Create a loop of 10
 DByte = CREAD Address + Loop  ' Read memory location ADDRESS + LOOP
 PRINT Dbyte                   ' Display the value read
 NEXT
 STOP
ADDRESS: CDATA "HELLO WORLD"   ' Create a string of text in FLASH memory

The program above reads and displays 10 values from the address located by the LABEL accompanying the CData command. Resulting in "HELLO WORLD" being displayed. 

Using the new in-line commands structure, the CRead and Print parts of the above program may be written as: -

 PRINT CREAD Address + Loop  ' Read and display memory location ADDRESS + LOOP

The CWrite command uses the same technique for writing to memory: -

 DEVICE 16F877                 ' A device with code modifying features
 DIM DByte AS BYTE
 DIM Loop AS BYTE
 CWRITE Address , [ "HELLO WORLD" ] ' Write a string to FLASH memory at location ADDRESS
 FOR Loop = 0 TO 9             ' Create a loop of 10
 PRINT CREAD Address + Loop    ' Read and display memory location ADDRESS + LOOP
 NEXT
 STOP
 ' Reserve 10 spaces in FLASH memory
ADDRESS: CDATA 32 , 32 , 32 , 32 , 32 , 32 , 32 , 32 , 32 , 32

Notice the string text now allowed in the CWrite command. This allows the whole PICmicro to be used for data storage and retrieval if desired. The configuration fuse setting WRTE must be enabled before CDATA, CRead and CWrite may be used. This enables the self-modifying feature (and is the default fuse setting of the compiler). If the CONFIG directive is used, then the WRTE_ON fuse setting must be included in the list: - CONFIG HS_OSC, WDT_ON, PWRTE_ON, BODEN_OFF, LVP_OFF, WRTE_ON, CP_OFF, DEBUG_OFF

Important Note

Take care not to overwrite existing code when using the CWrite command, and also remember that the all PICmicro devices have a finite amount of write cycles (approx 1000). A single program can easily exceed this limit, making that particular memory cell or cells inaccessible.
 
The configuration fuse setting WRTE must be enabled before CDATA, CRead and CWrite may be used. This enables the self-modifying feature. If the CONFIG directive is used, then the WRTE_ON fuse setting must be included in the list: - 
 
 CONFIG WDT_ON , XT_OSC , WRTE_ON 
 
Because the 14-bit core devices are only capable of holding 14 bits to a word, values greater than 16383 ($3FFF) cannot be stored. 

Formatting a CDATA table with a 16-bit core device

Sometimes it is nessecary to create a data table with a known format for its values. For example all values will occupy 4 bytes of data space even though the value itself would only occupy 1 or 2 bytes. Formatters are not supported with 14-bit core devices, because they can only hold a maximum value of $3FFF (16383). i.e. 14-bits.

 CDATA 100000 , 10000 , 1000 , 100 , 10 , 1

The above line of code would produce an uneven code space usage, as each value requires a different amount of code space to hold the values. 100000 would require 4 bytes of code space, 10000 and 1000  would require 2 bytes, but 100, 10, and 1 would only require 1 byte. Reading these values using CRead would cause problems because there is no way of knowing the amount of bytes to read in order to increment to the next valid value. The answer is to use formatters to ensure that a value occupies a predetermined amount of bytes. These are: -

 BYTE
 WORD 
 DWORD
 FLOAT

Placing one of these formatters before the value in question will force a given length.

 CDATA DWORD 100000 , DWORD 10000 , DWORD  1000 , DWORD  100 , DWORD 10 , DWORD 1


BYTE will force the value to occupy one byte of code space, regardless of it's value. Any values above 255 will be truncated to the least significant byte. 
WORD will force the value to occupy 2 bytes of code space, regardless of its value. Any values above 65535 will be truncated to the two least significant bytes. Any value below 255 will be padded to bring the memory count to 2 bytes. 
DWORD will force the value to occupy 4 bytes of code space, regardless of its value. Any value below 65535 will be padded to bring the memory count to 4 bytes. The line of code shown above uses the DWORD formatter to ensure all the values in the CDATA table occupy 4 bytes of code space. 
FLOAT will force a value to its floating point equivalent, which always takes up 4 bytes of code space. 
If all the values in an CData table are required to occupy the same amount of bytes, then a single formatter will ensure that this happens.

 CDATA AS DWORD 100000 , 10000 , 1000 , 100 , 10 , 1 

The above line has the same effect as the formatter previous example using seperate DWORD formatters, in that all values will occupy 4 bytes, regardless of their value. All four formatters can be used with the AS keyword. The example below illustrates the formatters in use.

' Convert a DWORD value into a string array
' Using only BASIC commands
' Similar principle to the STR$ command

Include "PROTON18_4.INC"     ' Use a 16-bit core device

 Dim P10 as Dword            ' Power of 10 variable
 Dim CNT as Byte
 Dim J as Byte

 Dim VALUE as Dword          ' Value to convert
 Dim STRING1[11] as Byte     ' Holds the converted value
 Dim PTR as Byte             ' Pointer within the Byte array

 Delayms 500                 ' Wait for PICmicro to stabilise
 Cls                         ' Clear the LCD
 Clear                       ' Clear all RAM before we start
 VALUE = 1234576             ' Value to convert
 Gosub DWORD_TO_STR          ' Convert VALUE to string
 Print STR STRING1           ' Display the result
 Stop

'-------------------------------------------------------------
' Convert a DWORD value into a string array
' Value to convert is placed in 'VALUE'
' Byte array 'STRING1' is built up with the ASCII equivalent
 
DWORD_TO_STR: 
 PTR = 0  
 J = 0
 Repeat
 P10 = CREAD DWORD_TBL + (J * 4)   
 CNT = 0

 While VALUE >= P10
 VALUE = VALUE - P10
 Inc CNT
 Wend   

 If CNT <> 0 Then 
 STRING1[PTR] = CNT + "0"
 Inc PTR
 Endif
 Inc J
 Until J > 8

 STRING1[PTR] = VALUE + "0"
 Inc PTR
 STRING1[PTR] = 0              ' Add the NULL to terminate the string
 Return
 
' CDATA table is formatted for all 32 bit values.
' Which means each value will require 4 bytes of code space  
DWORD_TBL: CDATA AS DWORD 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10

Label Names as Pointers

If a label's name is used in the list of values in a Cdata table, the labels address will be used. This is useful for accessing other tables of data using their address from a lookup table. See example below.

' Display text from two CDATA tables
' Based on their address located in a separate table
  
  Include "PROTON18_4.INC"            ' Use a 16-bit core device
        
  Dim ADDRESS as Word
  Dim LOOP as Word
  Dim DATA_BYTE as Byte
        
  Delayms 200                         ' Wait for PICmicro to stabilise
  Cls                                 ' Clear the LCD
  ADDRESS = CREAD ADDR_TABLE          ' Locate the address of the first string
  While 1 = 1                         ' Create an infinite loop
  DATA_BYTE = CREAD ADDRESS           ' Read each character from the CDATA string
  If DATA_BYTE = 0 Then EXIT_LOOP     ' Exit if NULL found
  Print DATA_BYTE                     ' Display the character
  Inc ADDRESS                         ' Next character
  Wend                                ' Close the loop
EXIT_LOOP:
  
  Cursor 2,1                          ' Point to line 2 of the LCD
  ADDRESS = CREAD ADDR_TABLE + 2      ' Locate the address of the second string
  While 1 = 1                         ' Create an infinite loop
  DATA_BYTE = CREAD ADDRESS           ' Read each character from the CDATA string
  If DATA_BYTE = 0 Then EXIT_LOOP2    ' Exit if NULL found
  Print DATA_BYTE                     ' Display the character
  Inc ADDRESS                         ' Next character
  Wend                                ' Close the loop
EXIT_LOOP2:
  Stop
             
ADDR_TABLE: CDATA AS WORD STRING1, STRING2 ' Table of address's
STRING1: CDATA "HELLO",0
STRING2: CDATA "WORLD",0

See Also

Hocam umarım bir çözüm bulabilriz.

Bu aşamada sana yazıları oluşturan haflerin sütün bilgileri gerekecek. Bu durumda çözüm sanıırm kendi oluşturduğun karekter tablosu ile bu kaydırmayı yapmak

Hocam bu kısmı birazdaha açıklayabilirmisiniz. herflerin sütün bilgilerini bulabilirim. Sonuçta her harf 6 sütünluk yer kaplıyor. Burdan yola çıkarak adresleri belirleyebiliriz. Aslında ben en çok adresleri karakter lcd lerdeki gibi önceden belirleyip kullanmaktan umutluyum. Bu akşam bunun üzerine birazdaha uğraşacağım. Xpos adresini başka bir lokkup tablosundan önceden belirleyip adresleri oradan almaya çalışacağım. Belki bu şekilde olabilir.

PROTON HELP DOSYASI

[Mucit23]

Hocam bu konuda başka bir çalışma yaptınızmı acaba son düşünceleriniz nelerdir. Ne yapmamı tavsiye edersiniz.

[ete]

Mucit başka bir şey yapmadım maalesef. Bir sürü işim var hangisine koşacağımı şaşırdırm.
Ancak senin işinle ilgili olarak mevcut düşüncem bunun yapılmaz demiyeyim ama neredeyse imkansıza yakın olduğunu yönünde. Sorun ekran karekterlerle dolduktan sonra sol baştan bit bazında kaydırılma zorunluluğu. Zira o noktaya kadar karekterleri komple kaydırabiliyorsun yalnızca bit bazında sütun adresini bir bit kaydırarak. Ama en sol noktaya geldiğin zaman artık karekterin sütun bitlerini ele alman gerekiyorki bu bilgiler elinde değil maalesef. İşte sorun burada.
Yineliyorum. Karekterleri sen tanımlarsan olur bu iş yoksa unut gitsin derim.

Ete

[Mucit23]

Peki hocam son bir önerim var. Buda olmazsa unuturum bu işi. Daha önce demiştim. Harfleri pixel pixel kaydırmayalımda karakter lcd lerdeki gibi öncende belirlenmiş sabit adreslere yerleştirerek kaydırsak olmazmı.
Örnekle açıklayayım

Bir lookup tablomuz olsun. 
lokup x,[WWW.ETEPiC.COM KAYAN YAZI DENEMESiDiR],asc
İçerisinde 37 karakter var. Şimdi lcd ekranı 127 sütün olduğunu düşünürsek, 1 pixeli aradan çıkartıp 126 Sütün olarak düşünelim. Bunu 6 ya bölsek 21 eder. Yani Ekrana yan yana tam olarak 21 karakter sığabiliyor. Biz şimdi Önceden lcd ekrandaki adresleri belirleyelim.

Başka bir lookup tablomuz olsun buradaki Z değeri ise ekranın adresini belirlesin
lookup z,[0,7,12,18,24,30,36,42,48,54,60,66,72,78,84,90,96,102,108,114,120,126],ADRES
Hocam lcd ekran adresleri tam olarak buşekilde olması lazım.
Biz ilk başta 0. adresten itibaren 20 karaktere kadar  sapace(boşluk) yani 32 değerini 21. adrese ise lookup tablosundaki ilk karakterimizi yerleştirelim. Belli bir süre kadar bekleyip bu sefer ikin karakteri yerleştirmek için bu sefer 19. adrese kadar space 20 ve 21. adrese ilk iki harfi yerleştirelim. Bu böylece Ekran tamamen dolana kadar devam etsin. Tüm ekran dolunca Bu sefer ekrana yazılacak akarakterlerin olduğu tablodan 21 karakterlik parçalar halinde ekrana yerleştirirsek Ekran dolduktan sonra yine karakterler kaymaya devam eder. (Teoride))) Bu şekilde tüm karakterler ekrana yerleştirildikten sonra  bu sefer harflerin sonlarına space ekleyerek Bu sefer ekrandan silinmesini sağlayabiliriz. Tüm karakterler silindikten sonra Tüm işlemler baştan başlar.
Tabi bu dediklerimin hepsi Teorik olarak kafamda dolanıyor. İşi icraata dökemiyorum. Benim aklımda böyle bir fikir var .
Siz ne dersiniz.

[ete]

Yazını hiç okumadan olur diyorum. Çünki karekter bazında kaydırmak çok zor değil. O zaman benim programdan mantığı alacaksın ve biraz değiştirerek Proton'a uygulayacaksın.

Şimdi yazına bakıyorum. Hesap hataların var.  Ekran 128 sütun , her karekter 5 pixellik sütun işgal eder. ara boşluklarla bu 7 pixel edecek demektir. O halde 128/7=18 karekter ekrana sığdırabiirsin.
18*7=126 edeceğine göre her iki baştan birer sütun boş bırakılacak demektir.
O halde karekterler 1-7-14-28-35-42-49-56-63-70-77-84-91-98-105-112-119 nolu sütunlarda yer alacak demektir.
Benim program mantığına uygun olarak,
- Önce en sağdaki 119 nolu adrese yazılacak yazı dizisinin ilk elemanını koyuyorsun
- sonra ekran gecikmesi ile birlikte bu sefer 112 ve 119 adreslerine iki karekter koyuyorsun. Ardından ekran gecikmesi
- sonra 105 -112-119 adreslerine 3 karekter koyuyorsun ve ekran gecikmesi
- sonra 98 -105-112-119 adreslerine 4 kaqrekter koyuyorsun sonra ekran gecikmesi
- Bu işi 18 karekteri ekrana koyuncaya kadar devam ediyorsun. 18 karekter sonunda ekran dolmuş olacaktır.
- Sonra 17. karekterden itibaren 18 karekteri ekrana koyuyorsun
- SOnra 16. karekterden itibaren 18 karekteri ekrana koyuyorsun
-1. karektere kadar bu şekilde devam ettikten sonra bu sefer baştan 17 karekteri ekrana koyuyor ve son karektere boş karekter koyuyorsun
- sonra 16 karekter,+1 boş
- Sonra 15 karekter +1 boş
-....devam ediyorsun
- 1 karekter+1boş şeklinde sona geliyorsun.
- ensonda boş karekteri ekrana koyup işi bitiriyorsun.
Bu dediklerim aşağı yukarı benim programında mantığını oluşturmaktadır.
BU yazılanları programa dönüştürürsen işin hallolacaktır.
Sen uzun yoldan da olsa yaz sonuçta bende yardım edeyim (edecek durum var ise) programı kısaltıp işi bitirelim.

Ete

[Mucit23]

Anladım hocam Ben akşam bu işle yine uğraşacağım. Dediğim gibi bu sefer sizin yazdığınız programa adapte etmek çok daha kolay olacaktır.

[Mucit23]

Merhabalar Ete hocam;
Dün akşam biraz uğraştım. Sizin yazdığını programa uydurmaya çalıştım. Sonunda yazıyı kaydırabildim. Yanlız hocam Sizin adreslemeniz yanlış oluyor. Eğer Sizin yaptığınız gibi yaparsam her harf arası 2 pixe boşluk oluyor. Dolayısıyla ekrana 17 karakter sığabiliyor. Her harf kendisi için 5 pixel yer kaplıyor. Sonda 1 pixel de iki harf arası boşluk için koyulması gerekiyor. Sonra 2. harfin dataları başlıyor.
Örnek vermek gerekirse
1. pixel başlangıc adresi olsun
1. pixel ile 5. pixel arası harf dataları 6. pixel boşluk, 7. pixel 2 harfin başlangıc adresi.Bu şekilde her harfin başlangıç adresine 6 ekliyerek bir sonraki harin başlangıç adresi ortaya çıkıyor. En fazla 22 harf sığdırabildim. yazı kaymasına kayıyor ama biraz zamanlama problemleri ortaya çıktı. Bunu görebilmeniz için ufak bir video çektim.

http://www.youtube.com/watch?v=dEUy6UEzzdw

Hocam videodanda anlaşılacağı üzere video ilk başta ekrana hızlı geliyor honra yavaşlamaya başlıyor. Tüm ekran dolunca normal hızında devam ediyor. Buna neyin seben olduğunu düşünüyorum. Aklıma bir sebeb geldi.
İlk başta herfleri ekrana yerleştirirken Her seferinde for düngüsünün döngü sayısı bir arttığı için zamanla gecikme artıyor. Dolayısıyla harf sola yanaştıkça kayma hızı yavaşlıyor. Tüm harfler yüklenince düngü sayısı sabit olduğu için normal hızında kaymaya devam ediyor. Çok inceledim birtek sorunun burada olduğunu düşünüyorum. Çözüm için siz ne önerirsiniz bileme ama yine benim aklımda 2 yöntem var.

1. si harfleri ekrana yerleştirirken herseferinde döngü sayısını sabit tutmak. Max 22 karakter ekrana sığdığan göre for döngüsünü 22 olacak şekilde ayarlıyalım. Her seferinde ekrana 1 harf yerleştirirken diyelim 22 karakter sığıyorsa ilk 21 harf (space) boşluk son harf kayacak olan metnin 1 harfi, Bi gecikmeden sonra ilk 20 harfboşluk. Son iki harf kayacak olan metnin 1. ve 2 harf leri ekrana yerleştirilir. Tüm ekran dolunca ikinci bölümde kaydırmaya devam edilir.

2. yöntemim ise döngü arasındaki gecikmeyle oynama. ekran dolmaya başlayınca döngü süresini azaltarak kayma hızını sabit tutmaya çalışmak. Ne kadar satabil olur bilemiyorum..

Benim akllıma bu iki yöntem geldi. Siz ne önerirsiniz?

[ete]

1. yöntemin daha mantıklı olduğunu ve uygulamasının kolay olduğunu düşünüyorum.
Aslında bu kadar gecikme farkı olmaması gerekirdi. Zira işlemci onalrı anında koyması gerekirdi. Ama ne hikmetse bir gecikme yaratıyor.
Yazdığın kodu görmedim ama şayet ekran doldurulurken hehangi bir pause (delay) komutu kullanmış isen bu sorunu o yaratır.
Benim uygulamamda ekran doldurulurken herhangi bir gecikme yok. Ekran doldurulup kaydırma yapılırken gecikme koyuyorum. Böylece benim uygulamamda bu beklemeyi fark edemiyorsun. Sende yazdıklarını bir gözden geçir istersen.
Ete

[Mucit23]

Hocam kodu eklemeyi unutmuşum. Sizin kodlarınız.. fazla bir değişiklik yok aslında.

Device 18F4620

Config_Start
   OSC = HS ; HS
   FCMEN = OFF ; Disabled
   IESO = OFF ; Disabled
   PWRT = OFF ; Disabled
   BOREN = OFF ; Disabled
   WDT = OFF ; Disabled
   MCLRE = On ; Enabled
   LPT1OSC = OFF ; Disabled
   PBADEN = OFF ; PORTB<4:0> digital on Reset
   STVREN = OFF ; Disabled
   LVP = OFF ; Disabled
   XINST = OFF ; Disabled
   Debug = OFF ; Disabled
Config_End

Xtal 20
TRISA=%00000000
TRISB=%00000000
TRISC=%00000000
TRISD=%00000000
TRISE=%00000000

PORTA=0:PORTB=0
PORTC=0:PORTD=0
    PORTE=0
   
LCD_DTPort = PORTB                 'GLCD DATA PORTLARI PORTB'YE BAĞLI
LCD_RSPin = PORTD.4                'GLCD RS PİNİ PORTD.4 BAĞLI
LCD_ENPin = PORTD.2                'GLCD ENABLE PİNİ PORTD.2 BAĞLI
LCD_RWPin = PORTD.3               'GLCD RW PİNİ PORTD.3 BAĞLI
LCD_CS1Pin = PORTD.0               'GLCD CS1 PİNİ PORTC.2 BAĞLI
LCD_CS2Pin = PORTD.1               'GLCD CS2 PİNİ PORTC.3 BAĞLI
LCD_Type =  Samsung             'GLCD TİPİ GRAFİK KS0108 128*64B WİNSTAR
Internal_Font = On                 
Font_Addr = 0
Declare GLCD_STROBE_DELAY = 5
GLCD_EXTERNAL_PRINT = PPRINT

Dim XPOS  As Byte
Dim YPOS  As Byte
Dim I     As Byte 
Dim X     As Byte
Dim Z     As Byte
Dim ASC   As Byte
Dim ADR   As Byte
Dim YER   As Byte
Dim TAM   As Byte
Dim ILK   As Byte
Dim SON   As Byte
Dim KES   As Byte
Dim POZ  As Bit
    DelayMS 10
    Cls
Print Font Arial____6o75
BASLA:
DelayMS 500
      X=0:YER=21:TAM=21
BIR:
   
   For I=YER To TAM
   X=TAM-YER
IKI:   
    Z=YER+X
    GoSub ADRES_AL
    GoSub KARAKTER_AL
    Print At 1,ADR,ASC
    X=X-1
    If X<255 Then IKI
    Next     
    YER=YER-1
    If YER=255 Then UC
     DelayMS 50
   GoTo BIR
UC:       
   ILK=0:SON=21:POZ=0
DORT:
   Z=0     
   For X=ILK To SON
     GoSub ADRES_AL 
     GoSub KARAKTER_AL
     If ASC=255 Then
       ASC=124
       If POZ=0 Then KES=SON
       POZ=1
     EndIf 
     Print At 1,ADR,ASC
     Inc Z
     If Z=22 Then Z=0
   Next
CIK:   
   DelayMS 50
   ILK=ILK+1:SON=ILK+21
   If POZ=1 And ILK>KES Then BASLA
   GoTo DORT
   
KARAKTER_AL:
ASC=LookUp X,["ETENIN|YAZI|KAYDIRMA|DENEME|SURUMU|BIRAZ|DAHA|EKLEYELIM",255]
Return

ADRES_AL:
ADR=LookUp Z,[ 1,7,13,19,25,31,37,43,49,55,61,67,73,79,85,91,97,103,109,115,121,127]
Return   

End     
Include "ARIAL_S_7.txt"

Hocam döngü arasında harici bir gecikme yok. Sizin dediğiniz gibi tüm harfler ekrana yerleştirildikten sonra belli bir gecikme var. Ondan sonra harfler bir kaydırılarak yeniden yazılıyor..

[ete]

Bu durumda bit bazında yerleştirme epeyce zaman alıyor anlaşılan sorun ordan kaynaklanıyor.
Yapacağın iş birinci öneri alternatifini uygulamak.

Kolay Gelsin
Ete

[Mucit23]

Anladım hocam. Öneriniz için teşekkür ederim. Bundan sonrasını benim halletmem gerekir