WebSVN – MLAB_E – Rev 1045 – /projekty/jacho/Dip_prace/SW/pic/I2C

CCS PCM C Compiler, Version 4.106, 47914               23-4-13 03:00

               Filename: C:\Users\Honza\Documents\pic\I2C_HUB\main.lst

               ROM used: 2678 words (33%)
                         Largest free fragment is 2048
               RAM used: 8 (2%) at main() level
                         42 (11%) worst case
               Stack:    2 locations

*
0000:  MOVLW  08
0001:  MOVWF  0A
0002:  GOTO   000
0003:  NOP
.................... #include "C:\Users\Honza\Documents\pic\I2C_HUB\main.h" 
.................... #include <16F887.h> 
.................... //////// Standard Header file for the PIC16F887 device //////////////// 
.................... #device PIC16F887 
.................... #list 
....................  
.................... #device adc=8 
....................  
.................... #FUSES NOWDT                       //No Watch Dog Timer 
.................... #FUSES INTRC                       //Internal RC Osc 
.................... #FUSES NOPUT                       //No Power Up Timer 
.................... #FUSES MCLR                        //Master Clear pin enabled 
.................... #FUSES NOPROTECT                   //Code not protected from reading 
.................... #FUSES NOCPD                       //No EE protection 
.................... #FUSES NOBROWNOUT                  //No brownout reset 
.................... #FUSES IESO                        //Internal External Switch Over mode enabled 
.................... #FUSES FCMEN                       //Fail-safe clock monitor enabled 
.................... #FUSES NOLVP                       //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O 
.................... #FUSES NODEBUG                     //No Debug mode for ICD 
.................... #FUSES NOWRT                       //Program memory not write protected 
.................... #FUSES BORV40                      //Brownout reset at 4.0V 
....................  
.................... #use delay(clock=8000000) 
*
0160:  MOVLW  3C
0161:  MOVWF  04
0162:  BCF    03.7
0163:  MOVF   00,W
0164:  BTFSC  03.2
0165:  GOTO   173
0166:  MOVLW  02
0167:  MOVWF  78
0168:  CLRF   77
0169:  DECFSZ 77,F
016A:  GOTO   169
016B:  DECFSZ 78,F
016C:  GOTO   168
016D:  MOVLW  97
016E:  MOVWF  77
016F:  DECFSZ 77,F
0170:  GOTO   16F
0171:  DECFSZ 00,F
0172:  GOTO   166
0173:  RETURN
....................  
....................  
....................  
....................  
.................... //For AKCE 
.................... //ADRESA pro èteni 0xE1 
.................... //pro zápis 0xE0 
....................  
....................  
.................... #define EEPROM_SDA  PIN_C4 
.................... #define EEPROM_SCL  PIN_C3 
.................... #use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL) 
*
00D1:  MOVLW  08
00D2:  MOVWF  78
00D3:  NOP
00D4:  BCF    07.3
00D5:  BCF    20.3
00D6:  MOVF   20,W
00D7:  BSF    03.5
00D8:  MOVWF  07
00D9:  NOP
00DA:  BCF    03.5
00DB:  RLF    3B,F
00DC:  BCF    07.4
00DD:  BTFSS  03.0
00DE:  GOTO   0E5
00DF:  BSF    20.4
00E0:  MOVF   20,W
00E1:  BSF    03.5
00E2:  MOVWF  07
00E3:  GOTO   0E9
00E4:  BCF    03.5
00E5:  BCF    20.4
00E6:  MOVF   20,W
00E7:  BSF    03.5
00E8:  MOVWF  07
00E9:  NOP
00EA:  BCF    03.5
00EB:  BSF    20.3
00EC:  MOVF   20,W
00ED:  BSF    03.5
00EE:  MOVWF  07
00EF:  BCF    03.5
00F0:  BTFSS  07.3
00F1:  GOTO   0F0
00F2:  DECFSZ 78,F
00F3:  GOTO   0D3
00F4:  NOP
00F5:  BCF    07.3
00F6:  BCF    20.3
00F7:  MOVF   20,W
00F8:  BSF    03.5
00F9:  MOVWF  07
00FA:  NOP
00FB:  BCF    03.5
00FC:  BSF    20.4
00FD:  MOVF   20,W
00FE:  BSF    03.5
00FF:  MOVWF  07
0100:  NOP
0101:  NOP
0102:  BCF    03.5
0103:  BSF    20.3
0104:  MOVF   20,W
0105:  BSF    03.5
0106:  MOVWF  07
0107:  BCF    03.5
0108:  BTFSS  07.3
0109:  GOTO   108
010A:  CLRF   78
010B:  NOP
010C:  BTFSC  07.4
010D:  BSF    78.0
010E:  BCF    07.3
010F:  BCF    20.3
0110:  MOVF   20,W
0111:  BSF    03.5
0112:  MOVWF  07
0113:  BCF    03.5
0114:  BCF    07.4
0115:  BCF    20.4
0116:  MOVF   20,W
0117:  BSF    03.5
0118:  MOVWF  07
0119:  BCF    03.5
011A:  RETURN
011B:  MOVLW  08
011C:  MOVWF  3C
011D:  MOVF   77,W
011E:  MOVWF  3D
011F:  BSF    20.4
0120:  MOVF   20,W
0121:  BSF    03.5
0122:  MOVWF  07
0123:  NOP
0124:  BCF    03.5
0125:  BSF    20.3
0126:  MOVF   20,W
0127:  BSF    03.5
0128:  MOVWF  07
0129:  BCF    03.5
012A:  BTFSS  07.3
012B:  GOTO   12A
012C:  BTFSC  07.4
012D:  BSF    03.0
012E:  BTFSS  07.4
012F:  BCF    03.0
0130:  RLF    78,F
0131:  NOP
0132:  BCF    20.3
0133:  MOVF   20,W
0134:  BSF    03.5
0135:  MOVWF  07
0136:  BCF    03.5
0137:  BCF    07.3
0138:  DECFSZ 3C,F
0139:  GOTO   11F
013A:  BSF    20.4
013B:  MOVF   20,W
013C:  BSF    03.5
013D:  MOVWF  07
013E:  NOP
013F:  BCF    03.5
0140:  BCF    07.4
0141:  MOVF   3D,W
0142:  BTFSC  03.2
0143:  GOTO   149
0144:  BCF    20.4
0145:  MOVF   20,W
0146:  BSF    03.5
0147:  MOVWF  07
0148:  BCF    03.5
0149:  NOP
014A:  BSF    20.3
014B:  MOVF   20,W
014C:  BSF    03.5
014D:  MOVWF  07
014E:  BCF    03.5
014F:  BTFSS  07.3
0150:  GOTO   14F
0151:  NOP
0152:  BCF    07.3
0153:  BCF    20.3
0154:  MOVF   20,W
0155:  BSF    03.5
0156:  MOVWF  07
0157:  NOP
0158:  BCF    03.5
0159:  BCF    07.4
015A:  BCF    20.4
015B:  MOVF   20,W
015C:  BSF    03.5
015D:  MOVWF  07
015E:  BCF    03.5
015F:  RETURN
.................... #use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD 
*
0065:  BCF    20.7
0066:  MOVF   20,W
0067:  BSF    03.5
0068:  MOVWF  07
0069:  BCF    03.5
006A:  BCF    07.7
006B:  MOVLW  08
006C:  MOVWF  78
006D:  GOTO   06E
006E:  NOP
006F:  BSF    78.7
0070:  GOTO   07F
0071:  BCF    78.7
0072:  RRF    44,F
0073:  BTFSC  03.0
0074:  BSF    07.7
0075:  BTFSS  03.0
0076:  BCF    07.7
0077:  BSF    78.6
0078:  GOTO   07F
0079:  BCF    78.6
007A:  DECFSZ 78,F
007B:  GOTO   072
007C:  GOTO   07D
007D:  NOP
007E:  BSF    07.7
007F:  MOVLW  3F
0080:  MOVWF  04
0081:  DECFSZ 04,F
0082:  GOTO   081
0083:  NOP
0084:  BTFSC  78.7
0085:  GOTO   071
0086:  BTFSC  78.6
0087:  GOTO   079
0088:  RETURN
....................  
....................  
....................  
.................... void main() 
.................... { 
*
0064:  DATA 00,00
*
0800:  CLRF   04
0801:  BCF    03.7
0802:  MOVLW  1F
0803:  ANDWF  03,F
0804:  MOVLW  71
0805:  BSF    03.5
0806:  MOVWF  0F
0807:  MOVF   0F,W
0808:  BCF    03.5
0809:  BCF    20.7
080A:  MOVF   20,W
080B:  BSF    03.5
080C:  MOVWF  07
080D:  BCF    03.5
080E:  BSF    07.7
080F:  BSF    03.5
0810:  BSF    03.6
0811:  MOVF   09,W
0812:  ANDLW  C0
0813:  MOVWF  09
0814:  BCF    03.6
0815:  BCF    1F.4
0816:  BCF    1F.5
0817:  MOVLW  00
0818:  BSF    03.6
0819:  MOVWF  08
081A:  BCF    03.5
081B:  CLRF   07
081C:  CLRF   08
081D:  CLRF   09
....................  
....................    setup_adc_ports(NO_ANALOGS|VSS_VDD); 
*
0821:  BSF    03.5
0822:  BSF    03.6
0823:  MOVF   09,W
0824:  ANDLW  C0
0825:  MOVWF  09
0826:  BCF    03.6
0827:  BCF    1F.4
0828:  BCF    1F.5
0829:  MOVLW  00
082A:  BSF    03.6
082B:  MOVWF  08
....................    setup_adc(ADC_CLOCK_DIV_2); 
082C:  BCF    03.5
082D:  BCF    03.6
082E:  BCF    1F.6
082F:  BCF    1F.7
0830:  BSF    03.5
0831:  BCF    1F.7
0832:  BCF    03.5
0833:  BSF    1F.0
....................    setup_spi(SPI_SS_DISABLED); 
0834:  BCF    14.5
0835:  BCF    20.5
0836:  MOVF   20,W
0837:  BSF    03.5
0838:  MOVWF  07
0839:  BCF    03.5
083A:  BSF    20.4
083B:  MOVF   20,W
083C:  BSF    03.5
083D:  MOVWF  07
083E:  BCF    03.5
083F:  BCF    20.3
0840:  MOVF   20,W
0841:  BSF    03.5
0842:  MOVWF  07
0843:  MOVLW  01
0844:  BCF    03.5
0845:  MOVWF  14
0846:  MOVLW  00
0847:  BSF    03.5
0848:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); 
0849:  MOVF   01,W
084A:  ANDLW  C7
084B:  IORLW  08
084C:  MOVWF  01
....................    setup_timer_1(T1_DISABLED); 
084D:  BCF    03.5
084E:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1); 
084F:  MOVLW  00
0850:  MOVWF  78
0851:  MOVWF  12
0852:  MOVLW  00
0853:  BSF    03.5
0854:  MOVWF  12
....................    setup_ccp1(CCP_OFF); 
0855:  BCF    03.5
0856:  BSF    20.2
0857:  MOVF   20,W
0858:  BSF    03.5
0859:  MOVWF  07
085A:  BCF    03.5
085B:  CLRF   17
085C:  BSF    03.5
085D:  CLRF   1B
085E:  CLRF   1C
085F:  MOVLW  01
0860:  MOVWF  1D
....................    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard 
0861:  BCF    03.5
0862:  BSF    03.6
0863:  CLRF   07
0864:  CLRF   08
0865:  CLRF   09
....................  
.................... printf("Simple Thermomether  \r\n",); 
0866:  MOVLW  04
0867:  MOVWF  0D
0868:  MOVLW  00
0869:  MOVWF  0F
086A:  BCF    0A.3
086B:  BCF    03.6
086C:  GOTO   089
086D:  BSF    0A.3
....................  
.................... unsigned int8 INTEP,INTEP1, NAP,NAP1, PROUD,PROUD1,KAPZ,KAPZ1,KAPC,KAPC1, STAV,STAV1; 
....................  
....................  
....................  
.................... int16 data4; 
.................... int16 data5; 
.................... int16 data6; 
.................... int16 data7; 
.................... int16 data8; 
.................... int16 data9; 
....................  
.................... byte XH; 
....................  
....................  
....................  
....................  
....................  
....................   while(TRUE) 
....................  {  
....................  
....................  
....................  
....................  
.................... //akcelerometr 
....................    int1 ack; 
....................    i2c_start();            // If the write command is acknowledged, 
086E:  BSF    20.4
086F:  MOVF   20,W
0870:  BSF    03.5
0871:  MOVWF  07
0872:  NOP
0873:  BCF    03.5
0874:  BSF    20.3
0875:  MOVF   20,W
0876:  BSF    03.5
0877:  MOVWF  07
0878:  NOP
0879:  BCF    03.5
087A:  BCF    07.4
087B:  BCF    20.4
087C:  MOVF   20,W
087D:  BSF    03.5
087E:  MOVWF  07
087F:  NOP
0880:  BCF    03.5
0881:  BCF    07.3
0882:  BCF    20.3
0883:  MOVF   20,W
0884:  BSF    03.5
0885:  MOVWF  07
....................    ack = i2c_write(0xE1);//hen the device is ready. 
0886:  MOVLW  E1
0887:  BCF    03.5
0888:  MOVWF  3B
0889:  BCF    0A.3
088A:  CALL   0D1
088B:  BSF    0A.3
088C:  MOVF   78,W
088D:  BCF    3A.0
088E:  BTFSC  78.0
088F:  BSF    3A.0
....................    i2c_stop(); 
0890:  BCF    20.4
0891:  MOVF   20,W
0892:  BSF    03.5
0893:  MOVWF  07
0894:  NOP
0895:  BCF    03.5
0896:  BSF    20.3
0897:  MOVF   20,W
0898:  BSF    03.5
0899:  MOVWF  07
089A:  BCF    03.5
089B:  BTFSS  07.3
089C:  GOTO   09B
089D:  NOP
089E:  GOTO   09F
089F:  NOP
08A0:  BSF    20.4
08A1:  MOVF   20,W
08A2:  BSF    03.5
08A3:  MOVWF  07
08A4:  NOP
....................   ack=!ack; 
08A5:  MOVLW  01
08A6:  BCF    03.5
08A7:  XORWF  3A,F
....................     
....................  
....................    i2c_start(); 
08A8:  BSF    20.4
08A9:  MOVF   20,W
08AA:  BSF    03.5
08AB:  MOVWF  07
08AC:  NOP
08AD:  BCF    03.5
08AE:  BSF    20.3
08AF:  MOVF   20,W
08B0:  BSF    03.5
08B1:  MOVWF  07
08B2:  NOP
08B3:  BCF    03.5
08B4:  BCF    07.4
08B5:  BCF    20.4
08B6:  MOVF   20,W
08B7:  BSF    03.5
08B8:  MOVWF  07
08B9:  NOP
08BA:  BCF    03.5
08BB:  BCF    07.3
08BC:  BCF    20.3
08BD:  MOVF   20,W
08BE:  BSF    03.5
08BF:  MOVWF  07
....................    I2C_Write(0xE0); 
08C0:  MOVLW  E0
08C1:  BCF    03.5
08C2:  MOVWF  3B
08C3:  BCF    0A.3
08C4:  CALL   0D1
08C5:  BSF    0A.3
....................     
....................    I2C_write(0x80); 
08C6:  MOVLW  80
08C7:  MOVWF  3B
08C8:  BCF    0A.3
08C9:  CALL   0D1
08CA:  BSF    0A.3
....................    i2c_stop();  
08CB:  BCF    20.4
08CC:  MOVF   20,W
08CD:  BSF    03.5
08CE:  MOVWF  07
08CF:  NOP
08D0:  BCF    03.5
08D1:  BSF    20.3
08D2:  MOVF   20,W
08D3:  BSF    03.5
08D4:  MOVWF  07
08D5:  BCF    03.5
08D6:  BTFSS  07.3
08D7:  GOTO   0D6
08D8:  NOP
08D9:  GOTO   0DA
08DA:  NOP
08DB:  BSF    20.4
08DC:  MOVF   20,W
08DD:  BSF    03.5
08DE:  MOVWF  07
08DF:  NOP
....................     
....................    i2c_start(); 
08E0:  BCF    03.5
08E1:  BSF    20.4
08E2:  MOVF   20,W
08E3:  BSF    03.5
08E4:  MOVWF  07
08E5:  NOP
08E6:  BCF    03.5
08E7:  BSF    20.3
08E8:  MOVF   20,W
08E9:  BSF    03.5
08EA:  MOVWF  07
08EB:  NOP
08EC:  BCF    03.5
08ED:  BCF    07.4
08EE:  BCF    20.4
08EF:  MOVF   20,W
08F0:  BSF    03.5
08F1:  MOVWF  07
08F2:  NOP
08F3:  BCF    03.5
08F4:  BCF    07.3
08F5:  BCF    20.3
08F6:  MOVF   20,W
08F7:  BSF    03.5
08F8:  MOVWF  07
....................    I2C_Write(0xE1); 
08F9:  MOVLW  E1
08FA:  BCF    03.5
08FB:  MOVWF  3B
08FC:  BCF    0A.3
08FD:  CALL   0D1
08FE:  BSF    0A.3
....................    XH=i2c_read(); 
08FF:  MOVLW  01
0900:  MOVWF  77
0901:  BCF    0A.3
0902:  CALL   11B
0903:  BSF    0A.3
0904:  MOVF   78,W
0905:  MOVWF  39
....................    i2c_stop();  
0906:  BCF    20.4
0907:  MOVF   20,W
0908:  BSF    03.5
0909:  MOVWF  07
090A:  NOP
090B:  BCF    03.5
090C:  BSF    20.3
090D:  MOVF   20,W
090E:  BSF    03.5
090F:  MOVWF  07
0910:  BCF    03.5
0911:  BTFSS  07.3
0912:  GOTO   111
0913:  NOP
0914:  GOTO   115
0915:  NOP
0916:  BSF    20.4
0917:  MOVF   20,W
0918:  BSF    03.5
0919:  MOVWF  07
091A:  NOP
....................  
.................... delay_ms(1000); 
091B:  MOVLW  04
091C:  BCF    03.5
091D:  MOVWF  3B
091E:  MOVLW  FA
091F:  MOVWF  3C
0920:  BCF    0A.3
0921:  CALL   160
0922:  BSF    0A.3
0923:  DECFSZ 3B,F
0924:  GOTO   11E
....................  
....................  
.................... //printf("Stav: %d (procenta)\r\n", ack); 
....................  
.................... printf("Stavx: %X(procenta)\r\n", XH); 
0925:  MOVLW  10
0926:  BSF    03.6
0927:  MOVWF  0D
0928:  MOVLW  00
0929:  MOVWF  0F
092A:  BCF    03.0
092B:  MOVLW  07
092C:  BCF    03.6
092D:  MOVWF  3B
092E:  BCF    0A.3
092F:  CALL   174
0930:  BSF    0A.3
0931:  MOVF   39,W
0932:  MOVWF  3B
0933:  MOVLW  37
0934:  MOVWF  3C
0935:  BCF    0A.3
0936:  GOTO   1C3
0937:  BSF    0A.3
0938:  MOVLW  14
0939:  BSF    03.6
093A:  MOVWF  0D
093B:  MOVLW  00
093C:  MOVWF  0F
093D:  BSF    03.0
093E:  MOVLW  0C
093F:  BCF    03.6
0940:  MOVWF  3B
0941:  BCF    0A.3
0942:  CALL   174
0943:  BSF    0A.3
....................  
....................  
....................  
....................  
....................  
....................  
....................    i2c_start(); 
0944:  BSF    20.4
0945:  MOVF   20,W
0946:  BSF    03.5
0947:  MOVWF  07
0948:  NOP
0949:  BCF    03.5
094A:  BSF    20.3
094B:  MOVF   20,W
094C:  BSF    03.5
094D:  MOVWF  07
094E:  NOP
094F:  BCF    03.5
0950:  BCF    07.4
0951:  BCF    20.4
0952:  MOVF   20,W
0953:  BSF    03.5
0954:  MOVWF  07
0955:  NOP
0956:  BCF    03.5
0957:  BCF    07.3
0958:  BCF    20.3
0959:  MOVF   20,W
095A:  BSF    03.5
095B:  MOVWF  07
....................    I2C_Write(0xE0); 
095C:  MOVLW  E0
095D:  BCF    03.5
095E:  MOVWF  3B
095F:  BCF    0A.3
0960:  CALL   0D1
0961:  BSF    0A.3
....................     
....................    I2C_write(0x01); 
0962:  MOVLW  01
0963:  MOVWF  3B
0964:  BCF    0A.3
0965:  CALL   0D1
0966:  BSF    0A.3
....................    i2c_stop();  
0967:  BCF    20.4
0968:  MOVF   20,W
0969:  BSF    03.5
096A:  MOVWF  07
096B:  NOP
096C:  BCF    03.5
096D:  BSF    20.3
096E:  MOVF   20,W
096F:  BSF    03.5
0970:  MOVWF  07
0971:  BCF    03.5
0972:  BTFSS  07.3
0973:  GOTO   172
0974:  NOP
0975:  GOTO   176
0976:  NOP
0977:  BSF    20.4
0978:  MOVF   20,W
0979:  BSF    03.5
097A:  MOVWF  07
097B:  NOP
....................     
....................  
....................  
....................  
....................  
....................  
....................   
....................  i2c_start(); 
097C:  BCF    03.5
097D:  BSF    20.4
097E:  MOVF   20,W
097F:  BSF    03.5
0980:  MOVWF  07
0981:  NOP
0982:  BCF    03.5
0983:  BSF    20.3
0984:  MOVF   20,W
0985:  BSF    03.5
0986:  MOVWF  07
0987:  NOP
0988:  BCF    03.5
0989:  BCF    07.4
098A:  BCF    20.4
098B:  MOVF   20,W
098C:  BSF    03.5
098D:  MOVWF  07
098E:  NOP
098F:  BCF    03.5
0990:  BCF    07.3
0991:  BCF    20.3
0992:  MOVF   20,W
0993:  BSF    03.5
0994:  MOVWF  07
....................    I2C_Write(0xAA); 
0995:  MOVLW  AA
0996:  BCF    03.5
0997:  MOVWF  3B
0998:  BCF    0A.3
0999:  CALL   0D1
099A:  BSF    0A.3
....................    I2C_write(0x0c); 
099B:  MOVLW  0C
099C:  MOVWF  3B
099D:  BCF    0A.3
099E:  CALL   0D1
099F:  BSF    0A.3
....................    
....................    i2c_start(); 
09A0:  BSF    20.4
09A1:  MOVF   20,W
09A2:  BSF    03.5
09A3:  MOVWF  07
09A4:  NOP
09A5:  BCF    03.5
09A6:  BSF    20.3
09A7:  MOVF   20,W
09A8:  BSF    03.5
09A9:  MOVWF  07
09AA:  NOP
09AB:  BCF    03.5
09AC:  BTFSS  07.3
09AD:  GOTO   1AC
09AE:  BCF    07.4
09AF:  BCF    20.4
09B0:  MOVF   20,W
09B1:  BSF    03.5
09B2:  MOVWF  07
09B3:  NOP
09B4:  BCF    03.5
09B5:  BCF    07.3
09B6:  BCF    20.3
09B7:  MOVF   20,W
09B8:  BSF    03.5
09B9:  MOVWF  07
....................    I2C_Write(0xAB); 
09BA:  MOVLW  AB
09BB:  BCF    03.5
09BC:  MOVWF  3B
09BD:  BCF    0A.3
09BE:  CALL   0D1
09BF:  BSF    0A.3
....................    INTEP=i2c_read(0); 
09C0:  CLRF   77
09C1:  BCF    0A.3
09C2:  CALL   11B
09C3:  BSF    0A.3
09C4:  MOVF   78,W
09C5:  MOVWF  21
....................    i2c_stop(); 
09C6:  BCF    20.4
09C7:  MOVF   20,W
09C8:  BSF    03.5
09C9:  MOVWF  07
09CA:  NOP
09CB:  BCF    03.5
09CC:  BSF    20.3
09CD:  MOVF   20,W
09CE:  BSF    03.5
09CF:  MOVWF  07
09D0:  BCF    03.5
09D1:  BTFSS  07.3
09D2:  GOTO   1D1
09D3:  NOP
09D4:  GOTO   1D5
09D5:  NOP
09D6:  BSF    20.4
09D7:  MOVF   20,W
09D8:  BSF    03.5
09D9:  MOVWF  07
09DA:  NOP
....................     
....................   i2c_start(); 
09DB:  BCF    03.5
09DC:  BSF    20.4
09DD:  MOVF   20,W
09DE:  BSF    03.5
09DF:  MOVWF  07
09E0:  NOP
09E1:  BCF    03.5
09E2:  BSF    20.3
09E3:  MOVF   20,W
09E4:  BSF    03.5
09E5:  MOVWF  07
09E6:  NOP
09E7:  BCF    03.5
09E8:  BCF    07.4
09E9:  BCF    20.4
09EA:  MOVF   20,W
09EB:  BSF    03.5
09EC:  MOVWF  07
09ED:  NOP
09EE:  BCF    03.5
09EF:  BCF    07.3
09F0:  BCF    20.3
09F1:  MOVF   20,W
09F2:  BSF    03.5
09F3:  MOVWF  07
....................    I2C_Write(0xAA); 
09F4:  MOVLW  AA
09F5:  BCF    03.5
09F6:  MOVWF  3B
09F7:  BCF    0A.3
09F8:  CALL   0D1
09F9:  BSF    0A.3
....................    I2C_write(0x0d); 
09FA:  MOVLW  0D
09FB:  MOVWF  3B
09FC:  BCF    0A.3
09FD:  CALL   0D1
09FE:  BSF    0A.3
....................    i2c_start(); 
09FF:  BSF    20.4
0A00:  MOVF   20,W
0A01:  BSF    03.5
0A02:  MOVWF  07
0A03:  NOP
0A04:  BCF    03.5
0A05:  BSF    20.3
0A06:  MOVF   20,W
0A07:  BSF    03.5
0A08:  MOVWF  07
0A09:  NOP
0A0A:  BCF    03.5
0A0B:  BTFSS  07.3
0A0C:  GOTO   20B
0A0D:  BCF    07.4
0A0E:  BCF    20.4
0A0F:  MOVF   20,W
0A10:  BSF    03.5
0A11:  MOVWF  07
0A12:  NOP
0A13:  BCF    03.5
0A14:  BCF    07.3
0A15:  BCF    20.3
0A16:  MOVF   20,W
0A17:  BSF    03.5
0A18:  MOVWF  07
....................    I2C_Write(0xAB); 
0A19:  MOVLW  AB
0A1A:  BCF    03.5
0A1B:  MOVWF  3B
0A1C:  BCF    0A.3
0A1D:  CALL   0D1
0A1E:  BSF    0A.3
....................    INTEP1=i2c_read(0); 
0A1F:  CLRF   77
0A20:  BCF    0A.3
0A21:  CALL   11B
0A22:  BSF    0A.3
0A23:  MOVF   78,W
0A24:  MOVWF  22
....................    i2c_stop(); 
0A25:  BCF    20.4
0A26:  MOVF   20,W
0A27:  BSF    03.5
0A28:  MOVWF  07
0A29:  NOP
0A2A:  BCF    03.5
0A2B:  BSF    20.3
0A2C:  MOVF   20,W
0A2D:  BSF    03.5
0A2E:  MOVWF  07
0A2F:  BCF    03.5
0A30:  BTFSS  07.3
0A31:  GOTO   230
0A32:  NOP
0A33:  GOTO   234
0A34:  NOP
0A35:  BSF    20.4
0A36:  MOVF   20,W
0A37:  BSF    03.5
0A38:  MOVWF  07
0A39:  NOP
....................     
....................    i2c_start(); 
0A3A:  BCF    03.5
0A3B:  BSF    20.4
0A3C:  MOVF   20,W
0A3D:  BSF    03.5
0A3E:  MOVWF  07
0A3F:  NOP
0A40:  BCF    03.5
0A41:  BSF    20.3
0A42:  MOVF   20,W
0A43:  BSF    03.5
0A44:  MOVWF  07
0A45:  NOP
0A46:  BCF    03.5
0A47:  BCF    07.4
0A48:  BCF    20.4
0A49:  MOVF   20,W
0A4A:  BSF    03.5
0A4B:  MOVWF  07
0A4C:  NOP
0A4D:  BCF    03.5
0A4E:  BCF    07.3
0A4F:  BCF    20.3
0A50:  MOVF   20,W
0A51:  BSF    03.5
0A52:  MOVWF  07
....................    I2C_Write(0xAA); 
0A53:  MOVLW  AA
0A54:  BCF    03.5
0A55:  MOVWF  3B
0A56:  BCF    0A.3
0A57:  CALL   0D1
0A58:  BSF    0A.3
....................    I2C_write(0x08); 
0A59:  MOVLW  08
0A5A:  MOVWF  3B
0A5B:  BCF    0A.3
0A5C:  CALL   0D1
0A5D:  BSF    0A.3
....................    i2c_stop(); 
0A5E:  BCF    20.4
0A5F:  MOVF   20,W
0A60:  BSF    03.5
0A61:  MOVWF  07
0A62:  NOP
0A63:  BCF    03.5
0A64:  BSF    20.3
0A65:  MOVF   20,W
0A66:  BSF    03.5
0A67:  MOVWF  07
0A68:  BCF    03.5
0A69:  BTFSS  07.3
0A6A:  GOTO   269
0A6B:  NOP
0A6C:  GOTO   26D
0A6D:  NOP
0A6E:  BSF    20.4
0A6F:  MOVF   20,W
0A70:  BSF    03.5
0A71:  MOVWF  07
0A72:  NOP
....................    i2c_start(); 
0A73:  BCF    03.5
0A74:  BSF    20.4
0A75:  MOVF   20,W
0A76:  BSF    03.5
0A77:  MOVWF  07
0A78:  NOP
0A79:  BCF    03.5
0A7A:  BSF    20.3
0A7B:  MOVF   20,W
0A7C:  BSF    03.5
0A7D:  MOVWF  07
0A7E:  NOP
0A7F:  BCF    03.5
0A80:  BCF    07.4
0A81:  BCF    20.4
0A82:  MOVF   20,W
0A83:  BSF    03.5
0A84:  MOVWF  07
0A85:  NOP
0A86:  BCF    03.5
0A87:  BCF    07.3
0A88:  BCF    20.3
0A89:  MOVF   20,W
0A8A:  BSF    03.5
0A8B:  MOVWF  07
....................    I2C_Write(0xAB); 
0A8C:  MOVLW  AB
0A8D:  BCF    03.5
0A8E:  MOVWF  3B
0A8F:  BCF    0A.3
0A90:  CALL   0D1
0A91:  BSF    0A.3
....................    NAP=i2c_read(0); 
0A92:  CLRF   77
0A93:  BCF    0A.3
0A94:  CALL   11B
0A95:  BSF    0A.3
0A96:  MOVF   78,W
0A97:  MOVWF  23
....................    i2c_stop(); 
0A98:  BCF    20.4
0A99:  MOVF   20,W
0A9A:  BSF    03.5
0A9B:  MOVWF  07
0A9C:  NOP
0A9D:  BCF    03.5
0A9E:  BSF    20.3
0A9F:  MOVF   20,W
0AA0:  BSF    03.5
0AA1:  MOVWF  07
0AA2:  BCF    03.5
0AA3:  BTFSS  07.3
0AA4:  GOTO   2A3
0AA5:  NOP
0AA6:  GOTO   2A7
0AA7:  NOP
0AA8:  BSF    20.4
0AA9:  MOVF   20,W
0AAA:  BSF    03.5
0AAB:  MOVWF  07
0AAC:  NOP
....................  
....................    i2c_start(); 
0AAD:  BCF    03.5
0AAE:  BSF    20.4
0AAF:  MOVF   20,W
0AB0:  BSF    03.5
0AB1:  MOVWF  07
0AB2:  NOP
0AB3:  BCF    03.5
0AB4:  BSF    20.3
0AB5:  MOVF   20,W
0AB6:  BSF    03.5
0AB7:  MOVWF  07
0AB8:  NOP
0AB9:  BCF    03.5
0ABA:  BCF    07.4
0ABB:  BCF    20.4
0ABC:  MOVF   20,W
0ABD:  BSF    03.5
0ABE:  MOVWF  07
0ABF:  NOP
0AC0:  BCF    03.5
0AC1:  BCF    07.3
0AC2:  BCF    20.3
0AC3:  MOVF   20,W
0AC4:  BSF    03.5
0AC5:  MOVWF  07
....................    I2C_Write(0xAA); 
0AC6:  MOVLW  AA
0AC7:  BCF    03.5
0AC8:  MOVWF  3B
0AC9:  BCF    0A.3
0ACA:  CALL   0D1
0ACB:  BSF    0A.3
....................    I2C_write(0x09); 
0ACC:  MOVLW  09
0ACD:  MOVWF  3B
0ACE:  BCF    0A.3
0ACF:  CALL   0D1
0AD0:  BSF    0A.3
....................    i2c_stop(); 
0AD1:  BCF    20.4
0AD2:  MOVF   20,W
0AD3:  BSF    03.5
0AD4:  MOVWF  07
0AD5:  NOP
0AD6:  BCF    03.5
0AD7:  BSF    20.3
0AD8:  MOVF   20,W
0AD9:  BSF    03.5
0ADA:  MOVWF  07
0ADB:  BCF    03.5
0ADC:  BTFSS  07.3
0ADD:  GOTO   2DC
0ADE:  NOP
0ADF:  GOTO   2E0
0AE0:  NOP
0AE1:  BSF    20.4
0AE2:  MOVF   20,W
0AE3:  BSF    03.5
0AE4:  MOVWF  07
0AE5:  NOP
....................    i2c_start(); 
0AE6:  BCF    03.5
0AE7:  BSF    20.4
0AE8:  MOVF   20,W
0AE9:  BSF    03.5
0AEA:  MOVWF  07
0AEB:  NOP
0AEC:  BCF    03.5
0AED:  BSF    20.3
0AEE:  MOVF   20,W
0AEF:  BSF    03.5
0AF0:  MOVWF  07
0AF1:  NOP
0AF2:  BCF    03.5
0AF3:  BCF    07.4
0AF4:  BCF    20.4
0AF5:  MOVF   20,W
0AF6:  BSF    03.5
0AF7:  MOVWF  07
0AF8:  NOP
0AF9:  BCF    03.5
0AFA:  BCF    07.3
0AFB:  BCF    20.3
0AFC:  MOVF   20,W
0AFD:  BSF    03.5
0AFE:  MOVWF  07
....................    I2C_Write(0xAB); 
0AFF:  MOVLW  AB
0B00:  BCF    03.5
0B01:  MOVWF  3B
0B02:  BCF    0A.3
0B03:  CALL   0D1
0B04:  BSF    0A.3
....................    NAP1=i2c_read(0); 
0B05:  CLRF   77
0B06:  BCF    0A.3
0B07:  CALL   11B
0B08:  BSF    0A.3
0B09:  MOVF   78,W
0B0A:  MOVWF  24
....................    i2c_stop(); 
0B0B:  BCF    20.4
0B0C:  MOVF   20,W
0B0D:  BSF    03.5
0B0E:  MOVWF  07
0B0F:  NOP
0B10:  BCF    03.5
0B11:  BSF    20.3
0B12:  MOVF   20,W
0B13:  BSF    03.5
0B14:  MOVWF  07
0B15:  BCF    03.5
0B16:  BTFSS  07.3
0B17:  GOTO   316
0B18:  NOP
0B19:  GOTO   31A
0B1A:  NOP
0B1B:  BSF    20.4
0B1C:  MOVF   20,W
0B1D:  BSF    03.5
0B1E:  MOVWF  07
0B1F:  NOP
....................     
....................     i2c_start(); 
0B20:  BCF    03.5
0B21:  BSF    20.4
0B22:  MOVF   20,W
0B23:  BSF    03.5
0B24:  MOVWF  07
0B25:  NOP
0B26:  BCF    03.5
0B27:  BSF    20.3
0B28:  MOVF   20,W
0B29:  BSF    03.5
0B2A:  MOVWF  07
0B2B:  NOP
0B2C:  BCF    03.5
0B2D:  BCF    07.4
0B2E:  BCF    20.4
0B2F:  MOVF   20,W
0B30:  BSF    03.5
0B31:  MOVWF  07
0B32:  NOP
0B33:  BCF    03.5
0B34:  BCF    07.3
0B35:  BCF    20.3
0B36:  MOVF   20,W
0B37:  BSF    03.5
0B38:  MOVWF  07
....................    I2C_Write(0xAA); 
0B39:  MOVLW  AA
0B3A:  BCF    03.5
0B3B:  MOVWF  3B
0B3C:  BCF    0A.3
0B3D:  CALL   0D1
0B3E:  BSF    0A.3
....................    I2C_write(0x0a); 
0B3F:  MOVLW  0A
0B40:  MOVWF  3B
0B41:  BCF    0A.3
0B42:  CALL   0D1
0B43:  BSF    0A.3
....................    i2c_stop(); 
0B44:  BCF    20.4
0B45:  MOVF   20,W
0B46:  BSF    03.5
0B47:  MOVWF  07
0B48:  NOP
0B49:  BCF    03.5
0B4A:  BSF    20.3
0B4B:  MOVF   20,W
0B4C:  BSF    03.5
0B4D:  MOVWF  07
0B4E:  BCF    03.5
0B4F:  BTFSS  07.3
0B50:  GOTO   34F
0B51:  NOP
0B52:  GOTO   353
0B53:  NOP
0B54:  BSF    20.4
0B55:  MOVF   20,W
0B56:  BSF    03.5
0B57:  MOVWF  07
0B58:  NOP
....................    i2c_start(); 
0B59:  BCF    03.5
0B5A:  BSF    20.4
0B5B:  MOVF   20,W
0B5C:  BSF    03.5
0B5D:  MOVWF  07
0B5E:  NOP
0B5F:  BCF    03.5
0B60:  BSF    20.3
0B61:  MOVF   20,W
0B62:  BSF    03.5
0B63:  MOVWF  07
0B64:  NOP
0B65:  BCF    03.5
0B66:  BCF    07.4
0B67:  BCF    20.4
0B68:  MOVF   20,W
0B69:  BSF    03.5
0B6A:  MOVWF  07
0B6B:  NOP
0B6C:  BCF    03.5
0B6D:  BCF    07.3
0B6E:  BCF    20.3
0B6F:  MOVF   20,W
0B70:  BSF    03.5
0B71:  MOVWF  07
....................    I2C_Write(0xAB); 
0B72:  MOVLW  AB
0B73:  BCF    03.5
0B74:  MOVWF  3B
0B75:  BCF    0A.3
0B76:  CALL   0D1
0B77:  BSF    0A.3
....................    PROUD=i2c_read(0); 
0B78:  CLRF   77
0B79:  BCF    0A.3
0B7A:  CALL   11B
0B7B:  BSF    0A.3
0B7C:  MOVF   78,W
0B7D:  MOVWF  25
....................    i2c_stop(); 
0B7E:  BCF    20.4
0B7F:  MOVF   20,W
0B80:  BSF    03.5
0B81:  MOVWF  07
0B82:  NOP
0B83:  BCF    03.5
0B84:  BSF    20.3
0B85:  MOVF   20,W
0B86:  BSF    03.5
0B87:  MOVWF  07
0B88:  BCF    03.5
0B89:  BTFSS  07.3
0B8A:  GOTO   389
0B8B:  NOP
0B8C:  GOTO   38D
0B8D:  NOP
0B8E:  BSF    20.4
0B8F:  MOVF   20,W
0B90:  BSF    03.5
0B91:  MOVWF  07
0B92:  NOP
....................  
....................    i2c_start(); 
0B93:  BCF    03.5
0B94:  BSF    20.4
0B95:  MOVF   20,W
0B96:  BSF    03.5
0B97:  MOVWF  07
0B98:  NOP
0B99:  BCF    03.5
0B9A:  BSF    20.3
0B9B:  MOVF   20,W
0B9C:  BSF    03.5
0B9D:  MOVWF  07
0B9E:  NOP
0B9F:  BCF    03.5
0BA0:  BCF    07.4
0BA1:  BCF    20.4
0BA2:  MOVF   20,W
0BA3:  BSF    03.5
0BA4:  MOVWF  07
0BA5:  NOP
0BA6:  BCF    03.5
0BA7:  BCF    07.3
0BA8:  BCF    20.3
0BA9:  MOVF   20,W
0BAA:  BSF    03.5
0BAB:  MOVWF  07
....................    I2C_Write(0xAA); 
0BAC:  MOVLW  AA
0BAD:  BCF    03.5
0BAE:  MOVWF  3B
0BAF:  BCF    0A.3
0BB0:  CALL   0D1
0BB1:  BSF    0A.3
....................    I2C_write(0x0b); 
0BB2:  MOVLW  0B
0BB3:  MOVWF  3B
0BB4:  BCF    0A.3
0BB5:  CALL   0D1
0BB6:  BSF    0A.3
....................    i2c_stop(); 
0BB7:  BCF    20.4
0BB8:  MOVF   20,W
0BB9:  BSF    03.5
0BBA:  MOVWF  07
0BBB:  NOP
0BBC:  BCF    03.5
0BBD:  BSF    20.3
0BBE:  MOVF   20,W
0BBF:  BSF    03.5
0BC0:  MOVWF  07
0BC1:  BCF    03.5
0BC2:  BTFSS  07.3
0BC3:  GOTO   3C2
0BC4:  NOP
0BC5:  GOTO   3C6
0BC6:  NOP
0BC7:  BSF    20.4
0BC8:  MOVF   20,W
0BC9:  BSF    03.5
0BCA:  MOVWF  07
0BCB:  NOP
....................    i2c_start(); 
0BCC:  BCF    03.5
0BCD:  BSF    20.4
0BCE:  MOVF   20,W
0BCF:  BSF    03.5
0BD0:  MOVWF  07
0BD1:  NOP
0BD2:  BCF    03.5
0BD3:  BSF    20.3
0BD4:  MOVF   20,W
0BD5:  BSF    03.5
0BD6:  MOVWF  07
0BD7:  NOP
0BD8:  BCF    03.5
0BD9:  BCF    07.4
0BDA:  BCF    20.4
0BDB:  MOVF   20,W
0BDC:  BSF    03.5
0BDD:  MOVWF  07
0BDE:  NOP
0BDF:  BCF    03.5
0BE0:  BCF    07.3
0BE1:  BCF    20.3
0BE2:  MOVF   20,W
0BE3:  BSF    03.5
0BE4:  MOVWF  07
....................    I2C_Write(0xAB); 
0BE5:  MOVLW  AB
0BE6:  BCF    03.5
0BE7:  MOVWF  3B
0BE8:  BCF    0A.3
0BE9:  CALL   0D1
0BEA:  BSF    0A.3
....................    PROUD1=i2c_read(0); 
0BEB:  CLRF   77
0BEC:  BCF    0A.3
0BED:  CALL   11B
0BEE:  BSF    0A.3
0BEF:  MOVF   78,W
0BF0:  MOVWF  26
....................    i2c_stop();   
0BF1:  BCF    20.4
0BF2:  MOVF   20,W
0BF3:  BSF    03.5
0BF4:  MOVWF  07
0BF5:  NOP
0BF6:  BCF    03.5
0BF7:  BSF    20.3
0BF8:  MOVF   20,W
0BF9:  BSF    03.5
0BFA:  MOVWF  07
0BFB:  BCF    03.5
0BFC:  BTFSS  07.3
0BFD:  GOTO   3FC
0BFE:  NOP
0BFF:  GOTO   400
0C00:  NOP
0C01:  BSF    20.4
0C02:  MOVF   20,W
0C03:  BSF    03.5
0C04:  MOVWF  07
0C05:  NOP
....................     
....................     
....................        i2c_start(); 
0C06:  BCF    03.5
0C07:  BSF    20.4
0C08:  MOVF   20,W
0C09:  BSF    03.5
0C0A:  MOVWF  07
0C0B:  NOP
0C0C:  BCF    03.5
0C0D:  BSF    20.3
0C0E:  MOVF   20,W
0C0F:  BSF    03.5
0C10:  MOVWF  07
0C11:  NOP
0C12:  BCF    03.5
0C13:  BCF    07.4
0C14:  BCF    20.4
0C15:  MOVF   20,W
0C16:  BSF    03.5
0C17:  MOVWF  07
0C18:  NOP
0C19:  BCF    03.5
0C1A:  BCF    07.3
0C1B:  BCF    20.3
0C1C:  MOVF   20,W
0C1D:  BSF    03.5
0C1E:  MOVWF  07
....................    I2C_Write(0xAA); 
0C1F:  MOVLW  AA
0C20:  BCF    03.5
0C21:  MOVWF  3B
0C22:  BCF    0A.3
0C23:  CALL   0D1
0C24:  BSF    0A.3
....................    I2C_write(0x04); 
0C25:  MOVLW  04
0C26:  MOVWF  3B
0C27:  BCF    0A.3
0C28:  CALL   0D1
0C29:  BSF    0A.3
....................    i2c_stop(); 
0C2A:  BCF    20.4
0C2B:  MOVF   20,W
0C2C:  BSF    03.5
0C2D:  MOVWF  07
0C2E:  NOP
0C2F:  BCF    03.5
0C30:  BSF    20.3
0C31:  MOVF   20,W
0C32:  BSF    03.5
0C33:  MOVWF  07
0C34:  BCF    03.5
0C35:  BTFSS  07.3
0C36:  GOTO   435
0C37:  NOP
0C38:  GOTO   439
0C39:  NOP
0C3A:  BSF    20.4
0C3B:  MOVF   20,W
0C3C:  BSF    03.5
0C3D:  MOVWF  07
0C3E:  NOP
....................    i2c_start(); 
0C3F:  BCF    03.5
0C40:  BSF    20.4
0C41:  MOVF   20,W
0C42:  BSF    03.5
0C43:  MOVWF  07
0C44:  NOP
0C45:  BCF    03.5
0C46:  BSF    20.3
0C47:  MOVF   20,W
0C48:  BSF    03.5
0C49:  MOVWF  07
0C4A:  NOP
0C4B:  BCF    03.5
0C4C:  BCF    07.4
0C4D:  BCF    20.4
0C4E:  MOVF   20,W
0C4F:  BSF    03.5
0C50:  MOVWF  07
0C51:  NOP
0C52:  BCF    03.5
0C53:  BCF    07.3
0C54:  BCF    20.3
0C55:  MOVF   20,W
0C56:  BSF    03.5
0C57:  MOVWF  07
....................    I2C_Write(0xAB); 
0C58:  MOVLW  AB
0C59:  BCF    03.5
0C5A:  MOVWF  3B
0C5B:  BCF    0A.3
0C5C:  CALL   0D1
0C5D:  BSF    0A.3
....................    KAPZ=i2c_read(0); 
0C5E:  CLRF   77
0C5F:  BCF    0A.3
0C60:  CALL   11B
0C61:  BSF    0A.3
0C62:  MOVF   78,W
0C63:  MOVWF  27
....................    i2c_stop(); 
0C64:  BCF    20.4
0C65:  MOVF   20,W
0C66:  BSF    03.5
0C67:  MOVWF  07
0C68:  NOP
0C69:  BCF    03.5
0C6A:  BSF    20.3
0C6B:  MOVF   20,W
0C6C:  BSF    03.5
0C6D:  MOVWF  07
0C6E:  BCF    03.5
0C6F:  BTFSS  07.3
0C70:  GOTO   46F
0C71:  NOP
0C72:  GOTO   473
0C73:  NOP
0C74:  BSF    20.4
0C75:  MOVF   20,W
0C76:  BSF    03.5
0C77:  MOVWF  07
0C78:  NOP
....................  
....................    i2c_start(); 
0C79:  BCF    03.5
0C7A:  BSF    20.4
0C7B:  MOVF   20,W
0C7C:  BSF    03.5
0C7D:  MOVWF  07
0C7E:  NOP
0C7F:  BCF    03.5
0C80:  BSF    20.3
0C81:  MOVF   20,W
0C82:  BSF    03.5
0C83:  MOVWF  07
0C84:  NOP
0C85:  BCF    03.5
0C86:  BCF    07.4
0C87:  BCF    20.4
0C88:  MOVF   20,W
0C89:  BSF    03.5
0C8A:  MOVWF  07
0C8B:  NOP
0C8C:  BCF    03.5
0C8D:  BCF    07.3
0C8E:  BCF    20.3
0C8F:  MOVF   20,W
0C90:  BSF    03.5
0C91:  MOVWF  07
....................    I2C_Write(0xAA); 
0C92:  MOVLW  AA
0C93:  BCF    03.5
0C94:  MOVWF  3B
0C95:  BCF    0A.3
0C96:  CALL   0D1
0C97:  BSF    0A.3
....................    I2C_write(0x05); 
0C98:  MOVLW  05
0C99:  MOVWF  3B
0C9A:  BCF    0A.3
0C9B:  CALL   0D1
0C9C:  BSF    0A.3
....................    i2c_stop(); 
0C9D:  BCF    20.4
0C9E:  MOVF   20,W
0C9F:  BSF    03.5
0CA0:  MOVWF  07
0CA1:  NOP
0CA2:  BCF    03.5
0CA3:  BSF    20.3
0CA4:  MOVF   20,W
0CA5:  BSF    03.5
0CA6:  MOVWF  07
0CA7:  BCF    03.5
0CA8:  BTFSS  07.3
0CA9:  GOTO   4A8
0CAA:  NOP
0CAB:  GOTO   4AC
0CAC:  NOP
0CAD:  BSF    20.4
0CAE:  MOVF   20,W
0CAF:  BSF    03.5
0CB0:  MOVWF  07
0CB1:  NOP
....................    i2c_start(); 
0CB2:  BCF    03.5
0CB3:  BSF    20.4
0CB4:  MOVF   20,W
0CB5:  BSF    03.5
0CB6:  MOVWF  07
0CB7:  NOP
0CB8:  BCF    03.5
0CB9:  BSF    20.3
0CBA:  MOVF   20,W
0CBB:  BSF    03.5
0CBC:  MOVWF  07
0CBD:  NOP
0CBE:  BCF    03.5
0CBF:  BCF    07.4
0CC0:  BCF    20.4
0CC1:  MOVF   20,W
0CC2:  BSF    03.5
0CC3:  MOVWF  07
0CC4:  NOP
0CC5:  BCF    03.5
0CC6:  BCF    07.3
0CC7:  BCF    20.3
0CC8:  MOVF   20,W
0CC9:  BSF    03.5
0CCA:  MOVWF  07
....................    I2C_Write(0xAB); 
0CCB:  MOVLW  AB
0CCC:  BCF    03.5
0CCD:  MOVWF  3B
0CCE:  BCF    0A.3
0CCF:  CALL   0D1
0CD0:  BSF    0A.3
....................    KAPZ1=i2c_read(0); 
0CD1:  CLRF   77
0CD2:  BCF    0A.3
0CD3:  CALL   11B
0CD4:  BSF    0A.3
0CD5:  MOVF   78,W
0CD6:  MOVWF  28
....................    i2c_stop();  
0CD7:  BCF    20.4
0CD8:  MOVF   20,W
0CD9:  BSF    03.5
0CDA:  MOVWF  07
0CDB:  NOP
0CDC:  BCF    03.5
0CDD:  BSF    20.3
0CDE:  MOVF   20,W
0CDF:  BSF    03.5
0CE0:  MOVWF  07
0CE1:  BCF    03.5
0CE2:  BTFSS  07.3
0CE3:  GOTO   4E2
0CE4:  NOP
0CE5:  GOTO   4E6
0CE6:  NOP
0CE7:  BSF    20.4
0CE8:  MOVF   20,W
0CE9:  BSF    03.5
0CEA:  MOVWF  07
0CEB:  NOP
....................     
....................     
....................    i2c_start(); 
0CEC:  BCF    03.5
0CED:  BSF    20.4
0CEE:  MOVF   20,W
0CEF:  BSF    03.5
0CF0:  MOVWF  07
0CF1:  NOP
0CF2:  BCF    03.5
0CF3:  BSF    20.3
0CF4:  MOVF   20,W
0CF5:  BSF    03.5
0CF6:  MOVWF  07
0CF7:  NOP
0CF8:  BCF    03.5
0CF9:  BCF    07.4
0CFA:  BCF    20.4
0CFB:  MOVF   20,W
0CFC:  BSF    03.5
0CFD:  MOVWF  07
0CFE:  NOP
0CFF:  BCF    03.5
0D00:  BCF    07.3
0D01:  BCF    20.3
0D02:  MOVF   20,W
0D03:  BSF    03.5
0D04:  MOVWF  07
....................    I2C_Write(0xAA); 
0D05:  MOVLW  AA
0D06:  BCF    03.5
0D07:  MOVWF  3B
0D08:  BCF    0A.3
0D09:  CALL   0D1
0D0A:  BSF    0A.3
....................    I2C_write(0x06); 
0D0B:  MOVLW  06
0D0C:  MOVWF  3B
0D0D:  BCF    0A.3
0D0E:  CALL   0D1
0D0F:  BSF    0A.3
....................    i2c_stop(); 
0D10:  BCF    20.4
0D11:  MOVF   20,W
0D12:  BSF    03.5
0D13:  MOVWF  07
0D14:  NOP
0D15:  BCF    03.5
0D16:  BSF    20.3
0D17:  MOVF   20,W
0D18:  BSF    03.5
0D19:  MOVWF  07
0D1A:  BCF    03.5
0D1B:  BTFSS  07.3
0D1C:  GOTO   51B
0D1D:  NOP
0D1E:  GOTO   51F
0D1F:  NOP
0D20:  BSF    20.4
0D21:  MOVF   20,W
0D22:  BSF    03.5
0D23:  MOVWF  07
0D24:  NOP
....................    i2c_start(); 
0D25:  BCF    03.5
0D26:  BSF    20.4
0D27:  MOVF   20,W
0D28:  BSF    03.5
0D29:  MOVWF  07
0D2A:  NOP
0D2B:  BCF    03.5
0D2C:  BSF    20.3
0D2D:  MOVF   20,W
0D2E:  BSF    03.5
0D2F:  MOVWF  07
0D30:  NOP
0D31:  BCF    03.5
0D32:  BCF    07.4
0D33:  BCF    20.4
0D34:  MOVF   20,W
0D35:  BSF    03.5
0D36:  MOVWF  07
0D37:  NOP
0D38:  BCF    03.5
0D39:  BCF    07.3
0D3A:  BCF    20.3
0D3B:  MOVF   20,W
0D3C:  BSF    03.5
0D3D:  MOVWF  07
....................    I2C_Write(0xAB); 
0D3E:  MOVLW  AB
0D3F:  BCF    03.5
0D40:  MOVWF  3B
0D41:  BCF    0A.3
0D42:  CALL   0D1
0D43:  BSF    0A.3
....................    KAPC=i2c_read(0); 
0D44:  CLRF   77
0D45:  BCF    0A.3
0D46:  CALL   11B
0D47:  BSF    0A.3
0D48:  MOVF   78,W
0D49:  MOVWF  29
....................    i2c_stop(); 
0D4A:  BCF    20.4
0D4B:  MOVF   20,W
0D4C:  BSF    03.5
0D4D:  MOVWF  07
0D4E:  NOP
0D4F:  BCF    03.5
0D50:  BSF    20.3
0D51:  MOVF   20,W
0D52:  BSF    03.5
0D53:  MOVWF  07
0D54:  BCF    03.5
0D55:  BTFSS  07.3
0D56:  GOTO   555
0D57:  NOP
0D58:  GOTO   559
0D59:  NOP
0D5A:  BSF    20.4
0D5B:  MOVF   20,W
0D5C:  BSF    03.5
0D5D:  MOVWF  07
0D5E:  NOP
....................  
....................    i2c_start(); 
0D5F:  BCF    03.5
0D60:  BSF    20.4
0D61:  MOVF   20,W
0D62:  BSF    03.5
0D63:  MOVWF  07
0D64:  NOP
0D65:  BCF    03.5
0D66:  BSF    20.3
0D67:  MOVF   20,W
0D68:  BSF    03.5
0D69:  MOVWF  07
0D6A:  NOP
0D6B:  BCF    03.5
0D6C:  BCF    07.4
0D6D:  BCF    20.4
0D6E:  MOVF   20,W
0D6F:  BSF    03.5
0D70:  MOVWF  07
0D71:  NOP
0D72:  BCF    03.5
0D73:  BCF    07.3
0D74:  BCF    20.3
0D75:  MOVF   20,W
0D76:  BSF    03.5
0D77:  MOVWF  07
....................    I2C_Write(0xAA); 
0D78:  MOVLW  AA
0D79:  BCF    03.5
0D7A:  MOVWF  3B
0D7B:  BCF    0A.3
0D7C:  CALL   0D1
0D7D:  BSF    0A.3
....................    I2C_write(0x07); 
0D7E:  MOVLW  07
0D7F:  MOVWF  3B
0D80:  BCF    0A.3
0D81:  CALL   0D1
0D82:  BSF    0A.3
....................    i2c_stop(); 
0D83:  BCF    20.4
0D84:  MOVF   20,W
0D85:  BSF    03.5
0D86:  MOVWF  07
0D87:  NOP
0D88:  BCF    03.5
0D89:  BSF    20.3
0D8A:  MOVF   20,W
0D8B:  BSF    03.5
0D8C:  MOVWF  07
0D8D:  BCF    03.5
0D8E:  BTFSS  07.3
0D8F:  GOTO   58E
0D90:  NOP
0D91:  GOTO   592
0D92:  NOP
0D93:  BSF    20.4
0D94:  MOVF   20,W
0D95:  BSF    03.5
0D96:  MOVWF  07
0D97:  NOP
....................    i2c_start(); 
0D98:  BCF    03.5
0D99:  BSF    20.4
0D9A:  MOVF   20,W
0D9B:  BSF    03.5
0D9C:  MOVWF  07
0D9D:  NOP
0D9E:  BCF    03.5
0D9F:  BSF    20.3
0DA0:  MOVF   20,W
0DA1:  BSF    03.5
0DA2:  MOVWF  07
0DA3:  NOP
0DA4:  BCF    03.5
0DA5:  BCF    07.4
0DA6:  BCF    20.4
0DA7:  MOVF   20,W
0DA8:  BSF    03.5
0DA9:  MOVWF  07
0DAA:  NOP
0DAB:  BCF    03.5
0DAC:  BCF    07.3
0DAD:  BCF    20.3
0DAE:  MOVF   20,W
0DAF:  BSF    03.5
0DB0:  MOVWF  07
....................    I2C_Write(0xAB); 
0DB1:  MOVLW  AB
0DB2:  BCF    03.5
0DB3:  MOVWF  3B
0DB4:  BCF    0A.3
0DB5:  CALL   0D1
0DB6:  BSF    0A.3
....................    KAPC1=i2c_read(0); 
0DB7:  CLRF   77
0DB8:  BCF    0A.3
0DB9:  CALL   11B
0DBA:  BSF    0A.3
0DBB:  MOVF   78,W
0DBC:  MOVWF  2A
....................    i2c_stop(); 
0DBD:  BCF    20.4
0DBE:  MOVF   20,W
0DBF:  BSF    03.5
0DC0:  MOVWF  07
0DC1:  NOP
0DC2:  BCF    03.5
0DC3:  BSF    20.3
0DC4:  MOVF   20,W
0DC5:  BSF    03.5
0DC6:  MOVWF  07
0DC7:  BCF    03.5
0DC8:  BTFSS  07.3
0DC9:  GOTO   5C8
0DCA:  NOP
0DCB:  GOTO   5CC
0DCC:  NOP
0DCD:  BSF    20.4
0DCE:  MOVF   20,W
0DCF:  BSF    03.5
0DD0:  MOVWF  07
0DD1:  NOP
....................     
....................       i2c_start(); 
0DD2:  BCF    03.5
0DD3:  BSF    20.4
0DD4:  MOVF   20,W
0DD5:  BSF    03.5
0DD6:  MOVWF  07
0DD7:  NOP
0DD8:  BCF    03.5
0DD9:  BSF    20.3
0DDA:  MOVF   20,W
0DDB:  BSF    03.5
0DDC:  MOVWF  07
0DDD:  NOP
0DDE:  BCF    03.5
0DDF:  BCF    07.4
0DE0:  BCF    20.4
0DE1:  MOVF   20,W
0DE2:  BSF    03.5
0DE3:  MOVWF  07
0DE4:  NOP
0DE5:  BCF    03.5
0DE6:  BCF    07.3
0DE7:  BCF    20.3
0DE8:  MOVF   20,W
0DE9:  BSF    03.5
0DEA:  MOVWF  07
....................    I2C_Write(0xAA); 
0DEB:  MOVLW  AA
0DEC:  BCF    03.5
0DED:  MOVWF  3B
0DEE:  BCF    0A.3
0DEF:  CALL   0D1
0DF0:  BSF    0A.3
....................    I2C_write(0x02); 
0DF1:  MOVLW  02
0DF2:  MOVWF  3B
0DF3:  BCF    0A.3
0DF4:  CALL   0D1
0DF5:  BSF    0A.3
....................    i2c_stop(); 
0DF6:  BCF    20.4
0DF7:  MOVF   20,W
0DF8:  BSF    03.5
0DF9:  MOVWF  07
0DFA:  NOP
0DFB:  BCF    03.5
0DFC:  BSF    20.3
0DFD:  MOVF   20,W
0DFE:  BSF    03.5
0DFF:  MOVWF  07
0E00:  BCF    03.5
0E01:  BTFSS  07.3
0E02:  GOTO   601
0E03:  NOP
0E04:  GOTO   605
0E05:  NOP
0E06:  BSF    20.4
0E07:  MOVF   20,W
0E08:  BSF    03.5
0E09:  MOVWF  07
0E0A:  NOP
....................    i2c_start(); 
0E0B:  BCF    03.5
0E0C:  BSF    20.4
0E0D:  MOVF   20,W
0E0E:  BSF    03.5
0E0F:  MOVWF  07
0E10:  NOP
0E11:  BCF    03.5
0E12:  BSF    20.3
0E13:  MOVF   20,W
0E14:  BSF    03.5
0E15:  MOVWF  07
0E16:  NOP
0E17:  BCF    03.5
0E18:  BCF    07.4
0E19:  BCF    20.4
0E1A:  MOVF   20,W
0E1B:  BSF    03.5
0E1C:  MOVWF  07
0E1D:  NOP
0E1E:  BCF    03.5
0E1F:  BCF    07.3
0E20:  BCF    20.3
0E21:  MOVF   20,W
0E22:  BSF    03.5
0E23:  MOVWF  07
....................    I2C_Write(0xAB); 
0E24:  MOVLW  AB
0E25:  BCF    03.5
0E26:  MOVWF  3B
0E27:  BCF    0A.3
0E28:  CALL   0D1
0E29:  BSF    0A.3
....................    STAV=i2c_read(0); 
0E2A:  CLRF   77
0E2B:  BCF    0A.3
0E2C:  CALL   11B
0E2D:  BSF    0A.3
0E2E:  MOVF   78,W
0E2F:  MOVWF  2B
....................    i2c_stop(); 
0E30:  BCF    20.4
0E31:  MOVF   20,W
0E32:  BSF    03.5
0E33:  MOVWF  07
0E34:  NOP
0E35:  BCF    03.5
0E36:  BSF    20.3
0E37:  MOVF   20,W
0E38:  BSF    03.5
0E39:  MOVWF  07
0E3A:  BCF    03.5
0E3B:  BTFSS  07.3
0E3C:  GOTO   63B
0E3D:  NOP
0E3E:  GOTO   63F
0E3F:  NOP
0E40:  BSF    20.4
0E41:  MOVF   20,W
0E42:  BSF    03.5
0E43:  MOVWF  07
0E44:  NOP
....................  
....................    i2c_start(); 
0E45:  BCF    03.5
0E46:  BSF    20.4
0E47:  MOVF   20,W
0E48:  BSF    03.5
0E49:  MOVWF  07
0E4A:  NOP
0E4B:  BCF    03.5
0E4C:  BSF    20.3
0E4D:  MOVF   20,W
0E4E:  BSF    03.5
0E4F:  MOVWF  07
0E50:  NOP
0E51:  BCF    03.5
0E52:  BCF    07.4
0E53:  BCF    20.4
0E54:  MOVF   20,W
0E55:  BSF    03.5
0E56:  MOVWF  07
0E57:  NOP
0E58:  BCF    03.5
0E59:  BCF    07.3
0E5A:  BCF    20.3
0E5B:  MOVF   20,W
0E5C:  BSF    03.5
0E5D:  MOVWF  07
....................    I2C_Write(0xAA); 
0E5E:  MOVLW  AA
0E5F:  BCF    03.5
0E60:  MOVWF  3B
0E61:  BCF    0A.3
0E62:  CALL   0D1
0E63:  BSF    0A.3
....................    I2C_write(0x03); 
0E64:  MOVLW  03
0E65:  MOVWF  3B
0E66:  BCF    0A.3
0E67:  CALL   0D1
0E68:  BSF    0A.3
....................    i2c_stop(); 
0E69:  BCF    20.4
0E6A:  MOVF   20,W
0E6B:  BSF    03.5
0E6C:  MOVWF  07
0E6D:  NOP
0E6E:  BCF    03.5
0E6F:  BSF    20.3
0E70:  MOVF   20,W
0E71:  BSF    03.5
0E72:  MOVWF  07
0E73:  BCF    03.5
0E74:  BTFSS  07.3
0E75:  GOTO   674
0E76:  NOP
0E77:  GOTO   678
0E78:  NOP
0E79:  BSF    20.4
0E7A:  MOVF   20,W
0E7B:  BSF    03.5
0E7C:  MOVWF  07
0E7D:  NOP
....................    i2c_start(); 
0E7E:  BCF    03.5
0E7F:  BSF    20.4
0E80:  MOVF   20,W
0E81:  BSF    03.5
0E82:  MOVWF  07
0E83:  NOP
0E84:  BCF    03.5
0E85:  BSF    20.3
0E86:  MOVF   20,W
0E87:  BSF    03.5
0E88:  MOVWF  07
0E89:  NOP
0E8A:  BCF    03.5
0E8B:  BCF    07.4
0E8C:  BCF    20.4
0E8D:  MOVF   20,W
0E8E:  BSF    03.5
0E8F:  MOVWF  07
0E90:  NOP
0E91:  BCF    03.5
0E92:  BCF    07.3
0E93:  BCF    20.3
0E94:  MOVF   20,W
0E95:  BSF    03.5
0E96:  MOVWF  07
....................    I2C_Write(0xAB); 
0E97:  MOVLW  AB
0E98:  BCF    03.5
0E99:  MOVWF  3B
0E9A:  BCF    0A.3
0E9B:  CALL   0D1
0E9C:  BSF    0A.3
....................    STAV1=i2c_read(0); 
0E9D:  CLRF   77
0E9E:  BCF    0A.3
0E9F:  CALL   11B
0EA0:  BSF    0A.3
0EA1:  MOVF   78,W
0EA2:  MOVWF  2C
....................    i2c_stop();  
0EA3:  BCF    20.4
0EA4:  MOVF   20,W
0EA5:  BSF    03.5
0EA6:  MOVWF  07
0EA7:  NOP
0EA8:  BCF    03.5
0EA9:  BSF    20.3
0EAA:  MOVF   20,W
0EAB:  BSF    03.5
0EAC:  MOVWF  07
0EAD:  BCF    03.5
0EAE:  BTFSS  07.3
0EAF:  GOTO   6AE
0EB0:  NOP
0EB1:  GOTO   6B2
0EB2:  NOP
0EB3:  BSF    20.4
0EB4:  MOVF   20,W
0EB5:  BSF    03.5
0EB6:  MOVWF  07
0EB7:  NOP
....................     
....................  
.................... data4 = (((unsigned int16) INTEP1 << 8) + INTEP ); 
0EB8:  BCF    03.5
0EB9:  CLRF   3C
0EBA:  MOVF   22,W
0EBB:  MOVWF  3B
0EBC:  MOVWF  3C
0EBD:  CLRF   3B
0EBE:  MOVF   21,W
0EBF:  ADDWF  3B,W
0EC0:  MOVWF  2D
0EC1:  MOVF   3C,W
0EC2:  MOVWF  2E
0EC3:  BTFSC  03.0
0EC4:  INCF   2E,F
.................... data4 = (data4/10)-273; 
0EC5:  MOVF   2E,W
0EC6:  MOVWF  3C
0EC7:  MOVF   2D,W
0EC8:  MOVWF  3B
0EC9:  CLRF   3E
0ECA:  MOVLW  0A
0ECB:  MOVWF  3D
0ECC:  BCF    0A.3
0ECD:  GOTO   1E6
0ECE:  BSF    0A.3
0ECF:  MOVF   79,W
0ED0:  MOVWF  3C
0ED1:  MOVF   78,W
0ED2:  MOVWF  3B
0ED3:  MOVLW  11
0ED4:  SUBWF  3B,W
0ED5:  MOVWF  2D
0ED6:  MOVF   3C,W
0ED7:  MOVWF  2E
0ED8:  MOVLW  01
0ED9:  BTFSS  03.0
0EDA:  MOVLW  02
0EDB:  SUBWF  2E,F
.................... data5 = (((unsigned int16) NAP1 << 8) + NAP ); 
0EDC:  CLRF   3C
0EDD:  MOVF   24,W
0EDE:  MOVWF  3B
0EDF:  MOVWF  3C
0EE0:  CLRF   3B
0EE1:  MOVF   23,W
0EE2:  ADDWF  3B,W
0EE3:  MOVWF  2F
0EE4:  MOVF   3C,W
0EE5:  MOVWF  30
0EE6:  BTFSC  03.0
0EE7:  INCF   30,F
.................... data6 = (((unsigned int16) PROUD1 << 8) + PROUD ); 
0EE8:  CLRF   3C
0EE9:  MOVF   26,W
0EEA:  MOVWF  3B
0EEB:  MOVWF  3C
0EEC:  CLRF   3B
0EED:  MOVF   25,W
0EEE:  ADDWF  3B,W
0EEF:  MOVWF  31
0EF0:  MOVF   3C,W
0EF1:  MOVWF  32
0EF2:  BTFSC  03.0
0EF3:  INCF   32,F
.................... data7 = (((unsigned int16) KAPZ1 << 8) + KAPZ ); 
0EF4:  CLRF   3C
0EF5:  MOVF   28,W
0EF6:  MOVWF  3B
0EF7:  MOVWF  3C
0EF8:  CLRF   3B
0EF9:  MOVF   27,W
0EFA:  ADDWF  3B,W
0EFB:  MOVWF  33
0EFC:  MOVF   3C,W
0EFD:  MOVWF  34
0EFE:  BTFSC  03.0
0EFF:  INCF   34,F
.................... data8 = (((unsigned int16) KAPC1 << 8) + KAPC ); 
0F00:  CLRF   3C
0F01:  MOVF   2A,W
0F02:  MOVWF  3B
0F03:  MOVWF  3C
0F04:  CLRF   3B
0F05:  MOVF   29,W
0F06:  ADDWF  3B,W
0F07:  MOVWF  35
0F08:  MOVF   3C,W
0F09:  MOVWF  36
0F0A:  BTFSC  03.0
0F0B:  INCF   36,F
.................... data9 = (((unsigned int16) STAV1 << 8) + STAV ); 
0F0C:  CLRF   3C
0F0D:  MOVF   2C,W
0F0E:  MOVWF  3B
0F0F:  MOVWF  3C
0F10:  CLRF   3B
0F11:  MOVF   2B,W
0F12:  ADDWF  3B,W
0F13:  MOVWF  37
0F14:  MOVF   3C,W
0F15:  MOVWF  38
0F16:  BTFSC  03.0
0F17:  INCF   38,F
....................  
....................   
....................     
....................  
....................  
.................... printf("Teplota uvnitr io: %Ld C\r\n", data4); 
0F18:  MOVLW  1B
0F19:  BSF    03.6
0F1A:  MOVWF  0D
0F1B:  MOVLW  00
0F1C:  MOVWF  0F
0F1D:  BCF    03.0
0F1E:  MOVLW  13
0F1F:  BCF    03.6
0F20:  MOVWF  3B
0F21:  BCF    0A.3
0F22:  CALL   174
0F23:  BSF    0A.3
0F24:  MOVLW  10
0F25:  MOVWF  04
0F26:  MOVF   2E,W
0F27:  MOVWF  3C
0F28:  MOVF   2D,W
0F29:  MOVWF  3B
0F2A:  BCF    0A.3
0F2B:  CALL   20D
0F2C:  BSF    0A.3
0F2D:  MOVLW  26
0F2E:  BSF    03.6
0F2F:  MOVWF  0D
0F30:  MOVLW  00
0F31:  MOVWF  0F
0F32:  BCF    03.0
0F33:  MOVLW  04
0F34:  BCF    03.6
0F35:  MOVWF  3B
0F36:  BCF    0A.3
0F37:  CALL   174
0F38:  BSF    0A.3
.................... printf("Napeti clanku: %Ld mV \r\n", data5); 
0F39:  MOVLW  29
0F3A:  BSF    03.6
0F3B:  MOVWF  0D
0F3C:  MOVLW  00
0F3D:  MOVWF  0F
0F3E:  BCF    03.0
0F3F:  MOVLW  0F
0F40:  BCF    03.6
0F41:  MOVWF  3B
0F42:  BCF    0A.3
0F43:  CALL   174
0F44:  BSF    0A.3
0F45:  MOVLW  10
0F46:  MOVWF  04
0F47:  MOVF   30,W
0F48:  MOVWF  3C
0F49:  MOVF   2F,W
0F4A:  MOVWF  3B
0F4B:  BCF    0A.3
0F4C:  CALL   20D
0F4D:  BSF    0A.3
0F4E:  MOVLW  32
0F4F:  BSF    03.6
0F50:  MOVWF  0D
0F51:  MOVLW  00
0F52:  MOVWF  0F
0F53:  BCF    03.0
0F54:  MOVLW  06
0F55:  BCF    03.6
0F56:  MOVWF  3B
0F57:  BCF    0A.3
0F58:  CALL   174
0F59:  BSF    0A.3
.................... printf("Proud: %Ld mA \r\n", data6); 
0F5A:  MOVLW  36
0F5B:  BSF    03.6
0F5C:  MOVWF  0D
0F5D:  MOVLW  00
0F5E:  MOVWF  0F
0F5F:  BCF    03.0
0F60:  MOVLW  07
0F61:  BCF    03.6
0F62:  MOVWF  3B
0F63:  BCF    0A.3
0F64:  CALL   174
0F65:  BSF    0A.3
0F66:  MOVLW  10
0F67:  MOVWF  04
0F68:  MOVF   32,W
0F69:  MOVWF  3C
0F6A:  MOVF   31,W
0F6B:  MOVWF  3B
0F6C:  BCF    0A.3
0F6D:  CALL   20D
0F6E:  BSF    0A.3
0F6F:  MOVLW  3B
0F70:  BSF    03.6
0F71:  MOVWF  0D
0F72:  MOVLW  00
0F73:  MOVWF  0F
0F74:  BCF    03.0
0F75:  MOVLW  06
0F76:  BCF    03.6
0F77:  MOVWF  3B
0F78:  BCF    0A.3
0F79:  CALL   174
0F7A:  BSF    0A.3
.................... printf("Kapacita zbytek: %Ld mAh\r\n", data7); 
0F7B:  MOVLW  3F
0F7C:  BSF    03.6
0F7D:  MOVWF  0D
0F7E:  MOVLW  00
0F7F:  MOVWF  0F
0F80:  BCF    03.0
0F81:  MOVLW  11
0F82:  BCF    03.6
0F83:  MOVWF  3B
0F84:  BCF    0A.3
0F85:  CALL   174
0F86:  BSF    0A.3
0F87:  MOVLW  10
0F88:  MOVWF  04
0F89:  MOVF   34,W
0F8A:  MOVWF  3C
0F8B:  MOVF   33,W
0F8C:  MOVWF  3B
0F8D:  BCF    0A.3
0F8E:  CALL   20D
0F8F:  BSF    0A.3
0F90:  MOVLW  49
0F91:  BSF    03.6
0F92:  MOVWF  0D
0F93:  MOVLW  00
0F94:  MOVWF  0F
0F95:  BCF    03.0
0F96:  MOVLW  06
0F97:  BCF    03.6
0F98:  MOVWF  3B
0F99:  BCF    0A.3
0F9A:  CALL   174
0F9B:  BSF    0A.3
.................... printf("Kapacita max: %Ld mAh\r\n", data8); 
0F9C:  MOVLW  4D
0F9D:  BSF    03.6
0F9E:  MOVWF  0D
0F9F:  MOVLW  00
0FA0:  MOVWF  0F
0FA1:  BCF    03.0
0FA2:  MOVLW  0E
0FA3:  BCF    03.6
0FA4:  MOVWF  3B
0FA5:  BCF    0A.3
0FA6:  CALL   174
0FA7:  BSF    0A.3
0FA8:  MOVLW  10
0FA9:  MOVWF  04
0FAA:  MOVF   36,W
0FAB:  MOVWF  3C
0FAC:  MOVF   35,W
0FAD:  MOVWF  3B
0FAE:  BCF    0A.3
0FAF:  CALL   20D
0FB0:  BSF    0A.3
0FB1:  MOVLW  55
0FB2:  BSF    03.6
0FB3:  MOVWF  0D
0FB4:  MOVLW  00
0FB5:  MOVWF  0F
0FB6:  BSF    03.0
0FB7:  MOVLW  06
0FB8:  BCF    03.6
0FB9:  MOVWF  3B
0FBA:  BCF    0A.3
0FBB:  CALL   174
0FBC:  BSF    0A.3
.................... printf("Stav: %Ld (procenta)\r\n", data9); 
0FBD:  MOVLW  59
0FBE:  BSF    03.6
0FBF:  MOVWF  0D
0FC0:  MOVLW  00
0FC1:  MOVWF  0F
0FC2:  BCF    03.0
0FC3:  MOVLW  06
0FC4:  BCF    03.6
0FC5:  MOVWF  3B
0FC6:  BCF    0A.3
0FC7:  CALL   174
0FC8:  BSF    0A.3
0FC9:  MOVLW  10
0FCA:  MOVWF  04
0FCB:  MOVF   38,W
0FCC:  MOVWF  3C
0FCD:  MOVF   37,W
0FCE:  MOVWF  3B
0FCF:  BCF    0A.3
0FD0:  CALL   20D
0FD1:  BSF    0A.3
0FD2:  MOVLW  5D
0FD3:  BSF    03.6
0FD4:  MOVWF  0D
0FD5:  MOVLW  00
0FD6:  MOVWF  0F
0FD7:  BSF    03.0
0FD8:  MOVLW  0D
0FD9:  BCF    03.6
0FDA:  MOVWF  3B
0FDB:  BCF    0A.3
0FDC:  CALL   174
0FDD:  BSF    0A.3
....................  
....................  
.................... delay_ms (2000); 
0FDE:  MOVLW  08
0FDF:  MOVWF  3B
0FE0:  MOVLW  FA
0FE1:  MOVWF  3C
0FE2:  BCF    0A.3
0FE3:  CALL   160
0FE4:  BSF    0A.3
0FE5:  DECFSZ 3B,F
0FE6:  GOTO   7E0
....................   
....................   
....................   
....................  }  
0FE7:  GOTO   06E
.................... } 
....................  
0FE8:  SLEEP

Configuration Fuses:
   Word  1: 2CF5   INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG
   Word  2: 3FFF   NOWRT BORV40
Subversion Repositories – MLAB_E

(root)/projekty/jacho/Dip_prace/SW/pic/I2C_HUB/main.lst

Rev 1045
