Fórum témák

» Több friss téma
Fórum » Karakteres LCD-k meghajtása, vezérlése
Lapozás: OK   8 / 17
(#) nagym6 válasza don_peter hozzászólására (») Szept 26, 2014 /
 
Valóban ahogy írod, olvasni is kell a basic programban is minden beírás után a "STA0" parancs végrehajtás, és "STA1" adat írás-olvasás státuszbiteket. Megpróbáltam, kiiktattam a kijelzőből olvasást, helyette kellően hosszú késleltetést tettem be, így nem működött.
Találtam ASM CGRAM feltöltő rutint, a T6963C adatlapján. Mellékeltem, 58 és 95 sor erről szól. "Mode Set" kell átállítani CGRAM módba.
Előző hsz.-ben mellékelt "AN-029" 21 oldalán is van szó erről, hátha segít.
A hozzászólás módosítva: Szept 26, 2014

CgRam.rtf
    
(#) don_peter válasza nagym6 hozzászólására (») Szept 26, 2014 /
 
Köszi, majd ezt is megnézem.
Az adatlapok nagyon érthetetlen módon írják össze a CGRAM kezelését.
Nem értem az egészet.
Az egyik ezt a másik tök mást ír le.
Azt tudom már én is, hogy 0x1400-tól kezdődik a CGRAM ahová tárolhatom a 8x8-as karaktereket.
De egyelőre még nem tudom, hogyan..

Nos viszont az ékezetes karaktereket amelyeket tegnap említettem összeszedtem és írtam rá egy rutint amely egy stringet képes kiírni a képernyőre természetesen már behelyettesítve az ékezetes karaktereket.
Nem tudom, te milyen nyelvben programozol és tudod e hasznosítani, de ha nem is egy az egyben akkor is ötletet illetve segítséget nyújthat.:
A rutin: (C18)
  1. // Szöveg kiírása tömbből (char tomb[])
  2. void glcd_write(char *pttext){
  3.         unsigned char betu;
  4.         while(*pttext!=0){
  5.         betu = *pttext++;
  6.         switch(betu) {
  7.             case 'á':  betu = 0x85; break;
  8.             case 'é':  betu = 0x82; break;
  9.             case 'í':  betu = 0x8D; break;
  10.             case 'ó':  betu = 0x95; break;
  11.             case 'ú':  betu = 0x97; break;
  12.             case 'ü':  betu = 0x81; break;
  13.             case 'ű':  betu = 0x96; break;
  14.             case 'ő':  betu = 0x93; break;
  15.             case 'ö':  betu = 0x94; break;
  16.     }
  17.                 glcd_WriteCmd1(betu - 0x20, 0xc0);
  18.         }
  19. }

A meghívás, majd kiírás:
  1. char text[] = "Peti a király, áéíóúüűőö";
  2. glcd_gotoxy(2,2,1);
  3.     glcd_write(text);

Eredményt csatoltam.

IMAG1271.jpg
    
(#) don_peter hozzászólása Szept 26, 2014 / 1
 
No, végre sikerült kihámoznom, bár már működik, de még mindig nem értem pontosan a dolgot.
A lényeg, hogy az adatlap nem volt pontos és a CGRAM tekintetében elég hiányos.
Találtam egy Kínai oldalt ahol volt egy rutin és azt sikerült visszafejtenem és így megírnom a rutint..: Bővebben: Link
  1. void Load_CGRAM(static rom char *uschars, unsigned char uscharscount);
  2. static rom char icon[] = {0xE0,0xA0,0xE0,0x00,0x00,0x00,0x00,0x00}; //Fok
  3. void Load_CGRAM(static rom char *uschars, unsigned char uscharscount){
  4.         unsigned int i;  
  5.         glcd_WriteCmd2(0x0003, SetOFFSetR);
  6.         glcd_WriteCmd2(0x1c00, SetADDRPointer); // 7kb
  7.         glcd_WriteCmd1(1, AutoModeWrite);
  8.         for(i=0;i<(uscharscount*8);i++){  
  9.                 glcd_WriteByte(0, *uschars++);
  10.         }  
  11.         glcd_WriteCmd1(1, AutoModeReset);  
  12. }

Gyakorlatilag végig pörgettem az összes letárolt karaktert és ott volt közte az enyém is.
Innen már csak meg kellett keresnem a közvetlen címet ami az esetemben 0xA0-án pihent.
Szóval ez is meglett végre..

Tovább léphetek
A hozzászólás módosítva: Szept 26, 2014
(#) nagym6 válasza don_peter hozzászólására (») Szept 26, 2014 /
 
Köszi a rutinokat, ez segítség, ha ilyen feladat adódik. Szépen haladsz a témában. Én basic-ben programozgatok, ebből is következően nem profi szinten. Ez nagyon leegyszerűsíti a grafikus lcd programozást. De a CGRAM használatot ugyanúgy kell megoldani, mint nálad, abban nem egyszerűsít. Ha valakinek van ideje, türelme, esze a kijelző alapos megismeréséhez, asm vagy c nyelvű munkához, az azért természetesen jobb eredményt ad, lényegesen több munkával.
(#) don_peter válasza nagym6 hozzászólására (») Szept 26, 2014 /
 
Nagyon sok idő mire az ember elmélyíti a tudását egy-egy témában és valljuk meg őszintén, ami mér meg van írva azt nem szeretnénk még egyszer megírni vagy kitalálni...
Egy csomó időt megspórolhatunk. (és egy csomó projektem van)
Ennél a kijelzőnél nem volt kész program, csak hasonló amiből ki lehetett indulnom, de így is nagyon sok idő volt átírni és értelmezni..
Most már talán menni fog a munka ezzel a kijelző típussal is vagy is hát itt igazából a t6963 vezérlős kijelzőkre gondolok.
Az új forrasztógépem kijelzője lesz.
(#) nagym6 válasza don_peter hozzászólására (») Szept 27, 2014 /
 
Én 6x8 karaktermérettel használom, ez jobb, mert 8x8 -nál nagyon ritkán vannak a betűk, azaz nagy a karakterköz. A karakterkészletre gondolok. Ugyanaz a betűalak, csak 8x8-nál nagyobb a hézag közöttük, 6x8-nál kisebb, normál karakterköz van. A sima karakteres lcd-k megjelenítése a T6963C 6x8 karakterhez hasonló. FS1 lábon vezérelhető.
A T6963C két grafikus és két TXT memóriára is programozható, ekkor egyszerűen lehet váltani bármikor a kettő között. Amíg egyik memória a kijelzőn van, addig a másik kép a háttérben a másik memóriában készülhet. Elég akkor váltani a másikra, amikor készen van.
A hozzászólás módosítva: Szept 27, 2014
(#) don_peter válasza nagym6 hozzászólására (») Szept 27, 2014 /
 
Igen, az nekem is feltűnt. (nagyon nagyok a közök)
Egyelőre ezt még én nem néztem meg, de elvileg az egyik lábon nem magas hanem alacsony szintre állítva lesz 6x8-as karakter méret, ahogyan te is írtad: FS = Font Size (vagy fordítva)
Csak remélem, hogy mást nem kell variálni mert az már sok lenne
Majd később megnézem, hogy van ez és majd beszámolok a fejleményekről..
(#) don_peter válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
Megtennéd nekem, hogy megnézed neked hogy van beállítva a következő néhány cím?
  1. #define TextHome           0x0780;
  2. //#define TextArea              0x001E // Hány bájt egy sor (30) // Ha 8x8
  3. #define TextArea                0x0028 // Hány bájt egy sor (40) // Ha 6x8
  4. #define GraphicsHome    0x0000
  5. //#define GraphicsArea  0x001E // Hány bájt egy sor (30) // Ha 8x8
  6. #define GraphicsArea    0x0028 // Hány bájt egy sor (40) // Ha 6x8

Valamiért szemeteli a képet, úgy vélem a 8-adik sor alsó pixeleiben.
Mint ha nem férne bele az első sor felső (pixelei) része és azt tolná át oda. (pedig belefér)
(#) don_peter válasza don_peter hozzászólására (») Szept 28, 2014 /
 
Oké, közben rájöttem, hogy a TextHome-t nem jól számoltam.
Most már jó lesz.
Egyébként annak értéke minimum a 0x0A00 vagy is:
(kijelző szélessége / karakter szélességével) * kijelző magasságával == 2560 == 0x0A00 == 2,5kb
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
Nálam ezek a címek vannak, -a mellékletben- de ez az 1 kijelzőmemóriás beállítás. Tehát nem 2 memória van a kijelzőnek, amik között váltani lehetne. A szemetelés és eltolás valószinüleg az "FS" karakterméretnél keresendő. Nálam a basic-nél nem szabad menet közben váltani az "FS"-t, akkor vannak ilyen gondok. Csak a program elején egyszer megadni a karakterméretet, utána nem variálni. Ha 6x8 van megadva, menet közben váltok 8x8-ra, akkor meg szaggatott lesz kép, minden 6 pixel után 2 üres pixel van. Ami ugye a váltás miatti kitöltés a 6-ból 8-ba vízszintesen. Ha 8x8-ból váltok menet közben 6x8-ba, akkor összenyomott lesz, kiveszi 8-anként a 2 pixelt.

LcdGr.txt
    
(#) don_peter válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
Érdekes, hogy neked a text_home nincs beállítva.
Nekem be van sőt kijelzőmérettől függően ahogyan fentebb le is írtam változik a beállítás.
  1. TextHome = (res_x/betu)*res_y;  // 0x0780; 8x8-as betűméretnél
  2.                                 // 0x0A00; 6x8-as betűméretnél
A hozzászólás módosítva: Szept 28, 2014
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
De be van állítva, a text_home $0000 azaz 0 címen van. Ez a net-ről letöltött basic-ben eredetileg van így állítva, ezzel működik tökéletesen. 6x8 karaktermérettel.
A hozzászólás módosítva: Szept 28, 2014
(#) don_peter válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
Az érdekes mert ez nem címet, hanem memória területet ad meg a szöveges módnak.
Tehát ezzel tudod beállítani mekkora kijelződ van és mekkora memóriát igényel szöveges üzemmódba.
Én így értelmezem.
Tehát amikor 8x8-as karakterméret volt beállítva akkor 0x0780 mérettel vagy is 1920bit-el kellett számolni mivel 8x30 karaktert tud maximum megjeleníteni.
8x30 == 240 * 8 == 1920 == 0x0780
6x8-as karakterméretnél:
8x40 == 320 * 8 == 2560 == 0x0A00

Nekem csak így hajlandó működni normálisan..
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
A text_home itt kezdőcímet jelent, text_area a méret az előbbi címtől kezdve. Így tökéletesen működik az a basic, amit régebben mellékeltem.
Találtam még 2 anyagot, csatoltam.
(#) vilmosd válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
Mar bocs de ezt a C-s peldat mar az elejen beraktam, de a kolleganak nem tetszett.
(#) don_peter válasza vilmosd hozzászólására (») Szept 28, 2014 /
 
Már bocs, de már előbb megtaláltam mint ahogy linkelted volna csak az eredetiét használtam fel...
És tetszett a kollégának
A hozzászólás módosítva: Szept 28, 2014
(#) don_peter válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
No már akkor ki is fejtettem, hogy a feltöltött állományokból merítkeztem előzőleg és azok alapján indúltam el, de persze nem volt jó sem a memória, sem a címek illetve már nem is emlékezem, miket kellett teljesen átírni..
A lényeg, hogy már maga a kijelző működik és használható...

A kérdésem az lenne, hogy te csak szöveges vagy grafikus módban is használod?
Mert, ha 8x8-as betűméret van kiválasztva akkor jól és könnyen lehet használni a grafikus üzemmódot is, de ha a 6x8-as van kiválasztva akkor katasztrófa.
Nem is tudom, hogy lehetne abban normálisan használni.
Már azon gondolkodom, hogy írok egy webes programot ahol 6x8-asra karaktermérettel lehet kialakítani nagyobb grafikus felületet.

Most ezzel a váltással szívok.
Mindent átríttam ami szükséges a 8x8 és 6x8-as váltásra, a karakterek szépen meg is jelenek és persze jó helyen, de a grafika .....újra kell írni a teljes grafikus rajzoló függvényeket.
(#) vilmosd válasza don_peter hozzászólására (») Szept 28, 2014 /
 
Bocs de nalam itt virit a PC mar egy par eve.
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
Én szöveges és grafikus módban egyszerre használom. A helyzet nálam is hasonló, 6x8 módban a blokk beolvasás zavaros lesz. De csak a blokk beolvasás. Tehát egy pld.: 24x24 pixeles képet beolvasok bármelyik pozícióba, zavar lesz. Ugyanez 8x8 módban tökéletes. Ha egy 8x8 képet olvasok be 6x8 módban, jobbról a 7-8 oszlopot törli. Ha 16x8 képet, akkor ez olyan lesz, mintha különvenné 2db. 8x8-nak, mindkettő jobbról 7-8 oszlopát törli, majd az így kapott két 6x8-ast egymás mellé teszi. Tehát a 16x8 képnek a jobbról 7-8, és 15-16 oszlopa hiányzik, így, de összetolva jeleníti meg. Erre lehetne kalkulálni a kép készítésekor, de ha 24x8 képpel próbálom, ami 3db. 8x8-nak megfelelő méret, már nem ugyanígy csinál a kijelző. Nem 2 oszlopot vesz ki 8x8-anként mint a 16x8 képnél, hanem teljes mákos zűrzavar lesz. Tehát nem ugyanazzal a logikával kezel 16x8-as képet, mint a 24x8 képet.
Én basic-kel csinálom. Hátránya, hogy nem tudom pontosan, mit csinál a progi a kijelzővel. Azt hittem nálad ez nem jelentkezik, a közvetlen kijelző programozásnál. De ezek szerint ez lehet, hogy nem is a basic hibája, ha nálad is jelentkezik.
Van két féle kijelzőm, az Optrex, amiről itt beszélünk, és az LM4229, 240x128-as felbontású.
Az Optrex 6x8 és 8x8 módban rendben írja a karaktereket, bármekkora vonal, rajzolása is tökéletes. Csak a blokk beolvasás 6x8 módnál nem jó, 8x8-nál jó.
Az LM4229 8x8 módban sehogy sem jó, vízszintesen eltolva jelenik meg az egész kijelzőkép. Semmiféle beállítással nem tudom helyre tenni. Csak 6x8 módban jó. Szerintem a kijelző panelon a T6963C bekötése lehet ilyen. Itt jó a karakter írás, vonal rajzolás, a blokk beolvasás rossz. De ha 8x8 módba teszem, akkor jó a blokk beolvasás, csak az egész kép eltolt, mint előbb írtam.
Basicben csinálom, így nem igazán tudom mikor mit csinál a kijelzővel a program. Inicializálás is csak annyi, hogy megadom az ini utasítást, kijelző méretet, és 6x8 vagy 8x8 módot. Grafika vagy text memória címet, méretet nem tudok megadni, automatikusan a progi csinálja. Nem is tudom ezek értékét.
Beletörődtem, hogy az LM4229-el nem csinálok blokk beolvasást, minden más megy rajta 6x8-ban. Optrex-nél ha jó blokk beolvasást akarok, akkor 8x8 módban, de nagy karakterközökkel jeleníti meg a szöveget.
Az, hogy szöveges, vagy grafikus módban, vagy mindkettőben van, mindegy nálam. A fenti probléma ugyanúgy jelentkezik, bárhogy variálom a szöveges-grafikus módot.
A hozzászólás módosítva: Szept 28, 2014
(#) don_peter válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
Arra már rájöttem, hogy lehet megoldani a dolgot.
Lényegében a 8x8-as módban 8x8bit 1db karakter vagy blokkhely.
Tehát itt a beolvasás 8x8bit lesz és felülről lefelé haladva rajzolja ki a karaktert vagy blokkot.
Ugyan ez a helyzet a 6x8-assal is.
Tehát ha az van beállítva (6x8) akkor 6x8bitet fog felűről lefelé kirajzolni.
A baj ott kezdődik, hogy az előre legenerált kép az 8x8-as Blokkokban van, így azok nem jók 6x8-as mérethez mert levágja a bal széléről az első 2pixelt végig függőlegesen.
Tehát semmi más dolgunk nincsen csak 6x8-as blokkméretben megrajzolni a kívánt képet.

Kirajzolásnál megadtam egy hosszabb késleltetést így láttam, hogy rajzolja ki a blokkokat.
Szóval függőlegesen mindig megmarad a 8bit, de szélességre már változhat vagy 8 vagy 6-ra.

Az egyetlen baj, hogy nincs vagy nem találtam még 6x8-as blokkokkal dolgozó progit amivel meg tudnám rajzolni az esetleges képet amit ki akarok tenni.
Ráadásul amiket találtam forrásokat mind 8x8-as FS-el dolgoznak szóval ezen részt nekem kell a nulláról megírni..
Sajnos ugyan ez a helyzet a keret a vonal, és a doboznál is.

Most idáig jutottam:
  1. // Kép kirajzoló
  2. void glcd_kep(static const rom char *ptkep, unsigned short int PozX, unsigned short int PozY,
  3.                                                                          unsigned char  tx, unsigned char ty){
  4.         unsigned char i,x;     
  5.         for(i=0; i<tx; i++){
  6.                 for(x=0; x<ty; x++){
  7.                         glcd_gotoxy(PozX+x,PozY+i,0);
  8.                         glcd_WriteCmd1(*ptkep++,0xc0);
  9.                 }
  10.         }
  11. }
  12.  
  13. //Meghívás: (tömb, pozicióx, pozicióy, tömb szám, blokk szám)
  14. glcd_kep(tomb,11,18,5,4);

Ezzel gyakorlatilag ki lehet íratni az elkészített képet.
Egyelőre 8x8-ast írattam ki mivel nincs 6x8-as képem, de ezzel már meg lehet oldani a 6x8-as kirajzolást is, csak úgy kell legenerálni a képet.
  1. //Most így néz ki egy teli blokk:
  2. 0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF
  3. //És 6x8-ban így nézne ki:
  4. 0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF
  5. //Vagy:
  6. 0xFF, 0xFF,0xFF, 0xFF,0xFF, 0xFF,0x00,0x00
A hozzászólás módosítva: Szept 28, 2014
(#) don_peter válasza don_peter hozzászólására (») Szept 28, 2014 /
 
Az utolsó részt nem jól írtam és nem tudtam már szerkeszteni:
Így néz ki helyesen:
  1. //Tehát 8x8-asban 1 teli blokk
  2. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
  3. //És 6x8-ban így nézne ki:
  4. 0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F
A hozzászólás módosítva: Szept 28, 2014
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
Akkor nálam a basic megoldja a keret, vonal, doboz rajzolást, mert azok mindig jók.
Próbáltam 6x8 blokkokból a képet öszeállítani. Úgy, hogy 8x8 blokkokban csináltam, de bal szélső 2 pixel oszlopaikat üresen hagytam, bekalkuláltam, hogy ezeket kiejti. Így 16x8-nál jó, de 24x8-nál zűrzavar lett.
Ha 6x8 blokkokkal dolgozó progi lenne, szerintem akkor is be kellene tenni a két bal szélső kiejtésre kerülő pixel oszlopot, azaz 8x8-ban kellene. Persze az én basic progim nem igazán tudni mit csinál, amit írok, nem biztos, hogy nálad ugyanúgy van. Bár idáig úgy tűnik, azonosak a problémák.
(#) don_peter válasza nagym6 hozzászólására (») Szept 28, 2014 /
 
Majd, holnap készítek egy képet 6x8-asban és kipróbálom az elméletem.
Vagy ha van már legenerált vagy megírt 6x8-as képed hexában, akkor küld át és kipróbálom.
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
A 4-es sor nem 0x3F, 0x3F,... ? Ekkor a 6-7-es bit =0, többi 1-es. De lehet ugyanúgy 0xFF, minden bit 1, mindegy mi van a két kieső oszlopban. Csak azzal kell kalkulálni, hogy a kiesett oszlopok után a maradék a jó képet adja. Ha jól gondolom.
(#) nagym6 válasza don_peter hozzászólására (») Szept 28, 2014 /
 
A képeken van a szerkesztett blokk 8x8-ban. Pirossal jelöltem, amelyikeket szerintem kiejti 6x8-nál. Akkor ezek hiánya helyére -gondolom- betolódik jobbról a mellette lévő. Így a "16x8.jpg" szerkesztett 8x8 anyagból lesz a "16x8eredmény.jpg" képen látható.
Ez a 16x8-nál nekem jó is volt, de a 24x8-nál már zavar.
A .c kiterjesztésű mellékelt szövegfájlt Notepad megnyitja, kimásolható a képanyag.
A hozzászólás módosítva: Szept 28, 2014
(#) nagym6 válasza don_peter hozzászólására (») Szept 29, 2014 /
 
Itt vannak 6x8 betűk, de ez is lényegében 8x8-nak is vehető, csak a két bal szélső oszlop üres. Tehát ha 6x8-ban csinálom, ugyanaz a HEX értéke egy sornak. A "Mind.jpg" képen látni, ilyenek a betűk, hogy teljes 6x8 pixelt kitöltik. Látható legyen, hogy esetleg honnan hiányzik, honnan vág le.
(#) don_peter válasza nagym6 hozzászólására (») Szept 29, 2014 /
 
Ja igen... oké, benéztem valamit.
A jó érték a 0x3F...
A többit meg megnézem és vissza jelzek..
(#) don_peter válasza nagym6 hozzászólására (») Szept 29, 2014 / 1
 
No megnéztem a kérdéses képet.
Nekem jónak tűnik a dolog.
Beraktam a képet hexában és a csatolt képeken látható módon teszi ki egymás mellé a képeket.
8x8-asban kicsit távolabb és 6x8-nál már szépen zárja őket hézag nélkül.
Forrás kód:
  1. // kép
  2. static const rom char proba[] = {0x01, 0x20,
  3.                                                              0x01, 0x20,
  4.                                                              0x01, 0x20,
  5.                                                              0x02, 0x10,
  6.                                                              0x04, 0x08,
  7.                                                              0x08, 0x04,
  8.                                                              0x10, 0x02,
  9.                                                              0x20, 0x01};
  10.  
  11. //Beállítások
  12. //#define TextHome              //0x0780 (8x8-as betűméretnél)
  13. unsigned short int TextHome = 0x0A00;   // Változik, LCD méretének megfelelően ezért megy globális változóba
  14. //#define TextArea              0x001E // Hány bájt egy sor (30)
  15. #define TextArea                0x0028 // Hány bájt egy sor (40)
  16. #define GraphicsHome    0x0000
  17. //#define GraphicsArea  0x001E // Hány bájt egy sor (30)
  18. #define GraphicsArea    0x0028 // Hány bájt egy sor (40)
  19.  
  20. //Kirajzoló rutin
  21. // Kép kirajzoló
  22. void glcd_kep(static const rom char *ptkep, unsigned short int PozX, unsigned short int PozY,
  23.                                                                          unsigned char  tx, unsigned char ty){
  24.         unsigned char i,x;     
  25.         for(i=0; i<tx; i++){
  26.                 for(x=0; x<ty; x++){
  27.                         glcd_gotoxy(PozX+x,PozY+i,0);
  28.                         glcd_WriteCmd1(*ptkep++,0xc0);
  29.                 }
  30.         }
  31. }
  32.  
  33. // Meghívás
  34. glcd_kep(proba,10,10,8,2);
  35. glcd_kep(proba,12,10,8,2);
  36. glcd_kep(proba,14,10,8,2);
  37. glcd_kep(proba,16,10,8,2);
  38. glcd_kep(proba,18,10,8,2);
(#) nagym6 válasza don_peter hozzászólására (») Szept 29, 2014 /
 
Nekem is jónak tűnik a dolog, sőt szerintem biztosan jó. Nálam nagyobb blokkoknál volt gond. Ugyanennél az ábránál a 16x8 blokk jó volt, a 24x8 már zavarodott. Tehát 16x8-nál rendben kivette karakterenként a balról két oszlopot, amiket pirossal jelöltem. Időm lesz, megpróbálom mégegyszer a nagyobb blokkokat.
(#) don_peter válasza nagym6 hozzászólására (») Szept 29, 2014 /
 
Nincs valami képszerkesztőd ami tudja a 6x8-as méretet is?
Nézegetem, de nem igen van free a neten.
Ezzel a Bitmap2lcd-vel szórakozom, de ez meg demó és demóban nem engedni exportálni a képet hexában....

Egyébként jó lenne mert egy csomó LCD-t ismer és T6963c-t is alapból.
A hozzászólás módosítva: Szept 29, 2014
Következő: »»   8 / 17
Bejelentkezés

Belépés

Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem