Subversion Repositories svnkaklik

CCS PCW C Compiler, Version 3.110, 15448

               Filename: e:\@dokumenty\pic\vysilac\main.LST

               ROM used: 669 (16%)
                         Largest free fragment is 2048
               RAM used: 12 (6%) at main() level
                         23 (12%) worst case
               Stack:    5 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   1B2
0003:  NOP
....................  #include "E:\@Dokumenty\pic\vysilac\main.h" 
....................  #include <16F873.h> 
....................  //////// Standard Header file for the PIC16F873 device ////////////////  
.................... #device PIC16F873  
.................... #list  
....................  
.................... #use delay(clock=4000000)  
*
0023:  MOVLW  2E
0024:  MOVWF  04
0025:  MOVF   00,W
0026:  BTFSC  03.2
0027:  GOTO   037
0028:  MOVLW  01
0029:  MOVWF  21
002A:  CLRF   20
002B:  DECFSZ 20,F
002C:  GOTO   02B
002D:  DECFSZ 21,F
002E:  GOTO   02A
002F:  MOVLW  4A
0030:  MOVWF  20
0031:  DECFSZ 20,F
0032:  GOTO   031
0033:  NOP
0034:  NOP
0035:  DECFSZ 00,F
0036:  GOTO   028
0037:  RETLW  00
.................... #fuses XT,PUT,NOWDT  
....................   
....................  
....................   
.................... #DEFINE LCD_RS          PIN_B1      // rizeni registru LCD displeje  
.................... #DEFINE LCD_E           PIN_B2      // enable LCD displeje  
.................... #DEFINE LCD_DATA_LSB    PIN_B4      // 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  
*
0038:  MOVF   06,W
0039:  ANDLW  0F
003A:  MOVWF  35
003B:  SWAPF  34,W
003C:  MOVWF  20
003D:  MOVLW  F0
003E:  ANDWF  20,F
003F:  MOVF   20,W
0040:  ANDLW  F0
0041:  IORWF  35,W
0042:  MOVWF  06
....................    output_bit(LCD_E,1);       // vzestupna hrana  
0043:  BSF    06.2
0044:  BSF    03.5
0045:  BCF    06.2
....................    delay_us(1);               // pockej alespon 450ns od e nebo alespon 195ns od dat  
0046:  NOP
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us)  
0047:  BCF    03.5
0048:  BCF    06.2
0049:  BSF    03.5
004A:  BCF    06.2
004B:  BCF    03.5
004C:  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  
004D:  MOVF   32,F
004E:  BTFSS  03.2
004F:  GOTO   052
0050:  BCF    06.1
0051:  GOTO   053
0052:  BSF    06.1
0053:  BSF    03.5
0054:  BCF    06.1
....................    swap(n);  
0055:  BCF    03.5
0056:  SWAPF  33,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu  
0057:  MOVF   33,W
0058:  MOVWF  34
0059:  CALL   038
....................    swap(n);  
005A:  SWAPF  33,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu  
005B:  MOVF   33,W
005C:  MOVWF  34
005D:  CALL   038
....................    delay_us(40);              // minimalni doba na provedeni prikazu  
005E:  MOVLW  0D
005F:  MOVWF  20
0060:  DECFSZ 20,F
0061:  GOTO   060
0062:  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  
0063:  MOVLW  14
0064:  MOVWF  2E
0065:  CALL   023
....................   
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD  
0066:  MOVLW  0F
0067:  BSF    03.5
0068:  ANDWF  06,F
....................   
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav  
0069:  BCF    03.5
006A:  BCF    06.1
006B:  BSF    03.5
006C:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav  
006D:  BCF    03.5
006E:  BCF    06.2
006F:  BSF    03.5
0070:  BCF    06.2
....................   
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice  
0071:  BCF    03.5
0072:  CLRF   2B
0073:  MOVF   2B,W
0074:  SUBLW  02
0075:  BTFSS  03.0
0076:  GOTO   07F
....................    {  
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel  
0077:  MOVLW  02
0078:  MOVWF  2E
0079:  CALL   023
....................       lcd_send_nibble(3);              // rezim 8 bitu  
007A:  MOVLW  03
007B:  MOVWF  34
007C:  CALL   038
....................    }  
007D:  INCF   2B,F
007E:  GOTO   073
....................   
....................    delay_us(40);                       // cas na zpracovani  
007F:  MOVLW  0D
0080:  MOVWF  20
0081:  DECFSZ 20,F
0082:  GOTO   081
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu)  
0083:  MOVLW  02
0084:  MOVWF  34
0085:  CALL   038
....................    delay_us(40);                       // cas na zpracovani  
0086:  MOVLW  0D
0087:  MOVWF  20
0088:  DECFSZ 20,F
0089:  GOTO   088
....................   
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod)  
008A:  CLRF   2B
008B:  MOVF   2B,W
008C:  SUBLW  02
008D:  BTFSS  03.0
008E:  GOTO   09B
....................    {  
....................       lcd_send_byte(0,LCD_INIT_STRING[i]);  
008F:  MOVF   2B,W
0090:  CALL   004
0091:  MOVWF  2C
0092:  CLRF   32
0093:  MOVF   2C,W
0094:  MOVWF  33
0095:  CALL   04D
....................       delay_ms(2);  
0096:  MOVLW  02
0097:  MOVWF  2E
0098:  CALL   023
....................    }  
0099:  INCF   2B,F
009A:  GOTO   08B
009B:  BCF    0A.3
009C:  GOTO   1F4 (RETURN)
.................... }  
....................   
....................   
.................... // Proved presun kurzoru  
.................... //  
.................... // Pozice 1.1 je domu  
.................... //  
.................... void lcd_gotoxy( BYTE x, BYTE y)  
.................... {  
....................   
....................    BYTE Adr;  
....................   
....................    Adr=x-1;  
009D:  MOVLW  01
009E:  SUBWF  2E,W
009F:  MOVWF  30
....................    if(y==2)  
00A0:  MOVF   2F,W
00A1:  SUBLW  02
00A2:  BTFSS  03.2
00A3:  GOTO   0A6
....................      Adr+=LCD_LINE_2;  
00A4:  MOVLW  40
00A5:  ADDWF  30,F
....................   
....................    lcd_send_byte(0,0x80|Adr);  
00A6:  MOVF   30,W
00A7:  IORLW  80
00A8:  MOVWF  31
00A9:  CLRF   32
00AA:  MOVF   31,W
00AB:  MOVWF  33
00AC:  CALL   04D
00AD:  RETLW  00
.................... }  
....................   
....................   
.................... // Zapis znaku na displej, zpracovani ridicich znaku  
.................... //  
.................... void lcd_putc( char c)  
.................... {  
....................   
....................    switch (c)  
00AE:  MOVF   2D,W
00AF:  MOVWF  20
00B0:  MOVLW  0C
00B1:  SUBWF  20,W
00B2:  BTFSC  03.2
00B3:  GOTO   0C1
00B4:  MOVLW  0A
00B5:  SUBWF  20,W
00B6:  BTFSC  03.2
00B7:  GOTO   0C9
00B8:  MOVLW  0D
00B9:  SUBWF  20,W
00BA:  BTFSC  03.2
00BB:  GOTO   0CF
00BC:  MOVLW  08
00BD:  SUBWF  20,W
00BE:  BTFSC  03.2
00BF:  GOTO   0D4
00C0:  GOTO   0D9
....................    {  
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej  
00C1:  CLRF   32
00C2:  MOVLW  01
00C3:  MOVWF  33
00C4:  CALL   04D
....................                     delay_ms(2);  
00C5:  MOVLW  02
00C6:  MOVWF  2E
00C7:  CALL   023
....................                                             break;  
00C8:  GOTO   0E5
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky  
00C9:  MOVLW  01
00CA:  MOVWF  2E
00CB:  MOVLW  02
00CC:  MOVWF  2F
00CD:  CALL   09D
00CE:  GOTO   0E5
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home  
00CF:  MOVLW  01
00D0:  MOVWF  2E
00D1:  MOVWF  2F
00D2:  CALL   09D
00D3:  GOTO   0E5
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet  
00D4:  CLRF   32
00D5:  MOVLW  10
00D6:  MOVWF  33
00D7:  CALL   04D
00D8:  GOTO   0E5
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F  
00D9:  MOVF   2D,W
00DA:  SUBLW  1F
00DB:  BTFSS  03.0
00DC:  GOTO   0DF
00DD:  MOVLW  07
00DE:  ANDWF  2D,F
....................                     lcd_send_byte(1,c);     break; // zapis znak  
00DF:  MOVLW  01
00E0:  MOVWF  32
00E1:  MOVF   2D,W
00E2:  MOVWF  33
00E3:  CALL   04D
00E4:  GOTO   0E5
....................    }  
00E5:  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  VYSILAC        PIN_C3  
.................... #DEFINE  OSA_X          0           // adresa A/D prevodniku pro osu X  
.................... #DEFINE  OSA_Y          1           // adresa A/D prevodniku pro osu Y  
.................... #DEFINE  IMPULS         250         // sirka impulsu pro false |-|  
.................... #DEFINE  TTL1           PIN_b4  
.................... #DEFINE  TTL2           PIN_b3  
....................   
.................... int stredX, stredY, x, y;  
....................   
....................   
.................... void odeslat (int8 kodeslani)  
.................... {  
....................    int i;  
....................   
....................    for  (i=0;i<=7;i++)  
*
013E:  CLRF   2F
013F:  MOVF   2F,W
0140:  SUBLW  07
0141:  BTFSS  03.0
0142:  GOTO   196
....................    {  
....................      if (1==bit_test(kodeslani,i))  
0143:  MOVF   2E,W
0144:  MOVWF  20
0145:  MOVF   2F,W
0146:  MOVWF  21
0147:  BTFSC  03.2
0148:  GOTO   14D
0149:  BCF    03.0
014A:  RRF    20,F
014B:  DECFSZ 21,F
014C:  GOTO   149
014D:  MOVLW  00
014E:  BTFSC  20.0
014F:  MOVLW  01
0150:  SUBLW  01
0151:  BTFSS  03.2
0152:  GOTO   16B
....................      {  
....................         output_high(VYSILAC);  
0153:  BCF    29.3
0154:  MOVF   29,W
0155:  BSF    03.5
0156:  MOVWF  07
0157:  BCF    03.5
0158:  BSF    07.3
....................         delay_us(2*IMPULS);          // X pri 1: |--|___  
0159:  MOVLW  A6
015A:  MOVWF  20
015B:  DECFSZ 20,F
015C:  GOTO   15B
015D:  NOP
....................         output_low(VYSILAC);  
015E:  BCF    29.3
015F:  MOVF   29,W
0160:  BSF    03.5
0161:  MOVWF  07
0162:  BCF    03.5
0163:  BCF    07.3
....................         delay_us(3*IMPULS);  
0164:  MOVLW  F9
0165:  MOVWF  20
0166:  DECFSZ 20,F
0167:  GOTO   166
0168:  NOP
0169:  NOP
....................      }  
....................      else  
016A:  GOTO   194
....................      {  
....................          output_high(VYSILAC);  
016B:  BCF    29.3
016C:  MOVF   29,W
016D:  BSF    03.5
016E:  MOVWF  07
016F:  BCF    03.5
0170:  BSF    07.3
....................          delay_us(IMPULS);           // X pri 0: |-|__|-|_  
0171:  MOVLW  53
0172:  MOVWF  20
0173:  DECFSZ 20,F
0174:  GOTO   173
....................          output_low(VYSILAC);  
0175:  BCF    29.3
0176:  MOVF   29,W
0177:  BSF    03.5
0178:  MOVWF  07
0179:  BCF    03.5
017A:  BCF    07.3
....................   
....................          delay_us(2*IMPULS);  
017B:  MOVLW  A6
017C:  MOVWF  20
017D:  DECFSZ 20,F
017E:  GOTO   17D
017F:  NOP
....................   
....................          output_high(VYSILAC);  
0180:  BCF    29.3
0181:  MOVF   29,W
0182:  BSF    03.5
0183:  MOVWF  07
0184:  BCF    03.5
0185:  BSF    07.3
....................          delay_us(IMPULS);  
0186:  MOVLW  53
0187:  MOVWF  20
0188:  DECFSZ 20,F
0189:  GOTO   188
....................          output_low(VYSILAC);  
018A:  BCF    29.3
018B:  MOVF   29,W
018C:  BSF    03.5
018D:  MOVWF  07
018E:  BCF    03.5
018F:  BCF    07.3
....................          delay_us(IMPULS);  
0190:  MOVLW  53
0191:  MOVWF  20
0192:  DECFSZ 20,F
0193:  GOTO   192
....................      };  
....................    }  
0194:  INCF   2F,F
0195:  GOTO   13F
0196:  RETLW  00
.................... }  
....................   
.................... void synchronizace()  
.................... {  
.................... int8 sinchro;  
....................    sinchro=0b00001111;  
0197:  MOVLW  0F
0198:  MOVWF  2B
....................   
....................    odeslat (sinchro);                  // synchronizace: |--|___|--|___|--|___|--|___|-|__|-|_|-|__|-|_|-|__|-|_|-|__|-|_  
0199:  MOVF   2B,W
019A:  MOVWF  2E
019B:  CALL   13E
019C:  BCF    0A.3
019D:  GOTO   290 (RETURN)
.................... }  
....................   
....................   
....................   
.................... void odesli (int8 X, int8 Y)  
.................... {  
....................   odeslat(X+ (X << 4));  
019E:  SWAPF  2B,W
019F:  MOVWF  20
01A0:  MOVLW  F0
01A1:  ANDWF  20,F
01A2:  MOVF   20,W
01A3:  ADDWF  2B,W
01A4:  MOVWF  2D
01A5:  MOVWF  2E
01A6:  CALL   13E
....................   odeslat(Y+ (Y << 4));  
01A7:  SWAPF  2C,W
01A8:  MOVWF  20
01A9:  MOVLW  F0
01AA:  ANDWF  20,F
01AB:  MOVF   20,W
01AC:  ADDWF  2C,W
01AD:  MOVWF  2D
01AE:  MOVWF  2E
01AF:  CALL   13E
01B0:  BCF    0A.3
01B1:  GOTO   295 (RETURN)
....................   
.................... }  
....................   
....................   
.................... void kalibrace()  
.................... {  
.................... int8 min_x;  
.................... int8 max_x;  
.................... int8 min_y;  
.................... int8 max_y;  
.................... int8 sred_x;  
.................... int8 sred_y;  
.................... int8 adc;  
....................    min_x=max_x=min_y=max_y=sred_x=sred_y=128;  
....................   
....................    printf(lcd_putc,"Paku dejte do prostred a stisknete tlacitko");  
.................... znovu:     
....................    if (TTL1 || TTL2)  
....................    {  
....................    set_adc_channel(OSA_X);  
....................    delay_us(10);  
....................    sred_x=read_adc();  
....................    set_adc_channel(OSA_y);  
....................    delay_us(10);  
....................    sred_y=read_adc();  
....................    };  
....................      
....................    //else goto znovu;  
....................      
....................    printf(lcd_putc,"\f");  
....................    printf(lcd_putc,"Pak ");  
....................      
....................    set_adc_channel(OSA_X);  
....................    delay_us(10);  
....................      
....................    adc=read_adc();  
....................      
....................    if (max_x < adc )max_x=adc;  
....................    if (min_x > adc )min_x=adc;  
....................      
....................    set_adc_channel(OSA_y);  
....................    delay_us(10);  
....................      
....................    adc=read_adc();  
....................      
....................    if (max_y < adc )max_y=adc;  
....................    if (min_y > adc )min_y=adc;  
....................      
....................    if (TTL1 || TTL2) return;  
.................... }  
....................   
....................   
.................... void main()  
.................... {  
*
01BB:  CLRF   2A
.................... int c=0;  
*
01B2:  CLRF   04
01B3:  MOVLW  1F
01B4:  ANDWF  03,F
01B5:  MOVLW  07
01B6:  BSF    03.5
01B7:  MOVWF  1F
01B8:  MOVLW  FF
01B9:  BCF    03.5
01BA:  MOVWF  29
....................   
....................    setup_adc_ports(RA0_RA1_RA3_ANALOG);  
*
01BC:  MOVLW  04
01BD:  BSF    03.5
01BE:  MOVWF  1F
....................    setup_adc(ADC_CLOCK_DIV_2);  
01BF:  BCF    03.5
01C0:  MOVF   1F,W
01C1:  ANDLW  38
01C2:  IORLW  01
01C3:  MOVWF  1F
....................    setup_spi(FALSE);  
01C4:  BCF    14.5
01C5:  BCF    29.5
01C6:  MOVF   29,W
01C7:  BSF    03.5
01C8:  MOVWF  07
01C9:  BCF    03.5
01CA:  BSF    29.4
01CB:  MOVF   29,W
01CC:  BSF    03.5
01CD:  MOVWF  07
01CE:  BCF    03.5
01CF:  BCF    29.3
01D0:  MOVF   29,W
01D1:  BSF    03.5
01D2:  MOVWF  07
01D3:  MOVLW  00
01D4:  BCF    03.5
01D5:  MOVWF  14
01D6:  BSF    03.5
01D7:  MOVWF  14
....................    setup_counters(RTCC_INTERNAL,RTCC_DIV_2);  
01D8:  BCF    03.5
01D9:  CLRF   20
01DA:  BTFSS  20.3
01DB:  GOTO   1E4
01DC:  MOVLW  07
01DD:  CLRF   01
01DE:  MOVLW  81
01DF:  MOVWF  04
01E0:  MOVF   00,W
01E1:  ANDLW  C0
01E2:  IORLW  0F
01E3:  MOVWF  00
01E4:  CLRWDT
01E5:  MOVLW  81
01E6:  MOVWF  04
01E7:  MOVF   00,W
01E8:  ANDLW  C0
01E9:  IORWF  20,W
01EA:  MOVWF  00
....................    setup_timer_1(T1_DISABLED);  
01EB:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1);  
01EC:  MOVLW  00
01ED:  MOVWF  21
01EE:  MOVWF  12
01EF:  MOVLW  00
01F0:  BSF    03.5
01F1:  MOVWF  12
....................   
....................    lcd_init();  
01F2:  BCF    03.5
01F3:  GOTO   063
....................   
....................    while (c<=16)  
01F4:  MOVF   2A,W
01F5:  SUBLW  10
01F6:  BTFSS  03.0
01F7:  GOTO   208
....................    {  
....................    lcd_gotoxy(c,1);  
01F8:  MOVF   2A,W
01F9:  MOVWF  2E
01FA:  MOVLW  01
01FB:  MOVWF  2F
01FC:  CALL   09D
....................    printf(lcd_putc,"_");  
01FD:  MOVLW  5F
01FE:  MOVWF  2D
01FF:  CALL   0AE
....................    delay_ms(50);  
0200:  MOVLW  32
0201:  MOVWF  2E
0202:  CALL   023
....................    printf(lcd_putc,"\f");  
0203:  MOVLW  0C
0204:  MOVWF  2D
0205:  CALL   0AE
....................    c++;  
0206:  INCF   2A,F
....................    }  
0207:  GOTO   1F4
....................      
....................    printf(lcd_putc,"\fAhoj!");  
*
000C:  BCF    0A.0
000D:  BCF    0A.1
000E:  BCF    0A.2
000F:  ADDWF  02,F
0010:  RETLW  0C
0011:  RETLW  41
0012:  RETLW  68
0013:  RETLW  6F
0014:  RETLW  6A
0015:  RETLW  21
0016:  RETLW  00
*
0208:  CLRF   2B
0209:  MOVF   2B,W
020A:  CALL   00C
020B:  INCF   2B,F
020C:  MOVWF  2D
020D:  CALL   0AE
020E:  MOVLW  06
020F:  SUBWF  2B,W
0210:  BTFSS  03.2
0211:  GOTO   209
....................    delay_ms(1500);  
0212:  MOVLW  06
0213:  MOVWF  2B
0214:  MOVLW  FA
0215:  MOVWF  2E
0216:  CALL   023
0217:  DECFSZ 2B,F
0218:  GOTO   214
....................      
....................    printf(lcd_putc,"\f");  
0219:  MOVLW  0C
021A:  MOVWF  2D
021B:  CALL   0AE
....................   
....................   
....................    while(true)  
....................    {  
....................       set_adc_channel(OSA_X);  
021C:  MOVLW  00
021D:  MOVWF  21
021E:  MOVF   1F,W
021F:  ANDLW  C7
0220:  IORWF  21,W
0221:  MOVWF  1F
....................       lcd_gotoxy(1,1);  
0222:  MOVLW  01
0223:  MOVWF  2E
0224:  MOVWF  2F
0225:  CALL   09D
....................       x=read_adc() >> 4;  
0226:  BSF    1F.2
0227:  BTFSC  1F.2
0228:  GOTO   227
0229:  MOVF   1E,W
022A:  SWAPF  1E,W
022B:  MOVWF  27
022C:  MOVLW  0F
022D:  ANDWF  27,F
....................       printf(lcd_putc,"X: %D      ", x);  
*
00FB:  MOVF   2B,W
00FC:  MOVWF  20
00FD:  BTFSC  2B.7
00FE:  GOTO   103
00FF:  BTFSS  2C.2
0100:  GOTO   10D
0101:  MOVLW  20
0102:  GOTO   108
0103:  COMF   20,F
0104:  INCF   20,F
0105:  MOVF   20,W
0106:  MOVWF  2B
0107:  MOVLW  2D
0108:  MOVWF  21
0109:  MOVWF  2D
010A:  CALL   0AE
010B:  BTFSS  2C.2
010C:  BSF    2C.3
010D:  MOVF   2B,W
010E:  MOVWF  2D
010F:  MOVLW  64
0110:  MOVWF  2E
0111:  CALL   0E6
0112:  MOVF   20,W
0113:  MOVWF  2B
0114:  MOVF   21,W
0115:  MOVLW  30
0116:  BTFSS  03.2
0117:  GOTO   11F
0118:  BTFSC  2C.0
0119:  BSF    2C.3
011A:  BTFSC  2C.3
011B:  GOTO   125
011C:  BTFSC  2C.4
011D:  MOVLW  20
011E:  GOTO   121
011F:  BCF    2C.3
0120:  BCF    2C.4
0121:  ADDWF  21,F
0122:  MOVF   21,W
0123:  MOVWF  2D
0124:  CALL   0AE
0125:  MOVF   2B,W
0126:  MOVWF  2D
0127:  MOVLW  0A
0128:  MOVWF  2E
0129:  CALL   0E6
012A:  MOVF   20,W
012B:  MOVWF  2B
012C:  MOVF   21,W
012D:  MOVLW  30
012E:  BTFSS  03.2
012F:  GOTO   134
0130:  BTFSC  2C.3
0131:  GOTO   138
0132:  BTFSC  2C.4
0133:  MOVLW  20
0134:  ADDWF  21,F
0135:  MOVF   21,W
0136:  MOVWF  2D
0137:  CALL   0AE
0138:  MOVLW  30
0139:  ADDWF  2B,F
013A:  MOVF   2B,W
013B:  MOVWF  2D
013C:  CALL   0AE
013D:  RETLW  00
*
022E:  MOVLW  58
022F:  MOVWF  2D
0230:  CALL   0AE
0231:  MOVLW  3A
0232:  MOVWF  2D
0233:  CALL   0AE
0234:  MOVLW  20
0235:  MOVWF  2D
0236:  CALL   0AE
0237:  MOVF   27,W
0238:  MOVWF  2B
0239:  MOVLW  18
023A:  MOVWF  2C
023B:  CALL   0FB
023C:  MOVLW  06
023D:  MOVWF  2B
023E:  MOVLW  20
023F:  MOVWF  2D
0240:  CALL   0AE
0241:  DECFSZ 2B,F
0242:  GOTO   23E
....................       set_adc_channel(OSA_Y);  
0243:  MOVLW  08
0244:  MOVWF  21
0245:  MOVF   1F,W
0246:  ANDLW  C7
0247:  IORWF  21,W
0248:  MOVWF  1F
....................       lcd_gotoxy(1,2);  
0249:  MOVLW  01
024A:  MOVWF  2E
024B:  MOVLW  02
024C:  MOVWF  2F
024D:  CALL   09D
....................       y=read_adc() >> 4;  
024E:  BSF    1F.2
024F:  BTFSC  1F.2
0250:  GOTO   24F
0251:  MOVF   1E,W
0252:  SWAPF  1E,W
0253:  MOVWF  28
0254:  MOVLW  0F
0255:  ANDWF  28,F
....................       printf(lcd_putc,"Y: %D      ", y);  
0256:  MOVLW  59
0257:  MOVWF  2D
0258:  CALL   0AE
0259:  MOVLW  3A
025A:  MOVWF  2D
025B:  CALL   0AE
025C:  MOVLW  20
025D:  MOVWF  2D
025E:  CALL   0AE
025F:  MOVF   28,W
0260:  MOVWF  2B
0261:  MOVLW  18
0262:  MOVWF  2C
0263:  CALL   0FB
0264:  MOVLW  06
0265:  MOVWF  2B
0266:  MOVLW  20
0267:  MOVWF  2D
0268:  CALL   0AE
0269:  DECFSZ 2B,F
026A:  GOTO   266
....................   
....................   
....................   
....................   
....................   
....................  /*     output_high(PIN_C1);  
....................       output_low(PIN_C2);  
....................       delay_ms(100);  
....................       output_low(PIN_C1);  
....................       output_high(PIN_C2);  
....................       delay_ms(100);*/  
....................   
....................       lcd_gotoxy(7,2);  
026B:  MOVLW  07
026C:  MOVWF  2E
026D:  MOVLW  02
026E:  MOVWF  2F
026F:  CALL   09D
....................       printf(lcd_putc,"vysilam");  
*
0017:  BCF    0A.0
0018:  BCF    0A.1
0019:  BCF    0A.2
001A:  ADDWF  02,F
001B:  RETLW  76
001C:  RETLW  79
001D:  RETLW  73
001E:  RETLW  69
001F:  RETLW  6C
0020:  RETLW  61
0021:  RETLW  6D
0022:  RETLW  00
*
0270:  CLRF   2B
0271:  MOVF   2B,W
0272:  CALL   017
0273:  INCF   2B,F
0274:  MOVWF  2D
0275:  CALL   0AE
0276:  MOVLW  07
0277:  SUBWF  2B,W
0278:  BTFSS  03.2
0279:  GOTO   271
....................   
....................       output_high(PIN_C4);  
027A:  BCF    29.4
027B:  MOVF   29,W
027C:  BSF    03.5
027D:  MOVWF  07
027E:  BCF    03.5
027F:  BSF    07.4
....................       output_high(PIN_C6);  
0280:  BCF    29.6
0281:  MOVF   29,W
0282:  BSF    03.5
0283:  MOVWF  07
0284:  BCF    03.5
0285:  BSF    07.6
....................       delay_ms(1);  
0286:  MOVLW  01
0287:  MOVWF  2E
0288:  CALL   023
....................       output_low(PIN_C4);  
0289:  BCF    29.4
028A:  MOVF   29,W
028B:  BSF    03.5
028C:  MOVWF  07
028D:  BCF    03.5
028E:  BCF    07.4
....................       synchronizace();  
028F:  GOTO   197
....................       odesli(x,y);  
0290:  MOVF   27,W
0291:  MOVWF  2B
0292:  MOVF   28,W
0293:  MOVWF  2C
0294:  GOTO   19E
....................       output_low(PIN_C6);  
0295:  BCF    29.6
0296:  MOVF   29,W
0297:  BSF    03.5
0298:  MOVWF  07
0299:  BCF    03.5
029A:  BCF    07.6
....................   
....................   
....................    }  
029B:  GOTO   21C
....................   
.................... }  
....................  
029C:  SLEEP