Subversion Repositories svnkaklik

Rev

Rev 410 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download

CCS PCM C Compiler, Version 3.221, 27853               19-XII-05 23:22

               Filename: D:\KAKLIK\programy\PIC_C\mereni\PS2mys\PIC16F88\mys.LST

               ROM used: 953 words (23%)
                         Largest free fragment is 2048
               RAM used: 19 (11%) at main() level
                         33 (19%) worst case
               Stack:    5 locations

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   2E2
0003:  NOP
....................  #include "D:\KAKLIK\programy\PIC_C\mereni\PS2mys\PIC16F88\mys.h" 
....................  #include <16F88.h> 
....................  //////// Standard Header file for the PIC16F88 device ////////////////  
.................... #device PIC16F88  
.................... #list  
....................  
.................... #device adc=8  
.................... #fuses NOWDT,INTRC_IO, NOPUT, MCLR, BROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG, NOPROTECT, FCMEN, IESO  
.................... #use delay(clock=4000000)  
*
0033:  MOVLW  34
0034:  MOVWF  04
0035:  MOVF   00,W
0036:  BTFSC  03.2
0037:  GOTO   047
0038:  MOVLW  01
0039:  MOVWF  78
003A:  CLRF   77
003B:  DECFSZ 77,F
003C:  GOTO   03B
003D:  DECFSZ 78,F
003E:  GOTO   03A
003F:  MOVLW  4A
0040:  MOVWF  77
0041:  DECFSZ 77,F
0042:  GOTO   041
0043:  NOP
0044:  NOP
0045:  DECFSZ 00,F
0046:  GOTO   038
0047:  RETLW  00
....................   
....................  
....................   
.................... #define LCD_RS          PIN_A0      // rizeni registru LCD displeje  
.................... #define LCD_E           PIN_A1      // enable LCD displeje  
.................... #define LCD_DATA_LSB    PIN_B0      // pripojeni LSB bitu datoveho portu LCD displeje (celkem 4 bity vzestupne za sebou)  
.................... #include "C:\library\CCS\lcd.c" 
....................  // LCD modul pro ovladani dvouradkoveho LCD modulu se standardnim Hitachi radicem  
.................... // (c)miho 2002,2005  
.................... //  
.................... // Historie:  
.................... //  
.................... // 0.00  Uvodni verze se snadnou definici portu LCD displeje  
.................... // 0.01  Oprava portu (zapomenute stare identifikatory)  
.................... // 0.02  Doplnena moznost pripojeni datoveho portu LCD na libovolne porty  
.................... // 0.03  Doplnena procedura lcd_clr pro smazani 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_clr               smaze displej  
.................... //  
.................... //   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:                     // Datovy port displeje pripojeny na 4 bity za sebou na jeden port  
.................... //  
.................... // #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)  
.................... //  
.................... //  
.................... // Alternativni definice:              // Datovy port displeje pripojeny na libovolne 4 bitove porty (vede na kod delsi asi o 25 slov)  
.................... //  
.................... // #define LCD_RS          PIN_B2      // rizeni registru LCD displeje  
.................... // #define LCD_E           PIN_B1      // enable LCD displeje  
.................... // #define LCD_D0          PIN_C2      // D0 - datove bity pripojene na libovolne porty  
.................... // #define LCD_D1          PIN_C3      // D1  
.................... // #define LCD_D2          PIN_C4      // D2  
.................... // #define LCD_D3          PIN_C5      // D3  
....................   
....................   
....................   
....................   
.................... // Privatni sekce, cist jen v pripade, ze neco nefunguje  
....................   
....................   
....................   
....................   
.................... #ifdef LCD_DATA_LSB  
.................... // 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 datoveho 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  
.................... #endif  
....................   
....................   
.................... // Definice konstant pro LCD display  
.................... //  
.................... #define LCD_CURSOR_ON_  0x0E     // kurzor jako blikajici radka pod znakem  
.................... #define LCD_CURSOR_OFF_ 0x0C     // zadny kurzor  
.................... #define LCD_LINE_2      0x40     // adresa 1. znaku 2. radky  
....................   
....................   
.................... // Definice rezimu LCD displeje  
.................... //  
.................... BYTE const LCD_INIT_STRING[4] =  
.................... {  
....................    0x28,                         // intrfejs 4 bity, 2 radky, font 5x7  
....................    LCD_CURSOR_OFF_,              // display on, kurzor off,  
....................    0x01,                         // clear displeje  
....................    0x06                          // inkrement pozice kurzoru (posun kurzoru doprava)  
.................... };  
....................   
....................   
.................... // Odesle nibble do displeje (posle data a klikne signalem e)  
.................... //  
.................... void lcd_send_nibble( BYTE n )  
.................... {  
....................    #ifdef LCD_DATA_LSB  
....................       // data jsou za sebou na 4 bitech jednoho portu  
....................       *LCD_PORT = (*LCD_PORT & ~LCD_MASK) | ((n << LCD_SHIFT) & LCD_MASK);      // nastav datove bity portu a ostatni zachovej  
0048:  MOVF   06,W
0049:  ANDLW  F0
004A:  MOVWF  3B
004B:  MOVF   3A,W
004C:  ANDLW  0F
004D:  IORWF  3B,W
004E:  MOVWF  06
....................    #else  
....................       // data jsou na libovolnych 4 bitech libovolnych portu  
....................       output_bit(LCD_D0,bit_test(n,0));  
....................       output_bit(LCD_D1,bit_test(n,1));  
....................       output_bit(LCD_D2,bit_test(n,2));  
....................       output_bit(LCD_D3,bit_test(n,3));  
....................    #endif  
....................    output_bit(LCD_E,1);       // vzestupna hrana  
004F:  BSF    05.1
0050:  BSF    03.5
0051:  BCF    05.1
....................    delay_us(1);               // pockej alespon 450ns od e nebo alespon 195ns od dat  
0052:  NOP
....................    output_bit(LCD_E,0);       // sestupna hrana (minimalni perioda e je 1us)  
0053:  BCF    03.5
0054:  BCF    05.1
0055:  BSF    03.5
0056:  BCF    05.1
.................... }  
0057:  BCF    03.5
0058:  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  
0059:  MOVF   38,F
005A:  BTFSS  03.2
005B:  GOTO   05E
005C:  BCF    05.0
005D:  GOTO   05F
005E:  BSF    05.0
005F:  BSF    03.5
0060:  BCF    05.0
....................    swap(n);  
0061:  BCF    03.5
0062:  SWAPF  39,F
....................    lcd_send_nibble(n);        // posli horni pulku bajtu  
0063:  MOVF   39,W
0064:  MOVWF  3A
0065:  CALL   048
....................    swap(n);  
0066:  SWAPF  39,F
....................    lcd_send_nibble(n);        // posli spodni pulku bajtu  
0067:  MOVF   39,W
0068:  MOVWF  3A
0069:  CALL   048
....................    delay_us(40);              // minimalni doba na provedeni prikazu  
006A:  MOVLW  0D
006B:  MOVWF  77
006C:  DECFSZ 77,F
006D:  GOTO   06C
.................... }  
006E:  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  
006F:  MOVLW  14
0070:  MOVWF  34
0071:  CALL   033
....................   
.................... #ifdef LCD_DATA_LSB  
....................    // data jsou na 4 bitech za sebou, nastav smer pro vsechny dalsi prenosy  
....................    *LCD_TRIS = *LCD_TRIS & ~LCD_MASK;  // nuluj odpovidajici bity tris registru datoveho portu LCD  
0072:  MOVLW  F0
0073:  BSF    03.5
0074:  ANDWF  06,F
.................... #endif  
....................   
....................    output_bit(LCD_RS,0);               // nastav jako vystup a nastav klidovy stav  
0075:  BCF    03.5
0076:  BCF    05.0
0077:  BSF    03.5
0078:  BCF    05.0
....................    output_bit(LCD_E, 0);               // nastav jako vystup a nastav klidovy stav  
0079:  BCF    03.5
007A:  BCF    05.1
007B:  BSF    03.5
007C:  BCF    05.1
....................   
....................    for (i=0; i<3; i++)                 // nastav lcd do rezimu 8 bitu sbernice  
007D:  BCF    03.5
007E:  CLRF   2B
007F:  MOVF   2B,W
0080:  SUBLW  02
0081:  BTFSS  03.0
0082:  GOTO   08B
....................    {  
....................       delay_ms(2);                     // muze byt rozdelany prenos dat (2x 4 bity) nebo pomaly povel  
0083:  MOVLW  02
0084:  MOVWF  34
0085:  CALL   033
....................       lcd_send_nibble(3);              // rezim 8 bitu  
0086:  MOVLW  03
0087:  MOVWF  3A
0088:  CALL   048
....................    }  
0089:  INCF   2B,F
008A:  GOTO   07F
....................   
....................    delay_us(40);                       // cas na zpracovani  
008B:  MOVLW  0D
008C:  MOVWF  77
008D:  DECFSZ 77,F
008E:  GOTO   08D
....................    lcd_send_nibble(2);                 // nastav rezim 4 bitu (plati od nasledujiciho prenosu)  
008F:  MOVLW  02
0090:  MOVWF  3A
0091:  CALL   048
....................    delay_us(40);                       // cas na zpracovani  
0092:  MOVLW  0D
0093:  MOVWF  77
0094:  DECFSZ 77,F
0095:  GOTO   094
....................   
....................    for (i=0;i<3;i++)                   // proved inicializaci (nastaveni modu, smazani apod)  
0096:  CLRF   2B
0097:  MOVF   2B,W
0098:  SUBLW  02
0099:  BTFSS  03.0
009A:  GOTO   0A7
....................    {  
....................       lcd_send_byte(0,LCD_INIT_STRING[i]);  
009B:  MOVF   2B,W
009C:  CALL   004
009D:  MOVWF  2C
009E:  CLRF   38
009F:  MOVF   2C,W
00A0:  MOVWF  39
00A1:  CALL   059
....................       delay_ms(2);  
00A2:  MOVLW  02
00A3:  MOVWF  34
00A4:  CALL   033
....................    }  
00A5:  INCF   2B,F
00A6:  GOTO   097
.................... }  
00A7:  BCF    0A.3
00A8:  GOTO   324 (RETURN)
....................   
....................   
.................... // Proved presun kurzoru  
.................... //  
.................... // Pozice 1.1 je domu  
.................... //  
.................... void lcd_gotoxy( BYTE x, BYTE y)  
.................... {  
....................   
....................    BYTE Adr;  
....................   
....................    Adr=x-1;  
*
0108:  MOVLW  01
0109:  SUBWF  34,W
010A:  MOVWF  36
....................    if(y==2)  
010B:  MOVF   35,W
010C:  SUBLW  02
010D:  BTFSS  03.2
010E:  GOTO   111
....................      Adr+=LCD_LINE_2;  
010F:  MOVLW  40
0110:  ADDWF  36,F
....................   
....................    lcd_send_byte(0,0x80|Adr);  
0111:  MOVF   36,W
0112:  IORLW  80
0113:  MOVWF  37
0114:  CLRF   38
0115:  MOVF   37,W
0116:  MOVWF  39
0117:  CALL   059
.................... }  
0118:  RETLW  00
....................   
....................   
.................... // Zapis znaku na displej, zpracovani ridicich znaku  
.................... //  
.................... void lcd_putc( char c)  
.................... {  
....................   
....................    switch (c)  
....................    {  
0119:  MOVF   33,W
011A:  XORLW  0C
011B:  BTFSC  03.2
011C:  GOTO   127
011D:  XORLW  06
011E:  BTFSC  03.2
011F:  GOTO   12F
0120:  XORLW  07
0121:  BTFSC  03.2
0122:  GOTO   135
0123:  XORLW  05
0124:  BTFSC  03.2
0125:  GOTO   13A
0126:  GOTO   13F
....................       case '\f'   : lcd_send_byte(0,1);            // smaz displej  
0127:  CLRF   38
0128:  MOVLW  01
0129:  MOVWF  39
012A:  CALL   059
....................                     delay_ms(2);  
012B:  MOVLW  02
012C:  MOVWF  34
012D:  CALL   033
....................                                             break;  
012E:  GOTO   14B
....................       case '\n'   : lcd_gotoxy(1,2);        break; // presun se na 1. znak 2. radky  
012F:  MOVLW  01
0130:  MOVWF  34
0131:  MOVLW  02
0132:  MOVWF  35
0133:  CALL   108
0134:  GOTO   14B
....................       case '\r'   : lcd_gotoxy(1,1);        break; // presun home  
0135:  MOVLW  01
0136:  MOVWF  34
0137:  MOVWF  35
0138:  CALL   108
0139:  GOTO   14B
....................       case '\b'   : lcd_send_byte(0,0x10);  break; // posun kurzor o 1 zpet  
013A:  CLRF   38
013B:  MOVLW  10
013C:  MOVWF  39
013D:  CALL   059
013E:  GOTO   14B
....................       default     : if (c<0x20) c&=0x7;            // preklopeni definovatelnych znaku na rozsah 0 az 0x1F  
013F:  MOVF   33,W
0140:  SUBLW  1F
0141:  BTFSS  03.0
0142:  GOTO   145
0143:  MOVLW  07
0144:  ANDWF  33,F
....................                     lcd_send_byte(1,c);     break; // zapis znak  
0145:  MOVLW  01
0146:  MOVWF  38
0147:  MOVF   33,W
0148:  MOVWF  39
0149:  CALL   059
014A:  GOTO   14B
....................    }  
.................... }  
014B:  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_);  
.................... }  
....................   
....................   
.................... // Smaz displej  
.................... //  
.................... void lcd_clr()  
.................... {  
....................    lcd_putc('\f');  
.................... }  
....................   
....................   
.................... // 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_UP     "\x80\x04\x0E\x15\x04\x04\x04\x80"      /* symbol sipka nahoru       */  
.................... #define LCD_CHAR_DOWN   "\x80\x04\x04\x04\x15\x0E\x04\x80"      /* symbol Sipka dolu         */  
.................... #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 TRIGGER_PIN     PIN_B4  
....................   
.................... #DEFINE  DATA     PIN_B5      // musi byt definovan kanal DATA  
.................... #DEFINE  CLK      PIN_B6      // a taky hodiny CLK  
.................... #include "C:\library\kaklik\CCS\ps2.c" 
....................  ////////////////////////////////////////////////////////////////////////////////  
.................... // Modul pro komunikaci s PS/2 mysi  
.................... //  
.................... // #DEFINE  DATA     PIN_B0      // musi byt definovan kanal DATA  
.................... // #DEFINE  CLK      PIN_B1      // a taky hodiny CLK  
.................... //  
.................... ////////////////////////////////////////////////////////////////////////////////  
....................   
.................... #define  PRVNI    1000                 // nastaveni prodlevy pred zacatkem vysilani bajtu  
.................... #define  DRUHY    2  
.................... #define  TRETI    DRUHY  
....................   
.................... // prikazy  
.................... #define  RESET                   0xFF  
.................... #define  ENABLE_DATA_REPORTING   0xF4  
.................... #define  READ_DATA               0xEB  
.................... #define  STATUS_REQUEST          0xE9  
.................... #define  SET_REMOTE_MODE         0xF0  
.................... #define  SET_STREAM_MODE         0xEA  
.................... #define  GET_DEVICE_ID           0xF2  
....................   
....................   
.................... void send(byte command)  
.................... {  
.................... unsigned int8 n;  
.................... unsigned int8 parity=0;  
*
00A9:  CLRF   2D
....................   
....................    //Request-to-send  
....................    output_float(DATA);  
00AA:  BSF    03.5
00AB:  BSF    06.5
....................    output_low(CLK);  
00AC:  BCF    06.6
00AD:  BCF    03.5
00AE:  BCF    06.6
....................    delay_us(100);  
00AF:  MOVLW  21
00B0:  MOVWF  77
00B1:  DECFSZ 77,F
00B2:  GOTO   0B1
....................    // start bit  
....................    output_low(DATA);  
00B3:  BSF    03.5
00B4:  BCF    06.5
00B5:  BCF    03.5
00B6:  BCF    06.5
....................    while(input(CLK));         // ceka se na hodiny od mysi (mys zataha za hodiny)  
00B7:  BSF    03.5
00B8:  BSF    06.6
00B9:  BCF    03.5
00BA:  BTFSC  06.6
00BB:  GOTO   0B7
....................    // 8 bitu  
....................    for(n=0; n<8; n++)  
00BC:  CLRF   2C
00BD:  MOVF   2C,W
00BE:  SUBLW  07
00BF:  BTFSS  03.0
00C0:  GOTO   0DA
....................    {  
....................       while(input(CLK));  
00C1:  BSF    03.5
00C2:  BSF    06.6
00C3:  BCF    03.5
00C4:  BTFSC  06.6
00C5:  GOTO   0C1
....................       output_bit(DATA, command & 1);  
00C6:  BTFSC  2B.0
00C7:  GOTO   0CA
00C8:  BCF    06.5
00C9:  GOTO   0CB
00CA:  BSF    06.5
00CB:  BSF    03.5
00CC:  BCF    06.5
....................       parity += command & 1;  
00CD:  BCF    03.5
00CE:  MOVF   2B,W
00CF:  ANDLW  01
00D0:  ADDWF  2D,F
....................       command >>= 1;  
00D1:  BCF    03.0
00D2:  RRF    2B,F
....................       while(!input(CLK));  
00D3:  BSF    03.5
00D4:  BSF    06.6
00D5:  BCF    03.5
00D6:  BTFSS  06.6
00D7:  GOTO   0D3
....................    };  
00D8:  INCF   2C,F
00D9:  GOTO   0BD
....................    // parita  
....................    while(input(CLK));  
00DA:  BSF    03.5
00DB:  BSF    06.6
00DC:  BCF    03.5
00DD:  BTFSC  06.6
00DE:  GOTO   0DA
....................    output_bit(DATA, ~parity & 1);  
00DF:  MOVF   2D,W
00E0:  XORLW  FF
00E1:  ANDLW  01
00E2:  XORLW  00
00E3:  BTFSS  03.2
00E4:  GOTO   0E7
00E5:  BCF    06.5
00E6:  GOTO   0E8
00E7:  BSF    06.5
00E8:  BSF    03.5
00E9:  BCF    06.5
....................    while(!input(CLK));  
00EA:  BSF    06.6
00EB:  BCF    03.5
00EC:  BTFSC  06.6
00ED:  GOTO   0F0
00EE:  BSF    03.5
00EF:  GOTO   0EA
....................   
....................    // stop bit  
....................    output_float(DATA);  
00F0:  BSF    03.5
00F1:  BSF    06.5
....................    while(input(DATA));        // mys musi sama jeste jednou zatahat za hodiny a data  
00F2:  BSF    06.5
00F3:  BCF    03.5
00F4:  BTFSS  06.5
00F5:  GOTO   0F8
00F6:  BSF    03.5
00F7:  GOTO   0F2
....................    while(input(CLK));  
00F8:  BSF    03.5
00F9:  BSF    06.6
00FA:  BCF    03.5
00FB:  BTFSC  06.6
00FC:  GOTO   0F8
....................   
....................    // ceka se az nastane klidovy stav  
....................    while(!input(CLK) || !input(DATA));  
00FD:  BSF    03.5
00FE:  BSF    06.6
00FF:  BCF    03.5
0100:  BTFSS  06.6
0101:  GOTO   0FD
0102:  BSF    03.5
0103:  BSF    06.5
0104:  BCF    03.5
0105:  BTFSS  06.5
0106:  GOTO   0FD
.................... }  
0107:  RETLW  00
....................   
....................   
.................... int8 read_byte()           // dodelat paritu  
.................... {  
.................... unsigned int8 bajt;  
.................... unsigned int8 i;  
.................... int1  parity=0;  
*
023A:  BCF    35.0
....................   
....................    // cekani na startbit  
....................    while(input(CLK) || input(DATA)); // oba signaly musi byt v 0  
023B:  BSF    03.5
023C:  BSF    06.6
023D:  BCF    03.5
023E:  BTFSC  06.6
023F:  GOTO   23B
0240:  BSF    03.5
0241:  BSF    06.5
0242:  BCF    03.5
0243:  BTFSC  06.5
0244:  GOTO   23B
....................    while(!input(CLK));     // ceka se na nabeznou hranu hodin  
0245:  BSF    03.5
0246:  BSF    06.6
0247:  BCF    03.5
0248:  BTFSS  06.6
0249:  GOTO   245
....................   
....................    bajt = 0;  
024A:  CLRF   33
....................    for(i=0; i<8; i++)  
024B:  CLRF   34
024C:  MOVF   34,W
024D:  SUBLW  07
024E:  BTFSS  03.0
024F:  GOTO   27C
....................    {  
....................       while(input(CLK));   // ceka na nulu hodin  
0250:  BSF    03.5
0251:  BSF    06.6
0252:  BCF    03.5
0253:  BTFSC  06.6
0254:  GOTO   250
....................   
....................       bajt >>= 1;  
0255:  BCF    03.0
0256:  RRF    33,F
....................       bajt |= input(DATA) << 7; // zapise se stav do promene  
0257:  BSF    03.5
0258:  BSF    06.5
0259:  MOVLW  00
025A:  BCF    03.5
025B:  BTFSC  06.5
025C:  MOVLW  01
025D:  MOVWF  77
025E:  RRF    77,W
025F:  CLRF   77
0260:  BTFSC  03.0
0261:  BSF    77.7
0262:  MOVF   77,W
0263:  IORWF  33,F
....................       parity^=input(DATA);  
0264:  MOVLW  00
0265:  BTFSC  35.0
0266:  MOVLW  01
0267:  MOVWF  36
0268:  BSF    03.5
0269:  BSF    06.5
026A:  MOVLW  00
026B:  BCF    03.5
026C:  BTFSC  06.5
026D:  MOVLW  01
026E:  XORWF  36,W
026F:  MOVWF  78
0270:  BTFSC  78.0
0271:  GOTO   274
0272:  BCF    35.0
0273:  GOTO   275
0274:  BSF    35.0
....................   
....................       while(!input(CLK));  // ceka na jednicku hodin  
0275:  BSF    03.5
0276:  BSF    06.6
0277:  BCF    03.5
0278:  BTFSS  06.6
0279:  GOTO   275
....................    };  
027A:  INCF   34,F
027B:  GOTO   24C
....................    while(input(CLK));  
027C:  BSF    03.5
027D:  BSF    06.6
027E:  BCF    03.5
027F:  BTFSC  06.6
0280:  GOTO   27C
....................    parity^=input(DATA);  
0281:  MOVLW  00
0282:  BTFSC  35.0
0283:  MOVLW  01
0284:  MOVWF  36
0285:  BSF    03.5
0286:  BSF    06.5
0287:  MOVLW  00
0288:  BCF    03.5
0289:  BTFSC  06.5
028A:  MOVLW  01
028B:  XORWF  36,W
028C:  MOVWF  78
028D:  BTFSC  78.0
028E:  GOTO   291
028F:  BCF    35.0
0290:  GOTO   292
0291:  BSF    35.0
.................... //   if (parity)  
....................    while(!input(CLK));  // ceka na jednicku hodin  
0292:  BSF    03.5
0293:  BSF    06.6
0294:  BCF    03.5
0295:  BTFSS  06.6
0296:  GOTO   292
....................    while(input(CLK));  
0297:  BSF    03.5
0298:  BSF    06.6
0299:  BCF    03.5
029A:  BTFSC  06.6
029B:  GOTO   297
....................    while(!input(CLK));  // ceka na jednicku hodin  
029C:  BSF    03.5
029D:  BSF    06.6
029E:  BCF    03.5
029F:  BTFSS  06.6
02A0:  GOTO   29C
....................    return (bajt);  
02A1:  MOVF   33,W
02A2:  MOVWF  78
.................... }  
02A3:  RETLW  00
....................   
....................   
.................... void read_standard_byte(signed int8 *x,*y,unsigned int8 *tl1,*tl2,*tl3)  
.................... {  
.................... unsigned int8 st,nd,rd;  
....................   
....................    st = read_byte();  
02A4:  CALL   23A
02A5:  MOVF   78,W
02A6:  MOVWF  30
....................    nd = read_byte();  
02A7:  CALL   23A
02A8:  MOVF   78,W
02A9:  MOVWF  31
....................    rd = read_byte();  
02AA:  CALL   23A
02AB:  MOVF   78,W
02AC:  MOVWF  32
....................      
....................    if ((st & 0b1000) == 0b1000) *x=-nd; else *x=nd;  
02AD:  MOVF   30,W
02AE:  ANDLW  08
02AF:  SUBLW  08
02B0:  BTFSS  03.2
02B1:  GOTO   2B8
02B2:  MOVF   2B,W
02B3:  MOVWF  04
02B4:  MOVF   31,W
02B5:  SUBLW  00
02B6:  MOVWF  00
02B7:  GOTO   2BC
02B8:  MOVF   2B,W
02B9:  MOVWF  04
02BA:  MOVF   31,W
02BB:  MOVWF  00
....................    if ((st & 0b10000) == 0b10000) *y=-rd; else *y=rd;   
02BC:  MOVF   30,W
02BD:  ANDLW  10
02BE:  SUBLW  10
02BF:  BTFSS  03.2
02C0:  GOTO   2C7
02C1:  MOVF   2C,W
02C2:  MOVWF  04
02C3:  MOVF   32,W
02C4:  SUBLW  00
02C5:  MOVWF  00
02C6:  GOTO   2CB
02C7:  MOVF   2C,W
02C8:  MOVWF  04
02C9:  MOVF   32,W
02CA:  MOVWF  00
....................         
....................    *tl1=st & 1;  
02CB:  MOVF   2D,W
02CC:  MOVWF  04
02CD:  MOVF   30,W
02CE:  ANDLW  01
02CF:  MOVWF  00
....................    *tl2=(st >> 1) & 1;  
02D0:  MOVF   2E,W
02D1:  MOVWF  04
02D2:  BCF    03.0
02D3:  RRF    30,W
02D4:  ANDLW  01
02D5:  MOVWF  00
....................    *tl3=(st >> 2) & 1;  
02D6:  MOVF   2F,W
02D7:  MOVWF  04
02D8:  RRF    30,W
02D9:  MOVWF  77
02DA:  RRF    77,F
02DB:  MOVLW  3F
02DC:  ANDWF  77,F
02DD:  MOVF   77,W
02DE:  ANDLW  01
02DF:  MOVWF  00
.................... }  
02E0:  BCF    0A.3
02E1:  GOTO   3A5 (RETURN)
.................... void ps2break()  
.................... {  
....................    output_low(CLK);  
.................... }  
.................... void ps2enable()  
.................... {  
....................    output_float(CLK);  
.................... }  
....................  
....................   
....................   
....................   
.................... void trigger()  
.................... {  
....................    output_high(TRIGGER_PIN);  
....................    delay_us(50);  
....................    output_low(TRIGGER_PIN);  
.................... }  
....................   
.................... void main()  
.................... {  
02E2:  CLRF   04
02E3:  MOVLW  1F
02E4:  ANDWF  03,F
02E5:  BSF    03.5
02E6:  BCF    1F.4
02E7:  BCF    1F.5
02E8:  MOVF   1B,W
02E9:  ANDLW  80
02EA:  MOVWF  1B
02EB:  MOVLW  07
02EC:  MOVWF  1C
02ED:  MOVF   1C,W
02EE:  BCF    03.5
02EF:  BCF    0D.6
02F0:  MOVLW  60
02F1:  BSF    03.5
02F2:  MOVWF  0F
.................... signed int16 x=0,y=0;  
02F3:  BCF    03.5
02F4:  CLRF   21
02F5:  CLRF   22
02F6:  CLRF   23
02F7:  CLRF   24
.................... signed int8 hodnota,dx,dy;  
.................... unsigned int8 tl1,tl2,tl3;  
....................   
....................    setup_adc_ports(NO_ANALOGS|VSS_VDD);  
02F8:  BSF    03.5
02F9:  BCF    1F.4
02FA:  BCF    1F.5
02FB:  MOVF   1B,W
02FC:  ANDLW  80
02FD:  MOVWF  1B
....................    setup_adc(ADC_OFF);  
02FE:  BCF    03.5
02FF:  BCF    1F.0
....................    setup_spi(FALSE);  
0300:  BCF    14.5
0301:  BSF    03.5
0302:  BCF    06.2
0303:  BSF    06.1
0304:  BCF    06.4
0305:  MOVLW  00
0306:  BCF    03.5
0307:  MOVWF  14
0308:  BSF    03.5
0309:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);  
030A:  MOVF   01,W
030B:  ANDLW  C7
030C:  IORLW  08
030D:  MOVWF  01
....................    setup_timer_1(T1_DISABLED);  
030E:  BCF    03.5
030F:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1);  
0310:  MOVLW  00
0311:  MOVWF  78
0312:  MOVWF  12
0313:  MOVLW  00
0314:  BSF    03.5
0315:  MOVWF  12
....................    setup_comparator(NC_NC_NC_NC);  
0316:  MOVLW  07
0317:  MOVWF  1C
0318:  MOVF   05,W
0319:  MOVLW  03
031A:  MOVWF  77
031B:  DECFSZ 77,F
031C:  GOTO   31B
031D:  MOVF   1C,W
031E:  BCF    03.5
031F:  BCF    0D.6
....................    setup_vref(FALSE);  
0320:  BSF    03.5
0321:  CLRF   1D
....................   
....................    lcd_init();  
0322:  BCF    03.5
0323:  GOTO   06F
....................    Delay_ms(500);  
0324:  MOVLW  02
0325:  MOVWF  2B
0326:  MOVLW  FA
0327:  MOVWF  34
0328:  CALL   033
0329:  DECFSZ 2B,F
032A:  GOTO   326
....................   
....................    send(SET_REMOTE_MODE);  
032B:  MOVLW  F0
032C:  MOVWF  2B
032D:  CALL   0A9
....................   
....................    while (true)  
....................    {  
....................       LCD_gotoxy(1,1);  
032E:  MOVLW  01
032F:  MOVWF  34
0330:  MOVWF  35
0331:  CALL   108
....................       printf(lcd_putc,"%X X=%ld Y=%ld TL1=%U   TL2=%U TL3=%U",hodnota, x,y,tl1,tl2,tl3);  
0332:  MOVF   25,W
0333:  MOVWF  2B
0334:  MOVLW  37
0335:  MOVWF  2C
0336:  GOTO   14C
0337:  MOVLW  20
0338:  MOVWF  33
0339:  CALL   119
033A:  MOVLW  58
033B:  MOVWF  33
033C:  CALL   119
033D:  MOVLW  3D
033E:  MOVWF  33
033F:  CALL   119
0340:  MOVLW  10
0341:  MOVWF  04
0342:  MOVF   22,W
0343:  MOVWF  2C
0344:  MOVF   21,W
0345:  MOVWF  2B
0346:  CALL   16E
0347:  MOVLW  20
0348:  MOVWF  33
0349:  CALL   119
034A:  MOVLW  59
034B:  MOVWF  33
034C:  CALL   119
034D:  MOVLW  3D
034E:  MOVWF  33
034F:  CALL   119
0350:  MOVLW  10
0351:  MOVWF  04
0352:  MOVF   24,W
0353:  MOVWF  2C
0354:  MOVF   23,W
0355:  MOVWF  2B
0356:  CALL   16E
0357:  MOVLW  0E
0358:  MOVWF  2B
0359:  MOVF   2B,W
035A:  CALL   00C
035B:  INCF   2B,F
035C:  MOVWF  77
035D:  MOVWF  33
035E:  CALL   119
035F:  MOVLW  13
0360:  SUBWF  2B,W
0361:  BTFSS  03.2
0362:  GOTO   359
0363:  MOVF   28,W
0364:  MOVWF  2F
0365:  MOVLW  18
0366:  MOVWF  30
0367:  CALL   1ED
0368:  MOVLW  03
0369:  MOVWF  2C
036A:  MOVLW  20
036B:  MOVWF  33
036C:  CALL   119
036D:  DECFSZ 2C,F
036E:  GOTO   36A
036F:  MOVLW  15
0370:  MOVWF  2D
0371:  MOVF   2D,W
0372:  CALL   00C
0373:  INCF   2D,F
0374:  MOVWF  77
0375:  MOVWF  33
0376:  CALL   119
0377:  MOVLW  19
0378:  SUBWF  2D,W
0379:  BTFSS  03.2
037A:  GOTO   371
037B:  MOVF   29,W
037C:  MOVWF  2F
037D:  MOVLW  18
037E:  MOVWF  30
037F:  CALL   1ED
0380:  MOVLW  1B
0381:  MOVWF  2E
0382:  MOVF   2E,W
0383:  CALL   00C
0384:  INCF   2E,F
0385:  MOVWF  77
0386:  MOVWF  33
0387:  CALL   119
0388:  MOVLW  20
0389:  SUBWF  2E,W
038A:  BTFSS  03.2
038B:  GOTO   382
038C:  MOVF   2A,W
038D:  MOVWF  2F
038E:  MOVLW  18
038F:  MOVWF  30
0390:  CALL   1ED
....................       delay_ms(20);  
0391:  MOVLW  14
0392:  MOVWF  34
0393:  CALL   033
....................       send(READ_DATA);  
0394:  MOVLW  EB
0395:  MOVWF  2B
0396:  CALL   0A9
....................       hodnota=read_byte();  
0397:  CALL   23A
0398:  MOVF   78,W
0399:  MOVWF  25
....................       read_standard_byte(&dx,&dy,&tl1,&tl2,&tl3);  
039A:  MOVLW  26
039B:  MOVWF  2B
039C:  MOVLW  27
039D:  MOVWF  2C
039E:  MOVLW  28
039F:  MOVWF  2D
03A0:  MOVLW  29
03A1:  MOVWF  2E
03A2:  MOVLW  2A
03A3:  MOVWF  2F
03A4:  GOTO   2A4
....................       x+=dx;  
03A5:  CLRF   7A
03A6:  MOVF   26,W
03A7:  BTFSC  26.7
03A8:  DECF   7A,F
03A9:  ADDWF  21,F
03AA:  BTFSC  03.0
03AB:  INCF   22,F
03AC:  MOVF   7A,W
03AD:  ADDWF  22,F
....................       y+=dy;  
03AE:  CLRF   7A
03AF:  MOVF   27,W
03B0:  BTFSC  27.7
03B1:  DECF   7A,F
03B2:  ADDWF  23,F
03B3:  BTFSC  03.0
03B4:  INCF   24,F
03B5:  MOVF   7A,W
03B6:  ADDWF  24,F
....................    }  
03B7:  GOTO   32E
.................... }  
....................  
03B8:  SLEEP

Configuration Fuses:
   Word  1: 3F78   NOWDT NOPUT MCLR BROWNOUT NOLVP NOCPD NOWRT NODEBUG CCPB0 NOPROTECT INTRC_IO
   Word  2: 3FFF   FCMEN IESO