OK Mégsem
Fórum témák

» Több friss téma
Cikkek » Launchpad: ismerkedés az MSP430 mikrovezérlőkkel I.
Launchpad: ismerkedés az MSP430 mikrovezérlőkkel I.
Szerző: icserny, idő: Szept 7, 2011, Olvasva: 51204, Oldal olvasási idő: kb. 4 perc
Lapozás: OK   7 / 9

Harmadik kísérlet: saját karakterek definiálása

Az LCD modulok beépített karakterkészlete nem alkalmas a magyar nyelvű szövegek ékezetehelyes megjelenítésére. Bár a karakterkészlet elvétve tartalmaz más nyelvekben is használatos ékezetes betük, a 128 fölötti kódok zöméhez általában japán vagy cirill betűk tartoznak,  ahogy az alábbi ábrán is láthatjuk.

kodtabla.png

6_5. ábra: egy tipikus LCD modul kódtáblája

Szerencsére van rá lehetőség, hogy néhány saját karaktert definiáljuk (szám szerint legfeljebb 8 db-ot), így ezek, és a kódtáblában már eleve benne levők felhasználásával legalább az ékezetes kisbetűk kiíratását meg tudjuk oldani.A karekterek definiálása az ún. CGRAM terület feltöltésével történik, ahol (a CGRAM területen belül) a 0. címtól kezdődően karakterenként 8 bájtban adhatjuk meg egy-egy karakter 8x8-as pontmátrixban definiált képét.

A CGRAM terület kijelölése a 6_2. táblázatban ismertetett "CGRAM cím beállítása" paranccsal történik. Ezt követően minden adatbeírás a CGRAM soron következő címére történik, amíg egy "DDRAM cím beállítása" paranccsal vissza nem állunk a megjelenítési adattár területére.

Az alábbi programban az lcd_cgram_init() függvény végzi el a CGRAM terület feltöltését a konstans tömbként definiált adattáblából. A konstansként definiált adatokat a fordító a programtároló flash memóriában helyezi el.

Az ékezetes karaktereket felhasználó demóprogramban egy kétsoros LCD képernyő egy-egy sorában a Hungarica együttes közismert dalának egy-egy versszakát jelenítjük meg, fényújság-szerűen, jobbról balra beúsztatva. Ebben bemutatjuk, hogy hogyan lehet a kurzort pozicionálni, s bemutatjuk azt is, hogy hogyan lehet a képernyőre kiírt teljes szöveget egy utasítással  egy karakternyit balra léptetni.

A karakterek kiíratására definiáltunk egy lcd_putc() függvényt, amely automatikusan elvégzi az ANSI kódoslású ékezetes karakterek átkódolását. A CGRAM-ban általunk definált karakterek a 0 - 7 közötti kóddal érhetők el, a 'ö' betű pedig a 0xEF kóddal érhető el.

A program jelentős mértékben megegyezik a korábbiakkal, ezért csak az eltérő részek listáját mutatjuk be. Nyissunk tehát egy új projektet lcd_cgram névvel, másoljuk bele az első vagy a második kísérlet LCD kezelő programját, s szerkesszük át az alábbiak szerint.

1. A program elejére a hardver definíciók utáni részbe szúrjuk be az alábbi sorokat:

