Subversion Repositories svnkaklik

CCS PCW C Compiler, Version 3.110, 15448

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

               ROM used: 691 (67%)
                         Largest free fragment is 333
               RAM used: 13 (19%) at main() level
                         25 (37%) worst case
               Stack:    5 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   1C9
0003:  NOP
....................  // Prijimac  
....................   
.................... #include "main.h" 
....................  #include <16F84.h> 
....................  //////// Standard Header file for the PIC16F84 device ////////////////  
.................... #device PIC16F84  
.................... #list  
....................  
.................... #use delay(clock=4000000)  
*
0015:  MOVLW  1C
0016:  MOVWF  04
0017:  MOVF   00,W
0018:  BTFSC  03.2
0019:  GOTO   029
001A:  MOVLW  01
001B:  MOVWF  0D
001C:  CLRF   0C
001D:  DECFSZ 0C,F
001E:  GOTO   01D
001F:  DECFSZ 0D,F
0020:  GOTO   01C
0021:  MOVLW  4A
0022:  MOVWF  0C
0023:  DECFSZ 0C,F
0024:  GOTO   023
0025:  NOP
0026:  NOP
0027:  DECFSZ 00,F
0028:  GOTO   01A
0029:  RETLW  00
.................... #fuses XT,NOWDT,PUT  
....................   
....................  
.................... #include "..\common.h" 
....................  #DEFINE  OSA_X          1           // adresy os  
.................... #DEFINE  OSA_Y          2  
.................... #DEFINE  TLs            3  
.................... #DEFINE  IMPULS         250         // sirka impulsu  
.................... #DEFINE  SYNC_NIBBLE    0b1111      // magiske cislo sync niblu  
....................  
....................   
.................... #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  
*
002A:  MOVF   06,W
002B:  ANDLW  C3
002C:  MOVWF  23
002D:  RLF    22,W
002E:  MOVWF  0C
002F:  RLF    0C,F
0030:  MOVLW  FC
0031:  ANDWF  0C,F
0032:  MOVF   0C,W
0033:  ANDLW  3C
0034:  IORWF  23,W
0035:  MOVWF  06
....................    output_bit(LCD_E,1);       // vzestupna hrana  
0036:  BSF    06.0
0037:  BSF    03.5
0038:  BCF    06.0
....................    delay_us(1);               // pockej alespon 450ns od e nebo alespon 195ns od dat  
0039:  NOP
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us)  
003A:  BCF    03.5
003B:  BCF    06.0
003C:  BSF    03.5
003D:  BCF    06.0
003E:  BCF    03.5
003F:  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  
0040:  MOVF   20,F
0041:  BTFSS  03.2
0042:  GOTO   045
0043:  BCF    06.1
0044:  GOTO   046
0045:  BSF    06.1
0046:  BSF    03.5
0047:  BCF    06.1
....................    swap(n);  
0048:  BCF    03.5
0049:  SWAPF  21,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu  
004A:  MOVF   21,W
004B:  MOVWF  22
004C:  CALL   02A
....................    swap(n);  
004D:  SWAPF  21,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu  
004E:  MOVF   21,W
004F:  MOVWF  22
0050:  CALL   02A
....................    delay_us(40);              // minimalni doba na provedeni prikazu  
0051:  MOVLW  0D
0052:  MOVWF  0C
0053:  DECFSZ 0C,F
0054:  GOTO   053
0055:  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  
0056:  MOVLW  14
0057:  MOVWF  1C
0058:  CALL   015
....................   
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD  
0059:  MOVLW  C3
005A:  BSF    03.5
005B:  ANDWF  06,F
....................   
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav  
005C:  BCF    03.5
005D:  BCF    06.1
005E:  BSF    03.5
005F:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav  
0060:  BCF    03.5
0061:  BCF    06.0
0062:  BSF    03.5
0063:  BCF    06.0
....................   
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice  
0064:  BCF    03.5
0065:  CLRF   19
0066:  MOVF   19,W
0067:  SUBLW  02
0068:  BTFSS  03.0
0069:  GOTO   072
....................    {  
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel  
006A:  MOVLW  02
006B:  MOVWF  1C
006C:  CALL   015
....................       lcd_send_nibble(3);              // rezim 8 bitu  
006D:  MOVLW  03
006E:  MOVWF  22
006F:  CALL   02A
....................    }  
0070:  INCF   19,F
0071:  GOTO   066
....................   
....................    delay_us(40);                       // cas na zpracovani  
0072:  MOVLW  0D
0073:  MOVWF  0C
0074:  DECFSZ 0C,F
0075:  GOTO   074
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu)  
0076:  MOVLW  02
0077:  MOVWF  22
0078:  CALL   02A
....................    delay_us(40);                       // cas na zpracovani  
0079:  MOVLW  0D
007A:  MOVWF  0C
007B:  DECFSZ 0C,F
007C:  GOTO   07B
....................   
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod)  
007D:  CLRF   19
007E:  MOVF   19,W
007F:  SUBLW  02
0080:  BTFSS  03.0
0081:  GOTO   08E
....................    {  
....................       lcd_send_byte(0,LCD_INIT_STRING[i]);  
0082:  MOVF   19,W
0083:  CALL   004
0084:  MOVWF  1A
0085:  CLRF   20
0086:  MOVF   1A,W
0087:  MOVWF  21
0088:  CALL   040
....................       delay_ms(2);  
0089:  MOVLW  02
008A:  MOVWF  1C
008B:  CALL   015
....................    }  
008C:  INCF   19,F
008D:  GOTO   07E
008E:  GOTO   1CD (RETURN)
.................... }  
....................   
....................   
.................... // Proved presun kurzoru  
.................... //  
.................... // Pozice 1.1 je domu  
.................... //  
.................... void lcd_gotoxy( BYTE x, BYTE y)  
.................... {  
....................   
....................    BYTE Adr;  
....................   
....................    Adr=x-1;  
008F:  MOVLW  01
0090:  SUBWF  1C,W
0091:  MOVWF  1E
....................    if(y==2)  
0092:  MOVF   1D,W
0093:  SUBLW  02
0094:  BTFSS  03.2
0095:  GOTO   098
....................      Adr+=LCD_LINE_2;  
0096:  MOVLW  40
0097:  ADDWF  1E,F
....................   
....................    lcd_send_byte(0,0x80|Adr);  
0098:  MOVF   1E,W
0099:  IORLW  80
009A:  MOVWF  1F
009B:  CLRF   20
009C:  MOVF   1F,W
009D:  MOVWF  21
009E:  CALL   040
009F:  RETLW  00
.................... }  
....................   
....................   
.................... // Zapis znaku na displej, zpracovani ridicich znaku  
.................... //  
.................... void lcd_putc( char c)  
.................... {  
....................   
....................    switch (c)  
00A0:  MOVF   1B,W
00A1:  MOVWF  0C
00A2:  MOVLW  0C
00A3:  SUBWF  0C,W
00A4:  BTFSC  03.2
00A5:  GOTO   0B3
00A6:  MOVLW  0A
00A7:  SUBWF  0C,W
00A8:  BTFSC  03.2
00A9:  GOTO   0BB
00AA:  MOVLW  0D
00AB:  SUBWF  0C,W
00AC:  BTFSC  03.2
00AD:  GOTO   0C1
00AE:  MOVLW  08
00AF:  SUBWF  0C,W
00B0:  BTFSC  03.2
00B1:  GOTO   0C6
00B2:  GOTO   0CB
....................    {  
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej  
00B3:  CLRF   20
00B4:  MOVLW  01
00B5:  MOVWF  21
00B6:  CALL   040
....................                     delay_ms(2);  
00B7:  MOVLW  02
00B8:  MOVWF  1C
00B9:  CALL   015
....................                                             break;  
00BA:  GOTO   0D7
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky  
00BB:  MOVLW  01
00BC:  MOVWF  1C
00BD:  MOVLW  02
00BE:  MOVWF  1D
00BF:  CALL   08F
00C0:  GOTO   0D7
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home  
00C1:  MOVLW  01
00C2:  MOVWF  1C
00C3:  MOVWF  1D
00C4:  CALL   08F
00C5:  GOTO   0D7
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet  
00C6:  CLRF   20
00C7:  MOVLW  10
00C8:  MOVWF  21
00C9:  CALL   040
00CA:  GOTO   0D7
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F  
00CB:  MOVF   1B,W
00CC:  SUBLW  1F
00CD:  BTFSS  03.0
00CE:  GOTO   0D1
00CF:  MOVLW  07
00D0:  ANDWF  1B,F
....................                     lcd_send_byte(1,c);     break; // zapis znak  
00D1:  MOVLW  01
00D2:  MOVWF  20
00D3:  MOVF   1B,W
00D4:  MOVWF  21
00D5:  CALL   040
00D6:  GOTO   0D7
....................    }  
00D7:  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_A2      // pin na ktery je pripojeno servo  
.................... #DEFINE  SERVO_Y        PIN_B0  
.................... #INCLUDE "prijimac.c" 
....................    
.................... //#DEFINE  DEBUG          PIN_A4      // ladici pomocne synchronizacni impulzy  
....................   
.................... //#DEFINE  PRIJIMAC       PIN_A3      // pin na ktery je pripojen prijimac  
....................   
.................... // Prijme datovy nibble vcetne zasynchronizovani  
.................... // Chybi dodelat timeout  
.................... int8 prijmi_nibble(int8* datovy, int8* data)  
.................... {  
....................    int8 i;  
....................   
....................    #IFDEF DEBUG  
....................    int1 tmp;  
....................    #ENDIF  
....................   
....................    *data=0;  
00D8:  MOVF   1E,W
00D9:  MOVWF  04
00DA:  CLRF   00
....................   
....................    // Cekam na dlouhou nulu  
....................    for (i=4; i>0; i--)  
00DB:  MOVLW  04
00DC:  MOVWF  1F
00DD:  MOVF   1F,F
00DE:  BTFSC  03.2
00DF:  GOTO   0EE
....................    {  
....................       if (input(PRIJIMAC)) i=4;  
00E0:  BSF    03.5
00E1:  BSF    05.3
00E2:  BCF    03.5
00E3:  BTFSS  05.3
00E4:  GOTO   0E7
00E5:  MOVLW  04
00E6:  MOVWF  1F
....................       delay_us(IMPULS/2);  
00E7:  MOVLW  29
00E8:  MOVWF  0C
00E9:  DECFSZ 0C,F
00EA:  GOTO   0E9
00EB:  NOP
....................    }  
00EC:  DECF   1F,F
00ED:  GOTO   0DD
....................   
....................    // Cekam na jednicku (start ramce)  
....................    for (; !input(PRIJIMAC); )  
00EE:  BSF    03.5
00EF:  BSF    05.3
00F0:  BCF    03.5
00F1:  BTFSS  05.3
....................    {  
....................    }  
00F2:  GOTO   0EE
....................   
....................    // Ctu typ nibblu  
....................    delay_us(2*IMPULS+2*IMPULS/3);  
00F3:  MOVLW  DD
00F4:  MOVWF  0C
00F5:  DECFSZ 0C,F
00F6:  GOTO   0F5
00F7:  NOP
00F8:  NOP
....................    *datovy=input(PRIJIMAC);  
00F9:  MOVF   1D,W
00FA:  MOVWF  04
00FB:  BSF    03.5
00FC:  BSF    05.3
00FD:  MOVLW  00
00FE:  BCF    03.5
00FF:  BTFSC  05.3
0100:  MOVLW  01
0101:  MOVWF  00
....................   
....................    // Prenasim bity  
....................    for (i=0; i<4; i++)  
0102:  CLRF   1F
0103:  MOVF   1F,W
0104:  SUBLW  03
0105:  BTFSS  03.0
0106:  GOTO   123
....................    {  
....................       delay_us(2*IMPULS);  
0107:  MOVLW  A6
0108:  MOVWF  0C
0109:  DECFSZ 0C,F
010A:  GOTO   109
010B:  NOP
....................       *data >>= 1;  
010C:  MOVF   1E,W
010D:  MOVWF  04
010E:  BCF    03.0
010F:  RRF    00,W
0110:  MOVWF  0C
0111:  MOVWF  00
....................       if (input(PRIJIMAC)) *data +=0b1000;  
0112:  BSF    03.5
0113:  BSF    05.3
0114:  BCF    03.5
0115:  BTFSS  05.3
0116:  GOTO   11C
0117:  MOVF   1E,W
0118:  MOVWF  04
0119:  MOVLW  08
011A:  ADDWF  00,W
011B:  MOVWF  00
....................   
....................       #IFDEF DEBUG  
....................       output_bit(DEBUG,tmp);  
....................       tmp=!tmp;  
....................       #ELSE  
....................       delay_us(20);  
011C:  MOVLW  06
011D:  MOVWF  0C
011E:  DECFSZ 0C,F
011F:  GOTO   11E
0120:  NOP
....................       #ENDIF  
....................    }  
0121:  INCF   1F,F
0122:  GOTO   103
....................   
....................    return FALSE;  
0123:  MOVLW  00
0124:  MOVWF  0D
0125:  RETLW  00
.................... }  
....................   
....................   
.................... // Prijme datovy ramec  
.................... // Pokud nastane chyba vraci kod chyby  
.................... int8 prijmi_ramec(int8* kanal, int8* data)  
.................... {  
....................    int8 datovy;  
....................    int8 suma;  
....................   
....................    // Cekej na synchronizacni nibble  
....................    do  
....................    {  
....................       if (prijmi_nibble(&datovy, data)) return 1;     // chyba timout  
0126:  MOVLW  1B
0127:  MOVWF  1D
0128:  MOVF   1A,W
0129:  MOVWF  1E
012A:  CALL   0D8
012B:  MOVF   0D,F
012C:  BTFSC  03.2
012D:  GOTO   131
012E:  MOVLW  01
012F:  MOVWF  0D
0130:  GOTO   181
....................    }  
....................    while(datovy);  
0131:  MOVF   1B,F
0132:  BTFSS  03.2
0133:  GOTO   126
....................   
....................    // Zkontroluj magickou hodnotu  
....................    if (*data != SYNC_NIBBLE) return 2;                // chyba magickeho kodu ramce  
0134:  MOVF   1A,W
0135:  MOVWF  04
0136:  MOVF   00,W
0137:  SUBLW  0F
0138:  BTFSC  03.2
0139:  GOTO   13D
013A:  MOVLW  02
013B:  MOVWF  0D
013C:  GOTO   181
....................   
....................    // Prijmi cislo kanalu  
....................    if (prijmi_nibble(&datovy, kanal)) return 1;      // chyba timeout  
013D:  MOVLW  1B
013E:  MOVWF  1D
013F:  MOVF   19,W
0140:  MOVWF  1E
0141:  CALL   0D8
0142:  MOVF   0D,F
0143:  BTFSC  03.2
0144:  GOTO   148
0145:  MOVLW  01
0146:  MOVWF  0D
0147:  GOTO   181
....................    if (!datovy) return 3;                             // chyba typu nibblu  
0148:  MOVF   1B,F
0149:  BTFSS  03.2
014A:  GOTO   14E
014B:  MOVLW  03
014C:  MOVWF  0D
014D:  GOTO   181
....................   
....................    // Prijmi data  
....................    if (prijmi_nibble(&datovy, data)) return 1;       // chyba timeout  
014E:  MOVLW  1B
014F:  MOVWF  1D
0150:  MOVF   1A,W
0151:  MOVWF  1E
0152:  CALL   0D8
0153:  MOVF   0D,F
0154:  BTFSC  03.2
0155:  GOTO   159
0156:  MOVLW  01
0157:  MOVWF  0D
0158:  GOTO   181
....................    if (!datovy) return 3;                             // chyba typu nibblu  
0159:  MOVF   1B,F
015A:  BTFSS  03.2
015B:  GOTO   15F
015C:  MOVLW  03
015D:  MOVWF  0D
015E:  GOTO   181
....................   
....................    // Prijmi zabezpeceni  
....................    if (prijmi_nibble(&datovy, &suma)) return 1;       // chyba timeout  
015F:  MOVLW  1B
0160:  MOVWF  1D
0161:  MOVLW  1C
0162:  MOVWF  1E
0163:  CALL   0D8
0164:  MOVF   0D,F
0165:  BTFSC  03.2
0166:  GOTO   16A
0167:  MOVLW  01
0168:  MOVWF  0D
0169:  GOTO   181
....................    if (!datovy) return 3;                             // chyba typu nibblu  
016A:  MOVF   1B,F
016B:  BTFSS  03.2
016C:  GOTO   170
016D:  MOVLW  03
016E:  MOVWF  0D
016F:  GOTO   181
....................   
....................    // Zkontroluj kontrolni soucet  
....................    if (((*kanal+*data) & 0b1111) != suma) return 3;     // chyba kontrolniho souctu  
0170:  MOVF   19,W
0171:  MOVWF  04
0172:  MOVF   00,W
0173:  MOVWF  1D
0174:  MOVF   1A,W
0175:  MOVWF  04
0176:  MOVF   00,W
0177:  ADDWF  1D,W
0178:  ANDLW  0F
0179:  SUBWF  1C,W
017A:  BTFSC  03.2
017B:  GOTO   17F
017C:  MOVLW  03
017D:  MOVWF  0D
017E:  GOTO   181
....................   
....................    return 0;  
017F:  MOVLW  00
0180:  MOVWF  0D
0181:  GOTO   1F5 (RETURN)
.................... }  
....................   
....................  
....................   
....................   
....................   
.................... int8     x,y,tlacitka;  
.................... int8     xc,yc;          // pocitadla aktualizace x a y  
.................... int      e1,e2,e3,e4;    // pocitadla chyb - ladici  
....................   
.................... void main()  
.................... {  
*
01C9:  CLRF   04
01CA:  MOVLW  1F
01CB:  ANDWF  03,F
....................    lcd_init();                  // zinicializuj LCD display  
01CC:  GOTO   056
....................    delay_ms(5);  
01CD:  MOVLW  05
01CE:  MOVWF  1C
01CF:  CALL   015
....................    printf(lcd_putc,"Ahoj...");  
*
000C:  BCF    0A.0
000D:  BCF    0A.1
000E:  BCF    0A.2
000F:  ADDWF  02,F
0010:  RETLW  41
0011:  RETLW  68
0012:  RETLW  6F
0013:  RETLW  6A
0014:  RETLW  00
*
01D0:  CLRF   19
01D1:  MOVF   19,W
01D2:  CALL   00C
01D3:  INCF   19,F
01D4:  MOVWF  1B
01D5:  CALL   0A0
01D6:  MOVLW  04
01D7:  SUBWF  19,W
01D8:  BTFSS  03.2
01D9:  GOTO   1D1
01DA:  MOVLW  03
01DB:  MOVWF  1A
01DC:  MOVLW  2E
01DD:  MOVWF  1B
01DE:  CALL   0A0
01DF:  DECFSZ 1A,F
01E0:  GOTO   1DC
....................    delay_ms(300);  
01E1:  MOVLW  02
01E2:  MOVWF  19
01E3:  MOVLW  96
01E4:  MOVWF  1C
01E5:  CALL   015
01E6:  DECFSZ 19,F
01E7:  GOTO   1E3
....................   
....................    x  = 0;  
01E8:  CLRF   0E
....................    y  = 0;  
01E9:  CLRF   0F
....................    xc = 0;  
01EA:  CLRF   11
....................    yc = 0;  
01EB:  CLRF   12
....................    e1 = 0;  
01EC:  CLRF   13
....................    e2 = 0;  
01ED:  CLRF   14
....................    e3 = 0;  
01EE:  CLRF   15
....................    e4 = 0;  
01EF:  CLRF   16
....................   
....................  while (true)  
....................  {  
....................    int8 kanal, data;  
....................   
....................    if (prijmi_ramec(&kanal,&data))  
01F0:  MOVLW  17
01F1:  MOVWF  19
01F2:  MOVLW  18
01F3:  MOVWF  1A
01F4:  GOTO   126
01F5:  MOVF   0D,F
01F6:  BTFSC  03.2
01F7:  GOTO   1FA
....................    e1++;  
01F8:  INCF   13,F
....................    else  
01F9:  GOTO   2AA
....................    {  
....................       switch (kanal)            // rozeskoc se podle adresy osy  
01FA:  MOVLW  01
01FB:  SUBWF  17,W
01FC:  ADDLW  FD
01FD:  BTFSC  03.0
01FE:  GOTO   20C
01FF:  ADDLW  03
0200:  GOTO   2AC
....................       {  
....................       case OSA_X:  
....................          {  
....................             x=data;  
0201:  MOVF   18,W
0202:  MOVWF  0E
....................             xc++;  
0203:  INCF   11,F
....................             break;  
0204:  GOTO   20C
....................          };  
....................       case OSA_Y:  
....................          {  
....................             y=data;  
0205:  MOVF   18,W
0206:  MOVWF  0F
....................             yc++;  
0207:  INCF   12,F
....................             break;  
0208:  GOTO   20C
....................          };  
....................       case TLs:  
....................          {  
....................             tlacitka=data;  
0209:  MOVF   18,W
020A:  MOVWF  10
....................             break;  
020B:  GOTO   20C
....................          };  
....................       };  
*
02AC:  BCF    0A.0
02AD:  BSF    0A.1
02AE:  BCF    0A.2
02AF:  ADDWF  02,F
02B0:  GOTO   201
02B1:  GOTO   205
02B2:  GOTO   209
....................   
....................   
....................       // ladici vypisy  
....................   
....................       lcd_gotoxy(1,1);                       // vytiskni X a Y  
*
020C:  MOVLW  01
020D:  MOVWF  1C
020E:  MOVWF  1D
020F:  CALL   08F
....................       printf(lcd_putc,"X%2U %3U%3U%3U  ", x, xc, e1, e2);  
*
0197:  MOVF   0D,W
0198:  MOVF   19,W
0199:  MOVWF  1B
019A:  MOVLW  64
019B:  MOVWF  1C
019C:  CALL   182
019D:  MOVF   0C,W
019E:  MOVWF  19
019F:  MOVF   0D,W
01A0:  MOVLW  30
01A1:  BTFSS  03.2
01A2:  GOTO   1AA
01A3:  BTFSC  1A.0
01A4:  BSF    1A.3
01A5:  BTFSC  1A.3
01A6:  GOTO   1B0
01A7:  BTFSC  1A.4
01A8:  MOVLW  20
01A9:  GOTO   1AC
01AA:  BCF    1A.3
01AB:  BCF    1A.4
01AC:  ADDWF  0D,F
01AD:  MOVF   0D,W
01AE:  MOVWF  1B
01AF:  CALL   0A0
01B0:  MOVF   19,W
01B1:  MOVWF  1B
01B2:  MOVLW  0A
01B3:  MOVWF  1C
01B4:  CALL   182
01B5:  MOVF   0C,W
01B6:  MOVWF  19
01B7:  MOVF   0D,W
01B8:  MOVLW  30
01B9:  BTFSS  03.2
01BA:  GOTO   1BF
01BB:  BTFSC  1A.3
01BC:  GOTO   1C3
01BD:  BTFSC  1A.4
01BE:  MOVLW  20
01BF:  ADDWF  0D,F
01C0:  MOVF   0D,W
01C1:  MOVWF  1B
01C2:  CALL   0A0
01C3:  MOVLW  30
01C4:  ADDWF  19,F
01C5:  MOVF   19,W
01C6:  MOVWF  1B
01C7:  CALL   0A0
01C8:  RETLW  00
*
0210:  MOVLW  58
0211:  MOVWF  1B
0212:  CALL   0A0
0213:  MOVF   0E,W
0214:  MOVWF  19
0215:  MOVLW  11
0216:  MOVWF  1A
0217:  CALL   197
0218:  MOVLW  20
0219:  MOVWF  1B
021A:  CALL   0A0
021B:  MOVF   11,W
021C:  MOVWF  19
021D:  MOVLW  10
021E:  MOVWF  1A
021F:  CALL   197
0220:  MOVF   13,W
0221:  MOVWF  19
0222:  MOVLW  10
0223:  MOVWF  1A
0224:  CALL   197
0225:  MOVF   14,W
0226:  MOVWF  19
0227:  MOVLW  10
0228:  MOVWF  1A
0229:  CALL   197
022A:  MOVLW  20
022B:  MOVWF  1B
022C:  CALL   0A0
022D:  MOVLW  20
022E:  MOVWF  1B
022F:  CALL   0A0
....................       lcd_gotoxy(1,2);  
0230:  MOVLW  01
0231:  MOVWF  1C
0232:  MOVLW  02
0233:  MOVWF  1D
0234:  CALL   08F
....................       printf(lcd_putc,"Y%2U %3U%3U%3U  ", y, yc, e3, tlacitka);  
0235:  MOVLW  59
0236:  MOVWF  1B
0237:  CALL   0A0
0238:  MOVF   0F,W
0239:  MOVWF  19
023A:  MOVLW  11
023B:  MOVWF  1A
023C:  CALL   197
023D:  MOVLW  20
023E:  MOVWF  1B
023F:  CALL   0A0
0240:  MOVF   12,W
0241:  MOVWF  19
0242:  MOVLW  10
0243:  MOVWF  1A
0244:  CALL   197
0245:  MOVF   15,W
0246:  MOVWF  19
0247:  MOVLW  10
0248:  MOVWF  1A
0249:  CALL   197
024A:  MOVF   10,W
024B:  MOVWF  19
024C:  MOVLW  10
024D:  MOVWF  1A
024E:  CALL   197
024F:  MOVLW  20
0250:  MOVWF  1B
0251:  CALL   0A0
0252:  MOVLW  20
0253:  MOVWF  1B
0254:  CALL   0A0
....................   
....................       // ovladani serv  
....................       output_high(SERVO_X);  
0255:  BSF    03.5
0256:  BCF    05.2
0257:  BCF    03.5
0258:  BSF    05.2
....................       delay_ms(1);  
0259:  MOVLW  01
025A:  MOVWF  1C
025B:  CALL   015
....................       for (data=x; data--; data>0)  
025C:  MOVF   0E,W
025D:  MOVWF  18
025E:  MOVF   18,W
025F:  DECF   18,F
0260:  XORLW  00
0261:  BTFSC  03.2
0262:  GOTO   26D
....................          delay_us(65);  
0263:  MOVLW  15
0264:  MOVWF  0C
0265:  DECFSZ 0C,F
0266:  GOTO   265
0267:  NOP
0268:  MOVF   18,F
0269:  BTFSS  03.2
026A:  GOTO   26C
026B:  MOVLW  00
026C:  GOTO   25E
....................       output_low(SERVO_X);  
026D:  BSF    03.5
026E:  BCF    05.2
026F:  BCF    03.5
0270:  BCF    05.2
....................   
....................       output_high(SERVO_Y);  
0271:  BSF    03.5
0272:  BCF    06.0
0273:  BCF    03.5
0274:  BSF    06.0
....................       delay_ms(1);  
0275:  MOVLW  01
0276:  MOVWF  1C
0277:  CALL   015
....................       for (data=y; data--; data>0)  
0278:  MOVF   0F,W
0279:  MOVWF  18
027A:  MOVF   18,W
027B:  DECF   18,F
027C:  XORLW  00
027D:  BTFSC  03.2
027E:  GOTO   289
....................          delay_us(65);  
027F:  MOVLW  15
0280:  MOVWF  0C
0281:  DECFSZ 0C,F
0282:  GOTO   281
0283:  NOP
0284:  MOVF   18,F
0285:  BTFSS  03.2
0286:  GOTO   288
0287:  MOVLW  00
0288:  GOTO   27A
....................       output_low(SERVO_Y);  
0289:  BSF    03.5
028A:  BCF    06.0
028B:  BCF    03.5
028C:  BCF    06.0
....................   
....................       for (data=30-x-y; data--; data>0)  
028D:  MOVF   0E,W
028E:  SUBLW  1E
028F:  MOVWF  0D
0290:  MOVF   0F,W
0291:  SUBWF  0D,W
0292:  MOVWF  18
0293:  MOVF   18,W
0294:  DECF   18,F
0295:  XORLW  00
0296:  BTFSC  03.2
0297:  GOTO   2A2
....................          delay_us(65);  
0298:  MOVLW  15
0299:  MOVWF  0C
029A:  DECFSZ 0C,F
029B:  GOTO   29A
029C:  NOP
029D:  MOVF   18,F
029E:  BTFSS  03.2
029F:  GOTO   2A1
02A0:  MOVLW  00
02A1:  GOTO   293
....................   
....................       // Vystupy tlacitek  
....................   
.................... //      if (bit_test(tlacitka,1)) output_high(pin_A2); else output_low(pin_A2);  
....................       output_bit(PIN_A2,bit_test(tlacitka,1));  
02A2:  BTFSC  10.1
02A3:  GOTO   2A6
02A4:  BCF    05.2
02A5:  GOTO   2A7
02A6:  BSF    05.2
02A7:  BSF    03.5
02A8:  BCF    05.2
02A9:  BCF    03.5
....................     }  
....................  }  
02AA:  GOTO   1F0
.................... }  
....................   
02AB:  SLEEP
....................   
....................