Subversion Repositories svnkaklik

CCS PCW C Compiler, Version 3.110, 15448

               Filename: d:\@kaklik\programy\pic_c\prenos\letadlo\prijimac\main.LST

               ROM used: 730 (71%)
                         Largest free fragment is 294
               RAM used: 9 (13%) at main() level
                         26 (38%) worst case
               Stack:    5 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   251
0003:  NOP
....................  #include "main.h" 
....................  #include <16F84.h> 
....................  //////// Standard Header file for the PIC16F84 device ////////////////  
.................... #device PIC16F84  
.................... #list  
....................  
.................... #use delay(clock=4000000)  
*
000C:  MOVLW  1A
000D:  MOVWF  04
000E:  MOVF   00,W
000F:  BTFSC  03.2
0010:  GOTO   020
0011:  MOVLW  01
0012:  MOVWF  0D
0013:  CLRF   0C
0014:  DECFSZ 0C,F
0015:  GOTO   014
0016:  DECFSZ 0D,F
0017:  GOTO   013
0018:  MOVLW  4A
0019:  MOVWF  0C
001A:  DECFSZ 0C,F
001B:  GOTO   01A
001C:  NOP
001D:  NOP
001E:  DECFSZ 00,F
001F:  GOTO   011
0020:  RETLW  00
*
011B:  MOVLW  1D
011C:  MOVWF  04
011D:  MOVLW  FC
011E:  ANDWF  00,F
011F:  RRF    00,F
0120:  RRF    00,F
0121:  MOVF   00,W
0122:  BTFSC  03.2
0123:  GOTO   128
0124:  GOTO   126
0125:  NOP
0126:  DECFSZ 00,F
0127:  GOTO   125
0128:  GOTO   154 (RETURN)
.................... #fuses XT,NOWDT,PUT  
....................   
....................  
.................... #include "..\common.h" 
....................  #DEFINE  OSA_X          0           // adresy os  
.................... #DEFINE  OSA_Y          1  
.................... #DEFINE  TLs            2  
.................... #DEFINE  IMPULS         250         // sirka impulsu  
....................  
....................   
.................... #DEFINE LCD_RS          PIN_B1      // rizeni registru LCD displeje  
.................... #DEFINE LCD_E           PIN_B0      // enable LCD displeje  
.................... #DEFINE LCD_DATA_LSB    PIN_B2      // pripojeni LSB bitu datoveho portu LCD displeje (celkem 4 bity vzestupne za sebou)  
.................... #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)  
.................... };  
*
0004:  BCF    0A.0
0005:  BCF    0A.1
0006:  BCF    0A.2
0007:  ADDWF  02,F
0008:  RETLW  28
0009:  RETLW  0C
000A:  RETLW  01
000B:  RETLW  06
....................   
....................   
.................... // 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  
*
0021:  MOVF   06,W
0022:  ANDLW  C3
0023:  MOVWF  21
0024:  RLF    20,W
0025:  MOVWF  0C
0026:  RLF    0C,F
0027:  MOVLW  FC
0028:  ANDWF  0C,F
0029:  MOVF   0C,W
002A:  ANDLW  3C
002B:  IORWF  21,W
002C:  MOVWF  06
....................    output_bit(LCD_E,1);       // vzestupna hrana  
002D:  BSF    06.0
002E:  BSF    03.5
002F:  BCF    06.0
....................    delay_us(1);               // pockej alespon 450ns od e nebo alespon 195ns od dat  
0030:  NOP
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us)  
0031:  BCF    03.5
0032:  BCF    06.0
0033:  BSF    03.5
0034:  BCF    06.0
0035:  BCF    03.5
0036:  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  
0037:  MOVF   1E,F
0038:  BTFSS  03.2
0039:  GOTO   03C
003A:  BCF    06.1
003B:  GOTO   03D
003C:  BSF    06.1
003D:  BSF    03.5
003E:  BCF    06.1
....................    swap(n);  
003F:  BCF    03.5
0040:  SWAPF  1F,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu  
0041:  MOVF   1F,W
0042:  MOVWF  20
0043:  CALL   021
....................    swap(n);  
0044:  SWAPF  1F,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu  
0045:  MOVF   1F,W
0046:  MOVWF  20
0047:  CALL   021
....................    delay_us(40);              // minimalni doba na provedeni prikazu  
0048:  MOVLW  0D
0049:  MOVWF  0C
004A:  DECFSZ 0C,F
004B:  GOTO   04A
004C:  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  
004D:  MOVLW  14
004E:  MOVWF  1A
004F:  CALL   00C
....................   
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD  
0050:  MOVLW  C3
0051:  BSF    03.5
0052:  ANDWF  06,F
....................   
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav  
0053:  BCF    03.5
0054:  BCF    06.1
0055:  BSF    03.5
0056:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav  
0057:  BCF    03.5
0058:  BCF    06.0
0059:  BSF    03.5
005A:  BCF    06.0
....................   
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice  
005B:  BCF    03.5
005C:  CLRF   17
005D:  MOVF   17,W
005E:  SUBLW  02
005F:  BTFSS  03.0
0060:  GOTO   069
....................    {  
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel  
0061:  MOVLW  02
0062:  MOVWF  1A
0063:  CALL   00C
....................       lcd_send_nibble(3);              // rezim 8 bitu  
0064:  MOVLW  03
0065:  MOVWF  20
0066:  CALL   021
....................    }  
0067:  INCF   17,F
0068:  GOTO   05D
....................   
....................    delay_us(40);                       // cas na zpracovani  
0069:  MOVLW  0D
006A:  MOVWF  0C
006B:  DECFSZ 0C,F
006C:  GOTO   06B
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu)  
006D:  MOVLW  02
006E:  MOVWF  20
006F:  CALL   021
....................    delay_us(40);                       // cas na zpracovani  
0070:  MOVLW  0D
0071:  MOVWF  0C
0072:  DECFSZ 0C,F
0073:  GOTO   072
....................   
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod)  
0074:  CLRF   17
0075:  MOVF   17,W
0076:  SUBLW  02
0077:  BTFSS  03.0
0078:  GOTO   085
....................    {  
....................       lcd_send_byte(0,LCD_INIT_STRING[i]);  
0079:  MOVF   17,W
007A:  CALL   004
007B:  MOVWF  18
007C:  CLRF   1E
007D:  MOVF   18,W
007E:  MOVWF  1F
007F:  CALL   037
....................       delay_ms(2);  
0080:  MOVLW  02
0081:  MOVWF  1A
0082:  CALL   00C
....................    }  
0083:  INCF   17,F
0084:  GOTO   075
0085:  GOTO   256 (RETURN)
.................... }  
....................   
....................   
.................... // Proved presun kurzoru  
.................... //  
.................... // Pozice 1.1 je domu  
.................... //  
.................... void lcd_gotoxy( BYTE x, BYTE y)  
.................... {  
....................   
....................    BYTE Adr;  
....................   
....................    Adr=x-1;  
*
01C1:  MOVLW  01
01C2:  SUBWF  1A,W
01C3:  MOVWF  1C
....................    if(y==2)  
01C4:  MOVF   1B,W
01C5:  SUBLW  02
01C6:  BTFSS  03.2
01C7:  GOTO   1CA
....................      Adr+=LCD_LINE_2;  
01C8:  MOVLW  40
01C9:  ADDWF  1C,F
....................   
....................    lcd_send_byte(0,0x80|Adr);  
01CA:  MOVF   1C,W
01CB:  IORLW  80
01CC:  MOVWF  1D
01CD:  CLRF   1E
01CE:  MOVF   1D,W
01CF:  MOVWF  1F
01D0:  CALL   037
01D1:  RETLW  00
.................... }  
....................   
....................   
.................... // Zapis znaku na displej, zpracovani ridicich znaku  
.................... //  
.................... void lcd_putc( char c)  
.................... {  
....................   
....................    switch (c)  
01D2:  MOVF   19,W
01D3:  MOVWF  0C
01D4:  MOVLW  0C
01D5:  SUBWF  0C,W
01D6:  BTFSC  03.2
01D7:  GOTO   1E5
01D8:  MOVLW  0A
01D9:  SUBWF  0C,W
01DA:  BTFSC  03.2
01DB:  GOTO   1ED
01DC:  MOVLW  0D
01DD:  SUBWF  0C,W
01DE:  BTFSC  03.2
01DF:  GOTO   1F3
01E0:  MOVLW  08
01E1:  SUBWF  0C,W
01E2:  BTFSC  03.2
01E3:  GOTO   1F8
01E4:  GOTO   1FD
....................    {  
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej  
01E5:  CLRF   1E
01E6:  MOVLW  01
01E7:  MOVWF  1F
01E8:  CALL   037
....................                     delay_ms(2);  
01E9:  MOVLW  02
01EA:  MOVWF  1A
01EB:  CALL   00C
....................                                             break;  
01EC:  GOTO   209
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky  
01ED:  MOVLW  01
01EE:  MOVWF  1A
01EF:  MOVLW  02
01F0:  MOVWF  1B
01F1:  CALL   1C1
01F2:  GOTO   209
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home  
01F3:  MOVLW  01
01F4:  MOVWF  1A
01F5:  MOVWF  1B
01F6:  CALL   1C1
01F7:  GOTO   209
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet  
01F8:  CLRF   1E
01F9:  MOVLW  10
01FA:  MOVWF  1F
01FB:  CALL   037
01FC:  GOTO   209
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F  
01FD:  MOVF   19,W
01FE:  SUBLW  1F
01FF:  BTFSS  03.0
0200:  GOTO   203
0201:  MOVLW  07
0202:  ANDWF  19,F
....................                     lcd_send_byte(1,c);     break; // zapis znak  
0203:  MOVLW  01
0204:  MOVWF  1E
0205:  MOVF   19,W
0206:  MOVWF  1F
0207:  CALL   037
0208:  GOTO   209
....................    }  
0209:  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);  
.................... //}  
....................  
.................... #DEFINE PRIJIMAC        PIN_A3      // pin na ktery je pripojen prijimac  
.................... #DEFINE  SERVO_X         PIN_A0        // pin na ktery je pripojeno servo  
.................... #DEFINE  SERVO_Y         PIN_A1  
....................   
.................... int8     bit,x,y;  
.................... int      counter;                      // pocitadlo 1 a 0 v detektoru  
.................... int      x_old=0,y_old;  
....................   
.................... void servo(int uhel, int souradnice)  
.................... {  
....................       
....................       
....................       if (X==souradnice) output_high(SERVO_X); else output_high(SERVO_Y);  
*
0129:  MOVF   18,W
012A:  SUBWF  0F,W
012B:  BTFSS  03.2
012C:  GOTO   132
012D:  BSF    03.5
012E:  BCF    05.0
012F:  BCF    03.5
0130:  BSF    05.0
0131:  GOTO   136
0132:  BSF    03.5
0133:  BCF    05.1
0134:  BCF    03.5
0135:  BSF    05.1
....................   
....................       delay_us(62.5*uhel);  
0136:  CLRF   1A
0137:  MOVF   17,W
0138:  MOVWF  19
0139:  GOTO   086
013A:  CLRF   1C
013B:  CLRF   1B
013C:  MOVLW  7A
013D:  MOVWF  1A
013E:  MOVLW  84
013F:  MOVWF  19
0140:  MOVF   0F,W
0141:  MOVWF  20
0142:  MOVF   0E,W
0143:  MOVWF  1F
0144:  MOVF   0D,W
0145:  MOVWF  1E
0146:  MOVF   0C,W
0147:  MOVWF  1D
0148:  GOTO   0A4
0149:  MOVF   0C,W
014A:  MOVWF  19
014B:  MOVF   0D,W
014C:  MOVWF  1A
014D:  MOVF   0E,W
014E:  MOVWF  1B
014F:  MOVF   0F,W
0150:  MOVWF  1C
0151:  MOVF   0C,W
0152:  MOVWF  1D
0153:  GOTO   11B
....................   
....................       if (SERVO_X==souradnice) output_low(SERVO_X); else output_low(SERVO_Y);  
0154:  MOVF   18,W
0155:  SUBLW  28
0156:  BTFSS  03.2
0157:  GOTO   15D
0158:  BSF    03.5
0159:  BCF    05.0
015A:  BCF    03.5
015B:  BCF    05.0
015C:  GOTO   161
015D:  BSF    03.5
015E:  BCF    05.1
015F:  BCF    03.5
0160:  BCF    05.1
0161:  RETLW  00
....................     //  delay_ms(10);  
....................       
....................     
.................... }  
....................   
.................... int8 prijmout(int8* bit)  
.................... {  
.................... // ||    |  
.................... // |--|_____   1  
.................... //       |  
.................... // |-|__|-|_   0  
....................   
....................    while (!input(PRIJIMAC)) ;                // cekej na jednicku  
0162:  BSF    03.5
0163:  BSF    05.3
0164:  BCF    03.5
0165:  BTFSS  05.3
0166:  GOTO   162
....................    delay_us(IMPULS/4);                       // presvec se, jestli je stale 1 po 1/4 impulsu  
0167:  MOVLW  14
0168:  MOVWF  0C
0169:  DECFSZ 0C,F
016A:  GOTO   169
016B:  NOP
....................    if (!input(PRIJIMAC)) return(false);          // vrat chybu, kdyz neni stale 1  
016C:  BSF    03.5
016D:  BSF    05.3
016E:  BCF    03.5
016F:  BTFSC  05.3
0170:  GOTO   174
0171:  MOVLW  00
0172:  MOVWF  0D
0173:  GOTO   198
....................    delay_us(3*IMPULS);                       // pockej na rozhodovaci misto  
0174:  MOVLW  F9
0175:  MOVWF  0C
0176:  DECFSZ 0C,F
0177:  GOTO   176
0178:  NOP
0179:  NOP
....................    if (input(PRIJIMAC)) *bit=0; else *bit=1; // dekoduj 1 nebo 0  
017A:  BSF    03.5
017B:  BSF    05.3
017C:  BCF    03.5
017D:  BTFSS  05.3
017E:  GOTO   183
017F:  MOVF   1A,W
0180:  MOVWF  04
0181:  CLRF   00
0182:  GOTO   187
0183:  MOVF   1A,W
0184:  MOVWF  04
0185:  MOVLW  01
0186:  MOVWF  00
....................    delay_us(IMPULS);                         // pockej na konec znaku  
0187:  MOVLW  53
0188:  MOVWF  0C
0189:  DECFSZ 0C,F
018A:  GOTO   189
....................   
....................    output_bit(PIN_A0, *bit);  // kontrolni vystup  
018B:  MOVF   1A,W
018C:  MOVWF  04
018D:  MOVF   00,F
018E:  BTFSS  03.2
018F:  GOTO   192
0190:  BCF    05.0
0191:  GOTO   193
0192:  BSF    05.0
0193:  BSF    03.5
0194:  BCF    05.0
....................   
....................    return(true);                                // vrat, ze se cteni povedlo  
0195:  MOVLW  01
0196:  BCF    03.5
0197:  MOVWF  0D
0198:  RETLW  00
.................... }  
....................   
.................... int8 read_nibble(int8* value)  
.................... {  
....................    int8 n;     // citac  
....................    int8 bit;   // pomocna promenna  
....................   
....................    *value=0;  
0199:  MOVF   17,W
019A:  MOVWF  04
019B:  CLRF   00
....................    for (n=1; n<=4; n++)                      // prijmi 4 bity  
019C:  MOVLW  01
019D:  MOVWF  18
019E:  MOVF   18,W
019F:  SUBLW  04
01A0:  BTFSS  03.0
01A1:  GOTO   1BE
....................    {  
....................       *value >>= 1;                          // posun jiz prectene do leva  
01A2:  MOVF   17,W
01A3:  MOVWF  04
01A4:  BCF    03.0
01A5:  RRF    00,W
01A6:  MOVWF  0C
01A7:  MOVWF  00
....................       if (0==prijmout(&bit)) return(false);      // prijmi bit; pri chybe cteni vrat chybu  
01A8:  MOVLW  19
01A9:  MOVWF  1A
01AA:  CALL   162
01AB:  MOVF   0D,F
01AC:  BTFSS  03.2
01AD:  GOTO   1B1
01AE:  MOVLW  00
01AF:  MOVWF  0D
01B0:  GOTO   1C0
....................       *value |= bit << 3;                    // pridej bit do nibblu  
01B1:  MOVF   17,W
01B2:  MOVWF  04
01B3:  RLF    19,W
01B4:  MOVWF  0C
01B5:  RLF    0C,F
01B6:  RLF    0C,F
01B7:  MOVLW  F8
01B8:  ANDWF  0C,F
01B9:  MOVF   0C,W
01BA:  IORWF  00,W
01BB:  MOVWF  00
....................    };  
01BC:  INCF   18,F
01BD:  GOTO   19E
....................    return(true);                                // vrat 1, jako ,ze je vse O.K.  
01BE:  MOVLW  01
01BF:  MOVWF  0D
01C0:  RETLW  00
.................... }  
....................   
.................... /*void dekodovat(void)  
.................... {  
....................    int8 osa, hodnota, kontrola;  
....................   
....................    counter=4;  
....................   
.................... decoder:  
....................   
....................       counter=0;                                   // vynuluj citac  
....................       do                                           // vyhledej synchronizacni jednicky  
....................       {  
....................          if (!prijmout(&bit)) goto decoder;      // prijmi bit; pri chybe zacni znovu  
....................          if (1==bit) counter++; else goto decoder;  // kdyz je bit 1, tak zvys citac; jinak zacni znovu  
....................       } while(counter<4);                          // pockej na 4 jednicky  
....................   
....................       if (!read_nibble(&osa)) goto decoder;   // nacti identifikator osy  
....................   
....................       if (!read_nibble(&hodnota)) goto decoder;   // nacti 1. nibble; pri chybe zacni znovu  
....................       if (!read_nibble(&kontrola)) goto decoder;  // nacti 2. nibble; pri chybe zacni znovu  
....................       if (hodnota != kontrola) goto decoder;               // zacni znovu, pokud jsou ruzne nibble  
....................   
....................       switch (osa)            // rozeskoc se podle adresy osy  
....................       {  
....................       case OSA_X:  
....................          {  
....................             x=hodnota;  
....................             break;  
....................          };  
....................       case OSA_Y:  
....................          {  
....................             y=hodnota;  
....................             break;  
....................          };  
....................       case TLs:  
....................          {  
....................             break;  
....................          };  
....................       };  
.................... }  
.................... */  
.................... void main()  
.................... {  
*
0251:  CLRF   04
0252:  MOVLW  1F
0253:  ANDWF  03,F
0254:  CLRF   12
....................    lcd_init();                  // zinicializuj LCD display  
0255:  GOTO   04D
....................   
....................    while (true)  
....................    {  
....................    int8 osa, hodnota, kontrola;  
....................   
....................    counter=4;  
0256:  MOVLW  04
0257:  MOVWF  11
....................   
.................... decoder:  
....................   
....................       servo(x_old,SERVO_X);  
0258:  MOVF   12,W
0259:  MOVWF  17
025A:  MOVLW  28
025B:  MOVWF  18
025C:  CALL   129
....................         
....................       servo(y_old,SERVO_Y);  
025D:  MOVF   13,W
025E:  MOVWF  17
025F:  MOVLW  29
0260:  MOVWF  18
0261:  CALL   129
....................   
....................       counter=0;                                   // vynuluj citac  
0262:  CLRF   11
....................       do                                           // vyhledej synchronizacni jednicky  
....................       {  
....................          if (!prijmout(&bit)) goto decoder;      // prijmi bit; pri chybe zacni znovu  
0263:  MOVLW  0E
0264:  MOVWF  1A
0265:  CALL   162
0266:  MOVF   0D,F
0267:  BTFSS  03.2
0268:  GOTO   26A
0269:  GOTO   258
....................          if (1==bit) counter++; else goto decoder;  // kdyz je bit 1, tak zvys citac; jinak zacni znovu  
026A:  DECFSZ 0E,W
026B:  GOTO   26E
026C:  INCF   11,F
026D:  GOTO   26F
026E:  GOTO   258
....................       } while(counter<4);                          // pockej na 4 jednicky  
026F:  MOVF   11,W
0270:  SUBLW  03
0271:  BTFSC  03.0
0272:  GOTO   263
....................   
....................       if (!read_nibble(&osa)) goto decoder;   // nacti identifikator osy  
0273:  MOVLW  14
0274:  MOVWF  17
0275:  CALL   199
0276:  MOVF   0D,F
0277:  BTFSS  03.2
0278:  GOTO   27A
0279:  GOTO   258
....................   
....................       if (!read_nibble(&hodnota)) goto decoder;   // nacti 1. nibble; pri chybe zacni znovu  
027A:  MOVLW  15
027B:  MOVWF  17
027C:  CALL   199
027D:  MOVF   0D,F
027E:  BTFSS  03.2
027F:  GOTO   281
0280:  GOTO   258
....................       if (!read_nibble(&kontrola)) goto decoder;  // nacti 2. nibble; pri chybe zacni znovu  
0281:  MOVLW  16
0282:  MOVWF  17
0283:  CALL   199
0284:  MOVF   0D,F
0285:  BTFSS  03.2
0286:  GOTO   288
0287:  GOTO   258
....................       if (hodnota != kontrola) goto decoder;               // zacni znovu, pokud jsou ruzne nibble  
0288:  MOVF   16,W
0289:  SUBWF  15,W
028A:  BTFSC  03.2
028B:  GOTO   28D
028C:  GOTO   258
....................   
....................       switch (osa)            // rozeskoc se podle adresy osy  
028D:  MOVF   14,W
028E:  ADDLW  FD
028F:  BTFSC  03.0
0290:  GOTO   29E
0291:  ADDLW  03
0292:  GOTO   2D3
....................       {  
....................       case OSA_X:  
....................          {  
....................       
....................             x=hodnota;  
0293:  MOVF   15,W
0294:  MOVWF  0F
....................             x_old=x;  
0295:  MOVF   0F,W
0296:  MOVWF  12
....................               
....................             break;  
0297:  GOTO   29E
....................          };  
....................       case OSA_Y:  
....................          {  
....................             y=hodnota;  
0298:  MOVF   15,W
0299:  MOVWF  10
....................             y_old=y;  
029A:  MOVF   10,W
029B:  MOVWF  13
....................               
....................             break;  
029C:  GOTO   29E
....................          };  
....................       case TLs:  
....................          {  
....................             break;  
029D:  GOTO   29E
....................          };  
....................       };  
*
02D3:  BCF    0A.0
02D4:  BSF    0A.1
02D5:  BCF    0A.2
02D6:  ADDWF  02,F
02D7:  GOTO   293
02D8:  GOTO   298
02D9:  GOTO   29D
....................   
....................   
....................       lcd_gotoxy(1,1);                       // vytiskni X a Y  
*
029E:  MOVLW  01
029F:  MOVWF  1A
02A0:  MOVWF  1B
02A1:  CALL   1C1
....................       printf(lcd_putc,"X: %U      ", x);  
*
021F:  MOVF   0D,W
0220:  MOVF   17,W
0221:  MOVWF  19
0222:  MOVLW  64
0223:  MOVWF  1A
0224:  CALL   20A
0225:  MOVF   0C,W
0226:  MOVWF  17
0227:  MOVF   0D,W
0228:  MOVLW  30
0229:  BTFSS  03.2
022A:  GOTO   232
022B:  BTFSC  18.0
022C:  BSF    18.3
022D:  BTFSC  18.3
022E:  GOTO   238
022F:  BTFSC  18.4
0230:  MOVLW  20
0231:  GOTO   234
0232:  BCF    18.3
0233:  BCF    18.4
0234:  ADDWF  0D,F
0235:  MOVF   0D,W
0236:  MOVWF  19
0237:  CALL   1D2
0238:  MOVF   17,W
0239:  MOVWF  19
023A:  MOVLW  0A
023B:  MOVWF  1A
023C:  CALL   20A
023D:  MOVF   0C,W
023E:  MOVWF  17
023F:  MOVF   0D,W
0240:  MOVLW  30
0241:  BTFSS  03.2
0242:  GOTO   247
0243:  BTFSC  18.3
0244:  GOTO   24B
0245:  BTFSC  18.4
0246:  MOVLW  20
0247:  ADDWF  0D,F
0248:  MOVF   0D,W
0249:  MOVWF  19
024A:  CALL   1D2
024B:  MOVLW  30
024C:  ADDWF  17,F
024D:  MOVF   17,W
024E:  MOVWF  19
024F:  CALL   1D2
0250:  RETLW  00
*
02A2:  MOVLW  58
02A3:  MOVWF  19
02A4:  CALL   1D2
02A5:  MOVLW  3A
02A6:  MOVWF  19
02A7:  CALL   1D2
02A8:  MOVLW  20
02A9:  MOVWF  19
02AA:  CALL   1D2
02AB:  MOVF   0F,W
02AC:  MOVWF  17
02AD:  MOVLW  18
02AE:  MOVWF  18
02AF:  CALL   21F
02B0:  MOVLW  06
02B1:  MOVWF  17
02B2:  MOVLW  20
02B3:  MOVWF  19
02B4:  CALL   1D2
02B5:  DECFSZ 17,F
02B6:  GOTO   2B2
....................       lcd_gotoxy(1,2);  
02B7:  MOVLW  01
02B8:  MOVWF  1A
02B9:  MOVLW  02
02BA:  MOVWF  1B
02BB:  CALL   1C1
....................       printf(lcd_putc,"Y: %U      ", y);  
02BC:  MOVLW  59
02BD:  MOVWF  19
02BE:  CALL   1D2
02BF:  MOVLW  3A
02C0:  MOVWF  19
02C1:  CALL   1D2
02C2:  MOVLW  20
02C3:  MOVWF  19
02C4:  CALL   1D2
02C5:  MOVF   10,W
02C6:  MOVWF  17
02C7:  MOVLW  18
02C8:  MOVWF  18
02C9:  CALL   21F
02CA:  MOVLW  06
02CB:  MOVWF  17
02CC:  MOVLW  20
02CD:  MOVWF  19
02CE:  CALL   1D2
02CF:  DECFSZ 17,F
02D0:  GOTO   2CC
....................     }  
02D1:  GOTO   256
.................... }  
....................   
02D2:  SLEEP
....................   
....................