WebSVN – MLAB_E – Rev 238 – //projekty/Ovladani_mobilnim

CCS PCM C Compiler, Version 4.058s, 42064               07-V-08 16:06

               Filename: main.lst

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

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   2F1
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) 
*
0119:  MOVLW  9A
011A:  MOVWF  04
011B:  BSF    03.7
011C:  MOVF   00,W
011D:  BTFSC  03.2
011E:  GOTO   12F
011F:  MOVLW  05
0120:  MOVWF  78
0121:  MOVLW  BF
0122:  MOVWF  77
0123:  CLRWDT
0124:  DECFSZ 77,F
0125:  GOTO   123
0126:  DECFSZ 78,F
0127:  GOTO   121
0128:  MOVLW  F9
0129:  MOVWF  77
012A:  DECFSZ 77,F
012B:  GOTO   12A
012C:  CLRWDT
012D:  DECFSZ 00,F
012E:  GOTO   11F
012F:  RETLW  00
*
016E:  MOVLW  04
016F:  SUBWF  20,F
0170:  BTFSS  03.0
0171:  GOTO   186
0172:  MOVLW  A0
0173:  MOVWF  04
0174:  BSF    03.7
0175:  MOVLW  F8
0176:  ANDWF  00,F
0177:  BCF    03.0
0178:  RRF    00,F
0179:  RRF    00,F
017A:  RRF    00,F
017B:  MOVF   00,W
017C:  BTFSC  03.2
017D:  GOTO   186
017E:  MOVLW  0A
017F:  MOVWF  77
0180:  DECFSZ 77,F
0181:  GOTO   180
0182:  GOTO   183
0183:  CLRWDT
0184:  DECFSZ 00,F
0185:  GOTO   17E
.................... #use rs232(STREAM=MOBIL,baud=19200,force_sw,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8) 
*
01E4:  BCF    20.6
01E5:  MOVF   20,W
01E6:  BSF    03.5
01E7:  MOVWF  07
01E8:  BCF    03.5
01E9:  BCF    07.6
01EA:  MOVLW  08
01EB:  MOVWF  78
01EC:  GOTO   1ED
01ED:  NOP
01EE:  BSF    78.7
01EF:  GOTO   202
01F0:  BCF    78.7
01F1:  BSF    03.5
01F2:  BSF    03.6
01F3:  RRF    18,F
01F4:  BCF    03.5
01F5:  BCF    03.6
01F6:  BTFSC  03.0
01F7:  BSF    07.6
01F8:  BTFSS  03.0
01F9:  BCF    07.6
01FA:  BSF    78.6
01FB:  GOTO   202
01FC:  BCF    78.6
01FD:  DECFSZ 78,F
01FE:  GOTO   1F1
01FF:  GOTO   200
0200:  NOP
0201:  BSF    07.6
0202:  MOVLW  49
0203:  MOVWF  04
0204:  DECFSZ 04,F
0205:  GOTO   204
0206:  GOTO   207
0207:  NOP
0208:  BTFSC  78.7
0209:  GOTO   1F0
020A:  BTFSC  78.6
020B:  GOTO   1FC
020C:  BCF    0A.3
020D:  BCF    0A.4
020E:  GOTO   38B (RETURN)
020F:  BSF    20.7
0210:  MOVF   20,W
0211:  BSF    03.5
0212:  MOVWF  07
0213:  BCF    03.5
0214:  BTFSC  07.7
0215:  GOTO   214
0216:  MOVLW  08
0217:  MOVWF  77
0218:  BSF    03.5
0219:  BSF    03.6
021A:  CLRF   17
021B:  BSF    77.7
021C:  GOTO   22F
021D:  BCF    77.7
021E:  GOTO   22F
021F:  BCF    03.0
0220:  BCF    03.5
0221:  BCF    03.6
0222:  BTFSC  07.7
0223:  BSF    03.0
0224:  BSF    03.5
0225:  BSF    03.6
0226:  RRF    17,F
0227:  BSF    77.6
0228:  GOTO   22F
0229:  BCF    77.6
022A:  DECFSZ 77,F
022B:  GOTO   21F
022C:  MOVF   17,W
022D:  MOVWF  78
022E:  GOTO   23B
022F:  MOVLW  49
0230:  BTFSC  77.7
0231:  MOVLW  14
0232:  MOVWF  78
0233:  DECFSZ 78,F
0234:  GOTO   233
0235:  GOTO   236
0236:  BTFSC  77.7
0237:  GOTO   21D
0238:  BTFSC  77.6
0239:  GOTO   229
023A:  GOTO   21F
023B:  BCF    03.5
023C:  BCF    03.6
023D:  RETLW  00
*
0306:  MOVLW  FF
0307:  BCF    03.5
0308:  MOVWF  20
.................... #use rs232(STREAM=VRTULE,baud=600,parity=N,xmit=PIN_B2,rcv=PIN_B4,bits=8) 
*
02C2:  BSF    03.5
02C3:  BCF    06.2
02C4:  BCF    03.5
02C5:  BCF    06.2
02C6:  MOVLW  08
02C7:  MOVWF  78
02C8:  GOTO   2C9
02C9:  NOP
02CA:  BSF    78.7
02CB:  GOTO   2DE
02CC:  BCF    78.7
02CD:  BSF    03.5
02CE:  BSF    03.6
02CF:  RRF    19,F
02D0:  BCF    03.5
02D1:  BCF    03.6
02D2:  BTFSC  03.0
02D3:  BSF    06.2
02D4:  BTFSS  03.0
02D5:  BCF    06.2
02D6:  BSF    78.6
02D7:  GOTO   2DE
02D8:  BCF    78.6
02D9:  DECFSZ 78,F
02DA:  GOTO   2CD
02DB:  GOTO   2DC
02DC:  NOP
02DD:  BSF    06.2
02DE:  MOVLW  09
02DF:  MOVWF  77
02E0:  CLRF   04
02E1:  DECFSZ 04,F
02E2:  GOTO   2E1
02E3:  DECFSZ 77,F
02E4:  GOTO   2E0
02E5:  MOVLW  F0
02E6:  MOVWF  04
02E7:  DECFSZ 04,F
02E8:  GOTO   2E7
02E9:  GOTO   2EA
02EA:  BTFSC  78.7
02EB:  GOTO   2CC
02EC:  BTFSC  78.6
02ED:  GOTO   2D8
02EE:  BCF    0A.3
02EF:  BCF    0A.4
02F0:  GOTO   620 (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 
*
0130:  MOVF   07,W
0131:  ANDLW  F0
0132:  BSF    03.5
0133:  BSF    03.6
0134:  MOVWF  21
0135:  MOVF   20,W
0136:  ANDLW  0F
0137:  IORWF  21,W
0138:  BCF    03.5
0139:  BCF    03.6
013A:  MOVWF  07
....................    output_bit(LCD_E,1);       // vzestupna hrana 
013B:  BSF    06.0
013C:  BSF    03.5
013D:  BCF    06.0
....................    delay_us(100);               // pockej alespon 450ns od e nebo alespon 195ns od dat 
013E:  CLRWDT
013F:  MOVLW  98
0140:  MOVWF  77
0141:  DECFSZ 77,F
0142:  GOTO   141
0143:  GOTO   144
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us) 
0144:  BCF    03.5
0145:  BCF    06.0
0146:  BSF    03.5
0147:  BCF    06.0
.................... } 
0148:  BCF    03.5
0149:  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 
014A:  BSF    03.5
014B:  BSF    03.6
014C:  MOVF   1E,F
014D:  BTFSS  03.2
014E:  GOTO   155
014F:  BCF    03.5
0150:  BCF    03.6
0151:  BCF    06.1
0152:  GOTO   158
0153:  BSF    03.5
0154:  BSF    03.6
0155:  BCF    03.5
0156:  BCF    03.6
0157:  BSF    06.1
0158:  BSF    03.5
0159:  BCF    06.1
....................    swap(n); 
015A:  BSF    03.6
015B:  SWAPF  1F,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu 
015C:  MOVF   1F,W
015D:  MOVWF  20
015E:  BCF    03.5
015F:  BCF    03.6
0160:  CALL   130
....................    swap(n); 
0161:  BSF    03.5
0162:  BSF    03.6
0163:  SWAPF  1F,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu 
0164:  MOVF   1F,W
0165:  MOVWF  20
0166:  BCF    03.5
0167:  BCF    03.6
0168:  CALL   130
....................    delay_us(200);              // minimalni doba na provedeni prikazu 
0169:  CLRWDT
016A:  MOVLW  C7
016B:  BSF    03.5
016C:  BSF    03.6
016D:  MOVWF  20
.................... } 
*
0186:  BCF    03.5
0187:  BCF    03.6
0188:  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 
0189:  MOVLW  14
018A:  BSF    03.5
018B:  BSF    03.6
018C:  MOVWF  1A
018D:  BCF    03.5
018E:  BCF    03.6
018F:  CALL   119
....................  
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD 
0190:  MOVLW  F0
0191:  BSF    03.5
0192:  ANDWF  07,F
....................  
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav 
0193:  BCF    03.5
0194:  BCF    06.1
0195:  BSF    03.5
0196:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav 
0197:  BCF    03.5
0198:  BCF    06.0
0199:  BSF    03.5
019A:  BCF    06.0
....................  
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice 
019B:  BSF    03.6
019C:  CLRF   17
019D:  MOVF   17,W
019E:  SUBLW  02
019F:  BTFSS  03.0
01A0:  GOTO   1B1
....................    { 
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel 
01A1:  MOVLW  02
01A2:  MOVWF  1A
01A3:  BCF    03.5
01A4:  BCF    03.6
01A5:  CALL   119
....................       lcd_send_nibble(3);              // rezim 8 bitu 
01A6:  MOVLW  03
01A7:  BSF    03.5
01A8:  BSF    03.6
01A9:  MOVWF  20
01AA:  BCF    03.5
01AB:  BCF    03.6
01AC:  CALL   130
....................    } 
01AD:  BSF    03.5
01AE:  BSF    03.6
01AF:  INCF   17,F
01B0:  GOTO   19D
....................  
....................    delay_us(40);                       // cas na zpracovani 
01B1:  CLRWDT
01B2:  MOVLW  3C
01B3:  MOVWF  77
01B4:  DECFSZ 77,F
01B5:  GOTO   1B4
01B6:  GOTO   1B7
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu) 
01B7:  MOVLW  02
01B8:  MOVWF  20
01B9:  BCF    03.5
01BA:  BCF    03.6
01BB:  CALL   130
....................    delay_us(40);                       // cas na zpracovani 
01BC:  CLRWDT
01BD:  MOVLW  3C
01BE:  MOVWF  77
01BF:  DECFSZ 77,F
01C0:  GOTO   1BF
01C1:  GOTO   1C2
....................  
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod) 
01C2:  BSF    03.5
01C3:  BSF    03.6
01C4:  CLRF   17
01C5:  MOVF   17,W
01C6:  SUBLW  02
01C7:  BTFSS  03.0
01C8:  GOTO   1E1
....................    { 
....................       lcd_send_byte(0,LCD_INIT_STRING[i]); 
01C9:  MOVF   17,W
01CA:  BCF    03.5
01CB:  BCF    03.6
01CC:  CALL   004
01CD:  BSF    03.5
01CE:  BSF    03.6
01CF:  MOVWF  18
01D0:  CLRF   1E
01D1:  MOVF   18,W
01D2:  MOVWF  1F
01D3:  BCF    03.5
01D4:  BCF    03.6
01D5:  CALL   14A
....................       delay_ms(2); 
01D6:  MOVLW  02
01D7:  BSF    03.5
01D8:  BSF    03.6
01D9:  MOVWF  1A
01DA:  BCF    03.5
01DB:  BCF    03.6
01DC:  CALL   119
....................    } 
01DD:  BSF    03.5
01DE:  BSF    03.6
01DF:  INCF   17,F
01E0:  GOTO   1C5
.................... } 
01E1:  BCF    03.5
01E2:  BCF    03.6
01E3:  RETLW  00
....................  
....................  
.................... // Proved presun kurzoru 
.................... // 
.................... // Pozice 1.1 je domu 
.................... // 
.................... #separate 
.................... void lcd_gotoxy( BYTE x, BYTE y) 
.................... { 
....................  
....................    BYTE Adr; 
....................  
....................    switch(y) 
....................    { 
*
023E:  MOVLW  01
023F:  BSF    03.5
0240:  BSF    03.6
0241:  SUBWF  1B,W
0242:  ADDLW  FC
0243:  BTFSC  03.0
0244:  GOTO   25E
0245:  ADDLW  04
0246:  BCF    03.5
0247:  BCF    03.6
0248:  GOTO   26B
....................       case 1: Adr=0; break; 
0249:  BSF    03.5
024A:  BSF    03.6
024B:  CLRF   1C
024C:  GOTO   25E
....................       case 2: Adr=0x40; break; 
024D:  MOVLW  40
024E:  BSF    03.5
024F:  BSF    03.6
0250:  MOVWF  1C
0251:  GOTO   25E
....................       case 3: Adr=0x14; break; 
0252:  MOVLW  14
0253:  BSF    03.5
0254:  BSF    03.6
0255:  MOVWF  1C
0256:  GOTO   25E
....................       case 4: Adr=0x54; break; 
0257:  MOVLW  54
0258:  BSF    03.5
0259:  BSF    03.6
025A:  MOVWF  1C
025B:  GOTO   25E
025C:  BSF    03.5
025D:  BSF    03.6
....................    } 
....................    Adr+=x-1; 
025E:  MOVLW  01
025F:  SUBWF  1A,W
0260:  ADDWF  1C,F
....................  
....................    lcd_send_byte(0,0x80|Adr); 
0261:  MOVF   1C,W
0262:  IORLW  80
0263:  MOVWF  1D
0264:  CLRF   1E
0265:  MOVF   1D,W
0266:  MOVWF  1F
0267:  BCF    03.5
0268:  BCF    03.6
0269:  CALL   14A
.................... } 
026A:  RETLW  00
....................  
....................  
.................... // Zapis znaku na displej, zpracovani ridicich znaku 
.................... // 
.................... #separate 
.................... void lcd_putc( char c) 
.................... { 
....................  
....................    switch (c) 
....................    { 
*
0273:  BSF    03.5
0274:  BSF    03.6
0275:  MOVF   19,W
0276:  XORLW  0C
0277:  BCF    03.5
0278:  BCF    03.6
0279:  BTFSC  03.2
027A:  GOTO   285
027B:  XORLW  06
027C:  BTFSC  03.2
027D:  GOTO   295
027E:  XORLW  07
027F:  BTFSC  03.2
0280:  GOTO   29F
0281:  XORLW  05
0282:  BTFSC  03.2
0283:  GOTO   2A8
0284:  GOTO   2B1
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej 
0285:  BSF    03.5
0286:  BSF    03.6
0287:  CLRF   1E
0288:  MOVLW  01
0289:  MOVWF  1F
028A:  BCF    03.5
028B:  BCF    03.6
028C:  CALL   14A
....................                     delay_ms(2); 
028D:  MOVLW  02
028E:  BSF    03.5
028F:  BSF    03.6
0290:  MOVWF  1A
0291:  BCF    03.5
0292:  BCF    03.6
0293:  CALL   119
....................                                             break; 
0294:  GOTO   2C1
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky 
0295:  MOVLW  01
0296:  BSF    03.5
0297:  BSF    03.6
0298:  MOVWF  1A
0299:  MOVLW  02
029A:  MOVWF  1B
029B:  BCF    03.5
029C:  BCF    03.6
029D:  CALL   23E
029E:  GOTO   2C1
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home 
029F:  MOVLW  01
02A0:  BSF    03.5
02A1:  BSF    03.6
02A2:  MOVWF  1A
02A3:  MOVWF  1B
02A4:  BCF    03.5
02A5:  BCF    03.6
02A6:  CALL   23E
02A7:  GOTO   2C1
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet 
02A8:  BSF    03.5
02A9:  BSF    03.6
02AA:  CLRF   1E
02AB:  MOVLW  10
02AC:  MOVWF  1F
02AD:  BCF    03.5
02AE:  BCF    03.6
02AF:  CALL   14A
02B0:  GOTO   2C1
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F 
02B1:  BSF    03.5
02B2:  BSF    03.6
02B3:  MOVF   19,W
02B4:  SUBLW  1F
02B5:  BTFSS  03.0
02B6:  GOTO   2B9
02B7:  MOVLW  07
02B8:  ANDWF  19,F
....................                     lcd_send_byte(1,c);     break; // zapis znak 
02B9:  MOVLW  01
02BA:  MOVWF  1E
02BB:  MOVF   19,W
02BC:  MOVWF  1F
02BD:  BCF    03.5
02BE:  BCF    03.6
02BF:  CALL   14A
02C0:  GOTO   2C1
....................    } 
.................... } 
02C1:  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() 
.................... { 
*
02F1:  CLRF   04
02F2:  BCF    03.7
02F3:  MOVLW  1F
02F4:  ANDWF  03,F
02F5:  BCF    20.6
02F6:  MOVF   20,W
02F7:  BSF    03.5
02F8:  MOVWF  07
02F9:  BCF    03.5
02FA:  BSF    07.6
02FB:  BSF    03.5
02FC:  BCF    06.2
02FD:  BCF    03.5
02FE:  BSF    06.2
02FF:  BSF    03.5
0300:  BSF    1F.0
0301:  BSF    1F.1
0302:  BSF    1F.2
0303:  BCF    1F.3
0304:  MOVLW  07
0305:  MOVWF  1C
.................... char odp[96]; 
.................... int pom,pom2,pom3,odkl,odkl2,maskovadlo,status; 
....................  
....................    setup_adc_ports(NO_ANALOGS); 
*
0309:  BSF    03.5
030A:  BSF    1F.0
030B:  BSF    1F.1
030C:  BSF    1F.2
030D:  BCF    1F.3
....................    setup_adc(ADC_OFF); 
030E:  BCF    03.5
030F:  BCF    1F.0
....................    setup_spi(SPI_SS_DISABLED); 
0310:  BCF    14.5
0311:  BCF    20.5
0312:  MOVF   20,W
0313:  BSF    03.5
0314:  MOVWF  07
0315:  BCF    03.5
0316:  BSF    20.4
0317:  MOVF   20,W
0318:  BSF    03.5
0319:  MOVWF  07
031A:  BCF    03.5
031B:  BCF    20.3
031C:  MOVF   20,W
031D:  BSF    03.5
031E:  MOVWF  07
031F:  MOVLW  01
0320:  BCF    03.5
0321:  MOVWF  14
0322:  MOVLW  00
0323:  BSF    03.5
0324:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); 
0325:  MOVF   01,W
0326:  ANDLW  C7
0327:  IORLW  08
0328:  MOVWF  01
....................    setup_timer_1(T1_DISABLED); 
0329:  BCF    03.5
032A:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1); 
032B:  MOVLW  00
032C:  MOVWF  78
032D:  MOVWF  12
032E:  MOVLW  00
032F:  BSF    03.5
0330:  MOVWF  12
....................    setup_comparator(NC_NC_NC_NC); 
0331:  MOVLW  07
0332:  MOVWF  1C
0333:  MOVF   05,W
0334:  CLRWDT
0335:  MOVLW  0E
0336:  MOVWF  77
0337:  DECFSZ 77,F
0338:  GOTO   337
0339:  GOTO   33A
033A:  MOVF   1C,W
033B:  BCF    03.5
033C:  BCF    0D.6
....................    setup_vref(FALSE); 
033D:  BSF    03.5
033E:  CLRF   1D
....................    setup_wdt(WDT_2304MS); 
033F:  MOVLW  0F
0340:  MOVWF  77
0341:  MOVLW  07
0342:  BCF    03.5
0343:  CLRF   01
0344:  MOVLW  81
0345:  MOVWF  04
0346:  BCF    03.7
0347:  MOVF   00,W
0348:  ANDLW  F0
0349:  IORLW  07
034A:  MOVWF  00
034B:  CLRWDT
034C:  MOVF   00,W
034D:  ANDLW  F7
034E:  BTFSC  77.3
034F:  ANDLW  F0
0350:  IORWF  77,W
0351:  MOVWF  00
....................    lcd_init(); 
0352:  CALL   189
....................     
....................    /* 
....................    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(); 
0353:  CLRWDT
....................     
....................     output_low(PIN_A4) ; 
0354:  BSF    03.5
0355:  BCF    05.4
0356:  BCF    03.5
0357:  BCF    05.4
....................     delay_ms(150); 
0358:  MOVLW  96
0359:  BSF    03.5
035A:  BSF    03.6
035B:  MOVWF  1A
035C:  BCF    03.5
035D:  BCF    03.6
035E:  CALL   119
....................     output_high(PIN_A4); 
035F:  BSF    03.5
0360:  BCF    05.4
0361:  BCF    03.5
0362:  BSF    05.4
....................     delay_ms(150); 
0363:  MOVLW  96
0364:  BSF    03.5
0365:  BSF    03.6
0366:  MOVWF  1A
0367:  BCF    03.5
0368:  BCF    03.6
0369:  CALL   119
....................     output_low(PIN_A4) ; 
036A:  BSF    03.5
036B:  BCF    05.4
036C:  BCF    03.5
036D:  BCF    05.4
....................     delay_ms(150); 
036E:  MOVLW  96
036F:  BSF    03.5
0370:  BSF    03.6
0371:  MOVWF  1A
0372:  BCF    03.5
0373:  BCF    03.6
0374:  CALL   119
....................     output_high(PIN_A4); 
0375:  BSF    03.5
0376:  BCF    05.4
0377:  BCF    03.5
0378:  BSF    05.4
....................     delay_ms(150); 
0379:  MOVLW  96
037A:  BSF    03.5
037B:  BSF    03.6
037C:  MOVWF  1A
037D:  BCF    03.5
037E:  BCF    03.6
037F:  CALL   119
....................      
.................... /* 
....................    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)     
0380:  CLRF   28
0381:  MOVF   28,W
0382:  CALL   00C
0383:  INCF   28,F
0384:  MOVWF  77
0385:  BSF    03.5
0386:  BSF    03.6
0387:  MOVWF  18
0388:  BCF    03.5
0389:  BCF    03.6
038A:  GOTO   1E4
038B:  MOVLW  0A
038C:  SUBWF  28,W
038D:  BTFSS  03.2
038E:  GOTO   381
.................... //SPEN=1; 
....................     
....................    
....................    while(fgetc(MOBIL)!=0x0A);       // predkoc prvni radek odpovedi 
038F:  CALL   20F
0390:  MOVF   78,W
0391:  SUBLW  0A
0392:  BTFSS  03.2
0393:  GOTO   38F
....................  
....................    odp[0]=fgetc(MOBIL);             // Nacti prvni dva znaky druheho radku odpovedi 
0394:  CALL   20F
0395:  MOVF   78,W
0396:  BSF    03.6
0397:  MOVWF  10
....................    odp[1]=fgetc(MOBIL); 
0398:  BCF    03.6
0399:  CALL   20F
039A:  MOVF   78,W
039B:  BSF    03.6
039C:  MOVWF  11
....................    while(fgetc(MOBIL)!=0x0A);       // Preskoc zbytek radku 
039D:  BCF    03.6
039E:  CALL   20F
039F:  MOVF   78,W
03A0:  SUBLW  0A
03A1:  BTFSS  03.2
03A2:  GOTO   39E
....................  
....................    while(kbhit(MOBIL)) {fgetc(MOBIL); delay_ms(100);}       // Preskoc zbytek radku 
03A3:  BTFSC  07.7
03A4:  GOTO   3AE
03A5:  CALL   20F
03A6:  MOVLW  64
03A7:  BSF    03.5
03A8:  BSF    03.6
03A9:  MOVWF  1A
03AA:  BCF    03.5
03AB:  BCF    03.6
03AC:  CALL   119
03AD:  GOTO   3A3
.................... output_high(PIN_A4) ; 
03AE:  BSF    03.5
03AF:  BCF    05.4
03B0:  BCF    03.5
03B1:  BSF    05.4
....................  
....................  
....................    if(odp[0] == 79 && odp[1] ==75)   // Je odpoved "OK"? 
03B2:  BSF    03.6
03B3:  MOVF   10,W
03B4:  SUBLW  4F
03B5:  BTFSS  03.2
03B6:  GOTO   417
03B7:  MOVF   11,W
03B8:  SUBLW  4B
03B9:  BTFSS  03.2
03BA:  GOTO   417
....................    { 
....................       lcd_gotoxy(1,1); 
03BB:  MOVLW  01
03BC:  BSF    03.5
03BD:  MOVWF  1A
03BE:  MOVWF  1B
03BF:  BCF    03.5
03C0:  BCF    03.6
03C1:  CALL   23E
....................       printf(lcd_putc,"\fNeni nova SMS zprava"); 
03C2:  CLRF   28
03C3:  MOVF   28,W
03C4:  CALL   01B
03C5:  INCF   28,F
03C6:  MOVWF  77
03C7:  BSF    03.5
03C8:  BSF    03.6
03C9:  MOVWF  19
03CA:  BCF    03.5
03CB:  BCF    03.6
03CC:  CALL   273
03CD:  MOVLW  15
03CE:  SUBWF  28,W
03CF:  BTFSS  03.2
03D0:  GOTO   3C3
....................       lcd_gotoxy(1,2); 
03D1:  MOVLW  01
03D2:  BSF    03.5
03D3:  BSF    03.6
03D4:  MOVWF  1A
03D5:  MOVLW  02
03D6:  MOVWF  1B
03D7:  BCF    03.5
03D8:  BCF    03.6
03D9:  CALL   23E
....................       printf(lcd_putc,""); 
....................       lcd_gotoxy(1,3); 
03DA:  MOVLW  01
03DB:  BSF    03.5
03DC:  BSF    03.6
03DD:  MOVWF  1A
03DE:  MOVLW  03
03DF:  MOVWF  1B
03E0:  BCF    03.5
03E1:  BCF    03.6
03E2:  CALL   23E
....................       printf(lcd_putc,"Zaslete SMS na cislo"); 
03E3:  CLRF   28
03E4:  MOVF   28,W
03E5:  CALL   035
03E6:  INCF   28,F
03E7:  MOVWF  77
03E8:  BSF    03.5
03E9:  BSF    03.6
03EA:  MOVWF  19
03EB:  BCF    03.5
03EC:  BCF    03.6
03ED:  CALL   273
03EE:  MOVLW  14
03EF:  SUBWF  28,W
03F0:  BTFSS  03.2
03F1:  GOTO   3E4
....................       lcd_gotoxy(1,4); 
03F2:  MOVLW  01
03F3:  BSF    03.5
03F4:  BSF    03.6
03F5:  MOVWF  1A
03F6:  MOVLW  04
03F7:  MOVWF  1B
03F8:  BCF    03.5
03F9:  BCF    03.6
03FA:  CALL   23E
....................       printf(lcd_putc,"    736 655 250"); 
03FB:  CLRF   28
03FC:  MOVF   28,W
03FD:  CALL   04E
03FE:  INCF   28,F
03FF:  MOVWF  77
0400:  BSF    03.5
0401:  BSF    03.6
0402:  MOVWF  19
0403:  BCF    03.5
0404:  BCF    03.6
0405:  CALL   273
0406:  MOVLW  0F
0407:  SUBWF  28,W
0408:  BTFSS  03.2
0409:  GOTO   3FC
....................       delay_ms(5000); 
040A:  MOVLW  14
040B:  MOVWF  28
040C:  MOVLW  FA
040D:  BSF    03.5
040E:  BSF    03.6
040F:  MOVWF  1A
0410:  BCF    03.5
0411:  BCF    03.6
0412:  CALL   119
0413:  DECFSZ 28,F
0414:  GOTO   40C
....................    }  
....................    else    
0415:  GOTO   71B
0416:  BSF    03.6
....................    { 
.................... //!!!KAKL      for(pom=0;pom<55;pom++)                //preskoc nedulezite informace 
....................       for(pom=0;pom<54;pom++)                //preskoc nedulezite informace 
0417:  BCF    03.6
0418:  CLRF   21
0419:  MOVF   21,W
041A:  SUBLW  35
041B:  BTFSS  03.0
041C:  GOTO   420
....................       { 
....................          fgetc(MOBIL); 
041D:  CALL   20F
....................       }  
041E:  INCF   21,F
041F:  GOTO   419
....................        
....................       //gets(odp);                       //uloz zakodovany text SMS 
....................     
....................       odp[0]=fgetc(MOBIL); 
0420:  CALL   20F
0421:  MOVF   78,W
0422:  BSF    03.6
0423:  MOVWF  10
....................       odp[1]=fgetc(MOBIL); 
0424:  BCF    03.6
0425:  CALL   20F
0426:  MOVF   78,W
0427:  BSF    03.6
0428:  MOVWF  11
....................       odp[2]=fgetc(MOBIL); 
0429:  BCF    03.6
042A:  CALL   20F
042B:  MOVF   78,W
042C:  BSF    03.6
042D:  MOVWF  12
....................       odp[3]=fgetc(MOBIL); 
042E:  BCF    03.6
042F:  CALL   20F
0430:  MOVF   78,W
0431:  BSF    03.6
0432:  MOVWF  13
....................       odp[4]=fgetc(MOBIL); 
0433:  BCF    03.6
0434:  CALL   20F
0435:  MOVF   78,W
0436:  BSF    03.6
0437:  MOVWF  14
....................       odp[5]=fgetc(MOBIL); 
0438:  BCF    03.6
0439:  CALL   20F
043A:  MOVF   78,W
043B:  BSF    03.6
043C:  MOVWF  15
....................       odp[6]=fgetc(MOBIL); 
043D:  BCF    03.6
043E:  CALL   20F
043F:  MOVF   78,W
0440:  BSF    03.6
0441:  MOVWF  16
....................       odp[7]=fgetc(MOBIL); 
0442:  BCF    03.6
0443:  CALL   20F
0444:  MOVF   78,W
0445:  BSF    03.6
0446:  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  
0447:  MOVF   10,F
0448:  BTFSS  03.2
0449:  GOTO   44C
044A:  MOVLW  30
044B:  MOVWF  11
....................       odp[0]=odp[0] - '0'; 
044C:  MOVLW  30
044D:  SUBWF  10,F
....................       odp[1]=odp[1] - '0'; 
044E:  SUBWF  11,F
....................       if(odp[0]>9) odp[0]=odp[0]-7; 
044F:  MOVF   10,W
0450:  SUBLW  09
0451:  BTFSC  03.0
0452:  GOTO   455
0453:  MOVLW  07
0454:  SUBWF  10,F
....................       if(odp[1]>9) odp[1]=odp[1]-7; 
0455:  MOVF   11,W
0456:  SUBLW  09
0457:  BTFSC  03.0
0458:  GOTO   45B
0459:  MOVLW  07
045A:  SUBWF  11,F
....................       odp[0]=odp[0] << 4; 
045B:  SWAPF  10,F
045C:  MOVLW  F0
045D:  ANDWF  10,F
....................       odp[0] |= odp[1]; 
045E:  MOVF   11,W
045F:  IORWF  10,F
....................     
....................       if(odp[2]==0) odp[3]='0'; 
0460:  MOVF   12,F
0461:  BTFSS  03.2
0462:  GOTO   465
0463:  MOVLW  30
0464:  MOVWF  13
....................       odp[2]=odp[2] - '0'; 
0465:  MOVLW  30
0466:  SUBWF  12,F
....................       odp[3]=odp[3] - '0'; 
0467:  SUBWF  13,F
....................       if(odp[2]>9) odp[2]=odp[2]-7; 
0468:  MOVF   12,W
0469:  SUBLW  09
046A:  BTFSC  03.0
046B:  GOTO   46E
046C:  MOVLW  07
046D:  SUBWF  12,F
....................       if(odp[3]>9) odp[3]=odp[3]-7; 
046E:  MOVF   13,W
046F:  SUBLW  09
0470:  BTFSC  03.0
0471:  GOTO   474
0472:  MOVLW  07
0473:  SUBWF  13,F
....................       odp[2]=odp[2] << 4; 
0474:  SWAPF  12,F
0475:  MOVLW  F0
0476:  ANDWF  12,F
....................       odp[2] |= odp[3]; 
0477:  MOVF   13,W
0478:  IORWF  12,F
....................     
....................       if(odp[4]==0) odp[5]='0'; 
0479:  MOVF   14,F
047A:  BTFSS  03.2
047B:  GOTO   47E
047C:  MOVLW  30
047D:  MOVWF  15
....................       odp[4]=odp[4] - '0'; 
047E:  MOVLW  30
047F:  SUBWF  14,F
....................       odp[5]=odp[5] - '0'; 
0480:  SUBWF  15,F
....................       if(odp[4]>9) odp[4]=odp[4]-7; 
0481:  MOVF   14,W
0482:  SUBLW  09
0483:  BTFSC  03.0
0484:  GOTO   487
0485:  MOVLW  07
0486:  SUBWF  14,F
....................       if(odp[5]>9) odp[5]=odp[5]-7; 
0487:  MOVF   15,W
0488:  SUBLW  09
0489:  BTFSC  03.0
048A:  GOTO   48D
048B:  MOVLW  07
048C:  SUBWF  15,F
....................       odp[4]=odp[4] << 4; 
048D:  SWAPF  14,F
048E:  MOVLW  F0
048F:  ANDWF  14,F
....................       odp[4] |= odp[5]; 
0490:  MOVF   15,W
0491:  IORWF  14,F
....................     
....................       if(odp[6]==0) odp[7]='0'; 
0492:  MOVF   16,F
0493:  BTFSS  03.2
0494:  GOTO   497
0495:  MOVLW  30
0496:  MOVWF  17
....................       odp[6]=odp[6] - '0'; 
0497:  MOVLW  30
0498:  SUBWF  16,F
....................       odp[7]=odp[7] - '0'; 
0499:  SUBWF  17,F
....................       if(odp[6]>9) odp[6]=odp[6]-7; 
049A:  MOVF   16,W
049B:  SUBLW  09
049C:  BTFSC  03.0
049D:  GOTO   4A0
049E:  MOVLW  07
049F:  SUBWF  16,F
....................       if(odp[7]>9) odp[7]=odp[7]-7; 
04A0:  MOVF   17,W
04A1:  SUBLW  09
04A2:  BTFSC  03.0
04A3:  GOTO   4A6
04A4:  MOVLW  07
04A5:  SUBWF  17,F
....................       odp[6]=odp[6] << 4; 
04A6:  SWAPF  16,F
04A7:  MOVLW  F0
04A8:  ANDWF  16,F
....................       odp[6] |= odp[7]; 
04A9:  MOVF   17,W
04AA:  IORWF  16,F
....................  
....................       odp[1]=odp[2]; 
04AB:  MOVF   12,W
04AC:  MOVWF  11
....................       odp[2]=odp[4]; 
04AD:  MOVF   14,W
04AE:  MOVWF  12
....................       odp[3]=odp[6]; 
04AF:  MOVF   16,W
04B0:  MOVWF  13
....................       odp[4],odp[5],odp[6]=""; 
04B1:  CLRF   16
....................     
....................       /*lcd_gotoxy(1,2);     
....................       printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2]odp[3]);   */ 
....................     
....................       pom3=0; 
04B2:  BCF    03.6
04B3:  CLRF   23
....................       for (pom = 0; pom < 4;pom++)             
04B4:  CLRF   21
04B5:  MOVF   21,W
04B6:  SUBLW  03
04B7:  BTFSS  03.0
04B8:  GOTO   52A
....................          { 
....................          maskovadlo =  maskovadlo >> 1;                 //rotace promene urcene pro maskovani 
04B9:  BCF    03.0
04BA:  RRF    26,F
....................          maskovadlo =  maskovadlo | 0x80; 
04BB:  BSF    26.7
....................          odkl = odp[pom] & maskovadlo;                  //odlozeni "prenosu" do odkl pomoci maskovadla 
04BC:  MOVLW  10
04BD:  ADDWF  21,W
04BE:  MOVWF  04
04BF:  BSF    03.7
04C0:  MOVF   00,W
04C1:  ANDWF  26,W
04C2:  MOVWF  24
....................          odp[pom] = odp[pom] << pom3;                     //rotace znaku 
04C3:  MOVLW  10
04C4:  ADDWF  21,W
04C5:  MOVWF  78
04C6:  MOVLW  01
04C7:  MOVWF  7A
04C8:  BTFSC  03.0
04C9:  INCF   7A,F
04CA:  MOVF   78,W
04CB:  MOVWF  28
04CC:  MOVF   7A,W
04CD:  MOVWF  29
04CE:  MOVLW  10
04CF:  ADDWF  21,W
04D0:  MOVWF  04
04D1:  BSF    03.7
04D2:  MOVF   00,W
04D3:  MOVWF  77
04D4:  MOVF   23,W
04D5:  MOVWF  78
04D6:  BTFSC  03.2
04D7:  GOTO   4DC
04D8:  BCF    03.0
04D9:  RLF    77,F
04DA:  DECFSZ 78,F
04DB:  GOTO   4D8
04DC:  MOVF   28,W
04DD:  MOVWF  04
04DE:  BCF    03.7
04DF:  BTFSC  29.0
04E0:  BSF    03.7
04E1:  MOVF   77,W
04E2:  MOVWF  00
....................          for (pom2 = 0; pom2 < (8-pom3);pom2++)            //rotace odkl2 
04E3:  CLRF   22
04E4:  MOVF   23,W
04E5:  SUBLW  08
04E6:  SUBWF  22,W
04E7:  BTFSC  03.0
04E8:  GOTO   4EE
....................             { 
....................             odkl2 = odkl2 >> 1; 
04E9:  BCF    03.0
04EA:  RRF    25,F
....................             odkl2 = odkl2 & 127;     
04EB:  BCF    25.7
....................             } 
04EC:  INCF   22,F
04ED:  GOTO   4E4
....................          odp[pom] = odp[pom] | odkl2;                     //pridani odkl2 ke znaku 
04EE:  MOVLW  10
04EF:  ADDWF  21,W
04F0:  MOVWF  78
04F1:  MOVLW  01
04F2:  MOVWF  7A
04F3:  BTFSC  03.0
04F4:  INCF   7A,F
04F5:  MOVLW  10
04F6:  ADDWF  21,W
04F7:  MOVWF  04
04F8:  BSF    03.7
04F9:  MOVF   00,W
04FA:  IORWF  25,W
04FB:  MOVWF  2B
04FC:  MOVF   78,W
04FD:  MOVWF  04
04FE:  BCF    03.7
04FF:  BTFSC  7A.0
0500:  BSF    03.7
0501:  MOVF   2B,W
0502:  MOVWF  00
....................          odp[pom] = odp[pom] & 127;                      //smazani nejvysiho bitu 
0503:  MOVLW  10
0504:  ADDWF  21,W
0505:  MOVWF  78
0506:  MOVLW  01
0507:  MOVWF  7A
0508:  BTFSC  03.0
0509:  INCF   7A,F
050A:  MOVLW  10
050B:  ADDWF  21,W
050C:  MOVWF  04
050D:  BSF    03.7
050E:  MOVF   00,W
050F:  ANDLW  7F
0510:  MOVWF  2B
0511:  MOVF   78,W
0512:  MOVWF  04
0513:  BCF    03.7
0514:  BTFSC  7A.0
0515:  BSF    03.7
0516:  MOVF   2B,W
0517:  MOVWF  00
....................          odkl2 = odkl;                              //ulozeni odlk na dalsi pruchod 
0518:  MOVF   24,W
0519:  MOVWF  25
....................          pom3++;                                    //inkrementace citace rotace 
051A:  INCF   23,F
....................          if (pom3 == 8)                              //kazdy 8my znak 
051B:  MOVF   23,W
051C:  SUBLW  08
051D:  BTFSS  03.2
051E:  GOTO   528
....................             { 
....................             pom3 = 0;                                 //smaz citac 
051F:  CLRF   23
....................             odp[pom+1] = odkl2;                        //uloz 8my znak vznikly z "prenosu" 
0520:  MOVLW  01
0521:  ADDWF  21,W
0522:  ADDLW  10
0523:  MOVWF  04
0524:  BSF    03.7
0525:  MOVF   25,W
0526:  MOVWF  00
....................             maskovadlo = 0;                           //smaz maskovadlo 
0527:  CLRF   26
....................             } 
....................          } 
0528:  INCF   21,F
0529:  GOTO   4B5
....................          odp[pom]='\0';  
052A:  MOVLW  10
052B:  ADDWF  21,W
052C:  MOVWF  04
052D:  BSF    03.7
052E:  CLRF   00
....................        
....................       /*lcd_gotoxy(1,3); 
....................       printf(lcd_putc,"%u %u %u %u",odp[0],odp[1],odp[2],odp[3]);   */ 
....................    lcd_init(); 
052F:  CALL   189
....................       lcd_gotoxy(1,1); 
0530:  MOVLW  01
0531:  BSF    03.5
0532:  BSF    03.6
0533:  MOVWF  1A
0534:  MOVWF  1B
0535:  BCF    03.5
0536:  BCF    03.6
0537:  CALL   23E
....................       printf(lcd_putc,"\fPrijata SMS s textem",); 
0538:  CLRF   28
0539:  MOVF   28,W
053A:  CALL   062
053B:  INCF   28,F
053C:  MOVWF  77
053D:  BSF    03.5
053E:  BSF    03.6
053F:  MOVWF  19
0540:  BCF    03.5
0541:  BCF    03.6
0542:  CALL   273
0543:  MOVLW  15
0544:  SUBWF  28,W
0545:  BTFSS  03.2
0546:  GOTO   539
....................       lcd_gotoxy(9,3); 
0547:  MOVLW  09
0548:  BSF    03.5
0549:  BSF    03.6
054A:  MOVWF  1A
054B:  MOVLW  03
054C:  MOVWF  1B
054D:  BCF    03.5
054E:  BCF    03.6
054F:  CALL   23E
....................       printf(lcd_putc,"%s",odp);  
0550:  MOVLW  10
0551:  MOVWF  04
0552:  BSF    03.7
0553:  MOVLW  00
0554:  IORWF  00,W
0555:  BTFSC  03.2
0556:  GOTO   56B
0557:  CLRF   29
0558:  MOVF   04,W
0559:  MOVWF  28
055A:  BCF    29.0
055B:  BTFSC  03.7
055C:  BSF    29.0
055D:  MOVF   00,W
055E:  BSF    03.5
055F:  BSF    03.6
0560:  MOVWF  19
0561:  BCF    03.5
0562:  BCF    03.6
0563:  CALL   273
0564:  MOVF   28,W
0565:  MOVWF  04
0566:  BCF    03.7
0567:  BTFSC  29.0
0568:  BSF    03.7
0569:  INCF   04,F
056A:  GOTO   553
....................       output_low(PIN_A4) ; 
056B:  BSF    03.5
056C:  BCF    05.4
056D:  BCF    03.5
056E:  BCF    05.4
....................       delay_ms(1000); 
056F:  MOVLW  04
0570:  MOVWF  28
0571:  MOVLW  FA
0572:  BSF    03.5
0573:  BSF    03.6
0574:  MOVWF  1A
0575:  BCF    03.5
0576:  BCF    03.6
0577:  CALL   119
0578:  DECFSZ 28,F
0579:  GOTO   571
....................       output_high(PIN_A4); 
057A:  BSF    03.5
057B:  BCF    05.4
057C:  BCF    03.5
057D:  BSF    05.4
....................  
.................... //!!!      fprintf(MOBIL,"AT+CMGD=1\r");          //smaz prijatou SMSku 
....................      
....................       if (odp[0] > 64 && odp[0] < 91 ) 
057E:  BSF    03.6
057F:  MOVF   10,W
0580:  SUBLW  40
0581:  BTFSC  03.0
0582:  GOTO   589
0583:  MOVF   10,W
0584:  SUBLW  5A
0585:  BTFSS  03.0
0586:  GOTO   589
....................          { 
....................          odp[0] += 32; 
0587:  MOVLW  20
0588:  ADDWF  10,F
....................          } 
....................      
....................       if (odp[1] > 64 && odp[1] < 91 ) 
0589:  MOVF   11,W
058A:  SUBLW  40
058B:  BTFSC  03.0
058C:  GOTO   593
058D:  MOVF   11,W
058E:  SUBLW  5A
058F:  BTFSS  03.0
0590:  GOTO   593
....................          { 
....................          odp[1] += 32; 
0591:  MOVLW  20
0592:  ADDWF  11,F
....................          } 
....................      
....................       if (odp[2] > 64 && odp[2] < 91 ) 
0593:  MOVF   12,W
0594:  SUBLW  40
0595:  BTFSC  03.0
0596:  GOTO   59D
0597:  MOVF   12,W
0598:  SUBLW  5A
0599:  BTFSS  03.0
059A:  GOTO   59D
....................          { 
....................          odp[2] += 32; 
059B:  MOVLW  20
059C:  ADDWF  12,F
....................          } 
....................      
....................       if (odp[3] > 64 && odp[3] < 91 ) 
059D:  MOVF   13,W
059E:  SUBLW  40
059F:  BTFSC  03.0
05A0:  GOTO   5A7
05A1:  MOVF   13,W
05A2:  SUBLW  5A
05A3:  BTFSS  03.0
05A4:  GOTO   5A7
....................          { 
....................          odp[3] += 32; 
05A5:  MOVLW  20
05A6:  ADDWF  13,F
....................          } 
....................      
....................       lcd_gotoxy(1,1); 
05A7:  MOVLW  01
05A8:  BSF    03.5
05A9:  MOVWF  1A
05AA:  MOVWF  1B
05AB:  BCF    03.5
05AC:  BCF    03.6
05AD:  CALL   23E
....................       printf(lcd_putc,"\f Odstraneni velkych",); 
05AE:  CLRF   28
05AF:  MOVF   28,W
05B0:  CALL   07C
05B1:  INCF   28,F
05B2:  MOVWF  77
05B3:  BSF    03.5
05B4:  BSF    03.6
05B5:  MOVWF  19
05B6:  BCF    03.5
05B7:  BCF    03.6
05B8:  CALL   273
05B9:  MOVLW  14
05BA:  SUBWF  28,W
05BB:  BTFSS  03.2
05BC:  GOTO   5AF
....................       lcd_gotoxy(1,2); 
05BD:  MOVLW  01
05BE:  BSF    03.5
05BF:  BSF    03.6
05C0:  MOVWF  1A
05C1:  MOVLW  02
05C2:  MOVWF  1B
05C3:  BCF    03.5
05C4:  BCF    03.6
05C5:  CALL   23E
....................       printf(lcd_putc,"       pismen"); 
05C6:  CLRF   28
05C7:  MOVF   28,W
05C8:  CALL   095
05C9:  INCF   28,F
05CA:  MOVWF  77
05CB:  BSF    03.5
05CC:  BSF    03.6
05CD:  MOVWF  19
05CE:  BCF    03.5
05CF:  BCF    03.6
05D0:  CALL   273
05D1:  MOVLW  0D
05D2:  SUBWF  28,W
05D3:  BTFSS  03.2
05D4:  GOTO   5C7
....................       lcd_gotoxy(9,4); 
05D5:  MOVLW  09
05D6:  BSF    03.5
05D7:  BSF    03.6
05D8:  MOVWF  1A
05D9:  MOVLW  04
05DA:  MOVWF  1B
05DB:  BCF    03.5
05DC:  BCF    03.6
05DD:  CALL   23E
....................       printf(lcd_putc,"%s",odp);  
05DE:  MOVLW  10
05DF:  MOVWF  04
05E0:  BSF    03.7
05E1:  MOVLW  00
05E2:  IORWF  00,W
05E3:  BTFSC  03.2
05E4:  GOTO   5F9
05E5:  CLRF   29
05E6:  MOVF   04,W
05E7:  MOVWF  28
05E8:  BCF    29.0
05E9:  BTFSC  03.7
05EA:  BSF    29.0
05EB:  MOVF   00,W
05EC:  BSF    03.5
05ED:  BSF    03.6
05EE:  MOVWF  19
05EF:  BCF    03.5
05F0:  BCF    03.6
05F1:  CALL   273
05F2:  MOVF   28,W
05F3:  MOVWF  04
05F4:  BCF    03.7
05F5:  BTFSC  29.0
05F6:  BSF    03.7
05F7:  INCF   04,F
05F8:  GOTO   5E1
....................       output_low(PIN_A4) ; 
05F9:  BSF    03.5
05FA:  BCF    05.4
05FB:  BCF    03.5
05FC:  BCF    05.4
....................       delay_ms(1000); 
05FD:  MOVLW  04
05FE:  MOVWF  28
05FF:  MOVLW  FA
0600:  BSF    03.5
0601:  BSF    03.6
0602:  MOVWF  1A
0603:  BCF    03.5
0604:  BCF    03.6
0605:  CALL   119
0606:  DECFSZ 28,F
0607:  GOTO   5FF
....................       output_high(PIN_A4); 
0608:  BSF    03.5
0609:  BCF    05.4
060A:  BCF    03.5
060B:  BSF    05.4
....................      
....................  
.................... //!!!KAKL 
....................       fprintf(VRTULE,"%s",odp); 
060C:  MOVLW  10
060D:  MOVWF  04
060E:  BSF    03.7
060F:  MOVLW  00
0610:  IORWF  00,W
0611:  BTFSC  03.2
0612:  GOTO   627
0613:  CLRF   29
0614:  MOVF   04,W
0615:  MOVWF  28
0616:  BCF    29.0
0617:  BTFSC  03.7
0618:  BSF    29.0
0619:  MOVF   00,W
061A:  BSF    03.5
061B:  BSF    03.6
061C:  MOVWF  19
061D:  BCF    03.5
061E:  BCF    03.6
061F:  GOTO   2C2
0620:  MOVF   28,W
0621:  MOVWF  04
0622:  BCF    03.7
0623:  BTFSC  29.0
0624:  BSF    03.7
0625:  INCF   04,F
0626:  GOTO   60F
....................  
....................  
....................       if (odp[0] == 122 && odp[1] == 97 && odp[2] == 112 && odp[3] == 49)    //odp=="zap1" 
0627:  BSF    03.6
0628:  MOVF   10,W
0629:  SUBLW  7A
062A:  BTFSS  03.2
062B:  GOTO   63C
062C:  MOVF   11,W
062D:  SUBLW  61
062E:  BTFSS  03.2
062F:  GOTO   63C
0630:  MOVF   12,W
0631:  SUBLW  70
0632:  BTFSS  03.2
0633:  GOTO   63C
0634:  MOVF   13,W
0635:  SUBLW  31
0636:  BTFSS  03.2
0637:  GOTO   63C
....................          { 
....................          status=1; 
0638:  MOVLW  01
0639:  BCF    03.6
063A:  MOVWF  27
063B:  BSF    03.6
....................          } 
....................      
....................       if (odp[0] == 118 && odp[1] == 121 && odp[2] == 112 && odp[3]== 49)    //odp=="vyp1" 
063C:  MOVF   10,W
063D:  SUBLW  76
063E:  BTFSS  03.2
063F:  GOTO   650
0640:  MOVF   11,W
0641:  SUBLW  79
0642:  BTFSS  03.2
0643:  GOTO   650
0644:  MOVF   12,W
0645:  SUBLW  70
0646:  BTFSS  03.2
0647:  GOTO   650
0648:  MOVF   13,W
0649:  SUBLW  31
064A:  BTFSS  03.2
064B:  GOTO   650
....................          { 
....................          status=2; 
064C:  MOVLW  02
064D:  BCF    03.6
064E:  MOVWF  27
064F:  BSF    03.6
....................          } 
....................      
....................       if (odp[0] == 97 && odp[1] == 104 && odp[2] == 111 && odp[3]== 106)    //odp=="ahoj" 
0650:  MOVF   10,W
0651:  SUBLW  61
0652:  BTFSS  03.2
0653:  GOTO   664
0654:  MOVF   11,W
0655:  SUBLW  68
0656:  BTFSS  03.2
0657:  GOTO   664
0658:  MOVF   12,W
0659:  SUBLW  6F
065A:  BTFSS  03.2
065B:  GOTO   664
065C:  MOVF   13,W
065D:  SUBLW  6A
065E:  BTFSS  03.2
065F:  GOTO   664
....................          { 
....................          status=3; 
0660:  MOVLW  03
0661:  BCF    03.6
0662:  MOVWF  27
0663:  BSF    03.6
....................          } 
....................             
....................       switch (status)  
....................       { 
0664:  BCF    03.6
0665:  MOVF   27,W
0666:  XORLW  01
0667:  BTFSC  03.2
0668:  GOTO   670
0669:  XORLW  03
066A:  BTFSC  03.2
066B:  GOTO   694
066C:  XORLW  01
066D:  BTFSC  03.2
066E:  GOTO   6B8
066F:  GOTO   6D8
....................  
....................          case 1:  output_low(zar1); 
0670:  BSF    03.5
0671:  BCF    05.3
0672:  BCF    03.5
0673:  BCF    05.3
....................                   printf(lcd_putc,"\f"); 
0674:  MOVLW  0C
0675:  BSF    03.5
0676:  BSF    03.6
0677:  MOVWF  19
0678:  BCF    03.5
0679:  BCF    03.6
067A:  CALL   273
....................                   lcd_gotoxy(1,2); 
067B:  MOVLW  01
067C:  BSF    03.5
067D:  BSF    03.6
067E:  MOVWF  1A
067F:  MOVLW  02
0680:  MOVWF  1B
0681:  BCF    03.5
0682:  BCF    03.6
0683:  CALL   23E
....................                   printf(lcd_putc," Zapnuto zarizeni 1"); 
0684:  CLRF   28
0685:  MOVF   28,W
0686:  CALL   0A7
0687:  INCF   28,F
0688:  MOVWF  77
0689:  BSF    03.5
068A:  BSF    03.6
068B:  MOVWF  19
068C:  BCF    03.5
068D:  BCF    03.6
068E:  CALL   273
068F:  MOVLW  13
0690:  SUBWF  28,W
0691:  BTFSS  03.2
0692:  GOTO   685
....................                   break; 
0693:  GOTO   710
....................  
....................          case 2:  output_high(zar1); 
0694:  BSF    03.5
0695:  BCF    05.3
0696:  BCF    03.5
0697:  BSF    05.3
....................                   printf(lcd_putc,"\f"); 
0698:  MOVLW  0C
0699:  BSF    03.5
069A:  BSF    03.6
069B:  MOVWF  19
069C:  BCF    03.5
069D:  BCF    03.6
069E:  CALL   273
....................                   lcd_gotoxy(1,2); 
069F:  MOVLW  01
06A0:  BSF    03.5
06A1:  BSF    03.6
06A2:  MOVWF  1A
06A3:  MOVLW  02
06A4:  MOVWF  1B
06A5:  BCF    03.5
06A6:  BCF    03.6
06A7:  CALL   23E
....................                   printf(lcd_putc," Vypnuto zarizeni 1"); 
06A8:  CLRF   28
06A9:  MOVF   28,W
06AA:  CALL   0BF
06AB:  INCF   28,F
06AC:  MOVWF  77
06AD:  BSF    03.5
06AE:  BSF    03.6
06AF:  MOVWF  19
06B0:  BCF    03.5
06B1:  BCF    03.6
06B2:  CALL   273
06B3:  MOVLW  13
06B4:  SUBWF  28,W
06B5:  BTFSS  03.2
06B6:  GOTO   6A9
....................                   break; 
06B7:  GOTO   710
....................      
....................          case 3:  printf(lcd_putc,"\f"); 
06B8:  MOVLW  0C
06B9:  BSF    03.5
06BA:  BSF    03.6
06BB:  MOVWF  19
06BC:  BCF    03.5
06BD:  BCF    03.6
06BE:  CALL   273
....................                   lcd_gotoxy(1,2); 
06BF:  MOVLW  01
06C0:  BSF    03.5
06C1:  BSF    03.6
06C2:  MOVWF  1A
06C3:  MOVLW  02
06C4:  MOVWF  1B
06C5:  BCF    03.5
06C6:  BCF    03.6
06C7:  CALL   23E
....................                   printf(lcd_putc,"  Preji hezky den!"); 
06C8:  CLRF   28
06C9:  MOVF   28,W
06CA:  CALL   0D7
06CB:  INCF   28,F
06CC:  MOVWF  77
06CD:  BSF    03.5
06CE:  BSF    03.6
06CF:  MOVWF  19
06D0:  BCF    03.5
06D1:  BCF    03.6
06D2:  CALL   273
06D3:  MOVLW  12
06D4:  SUBWF  28,W
06D5:  BTFSS  03.2
06D6:  GOTO   6C9
....................                   break; 
06D7:  GOTO   710
....................      
....................          default: printf(lcd_putc,"\f"); 
06D8:  MOVLW  0C
06D9:  BSF    03.5
06DA:  BSF    03.6
06DB:  MOVWF  19
06DC:  BCF    03.5
06DD:  BCF    03.6
06DE:  CALL   273
....................                   lcd_gotoxy(1,2); 
06DF:  MOVLW  01
06E0:  BSF    03.5
06E1:  BSF    03.6
06E2:  MOVWF  1A
06E3:  MOVLW  02
06E4:  MOVWF  1B
06E5:  BCF    03.5
06E6:  BCF    03.6
06E7:  CALL   23E
....................                   printf(lcd_putc,"    Prikaz nebyl"); 
06E8:  CLRF   28
06E9:  MOVF   28,W
06EA:  CALL   0EE
06EB:  INCF   28,F
06EC:  MOVWF  77
06ED:  BSF    03.5
06EE:  BSF    03.6
06EF:  MOVWF  19
06F0:  BCF    03.5
06F1:  BCF    03.6
06F2:  CALL   273
06F3:  MOVLW  10
06F4:  SUBWF  28,W
06F5:  BTFSS  03.2
06F6:  GOTO   6E9
....................                   lcd_gotoxy(1,3); 
06F7:  MOVLW  01
06F8:  BSF    03.5
06F9:  BSF    03.6
06FA:  MOVWF  1A
06FB:  MOVLW  03
06FC:  MOVWF  1B
06FD:  BCF    03.5
06FE:  BCF    03.6
06FF:  CALL   23E
....................                   printf(lcd_putc,"      rozeznan"); 
0700:  CLRF   28
0701:  MOVF   28,W
0702:  CALL   106
0703:  INCF   28,F
0704:  MOVWF  77
0705:  BSF    03.5
0706:  BSF    03.6
0707:  MOVWF  19
0708:  BCF    03.5
0709:  BCF    03.6
070A:  CALL   273
070B:  MOVLW  0E
070C:  SUBWF  28,W
070D:  BTFSS  03.2
070E:  GOTO   701
....................                   break;  
070F:  GOTO   710
....................       } 
....................       delay_ms(1000); 
0710:  MOVLW  04
0711:  MOVWF  28
0712:  MOVLW  FA
0713:  BSF    03.5
0714:  BSF    03.6
0715:  MOVWF  1A
0716:  BCF    03.5
0717:  BCF    03.6
0718:  CALL   119
0719:  DECFSZ 28,F
071A:  GOTO   712
....................    } 
....................  
....................  } 
071B:  GOTO   353
.................... } 
071C:  SLEEP

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

(root)//projekty/Ovladani_mobilnim_telefonem/SW/final/main.lst

Rev 238