***************************************************************************************

  1. unsigned char i,d;
  2. const unsigned char *ptr1, *ptr2;
  3. const unsigned char betwk[] = {0x02,0x04,0x0E,0x01,0x0F,0x11,0x0F,0x00,    //á
  4. 0x02,0x04,0x0E,0x11,0x1F,0x10,0x0E,0x00,    //é
  5. 0x02,0x04,0x0C,0x04,0x04,0x04,0x0E,0x00,    //í
  6. 0x02,0x04,0x0E,0x11,0x11,0x11,0x0E,0x00,    //ó
  7. 0x02,0x04,0x11,0x11,0x11,0x13,0x0D,0x00,    //ú
  8. 0x0A,0x00,0x11,0x11,0x11,0x13,0x0D,0x00,    //ü
  9. 0x05,0x0A,0x11,0x11,0x11,0x13,0x0D,0x00,    //ű
  10. 0x05,0x0A,0x0E,0x11,0x11,0x11,0x0E,0x00};   //ő
  11. const unsigned char vers1[] = {
  12. "Adjon az Isten szebb jövőt!
  13. Legyen úgy, mint régen!
  14. Piros, fehér, zöld szivárvány
  15. Ragyogjon újra az égen!    "};
  16. const unsigned char vers2[] = {
  17. "Adjon az Isten igaz hitet,
  18. Bátor szívet, erős kart,
  19. Oltalmunkra kardot, pajzsot,
  20. Isten óvja a magyart!        "};

**********************************************************************************************

Az i és d változók a főprogramban számlálóként működnek majd. A *ptr1 és *ptr2 mutatókat a két versszak címzésére használjuk majd. A konstansként definiált betwk[] kataktertömb a CGRAM feltöltéséhez kell (az ékezetes karakterek bitképét tartalmazza). A vers1[] és vers2[] szövegkonstansok pedig a kiírandó szöveget tartalmazzák.

A  ChangeBits(), delay_ms(), lcd_toggle_E(), lcd_write() és lcd_init() függvények maradjanak ugyanúgy, ahogy az előző két kísérletben voltak! Az lcd_puts() függvény azonban dobjuk ki, most nem lesz rá szükségünk. Helyette két új függvényt definiálunk, lcd_putc() éslcd_cgram_init() névvel, az alábbi lista szerint:

 

  1. /**----------------------------------------------
  2. *  Karakter kiírása az LCD-re az ékezetes
  3. *  karakterek kódjának áttranszformálásával
  4. *-----------------------------------------------
  5. * param data a kiírandó karakter ANSI kódja
  6. */
  7. void lcd_putc(unsigned char data) {
  8.          char c;
  9.          if (c=data) {
  10.            switch(c) {
  11.              case 'á':  c = 0x00; break;
  12.              case 'é':  c = 0x01; break;
  13.              case 'í':  c = 0x02; break;
  14.              case 'ó':  c = 0x03; break;
  15.              case 'ú':  c = 0x04; break;
  16.              case 'ü':  c = 0x05; break;
  17.              case 'ű':  c = 0x06; break;
  18.              case 'ő':  c = 0x07; break;
  19.              case 'ö':  c = 0xEF; break;
  20.            }
  21.            lcd_write(c,1);
  22.          }
  23. }
  24.  
  25. void lcd_cgram_init(void) {
  26.          lcd_write(0x40,0);                   // kurzor a CGRAM elejére
  27.          for(i=0; i<64; i++) {
  28.            lcd_write(betwk[i],1);             // karakterek feltöltése
  29.          }                                    // ékezetes karakterekkel
  30.          lcd_write(0x80,0);                   // kurzor a DDRAM elejére   
  31. }

 

Vegyük észre, hogy az lcd_putc() függvény elején az if utasítás feltételében nem egyenlőséget vizsgálunk, hanem egy értékadást helyeztünk el (átmásoljuk az adatot a c változóba), melynek végeredményét vizsgáljuk, hogy nullától különböző-e. A vizsgálatnak azonban nincs nagy jelentősége, csupán az esetleges nulla karaktereket szűrjük ki.

A főprogramban jelentős eltérések vannak a korábbiaktól, ezért azt teljes terjedelmében bemutatjuk.

 

  1. int main(void) {
  2.          WDTCTL = WDTPW + WDTHOLD;            //watchdog letiltása
  3.          P1DIR |= BIT0;
  4.          lcd_init();
  5.          lcd_cgram_init();                    // Ékezetes karakterek feltöltése
  6. //-- balra léptetés -----
  7.          ptr1=vers1;                          // Mutatók inicializálása
  8.          ptr2=vers2;
  9.          i = 0; 
  10.          d = 40;                              // a DDRAM első feltöltésénél számlál
  11. while(1) {     
  12. if(d) {d--;} else {                // első feltöltésnél nincs léptetés
  13.          delay_ms(200);                   // 200 ms késleltetés
  14.          P1OUT ^= BIT0;                   // LED1 villogtatás
  15.          lcd_write(0x18,0);               // kijelző balra léptetés
  16. }
  17. if(!*ptr1) {                       // Mutatók helyreállítása ha
  18.          ptr1=vers1;                     // elértük a szöveget lezáró nullát.
  19.          ptr2=vers2;                     // A második vers nem lehet rövidebb
  20. }                                  // az elsőnél!
  21. lcd_write(0x80+i,0);               // Kurzor az első sorba
  22. lcd_putc(*ptr1++);                 // Egy karakter kiírása (vers1)
  23. lcd_write(0xC0+i,0);               // Kurozor a második sorba
  24. lcd_putc(*ptr2++);                 // Egy karakter kiírása (vers2)
  25. i++;                               // DDRAM címszámláló
  26. if(i==40) i=0;                     // a 40. karakter után körbefordul
  27. while(!(P1IN&BIT3)) delay_ms(20);  // S2 nyomógomb figyelés, pergésmentesítéssel
  28. }     
  29. }

 

A programban kihasználtuk, hogy a kétsoros kijelző is 80 karakter tárolására alkalmas DDRAM területtel rendelkezik, ezért soronként 40 db karaktert írunk be, balra léptetésnél is ugyanennyi pozíció van, utána körbefordul a megjelenítés.


A cikk még nem ért véget, lapozz!
Következő: »»   7 / 9
Értékeléshez bejelentkezés szükséges!
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