CCS PCM C Compiler, Version 4.059d, 15399               04-V-07 12:10

               Filename: main.lst

               ROM used: 1664 words (81%)
                         Largest free fragment is 384
               RAM used: 114 (31%) at main() level
                         291 (79%) worst case
               Stack:    4 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   25B
0003:  NOP
.................... #include ".\main.h" 
.................... #include <16F877A.h> 
.................... //////// Standard Header file for the PIC16F877A device //////////////// 
.................... #device PIC16F877A 
.................... #list 
....................  
.................... #device adc=8 
....................  
.................... #FUSES WDT                      //Watch Dog Timer 
.................... #FUSES XT                       //Crystal osc <= 4mhz 
.................... #FUSES NOPUT                    //No Power Up Timer 
.................... #FUSES NOPROTECT                //Code not protected from reading 
.................... #FUSES NODEBUG                  //No Debug mode for ICD 
.................... #FUSES NOBROWNOUT               //No brownout reset 
.................... #FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O 
.................... #FUSES NOCPD                    //No EE protection 
.................... #FUSES NOWRT                    //Program memory not write protected 
....................  
.................... #use delay(clock=4000000,RESTART_WDT) 
*
0125:  MOVLW  9A
0126:  MOVWF  04
0127:  BSF    03.7
0128:  MOVF   00,W
0129:  BTFSC  03.2
012A:  GOTO   13C
012B:  MOVLW  01
012C:  MOVWF  78
012D:  MOVLW  BF
012E:  MOVWF  77
012F:  CLRWDT
0130:  DECFSZ 77,F
0131:  GOTO   12F
0132:  DECFSZ 78,F
0133:  GOTO   12D
0134:  MOVLW  4A
0135:  MOVWF  77
0136:  DECFSZ 77,F
0137:  GOTO   136
0138:  NOP
0139:  CLRWDT
013A:  DECFSZ 00,F
013B:  GOTO   12B
013C:  RETLW  00
.................... #use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8) 
....................  
....................  
....................  
.................... #define LCD_RS          PIN_B1      // rizeni registru LCD displeje 
.................... #define LCD_E           PIN_B0      // enable LCD displeje 
.................... #define LCD_DATA_LSB    PIN_C0      // pripojeni LSB bitu datoveho portu LCD displeje (celkem 4 bity vzestupne za sebou) 
.................... #define zar1 PIN_A3 
....................  
.................... #include "mylcd.c" 
.................... // LCD modul pro ovladani dvouradkoveho LCD modulu se standardnim Hitachi radicem 
.................... // (c)miho 2002 
.................... // 
.................... // Historie: 
.................... // 
.................... // 0.0   Uvodni verze se snadnou definici portu LCD displeje 
.................... // 
.................... // 
.................... // Funkce: 
.................... // 
.................... //   lcd_init()            inicializuje LCD displej a porty, nutno volat jako prvni 
.................... // 
.................... //   lcd_putc(c)           zapis snaku do lcd displeje, zpracovava nasledujici ridici znaky 
.................... //                         \f = \x0C   - nova stranka - smazani displeje 
.................... //                         \n = \x0A   - odradkovani (prechod na druhou radku) 
.................... //                         \b = \x08   - backspace - posunuti kurzoru o 1 pozici zpet 
.................... //                         \r = \x0D   - goto home to position 1,1 
.................... //                         \0  .. \7   - definovatelne znaky v pozicich 0 az 7 v CGRAM 
.................... //                         \20 .. \27  - alternativne zapsane znaky (oktalove) v pozicich 0 az 7 CGRAM 
.................... //                         Pozor na to, ze funkce printf konci tisk pokud narazi na \0 (konec retezce) 
.................... // 
.................... //   lcd_gotoxy(x,y)       presune kurzor na uvedenou adresu 
.................... //                         nekontroluje parametry 
.................... // 
.................... //   lcd_cursor_on         zapne kurzor 
.................... //   lcd_cursor_off        vypne kurzor 
.................... // 
.................... //   lcd_define_char(Index, Def)       Makro, ktere definuje znaky od pozice Index obsahem definicniho 
.................... //                                     retezce Def. Kazdych 8 znaku retezce Def definuje dalsi znak v CGRAM. 
.................... //                                     Kapacita CGRAM je celkem 8 znaku s indexem 0 az 7. 
.................... //                                     Na konci se provede lcd_gotoxy(1,1). 
.................... //                                     Na konci teto knihovny je priklad pouziti definovanych znaku 
.................... // 
.................... // Definice portu: 
.................... // 
.................... // #DEFINE LCD_RS          PIN_B2      // rizeni registru LCD displeje 
.................... // #DEFINE LCD_E           PIN_B1      // enable LCD displeje 
.................... // #DEFINE LCD_DATA_LSB    PIN_C2      // pripojeni LSB bitu datoveho portu LCD displeje (celkem 4 bity vzestupne za sebou) 
....................  
....................  
....................  
....................  
.................... // Privatni sekce, cist jen v pripade, ze neco nefunguje 
....................  
....................  
....................  
....................  
.................... // Generovane defince portu pro ucely teto knihovny aby kod generoval spravne IO operace a soucasne 
.................... // bylo mozne jednoduse deklarovat pripojene piny LCD displeje pri pouziti teto knihovny. Problem spociva 
.................... // v tom, ze se musi spravne ridit smery portu a soucasne datovy port zabira jen 4 bity ze zadaneho portu 
.................... // 
.................... #DEFINE LCD_SHIFT (LCD_DATA_LSB&7)                 // pocet bitu posuvu dataoveho kanalu v datovem portu 
.................... #DEFINE LCD_PORT  (LCD_DATA_LSB>>3)                // adresa LCD datoveho portu 
.................... #DEFINE LCD_TRIS  (LCD_PORT+0x80)                  // adresa prislusneho TRIS registru 
.................... #DEFINE LCD_MASK  (0xF<<LCD_SHIFT)                 // maska platnych bitu 
.................... // 
.................... #IF LCD_SHIFT>4                                    // kontrola mezi 
.................... #ERROR LCD data port LSB bit not in range 0..4 
.................... #ENDIF 
....................  
....................  
.................... // Definice konstant pro LCD display 
.................... // 
.................... #define LCD_CURSOR_ON_  0x0E     // kurzor jako blikajici radka pod znakem 
.................... #define LCD_CURSOR_OFF_ 0x0C     // zadny kurzor 
.................... #define LCD_LINE_2      0x40     // adresa 1. znaku 2. radky 
....................  
....................  
.................... // Definice rezimu LCD displeje 
.................... // 
.................... BYTE const LCD_INIT_STRING[4] = 
.................... { 
....................    0x28,                         // intrfejs 4 bity, 2 radky, font 5x7 
....................    LCD_CURSOR_OFF_,              // display on, kurzor off, 
....................    0x01,                         // clear displeje 
....................    0x06                          // inkrement pozice kurzoru (posun kurzoru doprava) 
.................... }; 
....................  
....................  
.................... // Odesle nibble do displeje (posle data a klikne signalem e) 
.................... // 
.................... void lcd_send_nibble( BYTE n ) 
.................... { 
....................    *LCD_PORT = (*LCD_PORT & ~LCD_MASK) | ((n << LCD_SHIFT) & LCD_MASK);      // nastav datove bity portu a ostatni zachovej 
013D:  MOVF   07,W
013E:  ANDLW  F0
013F:  BSF    03.5
0140:  BSF    03.6
0141:  MOVWF  21
0142:  MOVF   20,W
0143:  ANDLW  0F
0144:  IORWF  21,W
0145:  BCF    03.5
0146:  BCF    03.6
0147:  MOVWF  07
....................    output_bit(LCD_E,1);       // vzestupna hrana 
0148:  BSF    06.0
0149:  BSF    03.5
014A:  BCF    06.0
....................    delay_us(100);               // pockej alespon 450ns od e nebo alespon 195ns od dat 
014B:  CLRWDT
014C:  MOVLW  20
014D:  MOVWF  77
014E:  DECFSZ 77,F
014F:  GOTO   14E
0150:  GOTO   151
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us) 
0151:  BCF    03.5
0152:  BCF    06.0
0153:  BSF    03.5
0154:  BCF    06.0
.................... } 
0155:  BCF    03.5
0156:  RETLW  00
....................  
....................  
.................... // Odesle bajt do registru LCD 
.................... // 
.................... // Pokud je Adr=0 .. instrukcni registr 
.................... // Pokud je Adr=1 .. datovy registr 
.................... // 
.................... void lcd_send_byte( BOOLEAN Adr, BYTE n ) 
.................... { 
....................    output_bit(LCD_RS,Adr);    // vyber registr 
0157:  BSF    03.5
0158:  BSF    03.6
0159:  MOVF   1E,F
015A:  BTFSS  03.2
015B:  GOTO   162
015C:  BCF    03.5
015D:  BCF    03.6
015E:  BCF    06.1
015F:  GOTO   165
0160:  BSF    03.5
0161:  BSF    03.6
0162:  BCF    03.5
0163:  BCF    03.6
0164:  BSF    06.1
0165:  BSF    03.5
0166:  BCF    06.1
....................    swap(n); 
0167:  BSF    03.6
0168:  SWAPF  1F,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu 
0169:  MOVF   1F,W
016A:  MOVWF  20
016B:  BCF    03.5
016C:  BCF    03.6
016D:  CALL   13D
....................    swap(n); 
016E:  BSF    03.5
016F:  BSF    03.6
0170:  SWAPF  1F,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu 
0171:  MOVF   1F,W
0172:  MOVWF  20
0173:  BCF    03.5
0174:  BCF    03.6
0175:  CALL   13D
....................    delay_us(200);              // minimalni doba na provedeni prikazu 
0176:  CLRWDT
0177:  MOVLW  42
0178:  MOVWF  77
0179:  DECFSZ 77,F
017A:  GOTO   179
.................... } 
017B:  RETLW  00
....................  
....................  
.................... // Provede inicializaci LCD displeje, smaze obsah a nastavi mod displeje 
.................... // 
.................... // Tato procedura se musi volat pred pouzitim ostatnich lcd_ procedur 
.................... // 
.................... void lcd_init() 
.................... { 
....................  
....................    int i;                              // pocitadlo cyklu 
....................  
....................    delay_ms(20);                       // spozdeni pro provedeni startu displeje po zapnuti napajeni 
017C:  MOVLW  14
017D:  BSF    03.5
017E:  BSF    03.6
017F:  MOVWF  1A
0180:  BCF    03.5
0181:  BCF    03.6
0182:  CALL   125
....................  
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD 
0183:  MOVLW  F0
0184:  BSF    03.5
0185:  ANDWF  07,F
....................  
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav 
0186:  BCF    03.5
0187:  BCF    06.1
0188:  BSF    03.5
0189:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav 
018A:  BCF    03.5
018B:  BCF    06.0
018C:  BSF    03.5
018D:  BCF    06.0
....................  
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice 
018E:  BSF    03.6
018F:  CLRF   17
0190:  MOVF   17,W
0191:  SUBLW  02
0192:  BTFSS  03.0
0193:  GOTO   1A4
....................    { 
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel 
0194:  MOVLW  02
0195:  MOVWF  1A
0196:  BCF    03.5
0197:  BCF    03.6
0198:  CALL   125
....................       lcd_send_nibble(3);              // rezim 8 bitu 
0199:  MOVLW  03
019A:  BSF    03.5
019B:  BSF    03.6
019C:  MOVWF  20
019D:  BCF    03.5
019E:  BCF    03.6
019F:  CALL   13D
....................    } 
01A0:  BSF    03.5
01A1:  BSF    03.6
01A2:  INCF   17,F
01A3:  GOTO   190
....................  
....................    delay_us(40);                       // cas na zpracovani 
01A4:  CLRWDT
01A5:  MOVLW  0C
01A6:  MOVWF  77
01A7:  DECFSZ 77,F
01A8:  GOTO   1A7
01A9:  GOTO   1AA
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu) 
01AA:  MOVLW  02
01AB:  MOVWF  20
01AC:  BCF    03.5
01AD:  BCF    03.6
01AE:  CALL   13D
....................    delay_us(40);                       // cas na zpracovani 
01AF:  CLRWDT
01B0:  MOVLW  0C
01B1:  MOVWF  77
01B2:  DECFSZ 77,F
01B3:  GOTO   1B2
01B4:  GOTO   1B5
....................  
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod) 
01B5:  BSF    03.5
01B6:  BSF    03.6
01B7:  CLRF   17
01B8:  MOVF   17,W
01B9:  SUBLW  02
01BA:  BTFSS  03.0
01BB:  GOTO   1D4
....................    { 
....................       lcd_send_byte(0,LCD_INIT_STRING[i]); 
01BC:  MOVF   17,W
01BD:  BCF    03.5
01BE:  BCF    03.6
01BF:  CALL   004
01C0:  BSF    03.5
01C1:  BSF    03.6
01C2:  MOVWF  18
01C3:  CLRF   1E
01C4:  MOVF   18,W
01C5:  MOVWF  1F
01C6:  BCF    03.5
01C7:  BCF    03.6
01C8:  CALL   157
....................       delay_ms(2); 
01C9:  MOVLW  02
01CA:  BSF    03.5
01CB:  BSF    03.6
01CC:  MOVWF  1A
01CD:  BCF    03.5
01CE:  BCF    03.6
01CF:  CALL   125
....................    } 
01D0:  BSF    03.5
01D1:  BSF    03.6
01D2:  INCF   17,F
01D3:  GOTO   1B8
.................... } 
01D4:  BCF    03.5
01D5:  BCF    03.6
01D6:  GOTO   2BE (RETURN)
....................  
....................  
.................... // Proved presun kurzoru 
.................... // 
.................... // Pozice 1.1 je domu 
.................... // 
.................... #separate 
.................... void lcd_gotoxy( BYTE x, BYTE y) 
.................... { 
....................  
....................    BYTE Adr; 
....................  
....................    switch(y) 
....................    { 
01D7:  MOVLW  01
01D8:  BSF    03.5
01D9:  BSF    03.6
01DA:  SUBWF  1B,W
01DB:  ADDLW  FC
01DC:  BTFSC  03.0
01DD:  GOTO   1F7
01DE:  ADDLW  04
01DF:  BCF    03.5
01E0:  BCF    03.6
01E1:  GOTO   204
....................       case 1: Adr=0; break; 
01E2:  BSF    03.5
01E3:  BSF    03.6
01E4:  CLRF   1C
01E5:  GOTO   1F7
....................       case 2: Adr=0x40; break; 
01E6:  MOVLW  40
01E7:  BSF    03.5
01E8:  BSF    03.6
01E9:  MOVWF  1C
01EA:  GOTO   1F7
....................       case 3: Adr=0x14; break; 
01EB:  MOVLW  14
01EC:  BSF    03.5
01ED:  BSF    03.6
01EE:  MOVWF  1C
01EF:  GOTO   1F7
....................       case 4: Adr=0x54; break; 
01F0:  MOVLW  54
01F1:  BSF    03.5
01F2:  BSF    03.6
01F3:  MOVWF  1C
01F4:  GOTO   1F7
01F5:  BSF    03.5
01F6:  BSF    03.6
....................    } 
....................    Adr+=x-1; 
01F7:  MOVLW  01
01F8:  SUBWF  1A,W
01F9:  ADDWF  1C,F
....................  
....................    lcd_send_byte(0,0x80|Adr); 
01FA:  MOVF   1C,W
01FB:  IORLW  80
01FC:  MOVWF  1D
01FD:  CLRF   1E
01FE:  MOVF   1D,W
01FF:  MOVWF  1F
0200:  BCF    03.5
0201:  BCF    03.6
0202:  CALL   157
.................... } 
0203:  RETLW  00
....................  
....................  
.................... // Zapis znaku na displej, zpracovani ridicich znaku 
.................... // 
.................... #separate 
.................... void lcd_putc( char c) 
.................... { 
....................  
....................    switch (c) 
....................    { 
*
020C:  BSF    03.5
020D:  BSF    03.6
020E:  MOVF   19,W
020F:  XORLW  0C
0210:  BCF    03.5
0211:  BCF    03.6
0212:  BTFSC  03.2
0213:  GOTO   21E
0214:  XORLW  06
0215:  BTFSC  03.2
0216:  GOTO   22E
0217:  XORLW  07
0218:  BTFSC  03.2
0219:  GOTO   238
021A:  XORLW  05
021B:  BTFSC  03.2
021C:  GOTO   241
021D:  GOTO   24A
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej 
021E:  BSF    03.5
021F:  BSF    03.6
0220:  CLRF   1E
0221:  MOVLW  01
0222:  MOVWF  1F
0223:  BCF    03.5
0224:  BCF    03.6
0225:  CALL   157
....................                     delay_ms(2); 
0226:  MOVLW  02
0227:  BSF    03.5
0228:  BSF    03.6
0229:  MOVWF  1A
022A:  BCF    03.5
022B:  BCF    03.6
022C:  CALL   125
....................                                             break; 
022D:  GOTO   25A
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky 
022E:  MOVLW  01
022F:  BSF    03.5
0230:  BSF    03.6
0231:  MOVWF  1A
0232:  MOVLW  02
0233:  MOVWF  1B
0234:  BCF    03.5
0235:  BCF    03.6
0236:  CALL   1D7
0237:  GOTO   25A
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home 
0238:  MOVLW  01
0239:  BSF    03.5
023A:  BSF    03.6
023B:  MOVWF  1A
023C:  MOVWF  1B
023D:  BCF    03.5
023E:  BCF    03.6
023F:  CALL   1D7
0240:  GOTO   25A
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet 
0241:  BSF    03.5
0242:  BSF    03.6
0243:  CLRF   1E
0244:  MOVLW  10
0245:  MOVWF  1F
0246:  BCF    03.5
0247:  BCF    03.6
0248:  CALL   157
0249:  GOTO   25A
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F 
024A:  BSF    03.5
024B:  BSF    03.6
024C:  MOVF   19,W
024D:  SUBLW  1F
024E:  BTFSS  03.0
024F:  GOTO   252
0250:  MOVLW  07
0251:  ANDWF  19,F
....................                     lcd_send_byte(1,c);     break; // zapis znak 
0252:  MOVLW  01
0253:  MOVWF  1E
0254:  MOVF   19,W
0255:  MOVWF  1F
0256:  BCF    03.5
0257:  BCF    03.6
0258:  CALL   157
0259:  GOTO   25A
....................    } 
.................... } 
025A:  RETLW  00
....................  
....................  
.................... // Zapni kurzor 
.................... // 
.................... void lcd_cursor_on() 
.................... { 
....................    lcd_send_byte(0,LCD_CURSOR_ON_); 
.................... } 
....................  
....................  
.................... // Vypni kurzor 
.................... // 
.................... void lcd_cursor_off() 
.................... { 
....................    lcd_send_byte(0,LCD_CURSOR_OFF_); 
.................... } 
....................  
....................  
.................... // Definice vlastnich fontu 
.................... // 
.................... // Vlastnich definic muze byt jen 8 do pozic 0 az 7 pameti CGRAM radice lcd displeje 
.................... // Pro snadne definovani jsou pripraveny nasledujici definice a na konci souboru je uveden 
.................... // priklad pouziti definovanych znaku. 
....................  
....................  
.................... // Pomocna procedura pro posilani ridicich dat do radice displeje 
.................... // 
.................... void lcd_putc2(int Data) 
.................... { 
....................    lcd_send_byte(1,Data); 
.................... } 
....................  
....................  
.................... // Pomocne definice pro programovani obsahu CGRAM 
.................... // 
.................... #DEFINE lcd_define_start(Code)      lcd_send_byte(0,0x40+(Code<<3)); delay_ms(2) 
.................... #DEFINE lcd_define_def(String)      printf(lcd_putc2,String); 
.................... #DEFINE lcd_define_end()            lcd_send_byte(0,3); delay_ms(2) 
....................  
....................  
.................... // Vlastni vykonne makro pro definovani fontu do pozice Index CGRAM s definicnim retezcem Def 
.................... // 
.................... #DEFINE lcd_define_char(Index, Def) lcd_define_start(Index); lcd_define_def(Def); lcd_define_end(); 
....................  
....................  
.................... // Pripravene definice fontu vybranych znaku 
.................... // V tabulce nesmi byt 00 (konec retezce v printf()), misto toho davame 80 
.................... // 
.................... #DEFINE LCD_CHAR_BAT100 "\x0E\x1F\x1F\x1F\x1F\x1F\x1F\x1F"      /* symbol plne baterie       */ 
.................... #DEFINE LCD_CHAR_BAT50  "\x0E\x1F\x11\x11\x13\x17\x1F\x1F"      /* symbol polovicni baterie  */ 
.................... #DEFINE LCD_CHAR_BAT0   "\x0E\x1F\x11\x11\x11\x11\x11\x1F"      /* symbol vybite baterie     */ 
.................... #DEFINE LCD_CHAR_LUA    "\x04\x0E\x11\x11\x1F\x11\x11\x80"      /* A s carkou                */ 
.................... #DEFINE LCD_CHAR_LLA    "\x01\x02\x0E\x01\x1F\x11\x0F\x80"      /* a s carkou                */ 
.................... #DEFINE LCD_CHAR_HUC    "\x0A\x0E\x11\x10\x10\x11\x0E\x80"      /* C s hackem                */ 
.................... #DEFINE LCD_CHAR_HLC    "\x0A\x04\x0E\x10\x10\x11\x0E\x80"      /* c s hackem                */ 
.................... #DEFINE LCD_CHAR_HUD    "\x0A\x1C\x12\x11\x11\x12\x1C\x80"      /* D s hackem                */ 
.................... #DEFINE LCD_CHAR_HLD    "\x05\x03\x0D\x13\x11\x11\x0F\x80"      /* d s hackem                */ 
.................... #DEFINE LCD_CHAR_LUE    "\x04\x1F\x10\x10\x1E\x10\x1F\x80"      /* E s carkou                */ 
.................... #DEFINE LCD_CHAR_LLE    "\x01\x02\x0E\x11\x1F\x10\x0E\x80"      /* e s carkou                */ 
.................... #DEFINE LCD_CHAR_HUE    "\x0A\x1F\x10\x1E\x10\x10\x1F\x80"      /* E s hackem                */ 
.................... #DEFINE LCD_CHAR_HLE    "\x0A\x04\x0E\x11\x1F\x10\x0E\x80"      /* e s hackem                */ 
.................... #DEFINE LCD_CHAR_LUI    "\x04\x0E\x04\x04\x04\x04\x0E\x80"      /* I s carkou                */ 
.................... #DEFINE LCD_CHAR_LLI    "\x02\x04\x80\x0C\x04\x04\x0E\x80"      /* i s carkou                */ 
.................... #DEFINE LCD_CHAR_HUN    "\x0A\x15\x11\x19\x15\x13\x11\x80"      /* N s hackem                */ 
.................... #DEFINE LCD_CHAR_HLN    "\x0A\x04\x16\x19\x11\x11\x11\x80"      /* n s hackem                */ 
.................... #DEFINE LCD_CHAR_LUO    "\x04\x0E\x11\x11\x11\x11\x0E\x80"      /* O s carkou                */ 
.................... #DEFINE LCD_CHAR_LLO    "\x02\x04\x0E\x11\x11\x11\x0E\x80"      /* o s carkou                */ 
.................... #DEFINE LCD_CHAR_HUR    "\x0A\x1E\x11\x1E\x14\x12\x11\x80"      /* R s hackem                */ 
.................... #DEFINE LCD_CHAR_HLR    "\x0A\x04\x16\x19\x10\x10\x10\x80"      /* r s hackem                */ 
.................... #DEFINE LCD_CHAR_HUS    "\x0A\x0F\x10\x0E\x01\x01\x1E\x80"      /* S s hackem                */ 
.................... #DEFINE LCD_CHAR_HLS    "\x0A\x04\x0E\x10\x0E\x01\x1E\x80"      /* s s hackem                */ 
.................... #DEFINE LCD_CHAR_HUT    "\x0A\x1F\x04\x04\x04\x04\x04\x80"      /* T s hackem                */ 
.................... #DEFINE LCD_CHAR_HLT    "\x0A\x0C\x1C\x08\x08\x09\x06\x80"      /* t s hackem                */ 
.................... #DEFINE LCD_CHAR_LUU    "\x02\x15\x11\x11\x11\x11\x0E\x80"      /* U s carkou                */ 
.................... #DEFINE LCD_CHAR_LLU    "\x02\x04\x11\x11\x11\x13\x0D\x80"      /* u s carkou                */ 
.................... #DEFINE LCD_CHAR_CUU    "\x06\x17\x11\x11\x11\x11\x0E\x80"      /* U s krouzkem              */ 
.................... #DEFINE LCD_CHAR_CLU    "\x06\x06\x11\x11\x11\x11\x0E\x80"      /* u s krouzkem              */ 
.................... #DEFINE LCD_CHAR_LUY    "\x02\x15\x11\x0A\x04\x04\x04\x80"      /* Y s carkou                */ 
.................... #DEFINE LCD_CHAR_LLY    "\x02\x04\x11\x11\x0F\x01\x0E\x80"      /* y s carkou                */ 
.................... #DEFINE LCD_CHAR_HUZ    "\x0A\x1F\x01\x02\x04\x08\x1F\x80"      /* Z s hackem                */ 
.................... #DEFINE LCD_CHAR_HLZ    "\x0A\x04\x1F\x02\x04\x08\x1F\x80"      /* z s hackem                */ 
....................  
....................  
.................... // Priklad pouziti definovanych znaku 
.................... // 
.................... // 
.................... //void lcd_sample() 
.................... //{ 
.................... //   lcd_define_char(0,LCD_CHAR_BAT50);                 // Priklad definice znaku baterie do pozice 0 
.................... //   lcd_define_char(2,LCD_CHAR_HLE LCD_CHAR_LUI);      // Priklad definice znaku e s hackem a I s carkou od pozice 2 
.................... //                                                      // vsimnete si, ze neni carka mezi retezci s definici (oba retezce definuji 
.................... //                                                      // jediny definicni retezec) 
.................... //   printf(lcd_putc,"\fZnaky:\20\22\23");              // priklad vypisu znaku z pozice 0, 2 a 3 
.................... //   delay_ms(1000); 
.................... //   lcd_define_char(0,LCD_CHAR_BAT0);                  // Predefinovani tvaru znaku v pozici 0 
.................... //   delay_ms(1000); 
.................... //} 
....................  
....................  
.................... void main() 
.................... { 
025B:  CLRF   04
025C:  BCF    03.7
025D:  MOVLW  1F
025E:  ANDWF  03,F
025F:  MOVLW  0C
0260:  BSF    03.5
0261:  MOVWF  19
0262:  MOVLW  A6
0263:  MOVWF  18
0264:  MOVLW  90
0265:  BCF    03.5
0266:  MOVWF  18
0267:  BSF    03.5
0268:  BSF    1F.0
0269:  BSF    1F.1
026A:  BSF    1F.2
026B:  BCF    1F.3
026C:  MOVLW  07
026D:  MOVWF  1C
.................... char odp[96]; 
.................... int pom,pom2,pom3,odkl,odkl2,maskovadlo,status; 
....................  
....................    setup_adc_ports(NO_ANALOGS); 
*
0271:  BSF    03.5
0272:  BSF    1F.0
0273:  BSF    1F.1
0274:  BSF    1F.2
0275:  BCF    1F.3
....................    setup_adc(ADC_OFF); 
0276:  BCF    03.5
0277:  BCF    1F.0
....................    setup_psp(PSP_DISABLED); 
0278:  BSF    03.5
0279:  BCF    09.4
....................    setup_spi(SPI_SS_DISABLED); 
*
026E:  MOVLW  FF
026F:  BCF    03.5
0270:  MOVWF  20
*
027A:  BCF    03.5
027B:  BCF    14.5
027C:  BCF    20.5
027D:  MOVF   20,W
027E:  BSF    03.5
027F:  MOVWF  07
0280:  BCF    03.5
0281:  BSF    20.4
0282:  MOVF   20,W
0283:  BSF    03.5
0284:  MOVWF  07
0285:  BCF    03.5
0286:  BCF    20.3
0287:  MOVF   20,W
0288:  BSF    03.5
0289:  MOVWF  07
028A:  MOVLW  01
028B:  BCF    03.5
028C:  MOVWF  14
028D:  MOVLW  00
028E:  BSF    03.5
028F:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); 
0290:  MOVF   01,W
0291:  ANDLW  C7
0292:  IORLW  08
0293:  MOVWF  01
....................    setup_timer_1(T1_DISABLED); 
0294:  BCF    03.5
0295:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1); 
0296:  MOVLW  00
0297:  MOVWF  78
0298:  MOVWF  12
0299:  MOVLW  00
029A:  BSF    03.5
029B:  MOVWF  12
....................    setup_comparator(NC_NC_NC_NC); 
029C:  MOVLW  07
029D:  MOVWF  1C
029E:  MOVF   05,W
029F:  CLRWDT
02A0:  MOVLW  02
02A1:  MOVWF  77
02A2:  DECFSZ 77,F
02A3:  GOTO   2A2
02A4:  GOTO   2A5
02A5:  MOVF   1C,W
02A6:  BCF    03.5
02A7:  BCF    0D.6
....................    setup_vref(FALSE); 
02A8:  BSF    03.5
02A9:  CLRF   1D
....................    setup_wdt(WDT_2304MS); 
02AA:  MOVLW  0F
02AB:  MOVWF  77
02AC:  MOVLW  07
02AD:  BCF    03.5
02AE:  CLRF   01
02AF:  MOVLW  81
02B0:  MOVWF  04
02B1:  BCF    03.7
02B2:  MOVF   00,W
02B3:  ANDLW  F0
02B4:  IORLW  07
02B5:  MOVWF  00
02B6:  CLRWDT
02B7:  MOVF   00,W
02B8:  ANDLW  F7
02B9:  BTFSC  77.3
02BA:  ANDLW  F0
02BB:  IORWF  77,W
02BC:  MOVWF  00
....................    lcd_init(); 
02BD:  GOTO   17C
....................     
....................    /* 
....................    delay_us(10); 
....................    lcd_gotoxy(1,1); 
....................    printf(lcd_putc,"  Ovladani mobilem"); 
....................    lcd_gotoxy(1,2); 
....................    printf(lcd_putc,""); 
....................    lcd_gotoxy(1,3); 
....................    printf(lcd_putc," autor:  Tomas Kapl"); 
....................    lcd_gotoxy(1,4); 
....................    printf(lcd_putc,"    www.kapl.cz"); 
....................    delay_ms(5000); 
....................    */ 
....................     
....................    while(TRUE) 
....................    { 
....................     restart_wdt(); 
02BE:  CLRWDT
....................     
....................     output_low(PIN_A4) ; 
02BF:  BSF    03.5
02C0:  BCF    05.4
02C1:  BCF    03.5
02C2:  BCF    05.4
....................     delay_ms(150); 
02C3:  MOVLW  96
02C4:  BSF    03.5
02C5:  BSF    03.6
02C6:  MOVWF  1A
02C7:  BCF    03.5
02C8:  BCF    03.6
02C9:  CALL   125
....................     output_high(PIN_A4); 
02CA:  BSF    03.5
02CB:  BCF    05.4
02CC:  BCF    03.5
02CD:  BSF    05.4
....................     delay_ms(150); 
02CE:  MOVLW  96
02CF:  BSF    03.5
02D0:  BSF    03.6
02D1:  MOVWF  1A
02D2:  BCF    03.5
02D3:  BCF    03.6
02D4:  CALL   125
....................     output_low(PIN_A4) ; 
02D5:  BSF    03.5
02D6:  BCF    05.4
02D7:  BCF    03.5
02D8:  BCF    05.4
....................     delay_ms(150); 
02D9:  MOVLW  96
02DA:  BSF    03.5
02DB:  BSF    03.6
02DC:  MOVWF  1A
02DD:  BCF    03.5
02DE:  BCF    03.6
02DF:  CALL   125
....................     output_high(PIN_A4); 
02E0:  BSF    03.5
02E1:  BCF    05.4
02E2:  BCF    03.5
02E3:  BSF    05.4
....................     delay_ms(150); 
02E4:  MOVLW  96
02E5:  BSF    03.5
02E6:  BSF    03.6
02E7:  MOVWF  1A
02E8:  BCF    03.5
02E9:  BCF    03.6
02EA:  CALL   125
....................      
....................    printf("AT+CMGL=0\r");           //vycti prijate SMS 
02EB:  CLRF   28
02EC:  MOVF   28,W
02ED:  CALL   00C
02EE:  INCF   28,F
02EF:  MOVWF  77
02F0:  MOVF   77,W
02F1:  BTFSS  0C.4
02F2:  GOTO   2F1
02F3:  MOVWF  19
02F4:  MOVLW  0A
02F5:  SUBWF  28,W
02F6:  BTFSS  03.2
02F7:  GOTO   2EC
....................     
....................        
....................    gets(odp);                       //uloz odpoved prikazu do odp 
02F8:  MOVLW  10
02F9:  MOVWF  04
02FA:  BSF    03.7
02FB:  DECF   04,F
02FC:  INCF   04,F
02FD:  BTFSS  0C.5
02FE:  GOTO   2FD
02FF:  MOVF   1A,W
0300:  MOVWF  00
0301:  MOVLW  0D
0302:  SUBWF  00,W
0303:  BTFSS  03.2
0304:  GOTO   2FC
0305:  CLRF   00
....................    getc();                          //preskoc 0A 
0306:  BTFSS  0C.5
0307:  GOTO   306
0308:  MOVF   1A,W
....................    getc();                          //preskoc 0D 
0309:  BTFSS  0C.5
030A:  GOTO   309
030B:  MOVF   1A,W
....................    gets(odp);                       //uloz pocatek odpovedi do odp 
030C:  MOVLW  10
030D:  MOVWF  04
030E:  BSF    03.7
030F:  DECF   04,F
0310:  INCF   04,F
0311:  BTFSS  0C.5
0312:  GOTO   311
0313:  MOVF   1A,W
0314:  MOVWF  00
0315:  MOVLW  0D
0316:  SUBWF  00,W
0317:  BTFSS  03.2
0318:  GOTO   310
0319:  CLRF   00
....................     
....................    
....................    if(odp[0] == 79 && odp[1] ==75) 
031A:  BSF    03.6
031B:  MOVF   10,W
031C:  SUBLW  4F
031D:  BTFSS  03.2
031E:  GOTO   37F
031F:  MOVF   11,W
0320:  SUBLW  4B
0321:  BTFSS  03.2
0322:  GOTO   37F
....................    { 
....................       lcd_gotoxy(1,1); 
0323:  MOVLW  01
0324:  BSF    03.5
0325:  MOVWF  1A
0326:  MOVWF  1B
0327:  BCF    03.5
0328:  BCF    03.6
0329:  CALL   1D7
....................       printf(lcd_putc,"\fNeni nova SMS zprava"); 
032A:  CLRF   28
032B:  MOVF   28,W
032C:  CALL   01B
032D:  INCF   28,F
032E:  MOVWF  77
032F:  BSF    03.5
0330:  BSF    03.6
0331:  MOVWF  19
0332:  BCF    03.5
0333:  BCF    03.6
0334:  CALL   20C
0335:  MOVLW  15
0336:  SUBWF  28,W
0337:  BTFSS  03.2
0338:  GOTO   32B
....................       lcd_gotoxy(1,2); 
0339:  MOVLW  01
033A:  BSF    03.5
033B:  BSF    03.6
033C:  MOVWF  1A
033D:  MOVLW  02
033E:  MOVWF  1B
033F:  BCF    03.5
0340:  BCF    03.6
0341:  CALL   1D7
....................       printf(lcd_putc,""); 
....................       lcd_gotoxy(1,3); 
0342:  MOVLW  01
0343:  BSF    03.5
0344:  BSF    03.6
0345:  MOVWF  1A
0346:  MOVLW  03
0347:  MOVWF  1B
0348:  BCF    03.5
0349:  BCF    03.6
034A:  CALL   1D7
....................       printf(lcd_putc,"Zaslete SMS na cislo"); 
034B:  CLRF   28
034C:  MOVF   28,W
034D:  CALL   035
034E:  INCF   28,F
034F:  MOVWF  77
0350:  BSF    03.5
0351:  BSF    03.6
0352:  MOVWF  19
0353:  BCF    03.5
0354:  BCF    03.6
0355:  CALL   20C
0356:  MOVLW  14
0357:  SUBWF  28,W
0358:  BTFSS  03.2
0359:  GOTO   34C
....................       lcd_gotoxy(1,4); 
035A:  MOVLW  01
035B:  BSF    03.5
035C:  BSF    03.6
035D:  MOVWF  1A
035E:  MOVLW  04
035F:  MOVWF  1B
0360:  BCF    03.5
0361:  BCF    03.6
0362:  CALL   1D7
....................       printf(lcd_putc,"    736 655 250"); 
0363:  CLRF   28
0364:  MOVF   28,W
0365:  CALL   04E
0366:  INCF   28,F
0367:  MOVWF  77
0368:  BSF    03.5
0369:  BSF    03.6
036A:  MOVWF  19
036B:  BCF    03.5
036C:  BCF    03.6
036D:  CALL   20C
036E:  MOVLW  0F
036F:  SUBWF  28,W
0370:  BTFSS  03.2
0371:  GOTO   364
....................       delay_ms(5000); 
0372:  MOVLW  14
0373:  MOVWF  28
0374:  MOVLW  FA
0375:  BSF    03.5
0376:  BSF    03.6
0377:  MOVWF  1A
0378:  BCF    03.5
0379:  BCF    03.6
037A:  CALL   125
037B:  DECFSZ 28,F
037C:  GOTO   374
....................    }else 
037D:  GOTO   67E
037E:  BSF    03.6
....................    { 
....................     
....................       for(pom=0;pom<55;pom++)                //preskoc nedulezite informace 
037F:  BCF    03.6
0380:  CLRF   21
0381:  MOVF   21,W
0382:  SUBLW  36
0383:  BTFSS  03.0
0384:  GOTO   38A
....................       { 
....................          getc(); 
0385:  BTFSS  0C.5
0386:  GOTO   385
0387:  MOVF   1A,W
....................       } 
0388:  INCF   21,F
0389:  GOTO   381
....................        
....................       //gets(odp);                       //uloz zakodovany text SMS 
....................     
....................       odp[0]=getc(); 
038A:  BTFSS  0C.5
038B:  GOTO   38A
038C:  MOVF   1A,W
038D:  BSF    03.6
038E:  MOVWF  10
....................       odp[1]=getc(); 
038F:  BCF    03.6
0390:  BTFSS  0C.5
0391:  GOTO   390
0392:  MOVF   1A,W
0393:  BSF    03.6
0394:  MOVWF  11
....................       odp[2]=getc(); 
0395:  BCF    03.6
0396:  BTFSS  0C.5
0397:  GOTO   396
0398:  MOVF   1A,W
0399:  BSF    03.6
039A:  MOVWF  12
....................       odp[3]=getc(); 
039B:  BCF    03.6
039C:  BTFSS  0C.5
039D:  GOTO   39C
039E:  MOVF   1A,W
039F:  BSF    03.6
03A0:  MOVWF  13
....................       odp[4]=getc(); 
03A1:  BCF    03.6
03A2:  BTFSS  0C.5
03A3:  GOTO   3A2
03A4:  MOVF   1A,W
03A5:  BSF    03.6
03A6:  MOVWF  14
....................       odp[5]=getc(); 
03A7:  BCF    03.6
03A8:  BTFSS  0C.5
03A9:  GOTO   3A8
03AA:  MOVF   1A,W
03AB:  BSF    03.6
03AC:  MOVWF  15
....................       odp[6]=getc(); 
03AD:  BCF    03.6
03AE:  BTFSS  0C.5
03AF:  GOTO   3AE
03B0:  MOVF   1A,W
03B1:  BSF    03.6
03B2:  MOVWF  16
....................       odp[7]=getc(); 
03B3:  BCF    03.6
03B4:  BTFSS  0C.5
03B5:  GOTO   3B4
03B6:  MOVF   1A,W
03B7:  BSF    03.6
03B8:  MOVWF  17
....................     
....................       /*lcd_gotoxy(1,1); 
....................       printf(lcd_putc,"\f%s\n",odp);*/ 
....................     
....................       if(odp[0]==0) odp[1]='0';        // Prevod z ASCII do BIN  
03B9:  MOVF   10,F
03BA:  BTFSS  03.2
03BB:  GOTO   3BE
03BC:  MOVLW  30
03BD:  MOVWF  11
....................       odp[0]=odp[0] - '0'; 
03BE:  MOVLW  30
03BF:  SUBWF  10,F
....................       odp[1]=odp[1] - '0'; 
03C0:  SUBWF  11,F
....................       if(odp[0]>9) odp[0]=odp[0]-7; 
03C1:  MOVF   10,W
03C2:  SUBLW  09
03C3:  BTFSC  03.0
03C4:  GOTO   3C7
03C5:  MOVLW  07
03C6:  SUBWF  10,F
....................       if(odp[1]>9) odp[1]=odp[1]-7; 
03C7:  MOVF   11,W
03C8:  SUBLW  09
03C9:  BTFSC  03.0
03CA:  GOTO   3CD
03CB:  MOVLW  07
03CC:  SUBWF  11,F
....................       odp[0]=odp[0] << 4; 
03CD:  SWAPF  10,F
03CE:  MOVLW  F0
03CF:  ANDWF  10,F
....................       odp[0] |= odp[1]; 
03D0:  MOVF   11,W
03D1:  IORWF  10,F
....................     
....................       if(odp[2]==0) odp[3]='0'; 
03D2:  MOVF   12,F
03D3:  BTFSS  03.2
03D4:  GOTO   3D7
03D5:  MOVLW  30
03D6:  MOVWF  13
....................       odp[2]=odp[2] - '0'; 
03D7:  MOVLW  30
03D8:  SUBWF  12,F
....................       odp[3]=odp[3] - '0'; 
03D9:  SUBWF  13,F
....................       if(odp[2]>9) odp[2]=odp[2]-7; 
03DA:  MOVF   12,W
03DB:  SUBLW  09
03DC:  BTFSC  03.0
03DD:  GOTO   3E0
03DE:  MOVLW  07
03DF:  SUBWF  12,F
....................       if(odp[3]>9) odp[3]=odp[3]-7; 
03E0:  MOVF   13,W
03E1:  SUBLW  09
03E2:  BTFSC  03.0
03E3:  GOTO   3E6
03E4:  MOVLW  07
03E5:  SUBWF  13,F
....................       odp[2]=odp[2] << 4; 
03E6:  SWAPF  12,F
03E7:  MOVLW  F0
03E8:  ANDWF  12,F
....................       odp[2] |= odp[3]; 
03E9:  MOVF   13,W
03EA:  IORWF  12,F
....................     
....................       if(odp[4]==0) odp[5]='0'; 
03EB:  MOVF   14,F
03EC:  BTFSS  03.2
03ED:  GOTO   3F0
03EE:  MOVLW  30
03EF:  MOVWF  15
....................       odp[4]=odp[4] - '0'; 
03F0:  MOVLW  30
03F1:  SUBWF  14,F
....................       odp[5]=odp[5] - '0'; 
03F2:  SUBWF  15,F
....................       if(odp[4]>9) odp[4]=odp[4]-7; 
03F3:  MOVF   14,W
03F4:  SUBLW  09
03F5:  BTFSC  03.0
03F6:  GOTO   3F9
03F7:  MOVLW  07
03F8:  SUBWF  14,F
....................       if(odp[5]>9) odp[5]=odp[5]-7; 
03F9:  MOVF   15,W
03FA:  SUBLW  09
03FB:  BTFSC  03.0
03FC:  GOTO   3FF
03FD:  MOVLW  07
03FE:  SUBWF  15,F
....................       odp[4]=odp[4] << 4; 
03FF:  SWAPF  14,F
0400:  MOVLW  F0
0401:  ANDWF  14,F
....................       odp[4] |= odp[5]; 
0402:  MOVF   15,W
0403:  IORWF  14,F
....................     
....................       if(odp[6]==0) odp[7]='0'; 
0404:  MOVF   16,F
0405:  BTFSS  03.2
0406:  GOTO   409
0407:  MOVLW  30
0408:  MOVWF  17
....................       odp[6]=odp[6] - '0'; 
0409:  MOVLW  30
040A:  SUBWF  16,F
....................       odp[7]=odp[7] - '0'; 
040B:  SUBWF  17,F
....................       if(odp[6]>9) odp[6]=odp[6]-7; 
040C:  MOVF   16,W
040D:  SUBLW  09
040E:  BTFSC  03.0
040F:  GOTO   412
0410:  MOVLW  07
0411:  SUBWF  16,F
....................       if(odp[7]>9) odp[7]=odp[7]-7; 
0412:  MOVF   17,W
0413:  SUBLW  09
0414:  BTFSC  03.0
0415:  GOTO   418
0416:  MOVLW  07
0417:  SUBWF  17,F
....................       odp[6]=odp[6] << 4; 
0418:  SWAPF  16,F
0419:  MOVLW  F0
041A:  ANDWF  16,F
....................       odp[6] |= odp[7]; 
041B:  MOVF   17,W
041C:  IORWF  16,F
....................  
....................       odp[1]=odp[2]; 
041D:  MOVF   12,W
041E:  MOVWF  11
....................       odp[2]=odp[4]; 
041F:  MOVF   14,W
0420:  MOVWF  12
....................       odp[3]=odp[6]; 
0421:  MOVF   16,W
0422:  MOVWF  13
....................       odp[4],odp[5],odp[6]=""; 
0423:  CLRF   16
....................     
....................       /*lcd_gotoxy(1,2);     
....................       printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2]odp[3]);   */ 
....................     
....................       pom3=0; 
0424:  BCF    03.6
0425:  CLRF   23
....................       for (pom = 0; pom < 4;pom++)             
0426:  CLRF   21
0427:  MOVF   21,W
0428:  SUBLW  03
0429:  BTFSS  03.0
042A:  GOTO   49C
....................          { 
....................          maskovadlo =  maskovadlo >> 1;                 //rotace promene urcene pro maskovani 
042B:  BCF    03.0
042C:  RRF    26,F
....................          maskovadlo =  maskovadlo | 0x80; 
042D:  BSF    26.7
....................          odkl = odp[pom] & maskovadlo;                  //odlozeni "prenosu" do odkl pomoci maskovadla 
042E:  MOVLW  10
042F:  ADDWF  21,W
0430:  MOVWF  04
0431:  BSF    03.7
0432:  MOVF   00,W
0433:  ANDWF  26,W
0434:  MOVWF  24
....................          odp[pom] = odp[pom] << pom3;                     //rotace znaku 
0435:  MOVLW  10
0436:  ADDWF  21,W
0437:  MOVWF  78
0438:  MOVLW  01
0439:  MOVWF  7A
043A:  BTFSC  03.0
043B:  INCF   7A,F
043C:  MOVF   78,W
043D:  MOVWF  28
043E:  MOVF   7A,W
043F:  MOVWF  29
0440:  MOVLW  10
0441:  ADDWF  21,W
0442:  MOVWF  04
0443:  BSF    03.7
0444:  MOVF   00,W
0445:  MOVWF  77
0446:  MOVF   23,W
0447:  MOVWF  78
0448:  BTFSC  03.2
0449:  GOTO   44E
044A:  BCF    03.0
044B:  RLF    77,F
044C:  DECFSZ 78,F
044D:  GOTO   44A
044E:  MOVF   28,W
044F:  MOVWF  04
0450:  BCF    03.7
0451:  BTFSC  29.0
0452:  BSF    03.7
0453:  MOVF   77,W
0454:  MOVWF  00
....................          for (pom2 = 0; pom2 < (8-pom3);pom2++)            //rotace odkl2 
0455:  CLRF   22
0456:  MOVF   23,W
0457:  SUBLW  08
0458:  SUBWF  22,W
0459:  BTFSC  03.0
045A:  GOTO   460
....................             { 
....................             odkl2 = odkl2 >> 1; 
045B:  BCF    03.0
045C:  RRF    25,F
....................             odkl2 = odkl2 & 127;     
045D:  BCF    25.7
....................             } 
045E:  INCF   22,F
045F:  GOTO   456
....................          odp[pom] = odp[pom] | odkl2;                     //pridani odkl2 ke znaku 
0460:  MOVLW  10
0461:  ADDWF  21,W
0462:  MOVWF  78
0463:  MOVLW  01
0464:  MOVWF  7A
0465:  BTFSC  03.0
0466:  INCF   7A,F
0467:  MOVLW  10
0468:  ADDWF  21,W
0469:  MOVWF  04
046A:  BSF    03.7
046B:  MOVF   00,W
046C:  IORWF  25,W
046D:  MOVWF  2B
046E:  MOVF   78,W
046F:  MOVWF  04
0470:  BCF    03.7
0471:  BTFSC  7A.0
0472:  BSF    03.7
0473:  MOVF   2B,W
0474:  MOVWF  00
....................          odp[pom] = odp[pom] & 127;                      //smazani nejvysiho bitu 
0475:  MOVLW  10
0476:  ADDWF  21,W
0477:  MOVWF  78
0478:  MOVLW  01
0479:  MOVWF  7A
047A:  BTFSC  03.0
047B:  INCF   7A,F
047C:  MOVLW  10
047D:  ADDWF  21,W
047E:  MOVWF  04
047F:  BSF    03.7
0480:  MOVF   00,W
0481:  ANDLW  7F
0482:  MOVWF  2B
0483:  MOVF   78,W
0484:  MOVWF  04
0485:  BCF    03.7
0486:  BTFSC  7A.0
0487:  BSF    03.7
0488:  MOVF   2B,W
0489:  MOVWF  00
....................          odkl2 = odkl;                              //ulozeni odlk na dalsi pruchod 
048A:  MOVF   24,W
048B:  MOVWF  25
....................          pom3++;                                    //inkrementace citace rotace 
048C:  INCF   23,F
....................          if (pom3 == 8)                              //kazdy 8my znak 
048D:  MOVF   23,W
048E:  SUBLW  08
048F:  BTFSS  03.2
0490:  GOTO   49A
....................             { 
....................             pom3 = 0;                                 //smaz citac 
0491:  CLRF   23
....................             odp[pom+1] = odkl2;                        //uloz 8my znak vznikly z "prenosu" 
0492:  MOVLW  01
0493:  ADDWF  21,W
0494:  ADDLW  10
0495:  MOVWF  04
0496:  BSF    03.7
0497:  MOVF   25,W
0498:  MOVWF  00
....................             maskovadlo = 0;                           //smaz maskovadlo 
0499:  CLRF   26
....................             } 
....................          } 
049A:  INCF   21,F
049B:  GOTO   427
....................       odp[pom]='\0';  
049C:  MOVLW  10
049D:  ADDWF  21,W
049E:  MOVWF  04
049F:  BSF    03.7
04A0:  CLRF   00
....................       /*lcd_gotoxy(1,3); 
....................       printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2],odp[3]);   */ 
....................       lcd_gotoxy(1,1); 
04A1:  MOVLW  01
04A2:  BSF    03.5
04A3:  BSF    03.6
04A4:  MOVWF  1A
04A5:  MOVWF  1B
04A6:  BCF    03.5
04A7:  BCF    03.6
04A8:  CALL   1D7
....................       printf(lcd_putc,"\fPrijata SMS s textem",); 
04A9:  CLRF   28
04AA:  MOVF   28,W
04AB:  CALL   062
04AC:  INCF   28,F
04AD:  MOVWF  77
04AE:  BSF    03.5
04AF:  BSF    03.6
04B0:  MOVWF  19
04B1:  BCF    03.5
04B2:  BCF    03.6
04B3:  CALL   20C
04B4:  MOVLW  15
04B5:  SUBWF  28,W
04B6:  BTFSS  03.2
04B7:  GOTO   4AA
....................       lcd_gotoxy(9,3); 
04B8:  MOVLW  09
04B9:  BSF    03.5
04BA:  BSF    03.6
04BB:  MOVWF  1A
04BC:  MOVLW  03
04BD:  MOVWF  1B
04BE:  BCF    03.5
04BF:  BCF    03.6
04C0:  CALL   1D7
....................       printf(lcd_putc,"%s",odp);  
04C1:  MOVLW  10
04C2:  MOVWF  04
04C3:  BSF    03.7
04C4:  MOVLW  00
04C5:  IORWF  00,W
04C6:  BTFSC  03.2
04C7:  GOTO   4DC
04C8:  CLRF   29
04C9:  MOVF   04,W
04CA:  MOVWF  28
04CB:  BCF    29.0
04CC:  BTFSC  03.7
04CD:  BSF    29.0
04CE:  MOVF   00,W
04CF:  BSF    03.5
04D0:  BSF    03.6
04D1:  MOVWF  19
04D2:  BCF    03.5
04D3:  BCF    03.6
04D4:  CALL   20C
04D5:  MOVF   28,W
04D6:  MOVWF  04
04D7:  BCF    03.7
04D8:  BTFSC  29.0
04D9:  BSF    03.7
04DA:  INCF   04,F
04DB:  GOTO   4C4
....................       output_low(PIN_A4) ; 
04DC:  BSF    03.5
04DD:  BCF    05.4
04DE:  BCF    03.5
04DF:  BCF    05.4
....................       delay_ms(5000); 
04E0:  MOVLW  14
04E1:  MOVWF  28
04E2:  MOVLW  FA
04E3:  BSF    03.5
04E4:  BSF    03.6
04E5:  MOVWF  1A
04E6:  BCF    03.5
04E7:  BCF    03.6
04E8:  CALL   125
04E9:  DECFSZ 28,F
04EA:  GOTO   4E2
....................       output_high(PIN_A4); 
04EB:  BSF    03.5
04EC:  BCF    05.4
04ED:  BCF    03.5
04EE:  BSF    05.4
....................       printf("AT+CMGD=1\r");          //smaz prijatou SMSku 
04EF:  CLRF   28
04F0:  MOVF   28,W
04F1:  CALL   07C
04F2:  INCF   28,F
04F3:  MOVWF  77
04F4:  MOVF   77,W
04F5:  BTFSS  0C.4
04F6:  GOTO   4F5
04F7:  MOVWF  19
04F8:  MOVLW  0A
04F9:  SUBWF  28,W
04FA:  BTFSS  03.2
04FB:  GOTO   4F0
....................      
....................       if (odp[0] > 64 && odp[0] < 91 ) 
04FC:  BSF    03.6
04FD:  MOVF   10,W
04FE:  SUBLW  40
04FF:  BTFSC  03.0
0500:  GOTO   507
0501:  MOVF   10,W
0502:  SUBLW  5A
0503:  BTFSS  03.0
0504:  GOTO   507
....................          { 
....................          odp[0] += 32; 
0505:  MOVLW  20
0506:  ADDWF  10,F
....................          } 
....................      
....................       if (odp[1] > 64 && odp[1] < 91 ) 
0507:  MOVF   11,W
0508:  SUBLW  40
0509:  BTFSC  03.0
050A:  GOTO   511
050B:  MOVF   11,W
050C:  SUBLW  5A
050D:  BTFSS  03.0
050E:  GOTO   511
....................          { 
....................          odp[1] += 32; 
050F:  MOVLW  20
0510:  ADDWF  11,F
....................          } 
....................      
....................       if (odp[2] > 64 && odp[2] < 91 ) 
0511:  MOVF   12,W
0512:  SUBLW  40
0513:  BTFSC  03.0
0514:  GOTO   51B
0515:  MOVF   12,W
0516:  SUBLW  5A
0517:  BTFSS  03.0
0518:  GOTO   51B
....................          { 
....................          odp[2] += 32; 
0519:  MOVLW  20
051A:  ADDWF  12,F
....................          } 
....................      
....................       if (odp[3] > 64 && odp[3] < 91 ) 
051B:  MOVF   13,W
051C:  SUBLW  40
051D:  BTFSC  03.0
051E:  GOTO   525
051F:  MOVF   13,W
0520:  SUBLW  5A
0521:  BTFSS  03.0
0522:  GOTO   525
....................          { 
....................          odp[3] += 32; 
0523:  MOVLW  20
0524:  ADDWF  13,F
....................          } 
....................      
....................       lcd_gotoxy(1,1); 
0525:  MOVLW  01
0526:  BSF    03.5
0527:  MOVWF  1A
0528:  MOVWF  1B
0529:  BCF    03.5
052A:  BCF    03.6
052B:  CALL   1D7
....................       printf(lcd_putc,"\f Odstraneni velkych",); 
052C:  CLRF   28
052D:  MOVF   28,W
052E:  CALL   08B
052F:  INCF   28,F
0530:  MOVWF  77
0531:  BSF    03.5
0532:  BSF    03.6
0533:  MOVWF  19
0534:  BCF    03.5
0535:  BCF    03.6
0536:  CALL   20C
0537:  MOVLW  14
0538:  SUBWF  28,W
0539:  BTFSS  03.2
053A:  GOTO   52D
....................       lcd_gotoxy(1,2); 
053B:  MOVLW  01
053C:  BSF    03.5
053D:  BSF    03.6
053E:  MOVWF  1A
053F:  MOVLW  02
0540:  MOVWF  1B
0541:  BCF    03.5
0542:  BCF    03.6
0543:  CALL   1D7
....................       printf(lcd_putc,"       pismen"); 
0544:  CLRF   28
0545:  MOVF   28,W
0546:  CALL   0A4
0547:  INCF   28,F
0548:  MOVWF  77
0549:  BSF    03.5
054A:  BSF    03.6
054B:  MOVWF  19
054C:  BCF    03.5
054D:  BCF    03.6
054E:  CALL   20C
054F:  MOVLW  0D
0550:  SUBWF  28,W
0551:  BTFSS  03.2
0552:  GOTO   545
....................       lcd_gotoxy(9,4); 
0553:  MOVLW  09
0554:  BSF    03.5
0555:  BSF    03.6
0556:  MOVWF  1A
0557:  MOVLW  04
0558:  MOVWF  1B
0559:  BCF    03.5
055A:  BCF    03.6
055B:  CALL   1D7
....................       printf(lcd_putc,"%s",odp);  
055C:  MOVLW  10
055D:  MOVWF  04
055E:  BSF    03.7
055F:  MOVLW  00
0560:  IORWF  00,W
0561:  BTFSC  03.2
0562:  GOTO   577
0563:  CLRF   29
0564:  MOVF   04,W
0565:  MOVWF  28
0566:  BCF    29.0
0567:  BTFSC  03.7
0568:  BSF    29.0
0569:  MOVF   00,W
056A:  BSF    03.5
056B:  BSF    03.6
056C:  MOVWF  19
056D:  BCF    03.5
056E:  BCF    03.6
056F:  CALL   20C
0570:  MOVF   28,W
0571:  MOVWF  04
0572:  BCF    03.7
0573:  BTFSC  29.0
0574:  BSF    03.7
0575:  INCF   04,F
0576:  GOTO   55F
....................       output_low(PIN_A4) ; 
0577:  BSF    03.5
0578:  BCF    05.4
0579:  BCF    03.5
057A:  BCF    05.4
....................       delay_ms(5000); 
057B:  MOVLW  14
057C:  MOVWF  28
057D:  MOVLW  FA
057E:  BSF    03.5
057F:  BSF    03.6
0580:  MOVWF  1A
0581:  BCF    03.5
0582:  BCF    03.6
0583:  CALL   125
0584:  DECFSZ 28,F
0585:  GOTO   57D
....................       output_high(PIN_A4); 
0586:  BSF    03.5
0587:  BCF    05.4
0588:  BCF    03.5
0589:  BSF    05.4
....................      
....................      
....................       if (odp[0] == 122 && odp[1] == 97 && odp[2] == 112 && odp[3] == 49)    //odp=="zap1" 
058A:  BSF    03.6
058B:  MOVF   10,W
058C:  SUBLW  7A
058D:  BTFSS  03.2
058E:  GOTO   59F
058F:  MOVF   11,W
0590:  SUBLW  61
0591:  BTFSS  03.2
0592:  GOTO   59F
0593:  MOVF   12,W
0594:  SUBLW  70
0595:  BTFSS  03.2
0596:  GOTO   59F
0597:  MOVF   13,W
0598:  SUBLW  31
0599:  BTFSS  03.2
059A:  GOTO   59F
....................          { 
....................          status=1; 
059B:  MOVLW  01
059C:  BCF    03.6
059D:  MOVWF  27
059E:  BSF    03.6
....................          } 
....................      
....................       if (odp[0] == 118 && odp[1] == 121 && odp[2] == 112 && odp[3]== 49)    //odp=="vyp1" 
059F:  MOVF   10,W
05A0:  SUBLW  76
05A1:  BTFSS  03.2
05A2:  GOTO   5B3
05A3:  MOVF   11,W
05A4:  SUBLW  79
05A5:  BTFSS  03.2
05A6:  GOTO   5B3
05A7:  MOVF   12,W
05A8:  SUBLW  70
05A9:  BTFSS  03.2
05AA:  GOTO   5B3
05AB:  MOVF   13,W
05AC:  SUBLW  31
05AD:  BTFSS  03.2
05AE:  GOTO   5B3
....................          { 
....................          status=2; 
05AF:  MOVLW  02
05B0:  BCF    03.6
05B1:  MOVWF  27
05B2:  BSF    03.6
....................          } 
....................      
....................       if (odp[0] == 97 && odp[1] == 104 && odp[2] == 111 && odp[3]== 106)    //odp=="ahoj" 
05B3:  MOVF   10,W
05B4:  SUBLW  61
05B5:  BTFSS  03.2
05B6:  GOTO   5C7
05B7:  MOVF   11,W
05B8:  SUBLW  68
05B9:  BTFSS  03.2
05BA:  GOTO   5C7
05BB:  MOVF   12,W
05BC:  SUBLW  6F
05BD:  BTFSS  03.2
05BE:  GOTO   5C7
05BF:  MOVF   13,W
05C0:  SUBLW  6A
05C1:  BTFSS  03.2
05C2:  GOTO   5C7
....................          { 
....................          status=3; 
05C3:  MOVLW  03
05C4:  BCF    03.6
05C5:  MOVWF  27
05C6:  BSF    03.6
....................          } 
....................             
....................       switch (status) { 
05C7:  BCF    03.6
05C8:  MOVF   27,W
05C9:  XORLW  01
05CA:  BTFSC  03.2
05CB:  GOTO   5D3
05CC:  XORLW  03
05CD:  BTFSC  03.2
05CE:  GOTO   5F7
05CF:  XORLW  01
05D0:  BTFSC  03.2
05D1:  GOTO   61B
05D2:  GOTO   63B
....................  
....................          case 1:  output_low(zar1); 
05D3:  BSF    03.5
05D4:  BCF    05.3
05D5:  BCF    03.5
05D6:  BCF    05.3
....................                   printf(lcd_putc,"\f"); 
05D7:  MOVLW  0C
05D8:  BSF    03.5
05D9:  BSF    03.6
05DA:  MOVWF  19
05DB:  BCF    03.5
05DC:  BCF    03.6
05DD:  CALL   20C
....................                   lcd_gotoxy(1,2); 
05DE:  MOVLW  01
05DF:  BSF    03.5
05E0:  BSF    03.6
05E1:  MOVWF  1A
05E2:  MOVLW  02
05E3:  MOVWF  1B
05E4:  BCF    03.5
05E5:  BCF    03.6
05E6:  CALL   1D7
....................                   printf(lcd_putc," Zapnuto zarizeni 1"); 
05E7:  CLRF   28
05E8:  MOVF   28,W
05E9:  CALL   0B6
05EA:  INCF   28,F
05EB:  MOVWF  77
05EC:  BSF    03.5
05ED:  BSF    03.6
05EE:  MOVWF  19
05EF:  BCF    03.5
05F0:  BCF    03.6
05F1:  CALL   20C
05F2:  MOVLW  13
05F3:  SUBWF  28,W
05F4:  BTFSS  03.2
05F5:  GOTO   5E8
....................                   break; 
05F6:  GOTO   673
....................  
....................          case 2:  output_high(zar1); 
05F7:  BSF    03.5
05F8:  BCF    05.3
05F9:  BCF    03.5
05FA:  BSF    05.3
....................                   printf(lcd_putc,"\f"); 
05FB:  MOVLW  0C
05FC:  BSF    03.5
05FD:  BSF    03.6
05FE:  MOVWF  19
05FF:  BCF    03.5
0600:  BCF    03.6
0601:  CALL   20C
....................                   lcd_gotoxy(1,2); 
0602:  MOVLW  01
0603:  BSF    03.5
0604:  BSF    03.6
0605:  MOVWF  1A
0606:  MOVLW  02
0607:  MOVWF  1B
0608:  BCF    03.5
0609:  BCF    03.6
060A:  CALL   1D7
....................                   printf(lcd_putc," Vypnuto zarizeni 1"); 
060B:  CLRF   28
060C:  MOVF   28,W
060D:  CALL   0CE
060E:  INCF   28,F
060F:  MOVWF  77
0610:  BSF    03.5
0611:  BSF    03.6
0612:  MOVWF  19
0613:  BCF    03.5
0614:  BCF    03.6
0615:  CALL   20C
0616:  MOVLW  13
0617:  SUBWF  28,W
0618:  BTFSS  03.2
0619:  GOTO   60C
....................                   break; 
061A:  GOTO   673
....................      
....................          case 3:  printf(lcd_putc,"\f"); 
061B:  MOVLW  0C
061C:  BSF    03.5
061D:  BSF    03.6
061E:  MOVWF  19
061F:  BCF    03.5
0620:  BCF    03.6
0621:  CALL   20C
....................                   lcd_gotoxy(1,2); 
0622:  MOVLW  01
0623:  BSF    03.5
0624:  BSF    03.6
0625:  MOVWF  1A
0626:  MOVLW  02
0627:  MOVWF  1B
0628:  BCF    03.5
0629:  BCF    03.6
062A:  CALL   1D7
....................                   printf(lcd_putc,"  Preji hezky den!"); 
062B:  CLRF   28
062C:  MOVF   28,W
062D:  CALL   0E6
062E:  INCF   28,F
062F:  MOVWF  77
0630:  BSF    03.5
0631:  BSF    03.6
0632:  MOVWF  19
0633:  BCF    03.5
0634:  BCF    03.6
0635:  CALL   20C
0636:  MOVLW  12
0637:  SUBWF  28,W
0638:  BTFSS  03.2
0639:  GOTO   62C
....................                   break; 
063A:  GOTO   673
....................      
....................          default: printf(lcd_putc,"\f"); 
063B:  MOVLW  0C
063C:  BSF    03.5
063D:  BSF    03.6
063E:  MOVWF  19
063F:  BCF    03.5
0640:  BCF    03.6
0641:  CALL   20C
....................                   lcd_gotoxy(1,2); 
0642:  MOVLW  01
0643:  BSF    03.5
0644:  BSF    03.6
0645:  MOVWF  1A
0646:  MOVLW  02
0647:  MOVWF  1B
0648:  BCF    03.5
0649:  BCF    03.6
064A:  CALL   1D7
....................                   printf(lcd_putc,"    Prikaz nebyl"); 
064B:  CLRF   28
064C:  MOVF   28,W
064D:  CALL   0FD
064E:  INCF   28,F
064F:  MOVWF  77
0650:  BSF    03.5
0651:  BSF    03.6
0652:  MOVWF  19
0653:  BCF    03.5
0654:  BCF    03.6
0655:  CALL   20C
0656:  MOVLW  10
0657:  SUBWF  28,W
0658:  BTFSS  03.2
0659:  GOTO   64C
....................                   lcd_gotoxy(1,3); 
065A:  MOVLW  01
065B:  BSF    03.5
065C:  BSF    03.6
065D:  MOVWF  1A
065E:  MOVLW  03
065F:  MOVWF  1B
0660:  BCF    03.5
0661:  BCF    03.6
0662:  CALL   1D7
....................                   printf(lcd_putc,"      rozeznan"); 
0663:  CLRF   28
0664:  MOVF   28,W
0665:  CALL   112
0666:  INCF   28,F
0667:  MOVWF  77
0668:  BSF    03.5
0669:  BSF    03.6
066A:  MOVWF  19
066B:  BCF    03.5
066C:  BCF    03.6
066D:  CALL   20C
066E:  MOVLW  0E
066F:  SUBWF  28,W
0670:  BTFSS  03.2
0671:  GOTO   664
....................                   break; } 
0672:  GOTO   673
....................              
....................       delay_ms(5000); 
0673:  MOVLW  14
0674:  MOVWF  28
0675:  MOVLW  FA
0676:  BSF    03.5
0677:  BSF    03.6
0678:  MOVWF  1A
0679:  BCF    03.5
067A:  BCF    03.6
067B:  CALL   125
067C:  DECFSZ 28,F
067D:  GOTO   675
....................    } 
....................  } 
067E:  GOTO   2BE
.................... } 
067F:  SLEEP

Configuration Fuses:
   Word  1: 3F3D   XT WDT NOPUT NODEBUG NOPROTECT NOBROWNOUT NOLVP NOCPD NOWRT