CCS PCM C Compiler, Version 3.245, 27853               08-V-08 23:27

               Filename: D:\MLAB_E\projekty\Ovladani_mobilnim_telefonem\SW\final\main.lst

               ROM used: 1505 words (18%)
                         Largest free fragment is 2048
               RAM used: 56 (32%) at main() level
                         64 (37%) worst case
               Stack:    4 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   29D
0003:  NOP
.................... #include ".\main.h" 
.................... #include <16F876A.h> 
.................... //////// Standard Header file for the PIC16F876A device //////////////// 
.................... #device PIC16F876A 
.................... #list 
....................  
.................... #device adc=8 
....................  
.................... #FUSES NOWDT                      //Watch Dog Timer 
.................... #FUSES HS//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=18432000,RESTART_WDT) 
*
0126:  MOVLW  52
0127:  MOVWF  04
0128:  MOVF   00,W
0129:  BTFSC  03.2
012A:  GOTO   13B
012B:  MOVLW  05
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  F9
0135:  MOVWF  77
0136:  DECFSZ 77,F
0137:  GOTO   136
0138:  CLRWDT
0139:  DECFSZ 00,F
013A:  GOTO   12B
013B:  RETLW  00
*
0153:  MOVLW  04
0154:  SUBWF  58,F
0155:  BTFSS  03.0
0156:  GOTO   16B
0157:  MOVLW  58
0158:  MOVWF  04
0159:  MOVLW  F8
015A:  ANDWF  00,F
015B:  BCF    03.0
015C:  RRF    00,F
015D:  RRF    00,F
015E:  RRF    00,F
015F:  MOVF   00,W
0160:  BTFSC  03.2
0161:  GOTO   16B
0162:  MOVLW  0A
0163:  MOVWF  77
0164:  DECFSZ 77,F
0165:  GOTO   164
0166:  NOP
0167:  NOP
0168:  CLRWDT
0169:  DECFSZ 00,F
016A:  GOTO   162
016B:  BCF    0A.3
016C:  BCF    0A.4
016D:  GOTO   183 (RETURN)
.................... #use rs232(STREAM=MOBIL,baud=19200,force_sw,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8) 
*
01C3:  BCF    20.6
01C4:  MOVF   20,W
01C5:  BSF    03.5
01C6:  MOVWF  07
01C7:  BCF    03.5
01C8:  BCF    07.6
01C9:  MOVLW  08
01CA:  MOVWF  78
01CB:  NOP
01CC:  NOP
01CD:  NOP
01CE:  BSF    78.7
01CF:  GOTO   1DF
01D0:  BCF    78.7
01D1:  RRF    51,F
01D2:  BTFSC  03.0
01D3:  BSF    07.6
01D4:  BTFSS  03.0
01D5:  BCF    07.6
01D6:  BSF    78.6
01D7:  GOTO   1DF
01D8:  BCF    78.6
01D9:  DECFSZ 78,F
01DA:  GOTO   1D1
01DB:  NOP
01DC:  NOP
01DD:  NOP
01DE:  BSF    07.6
01DF:  MOVLW  49
01E0:  MOVWF  04
01E1:  DECFSZ 04,F
01E2:  GOTO   1E1
01E3:  NOP
01E4:  NOP
01E5:  NOP
01E6:  BTFSC  78.7
01E7:  GOTO   1D0
01E8:  BTFSC  78.6
01E9:  GOTO   1D8
01EA:  BCF    0A.3
01EB:  BCF    0A.4
01EC:  GOTO   324 (RETURN)
01ED:  MOVLW  08
01EE:  MOVWF  77
01EF:  BSF    20.7
01F0:  MOVF   20,W
01F1:  BSF    03.5
01F2:  MOVWF  07
01F3:  BCF    03.5
01F4:  BTFSS  07.7
01F5:  GOTO   1F8
01F6:  BSF    03.5
01F7:  GOTO   1F3
01F8:  CLRF   50
01F9:  BSF    77.7
01FA:  GOTO   209
01FB:  BCF    77.7
01FC:  GOTO   209
01FD:  BCF    03.0
01FE:  BTFSC  07.7
01FF:  BSF    03.0
0200:  RRF    50,F
0201:  BSF    77.6
0202:  GOTO   209
0203:  BCF    77.6
0204:  DECFSZ 77,F
0205:  GOTO   1FD
0206:  MOVF   50,W
0207:  MOVWF  78
0208:  GOTO   216
0209:  MOVLW  49
020A:  BTFSC  77.7
020B:  MOVLW  14
020C:  MOVWF  78
020D:  DECFSZ 78,F
020E:  GOTO   20D
020F:  NOP
0210:  NOP
0211:  BTFSC  77.7
0212:  GOTO   1FB
0213:  BTFSC  77.6
0214:  GOTO   203
0215:  GOTO   1FD
0216:  RETLW  00
*
02B1:  MOVLW  FF
02B2:  BCF    03.5
02B3:  MOVWF  20
.................... #use rs232(STREAM=VRTULE,baud=600,parity=N,xmit=PIN_B2,rcv=PIN_B4,bits=8) 
*
026F:  BSF    03.5
0270:  BCF    06.2
0271:  BCF    03.5
0272:  BCF    06.2
0273:  MOVLW  08
0274:  MOVWF  78
0275:  NOP
0276:  NOP
0277:  NOP
0278:  BSF    78.7
0279:  GOTO   289
027A:  BCF    78.7
027B:  RRF    51,F
027C:  BTFSC  03.0
027D:  BSF    06.2
027E:  BTFSS  03.0
027F:  BCF    06.2
0280:  BSF    78.6
0281:  GOTO   289
0282:  BCF    78.6
0283:  DECFSZ 78,F
0284:  GOTO   27B
0285:  NOP
0286:  NOP
0287:  NOP
0288:  BSF    06.2
0289:  MOVLW  09
028A:  MOVWF  77
028B:  CLRF   04
028C:  DECFSZ 04,F
028D:  GOTO   28C
028E:  DECFSZ 77,F
028F:  GOTO   28B
0290:  MOVLW  F0
0291:  MOVWF  04
0292:  DECFSZ 04,F
0293:  GOTO   292
0294:  NOP
0295:  NOP
0296:  BTFSC  78.7
0297:  GOTO   27A
0298:  BTFSC  78.6
0299:  GOTO   282
029A:  BCF    0A.3
029B:  BCF    0A.4
029C:  GOTO   514 (RETURN)
....................  
....................  
....................  
.................... #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 
....................  
.................... #bit SPEN=0x18.7 
.................... #bit RCIF=0x0C.5 
....................  
.................... #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 
*
013C:  MOVF   07,W
013D:  ANDLW  F0
013E:  MOVWF  59
013F:  MOVF   58,W
0140:  ANDLW  0F
0141:  IORWF  59,W
0142:  MOVWF  07
....................    output_bit(LCD_E,1);       // vzestupna hrana 
0143:  BSF    06.0
0144:  BSF    03.5
0145:  BCF    06.0
....................    delay_us(100);               // pockej alespon 450ns od e nebo alespon 195ns od dat 
0146:  CLRWDT
0147:  MOVLW  98
0148:  MOVWF  77
0149:  DECFSZ 77,F
014A:  GOTO   149
014B:  NOP
014C:  NOP
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us) 
014D:  BCF    03.5
014E:  BCF    06.0
014F:  BSF    03.5
0150:  BCF    06.0
.................... } 
0151:  BCF    03.5
0152:  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 
*
016E:  MOVF   56,F
016F:  BTFSS  03.2
0170:  GOTO   173
0171:  BCF    06.1
0172:  GOTO   174
0173:  BSF    06.1
0174:  BSF    03.5
0175:  BCF    06.1
....................    swap(n); 
0176:  BCF    03.5
0177:  SWAPF  57,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu 
0178:  MOVF   57,W
0179:  MOVWF  58
017A:  CALL   13C
....................    swap(n); 
017B:  SWAPF  57,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu 
017C:  MOVF   57,W
017D:  MOVWF  58
017E:  CALL   13C
....................    delay_us(200);              // minimalni doba na provedeni prikazu 
017F:  CLRWDT
0180:  MOVLW  C7
0181:  MOVWF  58
0182:  GOTO   153
.................... } 
0183:  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 
0184:  MOVLW  14
0185:  MOVWF  52
0186:  CALL   126
....................  
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD 
0187:  MOVLW  F0
0188:  BSF    03.5
0189:  ANDWF  07,F
....................  
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav 
018A:  BCF    03.5
018B:  BCF    06.1
018C:  BSF    03.5
018D:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav 
018E:  BCF    03.5
018F:  BCF    06.0
0190:  BSF    03.5
0191:  BCF    06.0
....................  
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice 
0192:  BCF    03.5
0193:  CLRF   50
0194:  MOVF   50,W
0195:  SUBLW  02
0196:  BTFSS  03.0
0197:  GOTO   1A0
....................    { 
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel 
0198:  MOVLW  02
0199:  MOVWF  52
019A:  CALL   126
....................       lcd_send_nibble(3);              // rezim 8 bitu 
019B:  MOVLW  03
019C:  MOVWF  58
019D:  CALL   13C
....................    } 
019E:  INCF   50,F
019F:  GOTO   194
....................  
....................    delay_us(40);                       // cas na zpracovani 
01A0:  CLRWDT
01A1:  MOVLW  3C
01A2:  MOVWF  77
01A3:  DECFSZ 77,F
01A4:  GOTO   1A3
01A5:  NOP
01A6:  NOP
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu) 
01A7:  MOVLW  02
01A8:  MOVWF  58
01A9:  CALL   13C
....................    delay_us(40);                       // cas na zpracovani 
01AA:  CLRWDT
01AB:  MOVLW  3C
01AC:  MOVWF  77
01AD:  DECFSZ 77,F
01AE:  GOTO   1AD
01AF:  NOP
01B0:  NOP
....................  
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod) 
01B1:  CLRF   50
01B2:  MOVF   50,W
01B3:  SUBLW  02
01B4:  BTFSS  03.0
01B5:  GOTO   1C2
....................    { 
....................       lcd_send_byte(0,LCD_INIT_STRING[i]); 
01B6:  MOVF   50,W
01B7:  CALL   004
01B8:  MOVWF  51
01B9:  CLRF   56
01BA:  MOVF   51,W
01BB:  MOVWF  57
01BC:  CALL   16E
....................       delay_ms(2); 
01BD:  MOVLW  02
01BE:  MOVWF  52
01BF:  CALL   126
....................    } 
01C0:  INCF   50,F
01C1:  GOTO   1B2
.................... } 
01C2:  RETLW  00
....................  
....................  
.................... // Proved presun kurzoru 
.................... // 
.................... // Pozice 1.1 je domu 
.................... // 
.................... #separate 
.................... void lcd_gotoxy( BYTE x, BYTE y) 
.................... { 
....................  
....................    BYTE Adr; 
....................  
....................    switch(y) 
....................    { 
*
0217:  MOVLW  01
0218:  SUBWF  53,W
0219:  ADDLW  FC
021A:  BTFSC  03.0
021B:  GOTO   229
021C:  ADDLW  04
021D:  GOTO   234
....................       case 1: Adr=0; break; 
021E:  CLRF   54
021F:  GOTO   229
....................       case 2: Adr=0x40; break; 
0220:  MOVLW  40
0221:  MOVWF  54
0222:  GOTO   229
....................       case 3: Adr=0x14; break; 
0223:  MOVLW  14
0224:  MOVWF  54
0225:  GOTO   229
....................       case 4: Adr=0x54; break; 
0226:  MOVLW  54
0227:  MOVWF  54
0228:  GOTO   229
....................    } 
....................    Adr+=x-1; 
0229:  MOVLW  01
022A:  SUBWF  52,W
022B:  ADDWF  54,F
....................  
....................    lcd_send_byte(0,0x80|Adr); 
022C:  MOVF   54,W
022D:  IORLW  80
022E:  MOVWF  55
022F:  CLRF   56
0230:  MOVF   55,W
0231:  MOVWF  57
0232:  CALL   16E
.................... } 
0233:  RETLW  00
....................  
....................  
.................... // Zapis znaku na displej, zpracovani ridicich znaku 
.................... // 
.................... #separate 
.................... void lcd_putc( char c) 
.................... { 
....................  
....................    switch (c) 
....................    { 
*
023C:  MOVF   51,W
023D:  XORLW  0C
023E:  BTFSC  03.2
023F:  GOTO   24A
0240:  XORLW  06
0241:  BTFSC  03.2
0242:  GOTO   252
0243:  XORLW  07
0244:  BTFSC  03.2
0245:  GOTO   258
0246:  XORLW  05
0247:  BTFSC  03.2
0248:  GOTO   25D
0249:  GOTO   262
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej 
024A:  CLRF   56
024B:  MOVLW  01
024C:  MOVWF  57
024D:  CALL   16E
....................                     delay_ms(2); 
024E:  MOVLW  02
024F:  MOVWF  52
0250:  CALL   126
....................                                             break; 
0251:  GOTO   26E
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky 
0252:  MOVLW  01
0253:  MOVWF  52
0254:  MOVLW  02
0255:  MOVWF  53
0256:  CALL   217
0257:  GOTO   26E
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home 
0258:  MOVLW  01
0259:  MOVWF  52
025A:  MOVWF  53
025B:  CALL   217
025C:  GOTO   26E
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet 
025D:  CLRF   56
025E:  MOVLW  10
025F:  MOVWF  57
0260:  CALL   16E
0261:  GOTO   26E
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F 
0262:  MOVF   51,W
0263:  SUBLW  1F
0264:  BTFSS  03.0
0265:  GOTO   268
0266:  MOVLW  07
0267:  ANDWF  51,F
....................                     lcd_send_byte(1,c);     break; // zapis znak 
0268:  MOVLW  01
0269:  MOVWF  56
026A:  MOVF   51,W
026B:  MOVWF  57
026C:  CALL   16E
026D:  GOTO   26E
....................    } 
.................... } 
026E:  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() 
.................... { 
*
029D:  CLRF   04
029E:  MOVLW  1F
029F:  ANDWF  03,F
02A0:  BCF    20.6
02A1:  MOVF   20,W
02A2:  BSF    03.5
02A3:  MOVWF  07
02A4:  BCF    03.5
02A5:  BSF    07.6
02A6:  BSF    03.5
02A7:  BCF    06.2
02A8:  BCF    03.5
02A9:  BSF    06.2
02AA:  BSF    03.5
02AB:  BSF    1F.0
02AC:  BSF    1F.1
02AD:  BSF    1F.2
02AE:  BCF    1F.3
02AF:  MOVLW  07
02B0:  MOVWF  1C
.................... char odp[40]; 
.................... int pom,pom2,pom3,odkl,odkl2,maskovadlo,status; 
....................  
....................    setup_adc_ports(NO_ANALOGS); 
*
02B4:  BSF    03.5
02B5:  BSF    1F.0
02B6:  BSF    1F.1
02B7:  BSF    1F.2
02B8:  BCF    1F.3
....................    setup_adc(ADC_OFF); 
02B9:  BCF    03.5
02BA:  BCF    1F.0
....................    setup_spi(SPI_SS_DISABLED); 
02BB:  BCF    14.5
02BC:  BCF    20.5
02BD:  MOVF   20,W
02BE:  BSF    03.5
02BF:  MOVWF  07
02C0:  BCF    03.5
02C1:  BSF    20.4
02C2:  MOVF   20,W
02C3:  BSF    03.5
02C4:  MOVWF  07
02C5:  BCF    03.5
02C6:  BCF    20.3
02C7:  MOVF   20,W
02C8:  BSF    03.5
02C9:  MOVWF  07
02CA:  MOVLW  01
02CB:  BCF    03.5
02CC:  MOVWF  14
02CD:  MOVLW  00
02CE:  BSF    03.5
02CF:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); 
02D0:  MOVF   01,W
02D1:  ANDLW  C7
02D2:  IORLW  08
02D3:  MOVWF  01
....................    setup_timer_1(T1_DISABLED); 
02D4:  BCF    03.5
02D5:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1); 
02D6:  MOVLW  00
02D7:  MOVWF  78
02D8:  MOVWF  12
02D9:  MOVLW  00
02DA:  BSF    03.5
02DB:  MOVWF  12
....................    setup_comparator(NC_NC_NC_NC); 
02DC:  MOVLW  07
02DD:  MOVWF  1C
02DE:  MOVF   05,W
02DF:  CLRWDT
02E0:  MOVLW  0E
02E1:  MOVWF  77
02E2:  DECFSZ 77,F
02E3:  GOTO   2E2
02E4:  NOP
02E5:  NOP
02E6:  MOVF   1C,W
02E7:  BCF    03.5
02E8:  BCF    0D.6
....................    setup_vref(FALSE); 
02E9:  BSF    03.5
02EA:  CLRF   1D
....................    setup_wdt(WDT_2304MS); 
02EB:  MOVLW  0F
02EC:  MOVWF  77
02ED:  MOVLW  07
02EE:  BCF    03.5
02EF:  CLRF   01
02F0:  MOVLW  81
02F1:  MOVWF  04
02F2:  MOVF   00,W
02F3:  ANDLW  F0
02F4:  IORLW  07
02F5:  MOVWF  00
02F6:  CLRWDT
02F7:  MOVF   00,W
02F8:  ANDLW  F7
02F9:  BTFSC  77.3
02FA:  ANDLW  F0
02FB:  IORWF  77,W
02FC:  MOVWF  00
....................    lcd_init(); 
02FD:  CALL   184
....................  
....................    while(TRUE) 
....................    { 
....................     restart_wdt(); 
02FE:  CLRWDT
....................  
....................     output_low(PIN_A4) ; 
02FF:  BSF    03.5
0300:  BCF    05.4
0301:  BCF    03.5
0302:  BCF    05.4
....................     delay_ms(150); 
0303:  MOVLW  96
0304:  MOVWF  52
0305:  CALL   126
....................     output_high(PIN_A4); 
0306:  BSF    03.5
0307:  BCF    05.4
0308:  BCF    03.5
0309:  BSF    05.4
....................     delay_ms(150); 
030A:  MOVLW  96
030B:  MOVWF  52
030C:  CALL   126
....................     output_low(PIN_A4) ; 
030D:  BSF    03.5
030E:  BCF    05.4
030F:  BCF    03.5
0310:  BCF    05.4
....................     delay_ms(150); 
0311:  MOVLW  96
0312:  MOVWF  52
0313:  CALL   126
....................     output_high(PIN_A4); 
0314:  BSF    03.5
0315:  BCF    05.4
0316:  BCF    03.5
0317:  BSF    05.4
....................     delay_ms(150); 
0318:  MOVLW  96
0319:  MOVWF  52
031A:  CALL   126
....................  
.................... /* 
....................    while(kbhit(MOBIL)) {fgetc(MOBIL); delay_ms(100);}       // Preskoc zbytek radku 
....................    fprintf(MOBIL,"AT\r");           //vycti prijate SMS 
....................    while(fgetc(MOBIL)!=0x0A);       // predkoc prvni radek odpovedi 
....................  
.................... delay_ms(500); 
.................... for(pom=0;pom<80;pom++) odp[pom]=0; 
....................    fprintf(MOBIL,"AT\r");           //vycti prijate SMS 
....................    odp[0]=fgetc(MOBIL); 
....................    odp[1]=fgetc(MOBIL); 
....................    odp[2]=fgetc(MOBIL); 
....................  
.................... fprintf(VRTULE,"*%s*\n\r",odp); 
....................    fgetc(MOBIL); 
.................... output_low(PIN_A4); 
....................    fgetc(MOBIL); 
....................    fgetc(MOBIL); 
....................  
.................... delay_ms(1000); 
.................... continue; 
.................... */ 
....................    fprintf(MOBIL,"AT+CMGL=1\r");           //vycti prijate SMS (0=nove;1=vsechny) 
031B:  CLRF   50
031C:  MOVF   50,W
031D:  CALL   00C
031E:  IORLW  00
031F:  BTFSC  03.2
0320:  GOTO   325
0321:  INCF   50,F
0322:  MOVWF  51
0323:  GOTO   1C3
0324:  GOTO   31C
.................... //SPEN=1; 
....................  
....................  
....................    while(fgetc(MOBIL)!=0x0A);       // predkoc prvni radek odpovedi 
0325:  CALL   1ED
0326:  MOVF   78,W
0327:  SUBLW  0A
0328:  BTFSS  03.2
0329:  GOTO   325
....................  
....................    odp[0]=fgetc(MOBIL);             // Nacti prvni dva znaky druheho radku odpovedi 
032A:  CALL   1ED
032B:  MOVF   78,W
032C:  MOVWF  21
....................    odp[1]=fgetc(MOBIL); 
032D:  CALL   1ED
032E:  MOVF   78,W
032F:  MOVWF  22
....................    while(fgetc(MOBIL)!=0x0A);       // Preskoc zbytek radku 
0330:  CALL   1ED
0331:  MOVF   78,W
0332:  SUBLW  0A
0333:  BTFSS  03.2
0334:  GOTO   330
....................  
.................... //   while(kbhit(MOBIL)) {fgetc(MOBIL); delay_ms(100);}       // Preskoc zbytek radku 
.................... output_high(PIN_A4); 
0335:  BSF    03.5
0336:  BCF    05.4
0337:  BCF    03.5
0338:  BSF    05.4
....................  
....................  
....................    if(odp[0] == 79 && odp[1] ==75)   // Je odpoved "OK"? 
0339:  MOVF   21,W
033A:  SUBLW  4F
033B:  BTFSS  03.2
033C:  GOTO   384
033D:  MOVF   22,W
033E:  SUBLW  4B
033F:  BTFSS  03.2
0340:  GOTO   384
....................    { 
....................       lcd_gotoxy(1,1); 
0341:  MOVLW  01
0342:  MOVWF  52
0343:  MOVWF  53
0344:  CALL   217
....................       printf(lcd_putc,"\fNeni nova SMS zprava"); 
0345:  CLRF   50
0346:  MOVF   50,W
0347:  CALL   01B
0348:  IORLW  00
0349:  BTFSC  03.2
034A:  GOTO   34F
034B:  INCF   50,F
034C:  MOVWF  51
034D:  CALL   23C
034E:  GOTO   346
....................       lcd_gotoxy(1,2); 
034F:  MOVLW  01
0350:  MOVWF  52
0351:  MOVLW  02
0352:  MOVWF  53
0353:  CALL   217
....................       printf(lcd_putc,""); 
0354:  CLRF   50
0355:  MOVF   50,W
0356:  CALL   035
0357:  IORLW  00
0358:  BTFSC  03.2
0359:  GOTO   35E
035A:  INCF   50,F
035B:  MOVWF  51
035C:  CALL   23C
035D:  GOTO   355
....................       lcd_gotoxy(1,3); 
035E:  MOVLW  01
035F:  MOVWF  52
0360:  MOVLW  03
0361:  MOVWF  53
0362:  CALL   217
....................       printf(lcd_putc,"Zaslete SMS na cislo"); 
0363:  CLRF   50
0364:  MOVF   50,W
0365:  CALL   03A
0366:  IORLW  00
0367:  BTFSC  03.2
0368:  GOTO   36D
0369:  INCF   50,F
036A:  MOVWF  51
036B:  CALL   23C
036C:  GOTO   364
....................       lcd_gotoxy(1,4); 
036D:  MOVLW  01
036E:  MOVWF  52
036F:  MOVLW  04
0370:  MOVWF  53
0371:  CALL   217
....................       printf(lcd_putc,"    736 655 250"); 
0372:  CLRF   50
0373:  MOVF   50,W
0374:  CALL   053
0375:  IORLW  00
0376:  BTFSC  03.2
0377:  GOTO   37C
0378:  INCF   50,F
0379:  MOVWF  51
037A:  CALL   23C
037B:  GOTO   373
....................       delay_ms(5000); 
037C:  MOVLW  14
037D:  MOVWF  50
037E:  MOVLW  FA
037F:  MOVWF  52
0380:  CALL   126
0381:  DECFSZ 50,F
0382:  GOTO   37E
....................    } 
....................    else 
0383:  GOTO   5DF
....................    { 
.................... //!!!KAKL      for(pom=0;pom<55;pom++)                //preskoc nedulezite informace 
....................       for(pom=0;pom<54;pom++)                //preskoc nedulezite informace 
0384:  CLRF   49
0385:  MOVF   49,W
0386:  SUBLW  35
0387:  BTFSS  03.0
0388:  GOTO   38C
....................       { 
....................          fgetc(MOBIL); 
0389:  CALL   1ED
....................       } 
038A:  INCF   49,F
038B:  GOTO   385
....................  
....................       //gets(odp);                       //uloz zakodovany text SMS 
....................  
....................       odp[0]=fgetc(MOBIL); 
038C:  CALL   1ED
038D:  MOVF   78,W
038E:  MOVWF  21
....................       odp[1]=fgetc(MOBIL); 
038F:  CALL   1ED
0390:  MOVF   78,W
0391:  MOVWF  22
....................       odp[2]=fgetc(MOBIL); 
0392:  CALL   1ED
0393:  MOVF   78,W
0394:  MOVWF  23
....................       odp[3]=fgetc(MOBIL); 
0395:  CALL   1ED
0396:  MOVF   78,W
0397:  MOVWF  24
....................       odp[4]=fgetc(MOBIL); 
0398:  CALL   1ED
0399:  MOVF   78,W
039A:  MOVWF  25
....................       odp[5]=fgetc(MOBIL); 
039B:  CALL   1ED
039C:  MOVF   78,W
039D:  MOVWF  26
....................       odp[6]=fgetc(MOBIL); 
039E:  CALL   1ED
039F:  MOVF   78,W
03A0:  MOVWF  27
....................       odp[7]=fgetc(MOBIL); 
03A1:  CALL   1ED
03A2:  MOVF   78,W
03A3:  MOVWF  28
....................  
....................       /*lcd_gotoxy(1,1); 
....................       printf(lcd_putc,"\f%s\n",odp);*/ 
....................  
....................       if(odp[0]==0) odp[1]='0';        // Prevod z ASCII do BIN 
03A4:  MOVF   21,F
03A5:  BTFSS  03.2
03A6:  GOTO   3A9
03A7:  MOVLW  30
03A8:  MOVWF  22
....................       odp[0]=odp[0] - '0'; 
03A9:  MOVLW  30
03AA:  SUBWF  21,F
....................       odp[1]=odp[1] - '0'; 
03AB:  SUBWF  22,F
....................       if(odp[0]>9) odp[0]=odp[0]-7; 
03AC:  MOVF   21,W
03AD:  SUBLW  09
03AE:  BTFSC  03.0
03AF:  GOTO   3B2
03B0:  MOVLW  07
03B1:  SUBWF  21,F
....................       if(odp[1]>9) odp[1]=odp[1]-7; 
03B2:  MOVF   22,W
03B3:  SUBLW  09
03B4:  BTFSC  03.0
03B5:  GOTO   3B8
03B6:  MOVLW  07
03B7:  SUBWF  22,F
....................       odp[0]=odp[0] << 4; 
03B8:  SWAPF  21,F
03B9:  MOVLW  F0
03BA:  ANDWF  21,F
....................       odp[0] |= odp[1]; 
03BB:  MOVF   22,W
03BC:  IORWF  21,F
....................  
....................       if(odp[2]==0) odp[3]='0'; 
03BD:  MOVF   23,F
03BE:  BTFSS  03.2
03BF:  GOTO   3C2
03C0:  MOVLW  30
03C1:  MOVWF  24
....................       odp[2]=odp[2] - '0'; 
03C2:  MOVLW  30
03C3:  SUBWF  23,F
....................       odp[3]=odp[3] - '0'; 
03C4:  SUBWF  24,F
....................       if(odp[2]>9) odp[2]=odp[2]-7; 
03C5:  MOVF   23,W
03C6:  SUBLW  09
03C7:  BTFSC  03.0
03C8:  GOTO   3CB
03C9:  MOVLW  07
03CA:  SUBWF  23,F
....................       if(odp[3]>9) odp[3]=odp[3]-7; 
03CB:  MOVF   24,W
03CC:  SUBLW  09
03CD:  BTFSC  03.0
03CE:  GOTO   3D1
03CF:  MOVLW  07
03D0:  SUBWF  24,F
....................       odp[2]=odp[2] << 4; 
03D1:  SWAPF  23,F
03D2:  MOVLW  F0
03D3:  ANDWF  23,F
....................       odp[2] |= odp[3]; 
03D4:  MOVF   24,W
03D5:  IORWF  23,F
....................  
....................       if(odp[4]==0) odp[5]='0'; 
03D6:  MOVF   25,F
03D7:  BTFSS  03.2
03D8:  GOTO   3DB
03D9:  MOVLW  30
03DA:  MOVWF  26
....................       odp[4]=odp[4] - '0'; 
03DB:  MOVLW  30
03DC:  SUBWF  25,F
....................       odp[5]=odp[5] - '0'; 
03DD:  SUBWF  26,F
....................       if(odp[4]>9) odp[4]=odp[4]-7; 
03DE:  MOVF   25,W
03DF:  SUBLW  09
03E0:  BTFSC  03.0
03E1:  GOTO   3E4
03E2:  MOVLW  07
03E3:  SUBWF  25,F
....................       if(odp[5]>9) odp[5]=odp[5]-7; 
03E4:  MOVF   26,W
03E5:  SUBLW  09
03E6:  BTFSC  03.0
03E7:  GOTO   3EA
03E8:  MOVLW  07
03E9:  SUBWF  26,F
....................       odp[4]=odp[4] << 4; 
03EA:  SWAPF  25,F
03EB:  MOVLW  F0
03EC:  ANDWF  25,F
....................       odp[4] |= odp[5]; 
03ED:  MOVF   26,W
03EE:  IORWF  25,F
....................  
....................       if(odp[6]==0) odp[7]='0'; 
03EF:  MOVF   27,F
03F0:  BTFSS  03.2
03F1:  GOTO   3F4
03F2:  MOVLW  30
03F3:  MOVWF  28
....................       odp[6]=odp[6] - '0'; 
03F4:  MOVLW  30
03F5:  SUBWF  27,F
....................       odp[7]=odp[7] - '0'; 
03F6:  SUBWF  28,F
....................       if(odp[6]>9) odp[6]=odp[6]-7; 
03F7:  MOVF   27,W
03F8:  SUBLW  09
03F9:  BTFSC  03.0
03FA:  GOTO   3FD
03FB:  MOVLW  07
03FC:  SUBWF  27,F
....................       if(odp[7]>9) odp[7]=odp[7]-7; 
03FD:  MOVF   28,W
03FE:  SUBLW  09
03FF:  BTFSC  03.0
0400:  GOTO   403
0401:  MOVLW  07
0402:  SUBWF  28,F
....................       odp[6]=odp[6] << 4; 
0403:  SWAPF  27,F
0404:  MOVLW  F0
0405:  ANDWF  27,F
....................       odp[6] |= odp[7]; 
0406:  MOVF   28,W
0407:  IORWF  27,F
....................  
....................       odp[1]=odp[2]; 
0408:  MOVF   23,W
0409:  MOVWF  22
....................       odp[2]=odp[4]; 
040A:  MOVF   25,W
040B:  MOVWF  23
....................       odp[3]=odp[6]; 
040C:  MOVF   27,W
040D:  MOVWF  24
....................       odp[4]=odp[5]=odp[6]=0; 
040E:  CLRF   27
040F:  MOVF   27,W
0410:  MOVWF  26
0411:  MOVWF  25
....................  
....................       /*lcd_gotoxy(1,2); 
....................       printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2]odp[3]);   */ 
....................  
....................       pom3=0; 
0412:  CLRF   4B
....................       for (pom = 0; pom < 4;pom++) 
0413:  CLRF   49
0414:  MOVF   49,W
0415:  SUBLW  03
0416:  BTFSS  03.0
0417:  GOTO   46B
....................          { 
....................          maskovadlo =  maskovadlo >> 1;                 //rotace promene urcene pro maskovani 
0418:  BCF    03.0
0419:  RRF    4E,F
....................          maskovadlo =  maskovadlo | 0x80; 
041A:  BSF    4E.7
....................          odkl = odp[pom] & maskovadlo;                  //odlozeni "prenosu" do odkl pomoci maskovadla 
041B:  MOVLW  21
041C:  ADDWF  49,W
041D:  MOVWF  04
041E:  MOVF   00,W
041F:  ANDWF  4E,W
0420:  MOVWF  4C
....................          odp[pom] = odp[pom] << pom3;                     //rotace znaku 
0421:  MOVLW  21
0422:  ADDWF  49,W
0423:  MOVWF  50
0424:  MOVLW  21
0425:  ADDWF  49,W
0426:  MOVWF  04
0427:  MOVF   00,W
0428:  MOVWF  77
0429:  MOVF   4B,W
042A:  MOVWF  78
042B:  BTFSC  03.2
042C:  GOTO   431
042D:  BCF    03.0
042E:  RLF    77,F
042F:  DECFSZ 78,F
0430:  GOTO   42D
0431:  MOVF   50,W
0432:  MOVWF  04
0433:  MOVF   77,W
0434:  MOVWF  00
....................          for (pom2 = 0; pom2 < (8-pom3);pom2++)            //rotace odkl2 
0435:  CLRF   4A
0436:  MOVF   4B,W
0437:  SUBLW  08
0438:  SUBWF  4A,W
0439:  BTFSC  03.0
043A:  GOTO   440
....................             { 
....................             odkl2 = odkl2 >> 1; 
043B:  BCF    03.0
043C:  RRF    4D,F
....................             odkl2 = odkl2 & 127; 
043D:  BCF    4D.7
....................             } 
043E:  INCF   4A,F
043F:  GOTO   436
....................          odp[pom] = odp[pom] | odkl2;                     //pridani odkl2 ke znaku 
0440:  MOVLW  21
0441:  ADDWF  49,W
0442:  MOVWF  50
0443:  MOVLW  21
0444:  ADDWF  49,W
0445:  MOVWF  04
0446:  MOVF   00,W
0447:  IORWF  4D,W
0448:  MOVWF  52
0449:  MOVF   50,W
044A:  MOVWF  04
044B:  MOVF   52,W
044C:  MOVWF  00
....................          odp[pom] = odp[pom] & 127;                      //smazani nejvysiho bitu 
044D:  MOVLW  21
044E:  ADDWF  49,W
044F:  MOVWF  50
0450:  MOVLW  21
0451:  ADDWF  49,W
0452:  MOVWF  04
0453:  MOVF   00,W
0454:  ANDLW  7F
0455:  MOVWF  52
0456:  MOVF   50,W
0457:  MOVWF  04
0458:  MOVF   52,W
0459:  MOVWF  00
....................          odkl2 = odkl;                              //ulozeni odlk na dalsi pruchod 
045A:  MOVF   4C,W
045B:  MOVWF  4D
....................          pom3++;                                    //inkrementace citace rotace 
045C:  INCF   4B,F
....................          if (pom3 == 8)                              //kazdy 8my znak 
045D:  MOVF   4B,W
045E:  SUBLW  08
045F:  BTFSS  03.2
0460:  GOTO   469
....................             { 
....................             pom3 = 0;                                 //smaz citac 
0461:  CLRF   4B
....................             odp[pom+1] = odkl2;                        //uloz 8my znak vznikly z "prenosu" 
0462:  MOVLW  01
0463:  ADDWF  49,W
0464:  ADDLW  21
0465:  MOVWF  04
0466:  MOVF   4D,W
0467:  MOVWF  00
....................             maskovadlo = 0;                           //smaz maskovadlo 
0468:  CLRF   4E
....................             } 
....................          } 
0469:  INCF   49,F
046A:  GOTO   414
....................          odp[pom]='\0'; 
046B:  MOVLW  21
046C:  ADDWF  49,W
046D:  MOVWF  04
046E:  CLRF   00
....................  
....................       /*lcd_gotoxy(1,3); 
....................       printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2],odp[3]);   */ 
....................    lcd_init(); 
046F:  CALL   184
....................       lcd_gotoxy(1,1); 
0470:  MOVLW  01
0471:  MOVWF  52
0472:  MOVWF  53
0473:  CALL   217
....................       printf(lcd_putc,"\fPrijata SMS s textem"); 
0474:  CLRF   50
0475:  MOVF   50,W
0476:  CALL   067
0477:  IORLW  00
0478:  BTFSC  03.2
0479:  GOTO   47E
047A:  INCF   50,F
047B:  MOVWF  51
047C:  CALL   23C
047D:  GOTO   475
....................       lcd_gotoxy(9,3); 
047E:  MOVLW  09
047F:  MOVWF  52
0480:  MOVLW  03
0481:  MOVWF  53
0482:  CALL   217
....................       printf(lcd_putc,"%s",odp); 
0483:  MOVLW  21
0484:  MOVWF  04
0485:  MOVLW  00
0486:  IORWF  00,W
0487:  BTFSC  03.2
0488:  GOTO   492
0489:  MOVF   04,W
048A:  MOVWF  50
048B:  MOVF   00,W
048C:  MOVWF  51
048D:  CALL   23C
048E:  MOVF   50,W
048F:  MOVWF  04
0490:  INCF   04,F
0491:  GOTO   485
....................       output_low(PIN_A4) ; 
0492:  BSF    03.5
0493:  BCF    05.4
0494:  BCF    03.5
0495:  BCF    05.4
....................       delay_ms(1000); 
0496:  MOVLW  04
0497:  MOVWF  50
0498:  MOVLW  FA
0499:  MOVWF  52
049A:  CALL   126
049B:  DECFSZ 50,F
049C:  GOTO   498
....................       output_high(PIN_A4); 
049D:  BSF    03.5
049E:  BCF    05.4
049F:  BCF    03.5
04A0:  BSF    05.4
....................  
.................... //!!!      fprintf(MOBIL,"AT+CMGD=1\r");          //smaz prijatou SMSku 
....................  
....................       if (odp[0] > 64 && odp[0] < 91 ) 
04A1:  MOVF   21,W
04A2:  SUBLW  40
04A3:  BTFSC  03.0
04A4:  GOTO   4AB
04A5:  MOVF   21,W
04A6:  SUBLW  5A
04A7:  BTFSS  03.0
04A8:  GOTO   4AB
....................          { 
....................          odp[0] += 32; 
04A9:  MOVLW  20
04AA:  ADDWF  21,F
....................          } 
....................  
....................       if (odp[1] > 64 && odp[1] < 91 ) 
04AB:  MOVF   22,W
04AC:  SUBLW  40
04AD:  BTFSC  03.0
04AE:  GOTO   4B5
04AF:  MOVF   22,W
04B0:  SUBLW  5A
04B1:  BTFSS  03.0
04B2:  GOTO   4B5
....................          { 
....................          odp[1] += 32; 
04B3:  MOVLW  20
04B4:  ADDWF  22,F
....................          } 
....................  
....................       if (odp[2] > 64 && odp[2] < 91 ) 
04B5:  MOVF   23,W
04B6:  SUBLW  40
04B7:  BTFSC  03.0
04B8:  GOTO   4BF
04B9:  MOVF   23,W
04BA:  SUBLW  5A
04BB:  BTFSS  03.0
04BC:  GOTO   4BF
....................          { 
....................          odp[2] += 32; 
04BD:  MOVLW  20
04BE:  ADDWF  23,F
....................          } 
....................  
....................       if (odp[3] > 64 && odp[3] < 91 ) 
04BF:  MOVF   24,W
04C0:  SUBLW  40
04C1:  BTFSC  03.0
04C2:  GOTO   4C9
04C3:  MOVF   24,W
04C4:  SUBLW  5A
04C5:  BTFSS  03.0
04C6:  GOTO   4C9
....................          { 
....................          odp[3] += 32; 
04C7:  MOVLW  20
04C8:  ADDWF  24,F
....................          } 
....................  
....................       lcd_gotoxy(1,1); 
04C9:  MOVLW  01
04CA:  MOVWF  52
04CB:  MOVWF  53
04CC:  CALL   217
....................       printf(lcd_putc,"\f Odstraneni velkych"); 
04CD:  CLRF   50
04CE:  MOVF   50,W
04CF:  CALL   081
04D0:  IORLW  00
04D1:  BTFSC  03.2
04D2:  GOTO   4D7
04D3:  INCF   50,F
04D4:  MOVWF  51
04D5:  CALL   23C
04D6:  GOTO   4CE
....................       lcd_gotoxy(1,2); 
04D7:  MOVLW  01
04D8:  MOVWF  52
04D9:  MOVLW  02
04DA:  MOVWF  53
04DB:  CALL   217
....................       printf(lcd_putc,"       pismen"); 
04DC:  CLRF   50
04DD:  MOVF   50,W
04DE:  CALL   09A
04DF:  IORLW  00
04E0:  BTFSC  03.2
04E1:  GOTO   4E6
04E2:  INCF   50,F
04E3:  MOVWF  51
04E4:  CALL   23C
04E5:  GOTO   4DD
....................       lcd_gotoxy(9,4); 
04E6:  MOVLW  09
04E7:  MOVWF  52
04E8:  MOVLW  04
04E9:  MOVWF  53
04EA:  CALL   217
....................       printf(lcd_putc,"%s",odp); 
04EB:  MOVLW  21
04EC:  MOVWF  04
04ED:  MOVLW  00
04EE:  IORWF  00,W
04EF:  BTFSC  03.2
04F0:  GOTO   4FA
04F1:  MOVF   04,W
04F2:  MOVWF  50
04F3:  MOVF   00,W
04F4:  MOVWF  51
04F5:  CALL   23C
04F6:  MOVF   50,W
04F7:  MOVWF  04
04F8:  INCF   04,F
04F9:  GOTO   4ED
....................       output_low(PIN_A4) ; 
04FA:  BSF    03.5
04FB:  BCF    05.4
04FC:  BCF    03.5
04FD:  BCF    05.4
....................       delay_ms(1000); 
04FE:  MOVLW  04
04FF:  MOVWF  50
0500:  MOVLW  FA
0501:  MOVWF  52
0502:  CALL   126
0503:  DECFSZ 50,F
0504:  GOTO   500
....................       output_high(PIN_A4); 
0505:  BSF    03.5
0506:  BCF    05.4
0507:  BCF    03.5
0508:  BSF    05.4
....................  
....................  
.................... //!!!KAKL 
....................       fprintf(VRTULE,"%s",odp); 
0509:  MOVLW  21
050A:  MOVWF  04
050B:  MOVLW  00
050C:  IORWF  00,W
050D:  BTFSC  03.2
050E:  GOTO   518
050F:  MOVF   04,W
0510:  MOVWF  50
0511:  MOVF   00,W
0512:  MOVWF  51
0513:  GOTO   26F
0514:  MOVF   50,W
0515:  MOVWF  04
0516:  INCF   04,F
0517:  GOTO   50B
....................  
....................  
....................       if (odp[0] == 122 && odp[1] == 97 && odp[2] == 112 && odp[3] == 49)    //odp=="zap1" 
0518:  MOVF   21,W
0519:  SUBLW  7A
051A:  BTFSS  03.2
051B:  GOTO   52A
051C:  MOVF   22,W
051D:  SUBLW  61
051E:  BTFSS  03.2
051F:  GOTO   52A
0520:  MOVF   23,W
0521:  SUBLW  70
0522:  BTFSS  03.2
0523:  GOTO   52A
0524:  MOVF   24,W
0525:  SUBLW  31
0526:  BTFSS  03.2
0527:  GOTO   52A
....................          { 
....................          status=1; 
0528:  MOVLW  01
0529:  MOVWF  4F
....................          } 
....................  
....................       if (odp[0] == 118 && odp[1] == 121 && odp[2] == 112 && odp[3]== 49)    //odp=="vyp1" 
052A:  MOVF   21,W
052B:  SUBLW  76
052C:  BTFSS  03.2
052D:  GOTO   53C
052E:  MOVF   22,W
052F:  SUBLW  79
0530:  BTFSS  03.2
0531:  GOTO   53C
0532:  MOVF   23,W
0533:  SUBLW  70
0534:  BTFSS  03.2
0535:  GOTO   53C
0536:  MOVF   24,W
0537:  SUBLW  31
0538:  BTFSS  03.2
0539:  GOTO   53C
....................          { 
....................          status=2; 
053A:  MOVLW  02
053B:  MOVWF  4F
....................          } 
....................  
....................       if (odp[0] == 97 && odp[1] == 104 && odp[2] == 111 && odp[3]== 106)    //odp=="ahoj" 
053C:  MOVF   21,W
053D:  SUBLW  61
053E:  BTFSS  03.2
053F:  GOTO   54E
0540:  MOVF   22,W
0541:  SUBLW  68
0542:  BTFSS  03.2
0543:  GOTO   54E
0544:  MOVF   23,W
0545:  SUBLW  6F
0546:  BTFSS  03.2
0547:  GOTO   54E
0548:  MOVF   24,W
0549:  SUBLW  6A
054A:  BTFSS  03.2
054B:  GOTO   54E
....................          { 
....................          status=3; 
054C:  MOVLW  03
054D:  MOVWF  4F
....................          } 
....................  
....................       switch (status) 
....................       { 
054E:  MOVF   4F,W
054F:  XORLW  01
0550:  BTFSC  03.2
0551:  GOTO   559
0552:  XORLW  03
0553:  BTFSC  03.2
0554:  GOTO   577
0555:  XORLW  01
0556:  BTFSC  03.2
0557:  GOTO   595
0558:  GOTO   5AF
....................  
....................          case 1:  output_low(zar1); 
0559:  BSF    03.5
055A:  BCF    05.3
055B:  BCF    03.5
055C:  BCF    05.3
....................                   printf(lcd_putc,"\f"); 
055D:  CLRF   50
055E:  MOVF   50,W
055F:  CALL   0AC
0560:  IORLW  00
0561:  BTFSC  03.2
0562:  GOTO   567
0563:  INCF   50,F
0564:  MOVWF  51
0565:  CALL   23C
0566:  GOTO   55E
....................                   lcd_gotoxy(1,2); 
0567:  MOVLW  01
0568:  MOVWF  52
0569:  MOVLW  02
056A:  MOVWF  53
056B:  CALL   217
....................                   printf(lcd_putc," Zapnuto zarizeni 1"); 
056C:  CLRF   50
056D:  MOVF   50,W
056E:  CALL   0B2
056F:  IORLW  00
0570:  BTFSC  03.2
0571:  GOTO   576
0572:  INCF   50,F
0573:  MOVWF  51
0574:  CALL   23C
0575:  GOTO   56D
....................                   break; 
0576:  GOTO   5D8
....................  
....................          case 2:  output_high(zar1); 
0577:  BSF    03.5
0578:  BCF    05.3
0579:  BCF    03.5
057A:  BSF    05.3
....................                   printf(lcd_putc,"\f"); 
057B:  CLRF   50
057C:  MOVF   50,W
057D:  CALL   0AC
057E:  IORLW  00
057F:  BTFSC  03.2
0580:  GOTO   585
0581:  INCF   50,F
0582:  MOVWF  51
0583:  CALL   23C
0584:  GOTO   57C
....................                   lcd_gotoxy(1,2); 
0585:  MOVLW  01
0586:  MOVWF  52
0587:  MOVLW  02
0588:  MOVWF  53
0589:  CALL   217
....................                   printf(lcd_putc," Vypnuto zarizeni 1"); 
058A:  CLRF   50
058B:  MOVF   50,W
058C:  CALL   0CA
058D:  IORLW  00
058E:  BTFSC  03.2
058F:  GOTO   594
0590:  INCF   50,F
0591:  MOVWF  51
0592:  CALL   23C
0593:  GOTO   58B
....................                   break; 
0594:  GOTO   5D8
....................  
....................          case 3:  printf(lcd_putc,"\f"); 
0595:  CLRF   50
0596:  MOVF   50,W
0597:  CALL   0AC
0598:  IORLW  00
0599:  BTFSC  03.2
059A:  GOTO   59F
059B:  INCF   50,F
059C:  MOVWF  51
059D:  CALL   23C
059E:  GOTO   596
....................                   lcd_gotoxy(1,2); 
059F:  MOVLW  01
05A0:  MOVWF  52
05A1:  MOVLW  02
05A2:  MOVWF  53
05A3:  CALL   217
....................                   printf(lcd_putc,"  Preji hezky den!"); 
05A4:  CLRF   50
05A5:  MOVF   50,W
05A6:  CALL   0E2
05A7:  IORLW  00
05A8:  BTFSC  03.2
05A9:  GOTO   5AE
05AA:  INCF   50,F
05AB:  MOVWF  51
05AC:  CALL   23C
05AD:  GOTO   5A5
....................                   break; 
05AE:  GOTO   5D8
....................  
....................          default: printf(lcd_putc,"\f"); 
05AF:  CLRF   50
05B0:  MOVF   50,W
05B1:  CALL   0AC
05B2:  IORLW  00
05B3:  BTFSC  03.2
05B4:  GOTO   5B9
05B5:  INCF   50,F
05B6:  MOVWF  51
05B7:  CALL   23C
05B8:  GOTO   5B0
....................                   lcd_gotoxy(1,2); 
05B9:  MOVLW  01
05BA:  MOVWF  52
05BB:  MOVLW  02
05BC:  MOVWF  53
05BD:  CALL   217
....................                   printf(lcd_putc,"    Prikaz nebyl"); 
05BE:  CLRF   50
05BF:  MOVF   50,W
05C0:  CALL   0F9
05C1:  IORLW  00
05C2:  BTFSC  03.2
05C3:  GOTO   5C8
05C4:  INCF   50,F
05C5:  MOVWF  51
05C6:  CALL   23C
05C7:  GOTO   5BF
....................                   lcd_gotoxy(1,3); 
05C8:  MOVLW  01
05C9:  MOVWF  52
05CA:  MOVLW  03
05CB:  MOVWF  53
05CC:  CALL   217
....................                   printf(lcd_putc,"      rozeznan"); 
05CD:  CLRF   50
05CE:  MOVF   50,W
05CF:  CALL   113
05D0:  IORLW  00
05D1:  BTFSC  03.2
05D2:  GOTO   5D7
05D3:  INCF   50,F
05D4:  MOVWF  51
05D5:  CALL   23C
05D6:  GOTO   5CE
....................                   break; 
05D7:  GOTO   5D8
....................       } 
....................       delay_ms(1000); 
05D8:  MOVLW  04
05D9:  MOVWF  50
05DA:  MOVLW  FA
05DB:  MOVWF  52
05DC:  CALL   126
05DD:  DECFSZ 50,F
05DE:  GOTO   5DA
....................    } 
....................  
....................  } 
05DF:  GOTO   2FE
.................... } 
05E0:  SLEEP

Configuration Fuses:
   Word  1: 3F3A   HS NOWDT NOPUT NODEBUG NOPROTECT NOBROWNOUT NOLVP NOCPD NOWRT