| 6 | 
           kaklik | 
           1 | 
           // LCD modul pro ovladani dvouradkoveho LCD modulu se standardnim Hitachi radicem
  | 
        
        
            | 
            | 
           2 | 
           // (c)miho 2002
  | 
        
        
            | 
            | 
           3 | 
           //
  | 
        
        
            | 
            | 
           4 | 
           // Historie:
  | 
        
        
            | 
            | 
           5 | 
           //
  | 
        
        
            | 
            | 
           6 | 
           // 0.0   Uvodni verze se snadnou definici portu LCD displeje
  | 
        
        
            | 
            | 
           7 | 
           //
  | 
        
        
            | 
            | 
           8 | 
           //
  | 
        
        
            | 
            | 
           9 | 
           // Funkce:
  | 
        
        
            | 
            | 
           10 | 
           //
  | 
        
        
            | 
            | 
           11 | 
           //   lcd_init()            inicializuje LCD displej a porty, nutno volat jako prvni
  | 
        
        
            | 
            | 
           12 | 
           //
  | 
        
        
            | 
            | 
           13 | 
           //   lcd_putc(c)           zapis snaku do lcd displeje, zpracovava nasledujici ridici znaky
  | 
        
        
            | 
            | 
           14 | 
           //                         \f = \x0C   - nova stranka - smazani displeje
  | 
        
        
            | 
            | 
           15 | 
           //                         \n = \x0A   - odradkovani (prechod na druhou radku)
  | 
        
        
            | 
            | 
           16 | 
           //                         \b = \x08   - backspace - posunuti kurzoru o 1 pozici zpet
  | 
        
        
            | 
            | 
           17 | 
           //                         \r = \x0D   - goto home to position 1,1
  | 
        
        
            | 
            | 
           18 | 
           //                         \0  .. \7   - definovatelne znaky v pozicich 0 az 7 v CGRAM
  | 
        
        
            | 
            | 
           19 | 
           //                         \20 .. \27  - alternativne zapsane znaky (oktalove) v pozicich 0 az 7 CGRAM
  | 
        
        
            | 
            | 
           20 | 
           //                         Pozor na to, ze funkce printf konci tisk pokud narazi na \0 (konec retezce)
  | 
        
        
            | 
            | 
           21 | 
           //
  | 
        
        
            | 
            | 
           22 | 
           //   lcd_gotoxy(x,y)       presune kurzor na uvedenou adresu
  | 
        
        
            | 
            | 
           23 | 
           //                         nekontroluje parametry
  | 
        
        
            | 
            | 
           24 | 
           //
  | 
        
        
            | 
            | 
           25 | 
           //   lcd_cursor_on         zapne kurzor
  | 
        
        
            | 
            | 
           26 | 
           //   lcd_cursor_off        vypne kurzor
  | 
        
        
            | 
            | 
           27 | 
           //
  | 
        
        
            | 
            | 
           28 | 
           //   lcd_define_char(Index, Def)       Makro, ktere definuje znaky od pozice Index obsahem definicniho
  | 
        
        
            | 
            | 
           29 | 
           //                                     retezce Def. Kazdych 8 znaku retezce Def definuje dalsi znak v CGRAM.
  | 
        
        
            | 
            | 
           30 | 
           //                                     Kapacita CGRAM je celkem 8 znaku s indexem 0 az 7.
  | 
        
        
            | 
            | 
           31 | 
           //                                     Na konci se provede lcd_gotoxy(1,1).
  | 
        
        
            | 
            | 
           32 | 
           //                                     Na konci teto knihovny je priklad pouziti definovanych znaku
  | 
        
        
            | 
            | 
           33 | 
           //
  | 
        
        
            | 
            | 
           34 | 
           // Definice portu:
  | 
        
        
            | 
            | 
           35 | 
           //
  | 
        
        
            | 
            | 
           36 | 
           // #DEFINE LCD_RS          PIN_B2      // rizeni registru LCD displeje
  | 
        
        
            | 
            | 
           37 | 
           // #DEFINE LCD_E           PIN_B1      // enable LCD displeje
  | 
        
        
            | 
            | 
           38 | 
           // #DEFINE LCD_DATA_LSB    PIN_C2      // pripojeni LSB bitu datoveho portu LCD displeje (celkem 4 bity vzestupne za sebou)
  | 
        
        
            | 
            | 
           39 | 
              | 
        
        
            | 
            | 
           40 | 
              | 
        
        
            | 
            | 
           41 | 
              | 
        
        
            | 
            | 
           42 | 
              | 
        
        
            | 
            | 
           43 | 
           // Privatni sekce, cist jen v pripade, ze neco nefunguje
  | 
        
        
            | 
            | 
           44 | 
              | 
        
        
            | 
            | 
           45 | 
              | 
        
        
            | 
            | 
           46 | 
              | 
        
        
            | 
            | 
           47 | 
              | 
        
        
            | 
            | 
           48 | 
           // Generovane defince portu pro ucely teto knihovny aby kod generoval spravne IO operace a soucasne
  | 
        
        
            | 
            | 
           49 | 
           // bylo mozne jednoduse deklarovat pripojene piny LCD displeje pri pouziti teto knihovny. Problem spociva
  | 
        
        
            | 
            | 
           50 | 
           // v tom, ze se musi spravne ridit smery portu a soucasne datovy port zabira jen 4 bity ze zadaneho portu
  | 
        
        
            | 
            | 
           51 | 
           //
  | 
        
        
            | 
            | 
           52 | 
           #DEFINE LCD_SHIFT (LCD_DATA_LSB&7)                 // pocet bitu posuvu dataoveho kanalu v datovem portu
  | 
        
        
            | 
            | 
           53 | 
           #DEFINE LCD_PORT  (LCD_DATA_LSB>>3)                // adresa LCD datoveho portu
  | 
        
        
            | 
            | 
           54 | 
           #DEFINE LCD_TRIS  (LCD_PORT+0x80)                  // adresa prislusneho TRIS registru
  | 
        
        
            | 
            | 
           55 | 
           #DEFINE LCD_MASK  (0xF<<LCD_SHIFT)                 // maska platnych bitu
  | 
        
        
            | 
            | 
           56 | 
           //
  | 
        
        
            | 
            | 
           57 | 
           #IF LCD_SHIFT>4                                    // kontrola mezi
  | 
        
        
            | 
            | 
           58 | 
           #ERROR LCD data port LSB bit not in range 0..4
  | 
        
        
            | 
            | 
           59 | 
           #ENDIF
  | 
        
        
            | 
            | 
           60 | 
              | 
        
        
            | 
            | 
           61 | 
              | 
        
        
            | 
            | 
           62 | 
           // Definice konstant pro LCD display
  | 
        
        
            | 
            | 
           63 | 
           //
  | 
        
        
            | 
            | 
           64 | 
           #define LCD_CURSOR_ON_  0x0E     // kurzor jako blikajici radka pod znakem
  | 
        
        
            | 
            | 
           65 | 
           #define LCD_CURSOR_OFF_ 0x0C     // zadny kurzor
  | 
        
        
            | 
            | 
           66 | 
           #define LCD_LINE_2      0x40     // adresa 1. znaku 2. radky
  | 
        
        
            | 
            | 
           67 | 
              | 
        
        
            | 
            | 
           68 | 
              | 
        
        
            | 
            | 
           69 | 
           // Definice rezimu LCD displeje
  | 
        
        
            | 
            | 
           70 | 
           //
  | 
        
        
            | 
            | 
           71 | 
           BYTE const LCD_INIT_STRING[4] =
  | 
        
        
            | 
            | 
           72 | 
           {
  | 
        
        
            | 
            | 
           73 | 
              0x28,                         // intrfejs 4 bity, 2 radky, font 5x7
  | 
        
        
            | 
            | 
           74 | 
              LCD_CURSOR_OFF_,              // display on, kurzor off,
  | 
        
        
            | 
            | 
           75 | 
              0x01,                         // clear displeje
  | 
        
        
            | 
            | 
           76 | 
              0x06                          // inkrement pozice kurzoru (posun kurzoru doprava)
  | 
        
        
            | 
            | 
           77 | 
           };
  | 
        
        
            | 
            | 
           78 | 
              | 
        
        
            | 
            | 
           79 | 
              | 
        
        
            | 
            | 
           80 | 
           // Odesle nibble do displeje (posle data a klikne signalem e)
  | 
        
        
            | 
            | 
           81 | 
           //
  | 
        
        
            | 
            | 
           82 | 
           void lcd_send_nibble( BYTE n )
  | 
        
        
            | 
            | 
           83 | 
           {
  | 
        
        
            | 
            | 
           84 | 
              *LCD_PORT = (*LCD_PORT & ~LCD_MASK) | ((n << LCD_SHIFT) & LCD_MASK);      // nastav datove bity portu a ostatni zachovej
  | 
        
        
            | 
            | 
           85 | 
              output_bit(LCD_E,1);       // vzestupna hrana
  | 
        
        
            | 
            | 
           86 | 
              delay_us(1);               // pockej alespon 450ns od e nebo alespon 195ns od dat
  | 
        
        
            | 
            | 
           87 | 
              output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us)
  | 
        
        
            | 
            | 
           88 | 
           }
  | 
        
        
            | 
            | 
           89 | 
              | 
        
        
            | 
            | 
           90 | 
              | 
        
        
            | 
            | 
           91 | 
           // Odesle bajt do registru LCD
  | 
        
        
            | 
            | 
           92 | 
           //
  | 
        
        
            | 
            | 
           93 | 
           // Pokud je Adr=0 .. instrukcni registr
  | 
        
        
            | 
            | 
           94 | 
           // Pokud je Adr=1 .. datovy registr
  | 
        
        
            | 
            | 
           95 | 
           //
  | 
        
        
            | 
            | 
           96 | 
           void lcd_send_byte( BOOLEAN Adr, BYTE n )
  | 
        
        
            | 
            | 
           97 | 
           {
  | 
        
        
            | 
            | 
           98 | 
              output_bit(LCD_RS,Adr);    // vyber registr
  | 
        
        
            | 
            | 
           99 | 
              swap(n);
  | 
        
        
            | 
            | 
           100 | 
              lcd_send_nibble(n);        // posli horni pulku bajtu
  | 
        
        
            | 
            | 
           101 | 
              swap(n);
  | 
        
        
            | 
            | 
           102 | 
              lcd_send_nibble(n);        // posli spodni pulku bajtu
  | 
        
        
            | 
            | 
           103 | 
              delay_us(40);              // minimalni doba na provedeni prikazu
  | 
        
        
            | 
            | 
           104 | 
           }
  | 
        
        
            | 
            | 
           105 | 
              | 
        
        
            | 
            | 
           106 | 
              | 
        
        
            | 
            | 
           107 | 
           // Provede inicializaci LCD displeje, smaze obsah a nastavi mod displeje
  | 
        
        
            | 
            | 
           108 | 
           //
  | 
        
        
            | 
            | 
           109 | 
           // Tato procedura se musi volat pred pouzitim ostatnich lcd_ procedur
  | 
        
        
            | 
            | 
           110 | 
           //
  | 
        
        
            | 
            | 
           111 | 
           void lcd_init()
  | 
        
        
            | 
            | 
           112 | 
           {
  | 
        
        
            | 
            | 
           113 | 
              | 
        
        
            | 
            | 
           114 | 
              int i;                              // pocitadlo cyklu
  | 
        
        
            | 
            | 
           115 | 
              | 
        
        
            | 
            | 
           116 | 
              delay_ms(20);                       // spozdeni pro provedeni startu displeje po zapnuti napajeni
  | 
        
        
            | 
            | 
           117 | 
              | 
        
        
            | 
            | 
           118 | 
              *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD
  | 
        
        
            | 
            | 
           119 | 
              | 
        
        
            | 
            | 
           120 | 
              output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav
  | 
        
        
            | 
            | 
           121 | 
              output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav
  | 
        
        
            | 
            | 
           122 | 
              | 
        
        
            | 
            | 
           123 | 
              for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice
  | 
        
        
            | 
            | 
           124 | 
              {
  | 
        
        
            | 
            | 
           125 | 
                 delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel
  | 
        
        
            | 
            | 
           126 | 
                 lcd_send_nibble(3);              // rezim 8 bitu
  | 
        
        
            | 
            | 
           127 | 
              }
  | 
        
        
            | 
            | 
           128 | 
              | 
        
        
            | 
            | 
           129 | 
              delay_us(40);                       // cas na zpracovani
  | 
        
        
            | 
            | 
           130 | 
              lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu)
  | 
        
        
            | 
            | 
           131 | 
              delay_us(40);                       // cas na zpracovani
  | 
        
        
            | 
            | 
           132 | 
              | 
        
        
            | 
            | 
           133 | 
              for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod)
  | 
        
        
            | 
            | 
           134 | 
              {
  | 
        
        
            | 
            | 
           135 | 
                 lcd_send_byte(0,LCD_INIT_STRING[i]);
  | 
        
        
            | 
            | 
           136 | 
                 delay_ms(2);
  | 
        
        
            | 
            | 
           137 | 
              }
  | 
        
        
            | 
            | 
           138 | 
           }
  | 
        
        
            | 
            | 
           139 | 
              | 
        
        
            | 
            | 
           140 | 
              | 
        
        
            | 
            | 
           141 | 
           // Proved presun kurzoru
  | 
        
        
            | 
            | 
           142 | 
           //
  | 
        
        
            | 
            | 
           143 | 
           // Pozice 1.1 je domu
  | 
        
        
            | 
            | 
           144 | 
           //
  | 
        
        
            | 
            | 
           145 | 
           void lcd_gotoxy( BYTE x, BYTE y)
  | 
        
        
            | 
            | 
           146 | 
           {
  | 
        
        
            | 
            | 
           147 | 
              | 
        
        
            | 
            | 
           148 | 
              BYTE Adr;
  | 
        
        
            | 
            | 
           149 | 
              | 
        
        
            | 
            | 
           150 | 
              Adr=x-1;
  | 
        
        
            | 
            | 
           151 | 
              if(y==2)
  | 
        
        
            | 
            | 
           152 | 
                Adr+=LCD_LINE_2;
  | 
        
        
            | 
            | 
           153 | 
              | 
        
        
            | 
            | 
           154 | 
              lcd_send_byte(0,0x80|Adr);
  | 
        
        
            | 
            | 
           155 | 
           }
  | 
        
        
            | 
            | 
           156 | 
              | 
        
        
            | 
            | 
           157 | 
              | 
        
        
            | 
            | 
           158 | 
           // Zapis znaku na displej, zpracovani ridicich znaku
  | 
        
        
            | 
            | 
           159 | 
           //
  | 
        
        
            | 
            | 
           160 | 
           void lcd_putc( char c)
  | 
        
        
            | 
            | 
           161 | 
           {
  | 
        
        
            | 
            | 
           162 | 
              | 
        
        
            | 
            | 
           163 | 
              switch (c)
  | 
        
        
            | 
            | 
           164 | 
              {
  | 
        
        
            | 
            | 
           165 | 
                 case '\f'   : lcd_send_byte(0,1);            // smaz displej
  | 
        
        
            | 
            | 
           166 | 
                               delay_ms(2);
  | 
        
        
            | 
            | 
           167 | 
                                                       break;
  | 
        
        
            | 
            | 
           168 | 
                 case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky
  | 
        
        
            | 
            | 
           169 | 
                 case '\r'   : lcd_gotoxy(1,1);        break; // presun home
  | 
        
        
            | 
            | 
           170 | 
                 case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet
  | 
        
        
            | 
            | 
           171 | 
                 default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F
  | 
        
        
            | 
            | 
           172 | 
                               lcd_send_byte(1,c);     break; // zapis znak
  | 
        
        
            | 
            | 
           173 | 
              }
  | 
        
        
            | 
            | 
           174 | 
           }
  | 
        
        
            | 
            | 
           175 | 
              | 
        
        
            | 
            | 
           176 | 
              | 
        
        
            | 
            | 
           177 | 
           // Zapni kurzor
  | 
        
        
            | 
            | 
           178 | 
           //
  | 
        
        
            | 
            | 
           179 | 
           void lcd_cursor_on()
  | 
        
        
            | 
            | 
           180 | 
           {
  | 
        
        
            | 
            | 
           181 | 
              lcd_send_byte(0,LCD_CURSOR_ON_);
  | 
        
        
            | 
            | 
           182 | 
           }
  | 
        
        
            | 
            | 
           183 | 
              | 
        
        
            | 
            | 
           184 | 
              | 
        
        
            | 
            | 
           185 | 
           // Vypni kurzor
  | 
        
        
            | 
            | 
           186 | 
           //
  | 
        
        
            | 
            | 
           187 | 
           void lcd_cursor_off()
  | 
        
        
            | 
            | 
           188 | 
           {
  | 
        
        
            | 
            | 
           189 | 
              lcd_send_byte(0,LCD_CURSOR_OFF_);
  | 
        
        
            | 
            | 
           190 | 
           }
  | 
        
        
            | 
            | 
           191 | 
              | 
        
        
            | 
            | 
           192 | 
              | 
        
        
            | 
            | 
           193 | 
           // Definice vlastnich fontu
  | 
        
        
            | 
            | 
           194 | 
           //
  | 
        
        
            | 
            | 
           195 | 
           // Vlastnich definic muze byt jen 8 do pozic 0 az 7 pameti CGRAM radice lcd displeje
  | 
        
        
            | 
            | 
           196 | 
           // Pro snadne definovani jsou pripraveny nasledujici definice a na konci souboru je uveden
  | 
        
        
            | 
            | 
           197 | 
           // priklad pouziti definovanych znaku.
  | 
        
        
            | 
            | 
           198 | 
              | 
        
        
            | 
            | 
           199 | 
              | 
        
        
            | 
            | 
           200 | 
           // Pomocna procedura pro posilani ridicich dat do radice displeje
  | 
        
        
            | 
            | 
           201 | 
           //
  | 
        
        
            | 
            | 
           202 | 
           void lcd_putc2(int Data)
  | 
        
        
            | 
            | 
           203 | 
           {
  | 
        
        
            | 
            | 
           204 | 
              lcd_send_byte(1,Data);
  | 
        
        
            | 
            | 
           205 | 
           }
  | 
        
        
            | 
            | 
           206 | 
              | 
        
        
            | 
            | 
           207 | 
              | 
        
        
            | 
            | 
           208 | 
           // Pomocne definice pro programovani obsahu CGRAM
  | 
        
        
            | 
            | 
           209 | 
           //
  | 
        
        
            | 
            | 
           210 | 
           #DEFINE lcd_define_start(Code)      lcd_send_byte(0,0x40+(Code<<3)); delay_ms(2)
  | 
        
        
            | 
            | 
           211 | 
           #DEFINE lcd_define_def(String)      printf(lcd_putc2,String);
  | 
        
        
            | 
            | 
           212 | 
           #DEFINE lcd_define_end()            lcd_send_byte(0,3); delay_ms(2)
  | 
        
        
            | 
            | 
           213 | 
              | 
        
        
            | 
            | 
           214 | 
              | 
        
        
            | 
            | 
           215 | 
           // Vlastni vykonne makro pro definovani fontu do pozice Index CGRAM s definicnim retezcem Def
  | 
        
        
            | 
            | 
           216 | 
           //
  | 
        
        
            | 
            | 
           217 | 
           #DEFINE lcd_define_char(Index, Def) lcd_define_start(Index); lcd_define_def(Def); lcd_define_end();
  | 
        
        
            | 
            | 
           218 | 
              | 
        
        
            | 
            | 
           219 | 
              | 
        
        
            | 
            | 
           220 | 
           // Pripravene definice fontu vybranych znaku
  | 
        
        
            | 
            | 
           221 | 
           // V tabulce nesmi byt 00 (konec retezce v printf()), misto toho davame 80
  | 
        
        
            | 
            | 
           222 | 
           //
  | 
        
        
            | 
            | 
           223 | 
           #DEFINE LCD_CHAR_BAT100 "\x0E\x1F\x1F\x1F\x1F\x1F\x1F\x1F"      /* symbol plne baterie       */
  | 
        
        
            | 
            | 
           224 | 
           #DEFINE LCD_CHAR_BAT50  "\x0E\x1F\x11\x11\x13\x17\x1F\x1F"      /* symbol polovicni baterie  */
  | 
        
        
            | 
            | 
           225 | 
           #DEFINE LCD_CHAR_BAT0   "\x0E\x1F\x11\x11\x11\x11\x11\x1F"      /* symbol vybite baterie     */
  | 
        
        
            | 
            | 
           226 | 
           #DEFINE LCD_CHAR_LUA    "\x04\x0E\x11\x11\x1F\x11\x11\x80"      /* A s carkou                */
  | 
        
        
            | 
            | 
           227 | 
           #DEFINE LCD_CHAR_LLA    "\x01\x02\x0E\x01\x1F\x11\x0F\x80"      /* a s carkou                */
  | 
        
        
            | 
            | 
           228 | 
           #DEFINE LCD_CHAR_HUC    "\x0A\x0E\x11\x10\x10\x11\x0E\x80"      /* C s hackem                */
  | 
        
        
            | 
            | 
           229 | 
           #DEFINE LCD_CHAR_HLC    "\x0A\x04\x0E\x10\x10\x11\x0E\x80"      /* c s hackem                */
  | 
        
        
            | 
            | 
           230 | 
           #DEFINE LCD_CHAR_HUD    "\x0A\x1C\x12\x11\x11\x12\x1C\x80"      /* D s hackem                */
  | 
        
        
            | 
            | 
           231 | 
           #DEFINE LCD_CHAR_HLD    "\x05\x03\x0D\x13\x11\x11\x0F\x80"      /* d s hackem                */
  | 
        
        
            | 
            | 
           232 | 
           #DEFINE LCD_CHAR_LUE    "\x04\x1F\x10\x10\x1E\x10\x1F\x80"      /* E s carkou                */
  | 
        
        
            | 
            | 
           233 | 
           #DEFINE LCD_CHAR_LLE    "\x01\x02\x0E\x11\x1F\x10\x0E\x80"      /* e s carkou                */
  | 
        
        
            | 
            | 
           234 | 
           #DEFINE LCD_CHAR_HUE    "\x0A\x1F\x10\x1E\x10\x10\x1F\x80"      /* E s hackem                */
  | 
        
        
            | 
            | 
           235 | 
           #DEFINE LCD_CHAR_HLE    "\x0A\x04\x0E\x11\x1F\x10\x0E\x80"      /* e s hackem                */
  | 
        
        
            | 
            | 
           236 | 
           #DEFINE LCD_CHAR_LUI    "\x04\x0E\x04\x04\x04\x04\x0E\x80"      /* I s carkou                */
  | 
        
        
            | 
            | 
           237 | 
           #DEFINE LCD_CHAR_LLI    "\x02\x04\x80\x0C\x04\x04\x0E\x80"      /* i s carkou                */
  | 
        
        
            | 
            | 
           238 | 
           #DEFINE LCD_CHAR_HUN    "\x0A\x15\x11\x19\x15\x13\x11\x80"      /* N s hackem                */
  | 
        
        
            | 
            | 
           239 | 
           #DEFINE LCD_CHAR_HLN    "\x0A\x04\x16\x19\x11\x11\x11\x80"      /* n s hackem                */
  | 
        
        
            | 
            | 
           240 | 
           #DEFINE LCD_CHAR_LUO    "\x04\x0E\x11\x11\x11\x11\x0E\x80"      /* O s carkou                */
  | 
        
        
            | 
            | 
           241 | 
           #DEFINE LCD_CHAR_LLO    "\x02\x04\x0E\x11\x11\x11\x0E\x80"      /* o s carkou                */
  | 
        
        
            | 
            | 
           242 | 
           #DEFINE LCD_CHAR_HUR    "\x0A\x1E\x11\x1E\x14\x12\x11\x80"      /* R s hackem                */
  | 
        
        
            | 
            | 
           243 | 
           #DEFINE LCD_CHAR_HLR    "\x0A\x04\x16\x19\x10\x10\x10\x80"      /* r s hackem                */
  | 
        
        
            | 
            | 
           244 | 
           #DEFINE LCD_CHAR_HUS    "\x0A\x0F\x10\x0E\x01\x01\x1E\x80"      /* S s hackem                */
  | 
        
        
            | 
            | 
           245 | 
           #DEFINE LCD_CHAR_HLS    "\x0A\x04\x0E\x10\x0E\x01\x1E\x80"      /* s s hackem                */
  | 
        
        
            | 
            | 
           246 | 
           #DEFINE LCD_CHAR_HUT    "\x0A\x1F\x04\x04\x04\x04\x04\x80"      /* T s hackem                */
  | 
        
        
            | 
            | 
           247 | 
           #DEFINE LCD_CHAR_HLT    "\x0A\x0C\x1C\x08\x08\x09\x06\x80"      /* t s hackem                */
  | 
        
        
            | 
            | 
           248 | 
           #DEFINE LCD_CHAR_LUU    "\x02\x15\x11\x11\x11\x11\x0E\x80"      /* U s carkou                */
  | 
        
        
            | 
            | 
           249 | 
           #DEFINE LCD_CHAR_LLU    "\x02\x04\x11\x11\x11\x13\x0D\x80"      /* u s carkou                */
  | 
        
        
            | 
            | 
           250 | 
           #DEFINE LCD_CHAR_CUU    "\x06\x17\x11\x11\x11\x11\x0E\x80"      /* U s krouzkem              */
  | 
        
        
            | 
            | 
           251 | 
           #DEFINE LCD_CHAR_CLU    "\x06\x06\x11\x11\x11\x11\x0E\x80"      /* u s krouzkem              */
  | 
        
        
            | 
            | 
           252 | 
           #DEFINE LCD_CHAR_LUY    "\x02\x15\x11\x0A\x04\x04\x04\x80"      /* Y s carkou                */
  | 
        
        
            | 
            | 
           253 | 
           #DEFINE LCD_CHAR_LLY    "\x02\x04\x11\x11\x0F\x01\x0E\x80"      /* y s carkou                */
  | 
        
        
            | 
            | 
           254 | 
           #DEFINE LCD_CHAR_HUZ    "\x0A\x1F\x01\x02\x04\x08\x1F\x80"      /* Z s hackem                */
  | 
        
        
            | 
            | 
           255 | 
           #DEFINE LCD_CHAR_HLZ    "\x0A\x04\x1F\x02\x04\x08\x1F\x80"      /* z s hackem                */
  | 
        
        
            | 
            | 
           256 | 
              | 
        
        
            | 
            | 
           257 | 
              | 
        
        
            | 
            | 
           258 | 
           // Priklad pouziti definovanych znaku
  | 
        
        
            | 
            | 
           259 | 
           //
  | 
        
        
            | 
            | 
           260 | 
           //
  | 
        
        
            | 
            | 
           261 | 
           //void lcd_sample()
  | 
        
        
            | 
            | 
           262 | 
           //{
  | 
        
        
            | 
            | 
           263 | 
           //   lcd_define_char(0,LCD_CHAR_BAT50);                 // Priklad definice znaku baterie do pozice 0
  | 
        
        
            | 
            | 
           264 | 
           //   lcd_define_char(2,LCD_CHAR_HLE LCD_CHAR_LUI);      // Priklad definice znaku e s hackem a I s carkou od pozice 2
  | 
        
        
            | 
            | 
           265 | 
           //                                                      // vsimnete si, ze neni carka mezi retezci s definici (oba retezce definuji
  | 
        
        
            | 
            | 
           266 | 
           //                                                      // jediny definicni retezec)
  | 
        
        
            | 
            | 
           267 | 
           //   printf(lcd_putc,"\fZnaky:\20\22\23");              // priklad vypisu znaku z pozice 0, 2 a 3
  | 
        
        
            | 
            | 
           268 | 
           //   delay_ms(1000);
  | 
        
        
            | 
            | 
           269 | 
           //   lcd_define_char(0,LCD_CHAR_BAT0);                  // Predefinovani tvaru znaku v pozici 0
  | 
        
        
            | 
            | 
           270 | 
           //   delay_ms(1000);
  | 
        
        
            | 
            | 
           271 | 
           //}
  |