WebSVN – svnkaklik – /schemata/prenos/letadlo/SW/vysilac/main.LST

CCS PCW C Compiler, Version 3.110, 15448

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

               ROM used: 1542 (38%)
                         Largest free fragment is 2048
               RAM used: 22 (11%) at main() level
                         40 (21%) worst case
               Stack:    5 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   5C1
0003:  NOP
....................  // Vysilac  
....................   
.................... #include "main.h" 
....................  #include <16F873.h> 
....................  //////// Standard Header file for the PIC16F873 device ////////////////  
.................... #device PIC16F873  
.................... #list  
....................  
.................... #use delay(clock=4000000)  
*
0077:  MOVLW  3F
0078:  MOVWF  04
0079:  MOVF   00,W
007A:  BTFSC  03.2
007B:  GOTO   08B
007C:  MOVLW  01
007D:  MOVWF  21
007E:  CLRF   20
007F:  DECFSZ 20,F
0080:  GOTO   07F
0081:  DECFSZ 21,F
0082:  GOTO   07E
0083:  MOVLW  4A
0084:  MOVWF  20
0085:  DECFSZ 20,F
0086:  GOTO   085
0087:  NOP
0088:  NOP
0089:  DECFSZ 00,F
008A:  GOTO   07C
008B:  RETLW  00
*
0321:  MOVLW  3A
0322:  MOVWF  04
0323:  MOVLW  FC
0324:  ANDWF  00,F
0325:  RRF    00,F
0326:  RRF    00,F
0327:  MOVF   00,W
0328:  BTFSC  03.2
0329:  GOTO   32E
032A:  GOTO   32C
032B:  NOP
032C:  DECFSZ 00,F
032D:  GOTO   32B
032E:  BCF    0A.3
032F:  GOTO   545 (RETURN)
.................... #fuses XT,PUT,NOWDT  
....................   
....................  
.................... #include "..\common.h" 
....................  #DEFINE  OSA_X          1           // adresy os  
.................... #DEFINE  OSA_Y          2  
.................... #DEFINE  OSA_Z          3  
.................... #DEFINE  OSA_W          4  
.................... #DEFINE  TLs            5  
.................... #DEFINE  Trim           6           // ovladani prijimace  
....................   
.................... #DEFINE  IMPULS         250         // sirka impulsu  
.................... #DEFINE  SYNC           15          // delka uvodniho ticha v IMPULS/4  
....................  
.................... //Displej  
.................... #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  
*
008C:  MOVF   06,W
008D:  ANDLW  0F
008E:  MOVWF  46
008F:  SWAPF  45,W
0090:  MOVWF  20
0091:  MOVLW  F0
0092:  ANDWF  20,F
0093:  MOVF   20,W
0094:  ANDLW  F0
0095:  IORWF  46,W
0096:  MOVWF  06
....................    output_bit(LCD_E,1);       // vzestupna hrana  
0097:  BSF    06.2
0098:  BSF    03.5
0099:  BCF    06.2
....................    delay_us(1);               // pockej alespon 450ns od e nebo alespon 195ns od dat  
009A:  NOP
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us)  
009B:  BCF    03.5
009C:  BCF    06.2
009D:  BSF    03.5
009E:  BCF    06.2
009F:  BCF    03.5
00A0:  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  
00A1:  MOVF   43,F
00A2:  BTFSS  03.2
00A3:  GOTO   0A6
00A4:  BCF    06.1
00A5:  GOTO   0A7
00A6:  BSF    06.1
00A7:  BSF    03.5
00A8:  BCF    06.1
....................    swap(n);  
00A9:  BCF    03.5
00AA:  SWAPF  44,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu  
00AB:  MOVF   44,W
00AC:  MOVWF  45
00AD:  CALL   08C
....................    swap(n);  
00AE:  SWAPF  44,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu  
00AF:  MOVF   44,W
00B0:  MOVWF  45
00B1:  CALL   08C
....................    delay_us(40);              // minimalni doba na provedeni prikazu  
00B2:  MOVLW  0D
00B3:  MOVWF  20
00B4:  DECFSZ 20,F
00B5:  GOTO   0B4
00B6:  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  
00B7:  MOVLW  14
00B8:  MOVWF  3F
00B9:  CALL   077
....................   
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD  
00BA:  MOVLW  0F
00BB:  BSF    03.5
00BC:  ANDWF  06,F
....................   
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav  
00BD:  BCF    03.5
00BE:  BCF    06.1
00BF:  BSF    03.5
00C0:  BCF    06.1
....................    output_bit(LCD_E,0);               // nastav jako vystup a nastav klidovy stav  
00C1:  BCF    03.5
00C2:  BCF    06.2
00C3:  BSF    03.5
00C4:  BCF    06.2
....................   
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice  
00C5:  BCF    03.5
00C6:  CLRF   36
00C7:  MOVF   36,W
00C8:  SUBLW  02
00C9:  BTFSS  03.0
00CA:  GOTO   0D3
....................    {  
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel  
00CB:  MOVLW  02
00CC:  MOVWF  3F
00CD:  CALL   077
....................       lcd_send_nibble(3);              // rezim 8 bitu  
00CE:  MOVLW  03
00CF:  MOVWF  45
00D0:  CALL   08C
....................    }  
00D1:  INCF   36,F
00D2:  GOTO   0C7
....................   
....................    delay_us(40);                       // cas na zpracovani  
00D3:  MOVLW  0D
00D4:  MOVWF  20
00D5:  DECFSZ 20,F
00D6:  GOTO   0D5
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu)  
00D7:  MOVLW  02
00D8:  MOVWF  45
00D9:  CALL   08C
....................    delay_us(40);                       // cas na zpracovani  
00DA:  MOVLW  0D
00DB:  MOVWF  20
00DC:  DECFSZ 20,F
00DD:  GOTO   0DC
....................   
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod)  
00DE:  CLRF   36
00DF:  MOVF   36,W
00E0:  SUBLW  02
00E1:  BTFSS  03.0
00E2:  GOTO   0EF
....................    {  
....................       lcd_send_byte(0,LCD_INIT_STRING[i]);  
00E3:  MOVF   36,W
00E4:  CALL   004
00E5:  MOVWF  37
00E6:  CLRF   43
00E7:  MOVF   37,W
00E8:  MOVWF  44
00E9:  CALL   0A1
....................       delay_ms(2);  
00EA:  MOVLW  02
00EB:  MOVWF  3F
00EC:  CALL   077
....................    }  
00ED:  INCF   36,F
00EE:  GOTO   0DF
00EF:  BCF    0A.3
00F0:  GOTO   602 (RETURN)
.................... }  
....................   
....................   
.................... // Proved presun kurzoru  
.................... //  
.................... // Pozice 1.1 je domu  
.................... //  
.................... void lcd_gotoxy( BYTE x, BYTE y)  
.................... {  
....................   
....................    BYTE Adr;  
....................   
....................    Adr=x-1;  
*
0227:  MOVLW  01
0228:  SUBWF  3F,W
0229:  MOVWF  41
....................    if(y==2)  
022A:  MOVF   40,W
022B:  SUBLW  02
022C:  BTFSS  03.2
022D:  GOTO   230
....................      Adr+=LCD_LINE_2;  
022E:  MOVLW  40
022F:  ADDWF  41,F
....................   
....................    lcd_send_byte(0,0x80|Adr);  
0230:  MOVF   41,W
0231:  IORLW  80
0232:  MOVWF  42
0233:  CLRF   43
0234:  MOVF   42,W
0235:  MOVWF  44
0236:  CALL   0A1
0237:  RETLW  00
.................... }  
....................   
....................   
.................... // Zapis znaku na displej, zpracovani ridicich znaku  
.................... //  
.................... void lcd_putc( char c)  
.................... {  
....................   
....................    switch (c)  
0238:  MOVF   3E,W
0239:  MOVWF  20
023A:  MOVLW  0C
023B:  SUBWF  20,W
023C:  BTFSC  03.2
023D:  GOTO   24B
023E:  MOVLW  0A
023F:  SUBWF  20,W
0240:  BTFSC  03.2
0241:  GOTO   253
0242:  MOVLW  0D
0243:  SUBWF  20,W
0244:  BTFSC  03.2
0245:  GOTO   259
0246:  MOVLW  08
0247:  SUBWF  20,W
0248:  BTFSC  03.2
0249:  GOTO   25E
024A:  GOTO   263
....................    {  
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej  
024B:  CLRF   43
024C:  MOVLW  01
024D:  MOVWF  44
024E:  CALL   0A1
....................                     delay_ms(2);  
024F:  MOVLW  02
0250:  MOVWF  3F
0251:  CALL   077
....................                                             break;  
0252:  GOTO   26F
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky  
0253:  MOVLW  01
0254:  MOVWF  3F
0255:  MOVLW  02
0256:  MOVWF  40
0257:  CALL   227
0258:  GOTO   26F
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home  
0259:  MOVLW  01
025A:  MOVWF  3F
025B:  MOVWF  40
025C:  CALL   227
025D:  GOTO   26F
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet  
025E:  CLRF   43
025F:  MOVLW  10
0260:  MOVWF  44
0261:  CALL   0A1
0262:  GOTO   26F
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F  
0263:  MOVF   3E,W
0264:  SUBLW  1F
0265:  BTFSS  03.0
0266:  GOTO   269
0267:  MOVLW  07
0268:  ANDWF  3E,F
....................                     lcd_send_byte(1,c);     break; // zapis znak  
0269:  MOVLW  01
026A:  MOVWF  43
026B:  MOVF   3E,W
026C:  MOVWF  44
026D:  CALL   0A1
026E:  GOTO   26F
....................    }  
026F:  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);  
.................... //}  
....................  
.................... #INCLUDE "lcd2.c" 
....................  #define  LCD_SC     0b0000011000     // posun displeje doleva  
.................... #define  RIGHT      1  
.................... #define  LEFT       0  
....................   
.................... void lcd_sh(int1 lr)  
.................... {  
....................    if (lr) lcd_send_byte(0,LCD_SC | 0x100); else lcd_send_byte(0,LCD_SC);  
.................... }  
....................  
.................... //Klavesnice  
.................... #DEFINE  PL             PIN_B3              // ovladani klavesnice  
.................... #DEFINE  STROBE_LED     PIN_C0  
.................... #DEFINE  STROBE_KL      PIN_C1  
.................... #DEFINE  DATA_OUT       PIN_C2  
.................... #DEFINE  CP             PIN_C3  
.................... #DEFINE  DATA_IN        PIN_C4  
.................... #INCLUDE "keybord.c" 
....................  //#DEFINE  PL             PIN_B3              // ovladani klavesnice  
.................... //#DEFINE  STROBE_LED     PIN_C0  
.................... //#DEFINE  STROBE_KL      PIN_C1  
.................... //#DEFINE  DATA_OUT       PIN_C2  
.................... //#DEFINE  CP             PIN_C3  
.................... //#DEFINE  DATA_IN        PIN_C4  
....................   
.................... #DEFINE  znak_0     14  
.................... #DEFINE  znak_1     10  
.................... #DEFINE  znak_2     11  
.................... #DEFINE  znak_3     12  
.................... #DEFINE  znak_4     20  
.................... #DEFINE  znak_5     21  
.................... #DEFINE  znak_6     22  
.................... #DEFINE  znak_7     04  
.................... #DEFINE  znak_8     05  
.................... #DEFINE  znak_9     06  
.................... #DEFINE  znak_R     15  
.................... #DEFINE  znak_F     16  
.................... #DEFINE  znak_C     27  
.................... #DEFINE  nic        80  
....................   
....................   
.................... void KL_init()  
.................... {  
.................... int8 i;  
....................    output_high(STROBE_KL);  
*
00F1:  BCF    25.1
00F2:  MOVF   25,W
00F3:  BSF    03.5
00F4:  MOVWF  07
00F5:  BCF    03.5
00F6:  BSF    07.1
....................    output_high(STROBE_LED);  
00F7:  BCF    25.0
00F8:  MOVF   25,W
00F9:  BSF    03.5
00FA:  MOVWF  07
00FB:  BCF    03.5
00FC:  BSF    07.0
....................   
....................    for (i=0;i<=7;i++)  
00FD:  CLRF   36
00FE:  MOVF   36,W
00FF:  SUBLW  07
0100:  BTFSS  03.0
0101:  GOTO   116
....................    {  
....................       output_low(DATA_IN);  
0102:  BCF    25.4
0103:  MOVF   25,W
0104:  BSF    03.5
0105:  MOVWF  07
0106:  BCF    03.5
0107:  BCF    07.4
....................       output_high(CP);  
0108:  BCF    25.3
0109:  MOVF   25,W
010A:  BSF    03.5
010B:  MOVWF  07
010C:  BCF    03.5
010D:  BSF    07.3
....................       output_low(CP);  
010E:  BCF    25.3
010F:  MOVF   25,W
0110:  BSF    03.5
0111:  MOVWF  07
0112:  BCF    03.5
0113:  BCF    07.3
....................    }  
0114:  INCF   36,F
0115:  GOTO   0FE
....................    output_low(STROBE_KL);  
0116:  BCF    25.1
0117:  MOVF   25,W
0118:  BSF    03.5
0119:  MOVWF  07
011A:  BCF    03.5
011B:  BCF    07.1
....................    output_low(STROBE_LED);  
011C:  BCF    25.0
011D:  MOVF   25,W
011E:  BSF    03.5
011F:  MOVWF  07
0120:  BCF    03.5
0121:  BCF    07.0
....................    output_high(CP);  
0122:  BCF    25.3
0123:  MOVF   25,W
0124:  BSF    03.5
0125:  MOVWF  07
0126:  BCF    03.5
0127:  BSF    07.3
....................    output_high(PL);  
0128:  BSF    03.5
0129:  BCF    06.3
012A:  BCF    03.5
012B:  BSF    06.3
012C:  BCF    0A.3
012D:  GOTO   603 (RETURN)
.................... }  
....................   
.................... void KL_CP(j)  
.................... {  
.................... int8 i;  
....................    for (i=0;i<=j;i++)  
....................    {  
....................       output_high(CP);  
....................       output_low(CP);  
....................    }  
.................... }  
....................   
.................... void LED(int8 LED)      //rosviti LED 1-7  
.................... {  
.................... int i;  
....................    output_low(CP);  
*
01E7:  BCF    25.3
01E8:  MOVF   25,W
01E9:  BSF    03.5
01EA:  MOVWF  07
01EB:  BCF    03.5
01EC:  BCF    07.3
....................    output_low(STROBE_LED);  
01ED:  BCF    25.0
01EE:  MOVF   25,W
01EF:  BSF    03.5
01F0:  MOVWF  07
01F1:  BCF    03.5
01F2:  BCF    07.0
....................    for (i=0;i<=7;i++)  
01F3:  CLRF   3C
01F4:  MOVF   3C,W
01F5:  SUBLW  07
01F6:  BTFSS  03.0
01F7:  GOTO   21A
....................    {  
....................       output_bit(DATA_IN,bit_test(LED,i));  
01F8:  MOVF   3B,W
01F9:  MOVWF  20
01FA:  MOVF   3C,W
01FB:  MOVWF  21
01FC:  BTFSC  03.2
01FD:  GOTO   202
01FE:  BCF    03.0
01FF:  RRF    20,F
0200:  DECFSZ 21,F
0201:  GOTO   1FE
0202:  BTFSC  20.0
0203:  GOTO   206
0204:  BCF    07.4
0205:  GOTO   207
0206:  BSF    07.4
0207:  BCF    25.4
0208:  MOVF   25,W
0209:  BSF    03.5
020A:  MOVWF  07
....................       output_high(CP);  
020B:  BCF    03.5
020C:  BCF    25.3
020D:  MOVF   25,W
020E:  BSF    03.5
020F:  MOVWF  07
0210:  BCF    03.5
0211:  BSF    07.3
....................       output_low(CP);  
0212:  BCF    25.3
0213:  MOVF   25,W
0214:  BSF    03.5
0215:  MOVWF  07
0216:  BCF    03.5
0217:  BCF    07.3
....................    };  
0218:  INCF   3C,F
0219:  GOTO   1F4
....................    output_high(STROBE_LED);  
021A:  BCF    25.0
021B:  MOVF   25,W
021C:  BSF    03.5
021D:  MOVWF  07
021E:  BCF    03.5
021F:  BSF    07.0
....................    output_low(STROBE_LED);  
0220:  BCF    25.0
0221:  MOVF   25,W
0222:  BSF    03.5
0223:  MOVWF  07
0224:  BCF    03.5
0225:  BCF    07.0
0226:  RETLW  00
.................... }  
....................   
.................... int8 klavesa()          //vrati cislo klavesy  
.................... {  
....................    int8 i;  
....................    int8 sloupec;  
....................   
....................    for(sloupec=0; sloupec<=7; sloupec++)  
*
012E:  CLRF   3E
012F:  MOVF   3E,W
0130:  SUBLW  07
0131:  BTFSS  03.0
0132:  GOTO   1E4
....................    {  
....................       output_low(STROBE_KL);  
0133:  BCF    25.1
0134:  MOVF   25,W
0135:  BSF    03.5
0136:  MOVWF  07
0137:  BCF    03.5
0138:  BCF    07.1
....................       output_low(DATA_IN);  
0139:  BCF    25.4
013A:  MOVF   25,W
013B:  BSF    03.5
013C:  MOVWF  07
013D:  BCF    03.5
013E:  BCF    07.4
....................       for (i=0;i<=7;i++)  
013F:  CLRF   3D
0140:  MOVF   3D,W
0141:  SUBLW  07
0142:  BTFSS  03.0
0143:  GOTO   152
....................       {                                   //nulovani sloupcu  
....................         output_high(CP);  
0144:  BCF    25.3
0145:  MOVF   25,W
0146:  BSF    03.5
0147:  MOVWF  07
0148:  BCF    03.5
0149:  BSF    07.3
....................         output_low(CP);  
014A:  BCF    25.3
014B:  MOVF   25,W
014C:  BSF    03.5
014D:  MOVWF  07
014E:  BCF    03.5
014F:  BCF    07.3
....................       }  
0150:  INCF   3D,F
0151:  GOTO   140
....................   
....................       output_high(DATA_IN);  
0152:  BCF    25.4
0153:  MOVF   25,W
0154:  BSF    03.5
0155:  MOVWF  07
0156:  BCF    03.5
0157:  BSF    07.4
....................       output_high(CP);                    //zavedeni 1 do registru sloupcu  
0158:  BCF    25.3
0159:  MOVF   25,W
015A:  BSF    03.5
015B:  MOVWF  07
015C:  BCF    03.5
015D:  BSF    07.3
....................       output_low(CP);  
015E:  BCF    25.3
015F:  MOVF   25,W
0160:  BSF    03.5
0161:  MOVWF  07
0162:  BCF    03.5
0163:  BCF    07.3
....................   
....................       output_low(DATA_IN);  
0164:  BCF    25.4
0165:  MOVF   25,W
0166:  BSF    03.5
0167:  MOVWF  07
0168:  BCF    03.5
0169:  BCF    07.4
....................       for (i=0;i<sloupec;i++)            //nastaveni sloupce  
016A:  CLRF   3D
016B:  MOVF   3E,W
016C:  SUBWF  3D,W
016D:  BTFSC  03.0
016E:  GOTO   17D
....................       {  
....................         output_high(CP);  
016F:  BCF    25.3
0170:  MOVF   25,W
0171:  BSF    03.5
0172:  MOVWF  07
0173:  BCF    03.5
0174:  BSF    07.3
....................         output_low(CP);  
0175:  BCF    25.3
0176:  MOVF   25,W
0177:  BSF    03.5
0178:  MOVWF  07
0179:  BCF    03.5
017A:  BCF    07.3
....................       }  
017B:  INCF   3D,F
017C:  GOTO   16B
....................   
....................       output_high(STROBE_KL);  
017D:  BCF    25.1
017E:  MOVF   25,W
017F:  BSF    03.5
0180:  MOVWF  07
0181:  BCF    03.5
0182:  BSF    07.1
....................       output_low(PL);  
0183:  BSF    03.5
0184:  BCF    06.3
0185:  BCF    03.5
0186:  BCF    06.3
....................       output_high(PL);  
0187:  BSF    03.5
0188:  BCF    06.3
0189:  BCF    03.5
018A:  BSF    06.3
....................   
....................       for (i=0;i<5;i++)                  //posunuti cteciho registru  
018B:  CLRF   3D
018C:  MOVF   3D,W
018D:  SUBLW  04
018E:  BTFSS  03.0
018F:  GOTO   19E
....................       {  
....................         output_high(CP);  
0190:  BCF    25.3
0191:  MOVF   25,W
0192:  BSF    03.5
0193:  MOVWF  07
0194:  BCF    03.5
0195:  BSF    07.3
....................         output_low(CP);  
0196:  BCF    25.3
0197:  MOVF   25,W
0198:  BSF    03.5
0199:  MOVWF  07
019A:  BCF    03.5
019B:  BCF    07.3
....................       }  
019C:  INCF   3D,F
019D:  GOTO   18C
....................   
....................      /* if (1==input(DATA_OUT)) return(sloupec);           // pokud je 4. radek  
....................       output_high(CP);  
....................       output_low(CP);  
....................       if (1==input(DATA_OUT)) return(sloupec);           // pokud je 3. radek  
....................       output_high(CP);  
....................       output_low(CP);*/  
....................       if (1==input(DATA_OUT)) return(sloupec);           // pokud je 0. radek  
019E:  BSF    25.2
019F:  MOVF   25,W
01A0:  BSF    03.5
01A1:  MOVWF  07
01A2:  MOVLW  00
01A3:  BCF    03.5
01A4:  BTFSC  07.2
01A5:  MOVLW  01
01A6:  SUBLW  01
01A7:  BTFSS  03.2
01A8:  GOTO   1AC
01A9:  MOVF   3E,W
01AA:  MOVWF  21
01AB:  GOTO   1E6
....................       output_high(CP);  
01AC:  BCF    25.3
01AD:  MOVF   25,W
01AE:  BSF    03.5
01AF:  MOVWF  07
01B0:  BCF    03.5
01B1:  BSF    07.3
....................       output_low(CP);  
01B2:  BCF    25.3
01B3:  MOVF   25,W
01B4:  BSF    03.5
01B5:  MOVWF  07
01B6:  BCF    03.5
01B7:  BCF    07.3
....................       if (1==input(DATA_OUT)) return(0b1000 | sloupec);  // pokud je 1. radek  
01B8:  BSF    25.2
01B9:  MOVF   25,W
01BA:  BSF    03.5
01BB:  MOVWF  07
01BC:  MOVLW  00
01BD:  BCF    03.5
01BE:  BTFSC  07.2
01BF:  MOVLW  01
01C0:  SUBLW  01
01C1:  BTFSS  03.2
01C2:  GOTO   1C7
01C3:  MOVF   3E,W
01C4:  IORLW  08
01C5:  MOVWF  21
01C6:  GOTO   1E6
....................       output_high(CP);  
01C7:  BCF    25.3
01C8:  MOVF   25,W
01C9:  BSF    03.5
01CA:  MOVWF  07
01CB:  BCF    03.5
01CC:  BSF    07.3
....................       output_low(CP);  
01CD:  BCF    25.3
01CE:  MOVF   25,W
01CF:  BSF    03.5
01D0:  MOVWF  07
01D1:  BCF    03.5
01D2:  BCF    07.3
....................       if (1==input(DATA_OUT)) return(0b10000 | sloupec); // pokud je 2. radek  
01D3:  BSF    25.2
01D4:  MOVF   25,W
01D5:  BSF    03.5
01D6:  MOVWF  07
01D7:  MOVLW  00
01D8:  BCF    03.5
01D9:  BTFSC  07.2
01DA:  MOVLW  01
01DB:  SUBLW  01
01DC:  BTFSS  03.2
01DD:  GOTO   1E2
01DE:  MOVF   3E,W
01DF:  IORLW  10
01E0:  MOVWF  21
01E1:  GOTO   1E6
....................   
....................   
....................    }  
01E2:  INCF   3E,F
01E3:  GOTO   12F
....................    return(0x80);  // nastavy nejvissi bit, ze neni nic zmacknuto  
01E4:  MOVLW  80
01E5:  MOVWF  21
01E6:  RETLW  00
.................... }  
....................   
.................... boolean read_KL(char *klv)  
.................... {  
....................    const char prev_tabulka[24]={'i','z','m','u','7','8','9','.','1','2','3','b','0','r','f','k','4','5','6','s',' ',' ','t','c'};  
....................   
....................    *klv = klavesa();  
....................    if (0x80==*klv) return(false);  
....................    else  
....................    {  
....................       *klv = prev_tabulka[*klv];  
....................       return(true);  
....................    }  
.................... }  
....................   
....................  
.................... //Vysilac  
.................... #DEFINE  VYSILAC        PIN_C5  
.................... #INCLUDE "vysilac.c" 
....................  // Odesle nulu nebo jednicku podle nejnizsiho bitu predanych dat  
.................... // Nula je posloupnost LH a jednicka je HL  
.................... void odeslat_bit(int bit)  
.................... {  
....................    output_bit(VYSILAC,bit);  
*
02C9:  MOVF   3E,F
02CA:  BTFSS  03.2
02CB:  GOTO   2CE
02CC:  BCF    07.5
02CD:  GOTO   2CF
02CE:  BSF    07.5
02CF:  BCF    25.5
02D0:  MOVF   25,W
02D1:  BSF    03.5
02D2:  MOVWF  07
....................    delay_us(IMPULS);  
02D3:  MOVLW  53
02D4:  BCF    03.5
02D5:  MOVWF  20
02D6:  DECFSZ 20,F
02D7:  GOTO   2D6
....................    output_bit(VYSILAC,!bit);  
02D8:  MOVF   3E,F
02D9:  BTFSC  03.2
02DA:  GOTO   2DD
02DB:  BCF    07.5
02DC:  GOTO   2DE
02DD:  BSF    07.5
02DE:  BCF    25.5
02DF:  MOVF   25,W
02E0:  BSF    03.5
02E1:  MOVWF  07
....................    delay_us(IMPULS);  
02E2:  MOVLW  53
02E3:  BCF    03.5
02E4:  MOVWF  20
02E5:  DECFSZ 20,F
02E6:  GOTO   2E5
02E7:  RETLW  00
.................... }  
....................   
.................... // odesle datovy ramec  
.................... void odeslat_paket(int8 kanal,int8 data)  
.................... {  
....................    int   i;  
....................    int8 suma;  
....................   
....................   
....................    data &= 0x1F;     // pro jistotu orizneme data, kdyby nekdo chtel prenaset vic poloh  
02E8:  MOVLW  1F
02E9:  ANDWF  3A,F
....................    data |= kanal << 5;    // slozi osu a hodnotu do packetu  
02EA:  SWAPF  39,W
02EB:  MOVWF  20
02EC:  RLF    20,F
02ED:  MOVLW  E0
02EE:  ANDWF  20,F
02EF:  MOVF   20,W
02F0:  IORWF  3A,F
....................   
....................    swap(data);          // vypocet kontrolniho souctu  
02F1:  SWAPF  3A,F
....................    suma = data & 0xF;     
02F2:  MOVF   3A,W
02F3:  ANDLW  0F
02F4:  MOVWF  3C
....................    swap(data);  
02F5:  SWAPF  3A,F
....................    suma += data & 0xF;  
02F6:  MOVF   3A,W
02F7:  ANDLW  0F
02F8:  ADDWF  3C,F
....................    suma++;  
02F9:  INCF   3C,F
....................   
....................    odeslat_bit(0);         // start bit  
02FA:  CLRF   3E
02FB:  CALL   2C9
....................   
....................    for (i=8; i>0; i--)     // data  
02FC:  MOVLW  08
02FD:  MOVWF  3B
02FE:  MOVF   3B,F
02FF:  BTFSC  03.2
0300:  GOTO   30B
....................    {  
....................       odeslat_bit(bit_test(data,7));  
0301:  MOVLW  00
0302:  BTFSC  3A.7
0303:  MOVLW  01
0304:  MOVWF  3D
0305:  MOVWF  3E
0306:  CALL   2C9
....................       data <<= 1;  
0307:  BCF    03.0
0308:  RLF    3A,F
....................    }  
0309:  DECF   3B,F
030A:  GOTO   2FE
....................   
....................    for (i=4; i>0; i--)     // checksum  
030B:  MOVLW  04
030C:  MOVWF  3B
030D:  MOVF   3B,F
030E:  BTFSC  03.2
030F:  GOTO   31A
....................    {  
....................       odeslat_bit(bit_test(suma,3));  
0310:  MOVLW  00
0311:  BTFSC  3C.3
0312:  MOVLW  01
0313:  MOVWF  3D
0314:  MOVWF  3E
0315:  CALL   2C9
....................       suma <<= 1;  
0316:  BCF    03.0
0317:  RLF    3C,F
....................    }  
0318:  DECF   3B,F
0319:  GOTO   30D
....................    output_high(VYSILAC);  
031A:  BCF    25.5
031B:  MOVF   25,W
031C:  BSF    03.5
031D:  MOVWF  07
031E:  BCF    03.5
031F:  BSF    07.5
0320:  RETLW  00
....................   
.................... }  
....................   
....................  
.................... //Joistick  
.................... #DEFINE  EEleve_x           0  
.................... #DEFINE  EEprave_x          1          //adresovani EEPROM  
.................... #DEFINE  EEhorni_y          2  
.................... #DEFINE  EEdolni_y          3  
....................   
.................... #DEFINE  EEmin_x            4  
.................... #DEFINE  EEmax_x            5  
.................... #DEFINE  EEmin_y            6  
.................... #DEFINE  EEmax_y            7  
.................... #DEFINE  EEstred_x          8  
.................... #DEFINE  EEstred_y          9  
....................   
.................... #DEFINE  AD_OSA_X          1           // adresa A/D prevodniku pro osu X  
.................... #DEFINE  AD_OSA_Y          0           // adresa A/D prevodniku pro osu Y  
.................... #DEFINE  TL1            PIN_C6  
.................... #DEFINE  TL2            PIN_C7  
.................... #INCLUDE "Joystick.c" 
....................  //#DEFINE  AD_OSA_X          0           // adresa A/D prevodniku pro osu X  
.................... //#DEFINE  AD_OSA_Y          1           // adresa A/D prevodniku pro osu Y  
.................... //#DEFINE  TL1           PIN_A2          // tlacitka  
.................... //#DEFINE  TL2           PIN_A4  
....................   
.................... //#DEFINE  EEleve_x           0  
.................... //#DEFINE  EEprave_x          1          //adresovani EEPROM  
.................... //#DEFINE  EEhorni_y          2  
.................... //#DEFINE  EEdolni_y          3  
....................   
.................... //#DEFINE  EEmin_x            4          // ulozeni hodnot (adresy)  
.................... //#DEFINE  EEmax_x            5  
.................... //#DEFINE  EEmin_y            6  
.................... //#DEFINE  EEmax_y            7  
.................... //#DEFINE  EEstred_x          8  
.................... //#DEFINE  EEstred_y          9  
....................   
....................   
.................... unsigned int min_x;  
.................... unsigned int max_x;  
.................... unsigned int min_y;  
.................... unsigned int max_y;  
.................... unsigned int stred_x;  
.................... unsigned int stred_y;  
.................... unsigned int leve_x;  
.................... unsigned int prave_x;  
.................... unsigned int horni_y;  
.................... unsigned int dolni_y;  
....................   
....................   
.................... /*#DEFINE  TEXT0    "Joy set to cent"  
.................... #DEFINE  TEXT1    "er and press OK"  
.................... #DEFINE  TEXT2    "Joy move in some "  
.................... #DEFINE  TEXT3    "full circle"  
.................... #DEFINE  TEXT4    "Calib. complete"*/  
....................   
.................... #DEFINE  TEXT0    " Dejte paku do "  
.................... #DEFINE  TEXT1    "prostred"  
.................... #DEFINE  TEXT2    "Udelajte par"  
.................... #DEFINE  TEXT3    "kruhu"  
.................... #DEFINE  TEXT4    "hotovo"  
....................   
....................   
.................... void Joystick (int *ted_x, int *ted_y, int8 *ted_tl1, int8 *ted_tl2)  
.................... {  
....................    set_adc_channel(AD_OSA_X);  
*
0270:  MOVLW  08
0271:  MOVWF  21
0272:  MOVF   1F,W
0273:  ANDLW  C7
0274:  IORWF  21,W
0275:  MOVWF  1F
....................    delay_us(10);  
0276:  MOVLW  03
0277:  MOVWF  20
0278:  DECFSZ 20,F
0279:  GOTO   278
....................    *ted_x=read_adc();  
027A:  MOVF   3D,W
027B:  MOVWF  04
027C:  BSF    1F.2
027D:  BTFSC  1F.2
027E:  GOTO   27D
027F:  MOVF   1E,W
0280:  MOVWF  00
....................    set_adc_channel(AD_OSA_Y);  
0281:  MOVLW  00
0282:  MOVWF  21
0283:  MOVF   1F,W
0284:  ANDLW  C7
0285:  IORWF  21,W
0286:  MOVWF  1F
....................    delay_us(10);  
0287:  MOVLW  03
0288:  MOVWF  20
0289:  DECFSZ 20,F
028A:  GOTO   289
....................    *ted_y=read_adc();  
028B:  MOVF   3E,W
028C:  MOVWF  04
028D:  BSF    1F.2
028E:  BTFSC  1F.2
028F:  GOTO   28E
0290:  MOVF   1E,W
0291:  MOVWF  00
....................   
....................   
....................  if (!input(TL1))  
0292:  BSF    25.6
0293:  MOVF   25,W
0294:  BSF    03.5
0295:  MOVWF  07
0296:  BCF    03.5
0297:  BTFSC  07.6
0298:  GOTO   2AA
....................   {  
....................   delay_us(500);  
0299:  MOVLW  A6
029A:  MOVWF  20
029B:  DECFSZ 20,F
029C:  GOTO   29B
029D:  NOP
....................   if (!input(TL1)) *ted_tl1=True;  
029E:  BSF    25.6
029F:  MOVF   25,W
02A0:  BSF    03.5
02A1:  MOVWF  07
02A2:  BCF    03.5
02A3:  BTFSC  07.6
02A4:  GOTO   2A9
02A5:  MOVF   3F,W
02A6:  MOVWF  04
02A7:  MOVLW  01
02A8:  MOVWF  00
....................   }  
....................   else *ted_TL1=False;  
02A9:  GOTO   2AD
02AA:  MOVF   3F,W
02AB:  MOVWF  04
02AC:  CLRF   00
....................   
....................  if (!input(TL2))  
02AD:  BSF    25.7
02AE:  MOVF   25,W
02AF:  BSF    03.5
02B0:  MOVWF  07
02B1:  BCF    03.5
02B2:  BTFSC  07.7
02B3:  GOTO   2C5
....................   {  
....................   delay_us(500);  
02B4:  MOVLW  A6
02B5:  MOVWF  20
02B6:  DECFSZ 20,F
02B7:  GOTO   2B6
02B8:  NOP
....................   if (!input(TL2)) *ted_tl2=True;  
02B9:  BSF    25.7
02BA:  MOVF   25,W
02BB:  BSF    03.5
02BC:  MOVWF  07
02BD:  BCF    03.5
02BE:  BTFSC  07.7
02BF:  GOTO   2C4
02C0:  MOVF   40,W
02C1:  MOVWF  04
02C2:  MOVLW  01
02C3:  MOVWF  00
....................   }  
....................   else *ted_tl2=False;  
02C4:  GOTO   2C8
02C5:  MOVF   40,W
02C6:  MOVWF  04
02C7:  CLRF   00
02C8:  RETLW  00
.................... }  
....................   
....................   
....................   
.................... void kalibrace()  
.................... {  
....................   
.................... int  x,y;  
.................... int8 tlac1,tlac2;  
....................   
....................    min_x = max_x = min_y = max_y = stred_x = stred_y = 128;  
*
0367:  MOVLW  80
0368:  MOVWF  2B
0369:  MOVWF  2A
036A:  MOVWF  29
036B:  MOVWF  28
036C:  MOVWF  27
036D:  MOVWF  26
....................   
.................... // ROZSACH JOYSTIKU  
....................    printf(lcd_putc,"\f");  
036E:  MOVLW  0C
036F:  MOVWF  3E
0370:  CALL   238
....................    printf(lcd_putc,TEXT2);  
*
000C:  BCF    0A.0
000D:  BCF    0A.1
000E:  BCF    0A.2
000F:  ADDWF  02,F
0010:  RETLW  55
0011:  RETLW  64
0012:  RETLW  65
0013:  RETLW  6C
0014:  RETLW  61
0015:  RETLW  6A
0016:  RETLW  74
0017:  RETLW  65
0018:  RETLW  20
0019:  RETLW  70
001A:  RETLW  61
001B:  RETLW  72
001C:  RETLW  00
*
0371:  CLRF   3D
0372:  MOVF   3D,W
0373:  CALL   00C
0374:  INCF   3D,F
0375:  MOVWF  3E
0376:  CALL   238
0377:  MOVLW  0C
0378:  SUBWF  3D,W
0379:  BTFSS  03.2
037A:  GOTO   372
....................    lcd_gotoxy(1,2);  
037B:  MOVLW  01
037C:  MOVWF  3F
037D:  MOVLW  02
037E:  MOVWF  40
037F:  CALL   227
....................    printf(lcd_putc,TEXT3);  
*
001D:  BCF    0A.0
001E:  BCF    0A.1
001F:  BCF    0A.2
0020:  ADDWF  02,F
0021:  RETLW  6B
0022:  RETLW  72
0023:  RETLW  75
0024:  RETLW  68
0025:  RETLW  75
0026:  RETLW  00
*
0380:  CLRF   3D
0381:  MOVF   3D,W
0382:  CALL   01D
0383:  INCF   3D,F
0384:  MOVWF  3E
0385:  CALL   238
0386:  MOVLW  05
0387:  SUBWF  3D,W
0388:  BTFSS  03.2
0389:  GOTO   381
....................   
....................    while(input(TL1))  
038A:  BSF    25.6
038B:  MOVF   25,W
038C:  BSF    03.5
038D:  MOVWF  07
038E:  BCF    03.5
038F:  BTFSS  07.6
0390:  GOTO   3B9
....................    {  
....................       if (0x17 == klavesa()) return;         // escape  
0391:  CALL   12E
0392:  MOVF   21,W
0393:  SUBLW  17
0394:  BTFSS  03.2
0395:  GOTO   397
0396:  GOTO   4BD
....................   
....................       Joystick(&x,&y,&tlac1,&tlac2);  
0397:  MOVLW  39
0398:  MOVWF  3D
0399:  MOVLW  3A
039A:  MOVWF  3E
039B:  MOVLW  3B
039C:  MOVWF  3F
039D:  MOVLW  3C
039E:  MOVWF  40
039F:  CALL   270
....................   
....................       if (max_x < x )max_x=x;  
03A0:  MOVF   39,W
03A1:  SUBWF  27,W
03A2:  BTFSC  03.0
03A3:  GOTO   3A6
03A4:  MOVF   39,W
03A5:  MOVWF  27
....................       if (min_x > x )min_x=x;  
03A6:  MOVF   26,W
03A7:  SUBWF  39,W
03A8:  BTFSC  03.0
03A9:  GOTO   3AC
03AA:  MOVF   39,W
03AB:  MOVWF  26
....................       if (max_y < y )max_y=y;                //zjisteni meznich hodnot  
03AC:  MOVF   3A,W
03AD:  SUBWF  29,W
03AE:  BTFSC  03.0
03AF:  GOTO   3B2
03B0:  MOVF   3A,W
03B1:  MOVWF  29
....................       if (min_y > y )min_y=y;  
03B2:  MOVF   28,W
03B3:  SUBWF  3A,W
03B4:  BTFSC  03.0
03B5:  GOTO   3B8
03B6:  MOVF   3A,W
03B7:  MOVWF  28
....................    };  
03B8:  GOTO   38A
....................   
....................    Delay_ms(500);  
03B9:  MOVLW  02
03BA:  MOVWF  3D
03BB:  MOVLW  FA
03BC:  MOVWF  3F
03BD:  CALL   077
03BE:  DECFSZ 3D,F
03BF:  GOTO   3BB
....................    printf(lcd_putc,"\f");  
03C0:  MOVLW  0C
03C1:  MOVWF  3E
03C2:  CALL   238
....................    printf(lcd_putc,TEXT0);  
*
0027:  BCF    0A.0
0028:  BCF    0A.1
0029:  BCF    0A.2
002A:  ADDWF  02,F
002B:  RETLW  20
002C:  RETLW  44
002D:  RETLW  65
002E:  RETLW  6A
002F:  RETLW  74
0030:  RETLW  65
0031:  RETLW  20
0032:  RETLW  70
0033:  RETLW  61
0034:  RETLW  6B
0035:  RETLW  75
0036:  RETLW  20
0037:  RETLW  64
0038:  RETLW  6F
0039:  RETLW  20
003A:  RETLW  00
*
03C3:  CLRF   3D
03C4:  MOVF   3D,W
03C5:  CALL   027
03C6:  INCF   3D,F
03C7:  MOVWF  3E
03C8:  CALL   238
03C9:  MOVLW  0F
03CA:  SUBWF  3D,W
03CB:  BTFSS  03.2
03CC:  GOTO   3C4
....................    lcd_gotoxy(1,2);  
03CD:  MOVLW  01
03CE:  MOVWF  3F
03CF:  MOVLW  02
03D0:  MOVWF  40
03D1:  CALL   227
....................    printf(lcd_putc,TEXT1);  
*
003B:  BCF    0A.0
003C:  BCF    0A.1
003D:  BCF    0A.2
003E:  ADDWF  02,F
003F:  RETLW  70
0040:  RETLW  72
0041:  RETLW  6F
0042:  RETLW  73
0043:  RETLW  74
0044:  RETLW  72
0045:  RETLW  65
0046:  RETLW  64
0047:  RETLW  00
*
03D2:  CLRF   3D
03D3:  MOVF   3D,W
03D4:  CALL   03B
03D5:  INCF   3D,F
03D6:  MOVWF  3E
03D7:  CALL   238
03D8:  MOVLW  08
03D9:  SUBWF  3D,W
03DA:  BTFSS  03.2
03DB:  GOTO   3D3
....................   
....................    while(input(TL1))  
03DC:  BSF    25.6
03DD:  MOVF   25,W
03DE:  BSF    03.5
03DF:  MOVWF  07
03E0:  BCF    03.5
03E1:  BTFSS  07.6
03E2:  GOTO   3ED
....................    joystick(&stred_x,&stred_y,&tlac1,&tlac2);            //nastaveni stredu  
03E3:  MOVLW  2A
03E4:  MOVWF  3D
03E5:  MOVLW  2B
03E6:  MOVWF  3E
03E7:  MOVLW  3B
03E8:  MOVWF  3F
03E9:  MOVLW  3C
03EA:  MOVWF  40
03EB:  CALL   270
03EC:  GOTO   3DC
....................   
....................   
....................   
....................     leve_x=max_x - stred_x;  
03ED:  MOVF   2A,W
03EE:  SUBWF  27,W
03EF:  MOVWF  2C
....................     prave_x=stred_x - min_x;  
03F0:  MOVF   26,W
03F1:  SUBWF  2A,W
03F2:  MOVWF  2D
....................     horni_y=max_y - stred_y;  
03F3:  MOVF   2B,W
03F4:  SUBWF  29,W
03F5:  MOVWF  2E
....................     dolni_y=stred_x - min_x;  
03F6:  MOVF   26,W
03F7:  SUBWF  2A,W
03F8:  MOVWF  2F
....................   
....................     leve_x = leve_x / 8;                     //vypocet parametru  
03F9:  RRF    2C,F
03FA:  RRF    2C,F
03FB:  RRF    2C,F
03FC:  MOVLW  1F
03FD:  ANDWF  2C,F
....................     prave_x = prave_x / 8;  
03FE:  RRF    2D,F
03FF:  RRF    2D,F
0400:  RRF    2D,F
0401:  ANDWF  2D,F
....................     horni_y = horni_y / 8;  
0402:  RRF    2E,F
0403:  RRF    2E,F
0404:  RRF    2E,F
0405:  ANDWF  2E,F
....................     dolni_y = dolni_y / 8;  
0406:  RRF    2F,F
0407:  RRF    2F,F
0408:  RRF    2F,F
0409:  ANDWF  2F,F
....................   
....................    write_eeprom(EEleve_x,leve_x);  
040A:  BSF    03.6
040B:  CLRF   0D
040C:  CLRF   0F
040D:  BCF    03.6
040E:  MOVF   2C,W
040F:  BSF    03.6
0410:  MOVWF  0C
0411:  BSF    03.5
0412:  BCF    0C.7
0413:  BSF    0C.2
0414:  BCF    03.5
0415:  BCF    03.6
0416:  MOVF   0B,W
0417:  MOVWF  20
0418:  BCF    0B.7
0419:  BSF    03.5
041A:  BSF    03.6
041B:  MOVLW  55
041C:  MOVWF  0D
041D:  MOVLW  AA
041E:  MOVWF  0D
041F:  BSF    0C.1
0420:  BTFSC  0C.1
0421:  GOTO   420
0422:  BCF    0C.2
0423:  BCF    03.5
0424:  BCF    03.6
0425:  MOVF   20,W
0426:  IORWF  0B,F
....................    write_eeprom(EEprave_x,prave_x);  
0427:  MOVLW  01
0428:  BSF    03.6
0429:  MOVWF  0D
042A:  CLRF   0F
042B:  BCF    03.6
042C:  MOVF   2D,W
042D:  BSF    03.6
042E:  MOVWF  0C
042F:  BSF    03.5
0430:  BCF    0C.7
0431:  BSF    0C.2
0432:  BCF    03.5
0433:  BCF    03.6
0434:  MOVF   0B,W
0435:  MOVWF  20
0436:  BCF    0B.7
0437:  BSF    03.5
0438:  BSF    03.6
0439:  MOVLW  55
043A:  MOVWF  0D
043B:  MOVLW  AA
043C:  MOVWF  0D
043D:  BSF    0C.1
043E:  BTFSC  0C.1
043F:  GOTO   43E
0440:  BCF    0C.2
0441:  BCF    03.5
0442:  BCF    03.6
0443:  MOVF   20,W
0444:  IORWF  0B,F
....................    write_eeprom(EEstred_x,stred_x);  
0445:  MOVLW  08
0446:  BSF    03.6
0447:  MOVWF  0D
0448:  CLRF   0F
0449:  BCF    03.6
044A:  MOVF   2A,W
044B:  BSF    03.6
044C:  MOVWF  0C
044D:  BSF    03.5
044E:  BCF    0C.7
044F:  BSF    0C.2
0450:  BCF    03.5
0451:  BCF    03.6
0452:  MOVF   0B,W
0453:  MOVWF  20
0454:  BCF    0B.7
0455:  BSF    03.5
0456:  BSF    03.6
0457:  MOVLW  55
0458:  MOVWF  0D
0459:  MOVLW  AA
045A:  MOVWF  0D
045B:  BSF    0C.1
045C:  BTFSC  0C.1
045D:  GOTO   45C
045E:  BCF    0C.2
045F:  BCF    03.5
0460:  BCF    03.6
0461:  MOVF   20,W
0462:  IORWF  0B,F
....................    write_eeprom(EEstred_y,stred_y);  
0463:  MOVLW  09
0464:  BSF    03.6
0465:  MOVWF  0D
0466:  CLRF   0F
0467:  BCF    03.6
0468:  MOVF   2B,W
0469:  BSF    03.6
046A:  MOVWF  0C
046B:  BSF    03.5
046C:  BCF    0C.7
046D:  BSF    0C.2
046E:  BCF    03.5
046F:  BCF    03.6
0470:  MOVF   0B,W
0471:  MOVWF  20
0472:  BCF    0B.7
0473:  BSF    03.5
0474:  BSF    03.6
0475:  MOVLW  55
0476:  MOVWF  0D
0477:  MOVLW  AA
0478:  MOVWF  0D
0479:  BSF    0C.1
047A:  BTFSC  0C.1
047B:  GOTO   47A
047C:  BCF    0C.2
047D:  BCF    03.5
047E:  BCF    03.6
047F:  MOVF   20,W
0480:  IORWF  0B,F
....................    write_eeprom(EEhorni_y,horni_y);  
0481:  MOVLW  02
0482:  BSF    03.6
0483:  MOVWF  0D
0484:  CLRF   0F
0485:  BCF    03.6
0486:  MOVF   2E,W
0487:  BSF    03.6
0488:  MOVWF  0C
0489:  BSF    03.5
048A:  BCF    0C.7
048B:  BSF    0C.2
048C:  BCF    03.5
048D:  BCF    03.6
048E:  MOVF   0B,W
048F:  MOVWF  20
0490:  BCF    0B.7
0491:  BSF    03.5
0492:  BSF    03.6
0493:  MOVLW  55
0494:  MOVWF  0D
0495:  MOVLW  AA
0496:  MOVWF  0D
0497:  BSF    0C.1
0498:  BTFSC  0C.1
0499:  GOTO   498
049A:  BCF    0C.2
049B:  BCF    03.5
049C:  BCF    03.6
049D:  MOVF   20,W
049E:  IORWF  0B,F
....................    write_eeprom(EEdolni_y,dolni_y);  
049F:  MOVLW  03
04A0:  BSF    03.6
04A1:  MOVWF  0D
04A2:  CLRF   0F
04A3:  BCF    03.6
04A4:  MOVF   2F,W
04A5:  BSF    03.6
04A6:  MOVWF  0C
04A7:  BSF    03.5
04A8:  BCF    0C.7
04A9:  BSF    0C.2
04AA:  BCF    03.5
04AB:  BCF    03.6
04AC:  MOVF   0B,W
04AD:  MOVWF  20
04AE:  BCF    0B.7
04AF:  BSF    03.5
04B0:  BSF    03.6
04B1:  MOVLW  55
04B2:  MOVWF  0D
04B3:  MOVLW  AA
04B4:  MOVWF  0D
04B5:  BSF    0C.1
04B6:  BTFSC  0C.1
04B7:  GOTO   4B6
04B8:  BCF    0C.2
04B9:  BCF    03.5
04BA:  BCF    03.6
04BB:  MOVF   20,W
04BC:  IORWF  0B,F
....................   
....................    //write_eeprom(EEmin_x,min_x);              //zapis  
....................    //write_eeprom(EEmax_x,max_x);  
....................    //write_eeprom(EEmin_y,min_y);  
....................    //write_eeprom(EEmax_y,max_y);  
.................... }  
....................   
....................   
....................   
....................  
....................   
.................... int  x,y,tlac1,tlac2;  
....................   
.................... void trimovat()  
.................... {  
....................    odeslat_paket(Trim,0b0001);  
*
04BE:  MOVLW  06
04BF:  MOVWF  39
04C0:  MOVLW  01
04C1:  MOVWF  3A
04C2:  CALL   2E8
....................    odeslat_paket(OSA_X,x);  
04C3:  MOVLW  01
04C4:  MOVWF  39
04C5:  MOVF   30,W
04C6:  MOVWF  3A
04C7:  CALL   2E8
....................    odeslat_paket(OSA_Y,y);  
04C8:  MOVLW  02
04C9:  MOVWF  39
04CA:  MOVF   31,W
04CB:  MOVWF  3A
04CC:  CALL   2E8
.................... }  
....................   
.................... void vysilat()  
.................... {  
....................   
....................    leve_x = read_eeprom(EEleve_x);  
*
04CE:  BSF    03.6
04CF:  CLRF   0D
04D0:  CLRF   0F
04D1:  BSF    03.5
04D2:  BCF    0C.7
04D3:  BSF    0C.0
04D4:  BCF    03.5
04D5:  MOVF   0C,W
04D6:  BCF    03.6
04D7:  MOVWF  2C
....................    prave_x = read_eeprom(EEprave_x);  
04D8:  MOVLW  01
04D9:  BSF    03.6
04DA:  MOVWF  0D
04DB:  CLRF   0F
04DC:  BSF    03.5
04DD:  BCF    0C.7
04DE:  BSF    0C.0
04DF:  BCF    03.5
04E0:  MOVF   0C,W
04E1:  BCF    03.6
04E2:  MOVWF  2D
....................    stred_x = read_eeprom(EEstred_x);  
04E3:  MOVLW  08
04E4:  BSF    03.6
04E5:  MOVWF  0D
04E6:  CLRF   0F
04E7:  BSF    03.5
04E8:  BCF    0C.7
04E9:  BSF    0C.0
04EA:  BCF    03.5
04EB:  MOVF   0C,W
04EC:  BCF    03.6
04ED:  MOVWF  2A
....................    stred_y = read_eeprom(EEstred_y);  
04EE:  MOVLW  09
04EF:  BSF    03.6
04F0:  MOVWF  0D
04F1:  CLRF   0F
04F2:  BSF    03.5
04F3:  BCF    0C.7
04F4:  BSF    0C.0
04F5:  BCF    03.5
04F6:  MOVF   0C,W
04F7:  BCF    03.6
04F8:  MOVWF  2B
....................    horni_y = read_eeprom(EEhorni_y);  
04F9:  MOVLW  02
04FA:  BSF    03.6
04FB:  MOVWF  0D
04FC:  CLRF   0F
04FD:  BSF    03.5
04FE:  BCF    0C.7
04FF:  BSF    0C.0
0500:  BCF    03.5
0501:  MOVF   0C,W
0502:  BCF    03.6
0503:  MOVWF  2E
....................    dolni_y = read_eeprom(EEdolni_y);  
0504:  MOVLW  03
0505:  BSF    03.6
0506:  MOVWF  0D
0507:  CLRF   0F
0508:  BSF    03.5
0509:  BCF    0C.7
050A:  BSF    0C.0
050B:  BCF    03.5
050C:  MOVF   0C,W
050D:  BCF    03.6
050E:  MOVWF  2F
....................   
....................    Delay_ms(200);  
050F:  MOVLW  C8
0510:  MOVWF  3F
0511:  CALL   077
....................    lcd_gotoxy(6,2);  
0512:  MOVLW  06
0513:  MOVWF  3F
0514:  MOVLW  02
0515:  MOVWF  40
0516:  CALL   227
....................    printf(lcd_putc,"Vysilam");  
*
0048:  BCF    0A.0
0049:  BCF    0A.1
004A:  BCF    0A.2
004B:  ADDWF  02,F
004C:  RETLW  56
004D:  RETLW  79
004E:  RETLW  73
004F:  RETLW  69
0050:  RETLW  6C
0051:  RETLW  61
0052:  RETLW  6D
0053:  RETLW  00
*
0517:  CLRF   39
0518:  MOVF   39,W
0519:  CALL   048
051A:  INCF   39,F
051B:  MOVWF  3E
051C:  CALL   238
051D:  MOVLW  07
051E:  SUBWF  39,W
051F:  BTFSS  03.2
0520:  GOTO   518
....................   
....................    while(0x80 == klavesa())  
0521:  CALL   12E
0522:  MOVF   21,W
0523:  SUBLW  80
0524:  BTFSS  03.2
0525:  GOTO   54D
....................       {  
....................          Joystick(&x,&y,&tlac1,&tlac2);  
0526:  MOVLW  30
0527:  MOVWF  3D
0528:  MOVLW  31
0529:  MOVWF  3E
052A:  MOVLW  32
052B:  MOVWF  3F
052C:  MOVLW  33
052D:  MOVWF  40
052E:  CALL   270
....................          /*if (stred_x >= x)  
....................          {  
....................             x = stred_x - x;  
....................             x = x/leve_x;  
....................          }  
....................          else  
....................          {  
....................             x = x - stred_x;  
....................             x = x/prave_x;  
....................          }  
....................   
....................          if (stred_y >= y)  
....................          {  
....................             y = stred_y - y;  
....................             y = y/dolni_y;  
....................          }  
....................          else  
....................          {  
....................             y = y - stred_y;  
....................             y = y/horni_y;  
....................          }*/  
....................   
....................          x=x/8;  
052F:  RRF    30,F
0530:  RRF    30,F
0531:  RRF    30,F
0532:  MOVLW  1F
0533:  ANDWF  30,F
....................          y=y/8;  
0534:  RRF    31,F
0535:  RRF    31,F
0536:  RRF    31,F
0537:  ANDWF  31,F
....................   
....................         odeslat_paket(OSA_X,x);  
0538:  MOVLW  01
0539:  MOVWF  39
053A:  MOVF   30,W
053B:  MOVWF  3A
053C:  CALL   2E8
....................         Delay_us(1600);  
053D:  MOVLW  01
053E:  MOVWF  3F
053F:  CALL   077
0540:  MOVLW  03
0541:  MOVWF  39
0542:  MOVLW  BA
0543:  MOVWF  3A
0544:  GOTO   321
0545:  DECFSZ 39,F
0546:  GOTO   542
....................         odeslat_paket(OSA_Y,y);  
0547:  MOVLW  02
0548:  MOVWF  39
0549:  MOVF   31,W
054A:  MOVWF  3A
054B:  CALL   2E8
....................    }  
054C:  GOTO   521
.................... }  
....................   
.................... void menu()  
.................... {  
.................... int8 polozka = 3;  
.................... int8 old_polozka = 0;  
*
0330:  MOVLW  03
0331:  MOVWF  36
0332:  CLRF   37
.................... int pom;  
....................   
....................    while(true)  
....................    {  
....................       pom = klavesa();  
0333:  CALL   12E
0334:  MOVF   21,W
0335:  MOVWF  38
....................       if (0x07 == pom) polozka++;  
0336:  MOVF   38,W
0337:  SUBLW  07
0338:  BTFSS  03.2
0339:  GOTO   33B
033A:  INCF   36,F
....................       if (0x0f == pom) polozka--;  
033B:  MOVF   38,W
033C:  SUBLW  0F
033D:  BTFSS  03.2
033E:  GOTO   340
033F:  DECF   36,F
....................       if (0x04 <= polozka) polozka = 1;  
0340:  MOVF   36,W
0341:  SUBLW  03
0342:  BTFSC  03.0
0343:  GOTO   346
0344:  MOVLW  01
0345:  MOVWF  36
....................       if (0x00 == polozka) polozka = 3;  
0346:  MOVF   36,F
0347:  BTFSS  03.2
0348:  GOTO   34B
0349:  MOVLW  03
034A:  MOVWF  36
....................       if (0x16 == pom)   // enter  
034B:  MOVF   38,W
034C:  SUBLW  16
034D:  BTFSS  03.2
034E:  GOTO   55E
....................       {  
....................          LED((1 << (polozka + 1)) | 1);  
034F:  MOVLW  01
0350:  ADDWF  36,W
0351:  MOVWF  21
0352:  MOVLW  01
0353:  MOVWF  20
0354:  MOVF   21,F
0355:  BTFSC  03.2
0356:  GOTO   35B
0357:  BCF    03.0
0358:  RLF    20,F
0359:  DECFSZ 21,F
035A:  GOTO   357
035B:  MOVF   20,W
035C:  IORLW  01
035D:  MOVWF  3A
035E:  MOVWF  3B
035F:  CALL   1E7
....................          switch(polozka)  
0360:  MOVLW  01
0361:  SUBWF  36,W
0362:  ADDLW  FD
0363:  BTFSC  03.0
0364:  GOTO   54E
0365:  ADDLW  03
0366:  GOTO   5B3
....................          {  
....................             case 1:  
....................               kalibrace();  
....................               break;  
*
04BD:  GOTO   54E
....................   
....................             case 2:  
....................               trimovat();  
....................               break;  
*
04CD:  GOTO   54E
....................   
....................             case 3:  
....................               vysilat();  
....................               break;  
*
054D:  GOTO   54E
....................          };  
*
05B3:  BSF    0A.0
05B4:  BCF    0A.1
05B5:  BSF    0A.2
05B6:  ADDWF  02,F
05B7:  GOTO   367
05B8:  GOTO   4BE
05B9:  GOTO   4CE
....................          LED(1 << (polozka + 1));  
*
054E:  MOVLW  01
054F:  ADDWF  36,W
0550:  MOVWF  21
0551:  MOVLW  01
0552:  MOVWF  39
0553:  MOVF   21,F
0554:  BTFSC  03.2
0555:  GOTO   55A
0556:  BCF    03.0
0557:  RLF    39,F
0558:  DECFSZ 21,F
0559:  GOTO   556
055A:  MOVF   39,W
055B:  MOVWF  3B
055C:  CALL   1E7
....................          old_polozka=0;  
055D:  CLRF   37
....................       };  
....................   
....................       if (polozka != old_polozka)  
055E:  MOVF   37,W
055F:  SUBWF  36,W
0560:  BTFSC  03.2
0561:  GOTO   5B0
....................       {  
....................          old_polozka=polozka;  
0562:  MOVF   36,W
0563:  MOVWF  37
....................          printf(lcd_putc,"\f");  
0564:  MOVLW  0C
0565:  MOVWF  3E
0566:  CALL   238
....................          switch(polozka)  
0567:  MOVLW  01
0568:  SUBWF  36,W
0569:  ADDLW  FD
056A:  BTFSC  03.0
056B:  GOTO   59E
056C:  ADDLW  03
056D:  GOTO   5BA
....................          {  
....................             case 1:  
....................               lcd_gotoxy(5,2);  
056E:  MOVLW  05
056F:  MOVWF  3F
0570:  MOVLW  02
0571:  MOVWF  40
0572:  CALL   227
....................               printf(lcd_putc,"Kalibrace");  
*
0054:  BCF    0A.0
0055:  BCF    0A.1
0056:  BCF    0A.2
0057:  ADDWF  02,F
0058:  RETLW  4B
0059:  RETLW  61
005A:  RETLW  6C
005B:  RETLW  69
005C:  RETLW  62
005D:  RETLW  72
005E:  RETLW  61
005F:  RETLW  63
0060:  RETLW  65
0061:  RETLW  00
*
0573:  CLRF   39
0574:  MOVF   39,W
0575:  CALL   054
0576:  INCF   39,F
0577:  MOVWF  3E
0578:  CALL   238
0579:  MOVLW  09
057A:  SUBWF  39,W
057B:  BTFSS  03.2
057C:  GOTO   574
....................               break;  
057D:  GOTO   59E
....................   
....................             case 2:  
....................               lcd_gotoxy(7,2);  
057E:  MOVLW  07
057F:  MOVWF  3F
0580:  MOVLW  02
0581:  MOVWF  40
0582:  CALL   227
....................               printf(lcd_putc,"Trim");  
*
0062:  BCF    0A.0
0063:  BCF    0A.1
0064:  BCF    0A.2
0065:  ADDWF  02,F
0066:  RETLW  54
0067:  RETLW  72
0068:  RETLW  69
0069:  RETLW  6D
006A:  RETLW  00
*
0583:  CLRF   39
0584:  MOVF   39,W
0585:  CALL   062
0586:  INCF   39,F
0587:  MOVWF  3E
0588:  CALL   238
0589:  MOVLW  04
058A:  SUBWF  39,W
058B:  BTFSS  03.2
058C:  GOTO   584
....................               break;  
058D:  GOTO   59E
....................   
....................             case 3:  
....................               lcd_gotoxy(6,2);  
058E:  MOVLW  06
058F:  MOVWF  3F
0590:  MOVLW  02
0591:  MOVWF  40
0592:  CALL   227
....................               printf(lcd_putc,"Vysilat");  
*
006B:  BCF    0A.0
006C:  BCF    0A.1
006D:  BCF    0A.2
006E:  ADDWF  02,F
006F:  RETLW  56
0070:  RETLW  79
0071:  RETLW  73
0072:  RETLW  69
0073:  RETLW  6C
0074:  RETLW  61
0075:  RETLW  74
0076:  RETLW  00
*
0593:  CLRF   39
0594:  MOVF   39,W
0595:  CALL   06B
0596:  INCF   39,F
0597:  MOVWF  3E
0598:  CALL   238
0599:  MOVLW  07
059A:  SUBWF  39,W
059B:  BTFSS  03.2
059C:  GOTO   594
....................               break;  
059D:  GOTO   59E
....................          };  
*
05BA:  BSF    0A.0
05BB:  BCF    0A.1
05BC:  BSF    0A.2
05BD:  ADDWF  02,F
05BE:  GOTO   56E
05BF:  GOTO   57E
05C0:  GOTO   58E
....................          LED(1 << (polozka + 1));  
*
059E:  MOVLW  01
059F:  ADDWF  36,W
05A0:  MOVWF  21
05A1:  MOVLW  01
05A2:  MOVWF  39
05A3:  MOVF   21,F
05A4:  BTFSC  03.2
05A5:  GOTO   5AA
05A6:  BCF    03.0
05A7:  RLF    39,F
05A8:  DECFSZ 21,F
05A9:  GOTO   5A6
05AA:  MOVF   39,W
05AB:  MOVWF  3B
05AC:  CALL   1E7
....................          Delay_ms(250);  
05AD:  MOVLW  FA
05AE:  MOVWF  3F
05AF:  CALL   077
....................       }  
....................    }  
05B0:  GOTO   333
05B1:  BCF    0A.3
05B2:  GOTO   604 (RETURN)
.................... }  
....................   
.................... void main()  
.................... {  
.................... int8 tlacitka,tlacitka_old;  
*
05C1:  CLRF   04
05C2:  MOVLW  1F
05C3:  ANDWF  03,F
05C4:  MOVLW  07
05C5:  BSF    03.5
05C6:  MOVWF  1F
05C7:  MOVLW  FF
05C8:  BCF    03.5
05C9:  MOVWF  25
....................    setup_adc_ports(RA0_RA1_RA3_ANALOG);  
05CA:  MOVLW  04
05CB:  BSF    03.5
05CC:  MOVWF  1F
....................    setup_adc(ADC_CLOCK_DIV_2);  
05CD:  BCF    03.5
05CE:  MOVF   1F,W
05CF:  ANDLW  38
05D0:  IORLW  01
05D1:  MOVWF  1F
....................    setup_spi(FALSE);  
05D2:  BCF    14.5
05D3:  BCF    25.5
05D4:  MOVF   25,W
05D5:  BSF    03.5
05D6:  MOVWF  07
05D7:  BCF    03.5
05D8:  BSF    25.4
05D9:  MOVF   25,W
05DA:  BSF    03.5
05DB:  MOVWF  07
05DC:  BCF    03.5
05DD:  BCF    25.3
05DE:  MOVF   25,W
05DF:  BSF    03.5
05E0:  MOVWF  07
05E1:  MOVLW  00
05E2:  BCF    03.5
05E3:  MOVWF  14
05E4:  BSF    03.5
05E5:  MOVWF  14
....................    setup_counters(RTCC_INTERNAL,RTCC_DIV_2);  
05E6:  BCF    03.5
05E7:  CLRF   20
05E8:  BTFSS  20.3
05E9:  GOTO   5F2
05EA:  MOVLW  07
05EB:  CLRF   01
05EC:  MOVLW  81
05ED:  MOVWF  04
05EE:  MOVF   00,W
05EF:  ANDLW  C0
05F0:  IORLW  0F
05F1:  MOVWF  00
05F2:  CLRWDT
05F3:  MOVLW  81
05F4:  MOVWF  04
05F5:  MOVF   00,W
05F6:  ANDLW  C0
05F7:  IORWF  20,W
05F8:  MOVWF  00
....................    setup_timer_1(T1_DISABLED);  
05F9:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1);  
05FA:  MOVLW  00
05FB:  MOVWF  21
05FC:  MOVWF  12
05FD:  MOVLW  00
05FE:  BSF    03.5
05FF:  MOVWF  12
....................   
....................    lcd_init();  
0600:  BCF    03.5
0601:  GOTO   0B7
....................    KL_init();  
0602:  GOTO   0F1
....................   
....................    menu();  
0603:  GOTO   330
....................   
.................... while(true)  
.................... {  
.................... //char xx;  
.................... //      if (true == read_kl(&xx))  
.................... //      {  
.................... //      printf(lcd_putc,"%C",xx );  
.................... //      }  
.................... }  
0604:  GOTO   604
.................... }  
....................  
0605:  SLEEP
Subversion Repositories svnkaklik

(root)/schemata/prenos/letadlo/SW/vysilac/main.LST – Rev 6
