WebSVN – MLAB – /Modules/Sensors/SHT25V01A/SW/PIC16F887/main.lst

CCS PCM C Compiler, Version 4.106, 47914               15-V-13 22:58

               Filename: Z:\home\kaklik\svnMLAB\Modules\Sensors\SHT25V01A\SW\PIC16F887\main.lst

               ROM used: 2319 words (28%)
                         Largest free fragment is 2048
               RAM used: 17 (5%) at main() level
                         43 (12%) worst case
               Stack:    2 locations

*
0000:  MOVLW  08
0001:  MOVWF  0A
0002:  GOTO   000
0003:  NOP
.................... /* 
.................... SHT25  sensor demo firmware  
.................... */ 
....................  
.................... #include "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_IO                    //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) 
*
0169:  MOVLW  30
016A:  MOVWF  04
016B:  BCF    03.7
016C:  MOVF   00,W
016D:  BTFSC  03.2
016E:  GOTO   17C
016F:  MOVLW  02
0170:  MOVWF  78
0171:  CLRF   77
0172:  DECFSZ 77,F
0173:  GOTO   172
0174:  DECFSZ 78,F
0175:  GOTO   171
0176:  MOVLW  97
0177:  MOVWF  77
0178:  DECFSZ 77,F
0179:  GOTO   178
017A:  DECFSZ 00,F
017B:  GOTO   16F
017C:  RETURN
....................  
.................... #use i2c(master, sda=PIN_C4, scl=PIN_C3) 
*
002C:  MOVLW  08
002D:  MOVWF  78
002E:  NOP
002F:  BCF    07.3
0030:  BCF    20.3
0031:  MOVF   20,W
0032:  BSF    03.5
0033:  MOVWF  07
0034:  NOP
0035:  BCF    03.5
0036:  RLF    30,F
0037:  BCF    07.4
0038:  BTFSS  03.0
0039:  GOTO   040
003A:  BSF    20.4
003B:  MOVF   20,W
003C:  BSF    03.5
003D:  MOVWF  07
003E:  GOTO   044
003F:  BCF    03.5
0040:  BCF    20.4
0041:  MOVF   20,W
0042:  BSF    03.5
0043:  MOVWF  07
0044:  NOP
0045:  BCF    03.5
0046:  BSF    20.3
0047:  MOVF   20,W
0048:  BSF    03.5
0049:  MOVWF  07
004A:  BCF    03.5
004B:  BTFSS  07.3
004C:  GOTO   04B
004D:  DECFSZ 78,F
004E:  GOTO   02E
004F:  NOP
0050:  BCF    07.3
0051:  BCF    20.3
0052:  MOVF   20,W
0053:  BSF    03.5
0054:  MOVWF  07
0055:  NOP
0056:  BCF    03.5
0057:  BSF    20.4
0058:  MOVF   20,W
0059:  BSF    03.5
005A:  MOVWF  07
005B:  NOP
005C:  NOP
005D:  BCF    03.5
005E:  BSF    20.3
005F:  MOVF   20,W
0060:  BSF    03.5
0061:  MOVWF  07
0062:  BCF    03.5
0063:  BTFSS  07.3
0064:  GOTO   063
0065:  CLRF   78
0066:  NOP
0067:  BTFSC  07.4
0068:  BSF    78.0
0069:  BCF    07.3
006A:  BCF    20.3
006B:  MOVF   20,W
006C:  BSF    03.5
006D:  MOVWF  07
006E:  BCF    03.5
006F:  BCF    07.4
0070:  BCF    20.4
0071:  MOVF   20,W
0072:  BSF    03.5
0073:  MOVWF  07
0074:  BCF    03.5
0075:  RETURN
*
017D:  MOVLW  08
017E:  MOVWF  31
017F:  MOVF   77,W
0180:  MOVWF  32
0181:  BSF    20.4
0182:  MOVF   20,W
0183:  BSF    03.5
0184:  MOVWF  07
0185:  NOP
0186:  BCF    03.5
0187:  BSF    20.3
0188:  MOVF   20,W
0189:  BSF    03.5
018A:  MOVWF  07
018B:  BCF    03.5
018C:  BTFSS  07.3
018D:  GOTO   18C
018E:  BTFSC  07.4
018F:  BSF    03.0
0190:  BTFSS  07.4
0191:  BCF    03.0
0192:  RLF    78,F
0193:  NOP
0194:  BCF    20.3
0195:  MOVF   20,W
0196:  BSF    03.5
0197:  MOVWF  07
0198:  BCF    03.5
0199:  BCF    07.3
019A:  DECFSZ 31,F
019B:  GOTO   181
019C:  BSF    20.4
019D:  MOVF   20,W
019E:  BSF    03.5
019F:  MOVWF  07
01A0:  NOP
01A1:  BCF    03.5
01A2:  BCF    07.4
01A3:  MOVF   32,W
01A4:  BTFSC  03.2
01A5:  GOTO   1AB
01A6:  BCF    20.4
01A7:  MOVF   20,W
01A8:  BSF    03.5
01A9:  MOVWF  07
01AA:  BCF    03.5
01AB:  NOP
01AC:  BSF    20.3
01AD:  MOVF   20,W
01AE:  BSF    03.5
01AF:  MOVWF  07
01B0:  BCF    03.5
01B1:  BTFSS  07.3
01B2:  GOTO   1B1
01B3:  NOP
01B4:  BCF    07.3
01B5:  BCF    20.3
01B6:  MOVF   20,W
01B7:  BSF    03.5
01B8:  MOVWF  07
01B9:  NOP
01BA:  BCF    03.5
01BB:  BCF    07.4
01BC:  BCF    20.4
01BD:  MOVF   20,W
01BE:  BSF    03.5
01BF:  MOVWF  07
01C0:  BCF    03.5
01C1:  RETURN
.................... #use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD 
*
00AE:  BCF    20.7
00AF:  MOVF   20,W
00B0:  BSF    03.5
00B1:  MOVWF  07
00B2:  BCF    03.5
00B3:  BCF    07.7
00B4:  MOVLW  08
00B5:  MOVWF  78
00B6:  GOTO   0B7
00B7:  NOP
00B8:  BSF    78.7
00B9:  GOTO   0C8
00BA:  BCF    78.7
00BB:  RRF    39,F
00BC:  BTFSC  03.0
00BD:  BSF    07.7
00BE:  BTFSS  03.0
00BF:  BCF    07.7
00C0:  BSF    78.6
00C1:  GOTO   0C8
00C2:  BCF    78.6
00C3:  DECFSZ 78,F
00C4:  GOTO   0BB
00C5:  GOTO   0C6
00C6:  NOP
00C7:  BSF    07.7
00C8:  MOVLW  3F
00C9:  MOVWF  04
00CA:  DECFSZ 04,F
00CB:  GOTO   0CA
00CC:  NOP
00CD:  BTFSC  78.7
00CE:  GOTO   0BA
00CF:  BTFSC  78.6
00D0:  GOTO   0C2
00D1:  RETURN
....................  
....................  
.................... #include "SHT25.h" 
....................  
.................... #define SHT25_HEATER_ON   0x04 
.................... #define SHT25_HEATER_OFF   0x00 
.................... #define SHT25_OTP_reload_off  0x02 
.................... #define SHT25_RH12_T14  0x00 
.................... #define SHT25_RH8_T12  0x01 
.................... #define SHT25_RH10_T13  0x80 
.................... #define SHT25_RH11_T11  0x81 
....................  
.................... #define SHT25_ADDR  0x80 
....................  
.................... #include "SHT25.c" 
.................... void SHT25_soft_reset() 
.................... { 
....................   i2c_start();     // Start condition 
*
0076:  BSF    20.4
0077:  MOVF   20,W
0078:  BSF    03.5
0079:  MOVWF  07
007A:  NOP
007B:  BCF    03.5
007C:  BSF    20.3
007D:  MOVF   20,W
007E:  BSF    03.5
007F:  MOVWF  07
0080:  NOP
0081:  BCF    03.5
0082:  BCF    07.4
0083:  BCF    20.4
0084:  MOVF   20,W
0085:  BSF    03.5
0086:  MOVWF  07
0087:  NOP
0088:  BCF    03.5
0089:  BCF    07.3
008A:  BCF    20.3
008B:  MOVF   20,W
008C:  BSF    03.5
008D:  MOVWF  07
....................   i2c_write(0x80); // Device address 
008E:  MOVLW  80
008F:  BCF    03.5
0090:  MOVWF  30
0091:  CALL   02C
....................   i2c_write(0xFE);    // Device command 
0092:  MOVLW  FE
0093:  MOVWF  30
0094:  CALL   02C
....................   i2c_stop();      // Stop condition 
0095:  BCF    20.4
0096:  MOVF   20,W
0097:  BSF    03.5
0098:  MOVWF  07
0099:  NOP
009A:  BCF    03.5
009B:  BSF    20.3
009C:  MOVF   20,W
009D:  BSF    03.5
009E:  MOVWF  07
009F:  BCF    03.5
00A0:  BTFSS  07.3
00A1:  GOTO   0A0
00A2:  NOP
00A3:  GOTO   0A4
00A4:  NOP
00A5:  BSF    20.4
00A6:  MOVF   20,W
00A7:  BSF    03.5
00A8:  MOVWF  07
00A9:  NOP
.................... } 
00AA:  BCF    03.5
00AB:  BSF    0A.3
00AC:  BCF    0A.4
00AD:  GOTO   06A (RETURN)
....................  
.................... unsigned int8 SHT25_setup(unsigned int8 setup_reg )  // writes to status register and returns its value 
.................... { 
.................... unsigned int8 reg; 
....................  
....................   i2c_start();     // Start condition 
*
05E4:  BSF    20.4
05E5:  MOVF   20,W
05E6:  BSF    03.5
05E7:  MOVWF  07
05E8:  NOP
05E9:  BCF    03.5
05EA:  BSF    20.3
05EB:  MOVF   20,W
05EC:  BSF    03.5
05ED:  MOVWF  07
05EE:  NOP
05EF:  BCF    03.5
05F0:  BCF    07.4
05F1:  BCF    20.4
05F2:  MOVF   20,W
05F3:  BSF    03.5
05F4:  MOVWF  07
05F5:  NOP
05F6:  BCF    03.5
05F7:  BCF    07.3
05F8:  BCF    20.3
05F9:  MOVF   20,W
05FA:  BSF    03.5
05FB:  MOVWF  07
....................   i2c_write(SHT25_ADDR); // Device address 
05FC:  MOVLW  80
05FD:  BCF    03.5
05FE:  MOVWF  30
05FF:  CALL   02C
....................   i2c_write(0xE7);    // Device command 
0600:  MOVLW  E7
0601:  MOVWF  30
0602:  CALL   02C
....................  
....................   i2c_start();     // Start condition 
0603:  BSF    20.4
0604:  MOVF   20,W
0605:  BSF    03.5
0606:  MOVWF  07
0607:  NOP
0608:  BCF    03.5
0609:  BSF    20.3
060A:  MOVF   20,W
060B:  BSF    03.5
060C:  MOVWF  07
060D:  NOP
060E:  BCF    03.5
060F:  BTFSS  07.3
0610:  GOTO   60F
0611:  BCF    07.4
0612:  BCF    20.4
0613:  MOVF   20,W
0614:  BSF    03.5
0615:  MOVWF  07
0616:  NOP
0617:  BCF    03.5
0618:  BCF    07.3
0619:  BCF    20.3
061A:  MOVF   20,W
061B:  BSF    03.5
061C:  MOVWF  07
....................   i2c_write(SHT25_ADDR+1); // Device address 
061D:  MOVLW  81
061E:  BCF    03.5
061F:  MOVWF  30
0620:  CALL   02C
....................   reg=i2c_read(0);    // Read status actual status register 
0621:  CLRF   77
0622:  CALL   17D
0623:  MOVF   78,W
0624:  MOVWF  2C
....................  
....................   reg = (reg & 0x3A) | setup_reg; 
0625:  MOVF   2C,W
0626:  ANDLW  3A
0627:  IORWF  2B,W
0628:  MOVWF  2C
....................  
....................   i2c_start();     // Start condition 
0629:  BSF    20.4
062A:  MOVF   20,W
062B:  BSF    03.5
062C:  MOVWF  07
062D:  NOP
062E:  BCF    03.5
062F:  BSF    20.3
0630:  MOVF   20,W
0631:  BSF    03.5
0632:  MOVWF  07
0633:  NOP
0634:  BCF    03.5
0635:  BTFSS  07.3
0636:  GOTO   635
0637:  BCF    07.4
0638:  BCF    20.4
0639:  MOVF   20,W
063A:  BSF    03.5
063B:  MOVWF  07
063C:  NOP
063D:  BCF    03.5
063E:  BCF    07.3
063F:  BCF    20.3
0640:  MOVF   20,W
0641:  BSF    03.5
0642:  MOVWF  07
....................   i2c_write(SHT25_ADDR); // Device address 
0643:  MOVLW  80
0644:  BCF    03.5
0645:  MOVWF  30
0646:  CALL   02C
....................   i2c_write(0xE6);    // Write to status register 
0647:  MOVLW  E6
0648:  MOVWF  30
0649:  CALL   02C
....................   i2c_write(reg);    // Device command 
064A:  MOVF   2C,W
064B:  MOVWF  30
064C:  CALL   02C
....................   i2c_stop();      // Stop condition 
064D:  BCF    20.4
064E:  MOVF   20,W
064F:  BSF    03.5
0650:  MOVWF  07
0651:  NOP
0652:  BCF    03.5
0653:  BSF    20.3
0654:  MOVF   20,W
0655:  BSF    03.5
0656:  MOVWF  07
0657:  BCF    03.5
0658:  BTFSS  07.3
0659:  GOTO   658
065A:  NOP
065B:  GOTO   65C
065C:  NOP
065D:  BSF    20.4
065E:  MOVF   20,W
065F:  BSF    03.5
0660:  MOVWF  07
0661:  NOP
....................  
....................   delay_ms(10); 
0662:  MOVLW  0A
0663:  BCF    03.5
0664:  MOVWF  30
0665:  CALL   169
....................  
....................   i2c_start();     // Start condition 
0666:  BSF    20.4
0667:  MOVF   20,W
0668:  BSF    03.5
0669:  MOVWF  07
066A:  NOP
066B:  BCF    03.5
066C:  BSF    20.3
066D:  MOVF   20,W
066E:  BSF    03.5
066F:  MOVWF  07
0670:  NOP
0671:  BCF    03.5
0672:  BCF    07.4
0673:  BCF    20.4
0674:  MOVF   20,W
0675:  BSF    03.5
0676:  MOVWF  07
0677:  NOP
0678:  BCF    03.5
0679:  BCF    07.3
067A:  BCF    20.3
067B:  MOVF   20,W
067C:  BSF    03.5
067D:  MOVWF  07
....................   i2c_write(SHT25_ADDR); // Device address 
067E:  MOVLW  80
067F:  BCF    03.5
0680:  MOVWF  30
0681:  CALL   02C
....................   i2c_write(0xE7);    // Device command 
0682:  MOVLW  E7
0683:  MOVWF  30
0684:  CALL   02C
....................  
....................   i2c_start();     // Start condition 
0685:  BSF    20.4
0686:  MOVF   20,W
0687:  BSF    03.5
0688:  MOVWF  07
0689:  NOP
068A:  BCF    03.5
068B:  BSF    20.3
068C:  MOVF   20,W
068D:  BSF    03.5
068E:  MOVWF  07
068F:  NOP
0690:  BCF    03.5
0691:  BTFSS  07.3
0692:  GOTO   691
0693:  BCF    07.4
0694:  BCF    20.4
0695:  MOVF   20,W
0696:  BSF    03.5
0697:  MOVWF  07
0698:  NOP
0699:  BCF    03.5
069A:  BCF    07.3
069B:  BCF    20.3
069C:  MOVF   20,W
069D:  BSF    03.5
069E:  MOVWF  07
....................   i2c_write(SHT25_ADDR+1); // Device address 
069F:  MOVLW  81
06A0:  BCF    03.5
06A1:  MOVWF  30
06A2:  CALL   02C
....................   reg=i2c_read(0);    // Read status actual status register 
06A3:  CLRF   77
06A4:  CALL   17D
06A5:  MOVF   78,W
06A6:  MOVWF  2C
....................  
....................   return (reg); 
06A7:  MOVF   2C,W
06A8:  MOVWF  78
.................... } 
06A9:  BSF    0A.3
06AA:  BCF    0A.4
06AB:  GOTO   0C0 (RETURN)
....................  
....................  
.................... float SHT25_get_temp() 
.................... { 
.................... unsigned int8 MSB, LSB, Check; 
.................... unsigned int16 data; 
....................  
....................    i2c_start(); 
*
045F:  BSF    20.4
0460:  MOVF   20,W
0461:  BSF    03.5
0462:  MOVWF  07
0463:  NOP
0464:  BCF    03.5
0465:  BSF    20.3
0466:  MOVF   20,W
0467:  BSF    03.5
0468:  MOVWF  07
0469:  NOP
046A:  BCF    03.5
046B:  BTFSS  07.3
046C:  GOTO   46B
046D:  BCF    07.4
046E:  BCF    20.4
046F:  MOVF   20,W
0470:  BSF    03.5
0471:  MOVWF  07
0472:  NOP
0473:  BCF    03.5
0474:  BCF    07.3
0475:  BCF    20.3
0476:  MOVF   20,W
0477:  BSF    03.5
0478:  MOVWF  07
....................    I2C_Write(SHT25_ADDR); 
0479:  MOVLW  80
047A:  BCF    03.5
047B:  MOVWF  30
047C:  CALL   02C
....................    I2C_write(0xE3); 
047D:  MOVLW  E3
047E:  MOVWF  30
047F:  CALL   02C
....................    i2c_stop(); 
0480:  BCF    20.4
0481:  MOVF   20,W
0482:  BSF    03.5
0483:  MOVWF  07
0484:  NOP
0485:  BCF    03.5
0486:  BSF    20.3
0487:  MOVF   20,W
0488:  BSF    03.5
0489:  MOVWF  07
048A:  BCF    03.5
048B:  BTFSS  07.3
048C:  GOTO   48B
048D:  NOP
048E:  GOTO   48F
048F:  NOP
0490:  BSF    20.4
0491:  MOVF   20,W
0492:  BSF    03.5
0493:  MOVWF  07
0494:  NOP
....................    
....................    delay_ms(100); 
0495:  MOVLW  64
0496:  BCF    03.5
0497:  MOVWF  30
0498:  CALL   169
....................     
....................    i2c_start(); 
0499:  BSF    20.4
049A:  MOVF   20,W
049B:  BSF    03.5
049C:  MOVWF  07
049D:  NOP
049E:  BCF    03.5
049F:  BSF    20.3
04A0:  MOVF   20,W
04A1:  BSF    03.5
04A2:  MOVWF  07
04A3:  NOP
04A4:  BCF    03.5
04A5:  BCF    07.4
04A6:  BCF    20.4
04A7:  MOVF   20,W
04A8:  BSF    03.5
04A9:  MOVWF  07
04AA:  NOP
04AB:  BCF    03.5
04AC:  BCF    07.3
04AD:  BCF    20.3
04AE:  MOVF   20,W
04AF:  BSF    03.5
04B0:  MOVWF  07
....................    I2C_Write(SHT25_ADDR+1); 
04B1:  MOVLW  81
04B2:  BCF    03.5
04B3:  MOVWF  30
04B4:  CALL   02C
....................    MSB=i2c_read(1); 
04B5:  MOVLW  01
04B6:  MOVWF  77
04B7:  CALL   17D
04B8:  MOVF   78,W
04B9:  MOVWF  2B
....................    LSB=i2c_read(1); 
04BA:  MOVLW  01
04BB:  MOVWF  77
04BC:  CALL   17D
04BD:  MOVF   78,W
04BE:  MOVWF  2C
....................    Check=i2c_read(0); 
04BF:  CLRF   77
04C0:  CALL   17D
04C1:  MOVF   78,W
04C2:  MOVWF  2D
....................    i2c_stop(); 
04C3:  BCF    20.4
04C4:  MOVF   20,W
04C5:  BSF    03.5
04C6:  MOVWF  07
04C7:  NOP
04C8:  BCF    03.5
04C9:  BSF    20.3
04CA:  MOVF   20,W
04CB:  BSF    03.5
04CC:  MOVWF  07
04CD:  BCF    03.5
04CE:  BTFSS  07.3
04CF:  GOTO   4CE
04D0:  NOP
04D1:  GOTO   4D2
04D2:  NOP
04D3:  BSF    20.4
04D4:  MOVF   20,W
04D5:  BSF    03.5
04D6:  MOVWF  07
04D7:  NOP
....................        
....................    LSB = LSB >> 2; // trow out status bits 
04D8:  BCF    03.5
04D9:  RRF    2C,F
04DA:  RRF    2C,F
04DB:  MOVLW  3F
04DC:  ANDWF  2C,F
....................  
....................    data = (((unsigned int16) MSB << 8) + (LSB << 4)); 
04DD:  CLRF   31
04DE:  MOVF   2B,W
04DF:  MOVWF  30
04E0:  MOVWF  31
04E1:  CLRF   30
04E2:  SWAPF  2C,W
04E3:  MOVWF  77
04E4:  MOVLW  F0
04E5:  ANDWF  77,F
04E6:  MOVF   77,W
04E7:  ADDWF  30,W
04E8:  MOVWF  2E
04E9:  MOVF   31,W
04EA:  MOVWF  2F
04EB:  BTFSC  03.0
04EC:  INCF   2F,F
....................    return(-46.85 + 175.72*((float)data/0xFFFF)); 
04ED:  MOVF   2F,W
04EE:  MOVWF  31
04EF:  MOVF   2E,W
04F0:  MOVWF  30
04F1:  CALL   1C2
04F2:  MOVF   77,W
04F3:  MOVWF  30
04F4:  MOVF   78,W
04F5:  MOVWF  31
04F6:  MOVF   79,W
04F7:  MOVWF  32
04F8:  MOVF   7A,W
04F9:  MOVWF  33
04FA:  MOVWF  37
04FB:  MOVF   79,W
04FC:  MOVWF  36
04FD:  MOVF   78,W
04FE:  MOVWF  35
04FF:  MOVF   77,W
0500:  MOVWF  34
0501:  CLRF   3B
0502:  MOVLW  FF
0503:  MOVWF  3A
0504:  MOVLW  7F
0505:  MOVWF  39
0506:  MOVLW  8E
0507:  MOVWF  38
0508:  CALL   1DF
0509:  MOVLW  52
050A:  MOVWF  3C
050B:  MOVLW  B8
050C:  MOVWF  3B
050D:  MOVLW  2F
050E:  MOVWF  3A
050F:  MOVLW  86
0510:  MOVWF  39
0511:  MOVF   7A,W
0512:  MOVWF  40
0513:  MOVF   79,W
0514:  MOVWF  3F
0515:  MOVF   78,W
0516:  MOVWF  3E
0517:  MOVF   77,W
0518:  MOVWF  3D
0519:  CALL   2A9
051A:  BCF    03.1
051B:  MOVLW  66
051C:  MOVWF  33
051D:  MOVWF  32
051E:  MOVLW  BB
051F:  MOVWF  31
0520:  MOVLW  84
0521:  MOVWF  30
0522:  MOVF   7A,W
0523:  MOVWF  37
0524:  MOVF   79,W
0525:  MOVWF  36
0526:  MOVF   78,W
0527:  MOVWF  35
0528:  MOVF   77,W
0529:  MOVWF  34
052A:  CALL   31E
.................... } 
052B:  BSF    0A.3
052C:  BCF    0A.4
052D:  GOTO   0A8 (RETURN)
....................  
.................... float SHT25_get_hum() 
.................... { 
.................... unsigned int8 MSB, LSB, Check; 
.................... unsigned int16 data; 
....................  
....................    i2c_start();   //RH 
052E:  BSF    20.4
052F:  MOVF   20,W
0530:  BSF    03.5
0531:  MOVWF  07
0532:  NOP
0533:  BCF    03.5
0534:  BSF    20.3
0535:  MOVF   20,W
0536:  BSF    03.5
0537:  MOVWF  07
0538:  NOP
0539:  BCF    03.5
053A:  BCF    07.4
053B:  BCF    20.4
053C:  MOVF   20,W
053D:  BSF    03.5
053E:  MOVWF  07
053F:  NOP
0540:  BCF    03.5
0541:  BCF    07.3
0542:  BCF    20.3
0543:  MOVF   20,W
0544:  BSF    03.5
0545:  MOVWF  07
....................    I2C_Write(SHT25_ADDR); 
0546:  MOVLW  80
0547:  BCF    03.5
0548:  MOVWF  30
0549:  CALL   02C
....................    I2C_write(0xE5); 
054A:  MOVLW  E5
054B:  MOVWF  30
054C:  CALL   02C
....................  
....................    delay_ms(100); 
054D:  MOVLW  64
054E:  MOVWF  30
054F:  CALL   169
....................  
....................    i2c_start(); 
0550:  BSF    20.4
0551:  MOVF   20,W
0552:  BSF    03.5
0553:  MOVWF  07
0554:  NOP
0555:  BCF    03.5
0556:  BSF    20.3
0557:  MOVF   20,W
0558:  BSF    03.5
0559:  MOVWF  07
055A:  NOP
055B:  BCF    03.5
055C:  BTFSS  07.3
055D:  GOTO   55C
055E:  BCF    07.4
055F:  BCF    20.4
0560:  MOVF   20,W
0561:  BSF    03.5
0562:  MOVWF  07
0563:  NOP
0564:  BCF    03.5
0565:  BCF    07.3
0566:  BCF    20.3
0567:  MOVF   20,W
0568:  BSF    03.5
0569:  MOVWF  07
....................    I2C_Write(SHT25_ADDR+1); 
056A:  MOVLW  81
056B:  BCF    03.5
056C:  MOVWF  30
056D:  CALL   02C
....................    MSB=i2c_read(1); 
056E:  MOVLW  01
056F:  MOVWF  77
0570:  CALL   17D
0571:  MOVF   78,W
0572:  MOVWF  2B
....................    LSB=i2c_read(1); 
0573:  MOVLW  01
0574:  MOVWF  77
0575:  CALL   17D
0576:  MOVF   78,W
0577:  MOVWF  2C
....................    Check=i2c_read(0); 
0578:  CLRF   77
0579:  CALL   17D
057A:  MOVF   78,W
057B:  MOVWF  2D
....................    i2c_stop();  
057C:  BCF    20.4
057D:  MOVF   20,W
057E:  BSF    03.5
057F:  MOVWF  07
0580:  NOP
0581:  BCF    03.5
0582:  BSF    20.3
0583:  MOVF   20,W
0584:  BSF    03.5
0585:  MOVWF  07
0586:  BCF    03.5
0587:  BTFSS  07.3
0588:  GOTO   587
0589:  NOP
058A:  GOTO   58B
058B:  NOP
058C:  BSF    20.4
058D:  MOVF   20,W
058E:  BSF    03.5
058F:  MOVWF  07
0590:  NOP
....................  
....................    LSB = LSB >> 2; // trow out status bits 
0591:  BCF    03.5
0592:  RRF    2C,F
0593:  RRF    2C,F
0594:  MOVLW  3F
0595:  ANDWF  2C,F
....................  
....................    data = (((unsigned int16) MSB << 8) + (LSB << 4) ); 
0596:  CLRF   31
0597:  MOVF   2B,W
0598:  MOVWF  30
0599:  MOVWF  31
059A:  CLRF   30
059B:  SWAPF  2C,W
059C:  MOVWF  77
059D:  MOVLW  F0
059E:  ANDWF  77,F
059F:  MOVF   77,W
05A0:  ADDWF  30,W
05A1:  MOVWF  2E
05A2:  MOVF   31,W
05A3:  MOVWF  2F
05A4:  BTFSC  03.0
05A5:  INCF   2F,F
....................    return( -6.0 + 125.0*((float)data/0xFFFF)); 
05A6:  MOVF   2F,W
05A7:  MOVWF  31
05A8:  MOVF   2E,W
05A9:  MOVWF  30
05AA:  CALL   1C2
05AB:  MOVF   77,W
05AC:  MOVWF  30
05AD:  MOVF   78,W
05AE:  MOVWF  31
05AF:  MOVF   79,W
05B0:  MOVWF  32
05B1:  MOVF   7A,W
05B2:  MOVWF  33
05B3:  MOVWF  37
05B4:  MOVF   79,W
05B5:  MOVWF  36
05B6:  MOVF   78,W
05B7:  MOVWF  35
05B8:  MOVF   77,W
05B9:  MOVWF  34
05BA:  CLRF   3B
05BB:  MOVLW  FF
05BC:  MOVWF  3A
05BD:  MOVLW  7F
05BE:  MOVWF  39
05BF:  MOVLW  8E
05C0:  MOVWF  38
05C1:  CALL   1DF
05C2:  CLRF   3C
05C3:  CLRF   3B
05C4:  MOVLW  7A
05C5:  MOVWF  3A
05C6:  MOVLW  85
05C7:  MOVWF  39
05C8:  MOVF   7A,W
05C9:  MOVWF  40
05CA:  MOVF   79,W
05CB:  MOVWF  3F
05CC:  MOVF   78,W
05CD:  MOVWF  3E
05CE:  MOVF   77,W
05CF:  MOVWF  3D
05D0:  CALL   2A9
05D1:  BCF    03.1
05D2:  CLRF   33
05D3:  CLRF   32
05D4:  MOVLW  C0
05D5:  MOVWF  31
05D6:  MOVLW  81
05D7:  MOVWF  30
05D8:  MOVF   7A,W
05D9:  MOVWF  37
05DA:  MOVF   79,W
05DB:  MOVWF  36
05DC:  MOVF   78,W
05DD:  MOVWF  35
05DE:  MOVF   77,W
05DF:  MOVWF  34
05E0:  CALL   31E
.................... }       
05E1:  BSF    0A.3
05E2:  BCF    0A.4
05E3:  GOTO   0B3 (RETURN)
....................  
....................  
....................  
....................  
....................  
.................... void main() 
.................... { 
*
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
*
0821:  CLRF   21
.................... unsigned int8 i=0, sht_config; 
.................... float temperature, humidity; 
....................  
....................    setup_adc_ports(NO_ANALOGS|VSS_VDD); 
0822:  BSF    03.5
0823:  BSF    03.6
0824:  MOVF   09,W
0825:  ANDLW  C0
0826:  MOVWF  09
0827:  BCF    03.6
0828:  BCF    1F.4
0829:  BCF    1F.5
082A:  MOVLW  00
082B:  BSF    03.6
082C:  MOVWF  08
....................    setup_adc(ADC_CLOCK_DIV_2); 
082D:  BCF    03.5
082E:  BCF    03.6
082F:  BCF    1F.6
0830:  BCF    1F.7
0831:  BSF    03.5
0832:  BCF    1F.7
0833:  BCF    03.5
0834:  BSF    1F.0
....................    setup_spi(SPI_SS_DISABLED); 
0835:  BCF    14.5
0836:  BCF    20.5
0837:  MOVF   20,W
0838:  BSF    03.5
0839:  MOVWF  07
083A:  BCF    03.5
083B:  BSF    20.4
083C:  MOVF   20,W
083D:  BSF    03.5
083E:  MOVWF  07
083F:  BCF    03.5
0840:  BCF    20.3
0841:  MOVF   20,W
0842:  BSF    03.5
0843:  MOVWF  07
0844:  MOVLW  01
0845:  BCF    03.5
0846:  MOVWF  14
0847:  MOVLW  00
0848:  BSF    03.5
0849:  MOVWF  14
....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); 
084A:  MOVF   01,W
084B:  ANDLW  C7
084C:  IORLW  08
084D:  MOVWF  01
....................    setup_timer_1(T1_DISABLED); 
084E:  BCF    03.5
084F:  CLRF   10
....................    setup_timer_2(T2_DISABLED,0,1); 
0850:  MOVLW  00
0851:  MOVWF  78
0852:  MOVWF  12
0853:  MOVLW  00
0854:  BSF    03.5
0855:  MOVWF  12
....................    setup_ccp1(CCP_OFF); 
0856:  BCF    03.5
0857:  BSF    20.2
0858:  MOVF   20,W
0859:  BSF    03.5
085A:  MOVWF  07
085B:  BCF    03.5
085C:  CLRF   17
085D:  BSF    03.5
085E:  CLRF   1B
085F:  CLRF   1C
0860:  MOVLW  01
0861:  MOVWF  1D
....................    setup_comparator(NC_NC_NC_NC); 
0862:  BCF    03.5
0863:  BSF    03.6
0864:  CLRF   07
0865:  CLRF   08
0866:  CLRF   09
....................  
....................    SHT25_soft_reset(); 
0867:  BCF    0A.3
0868:  BCF    03.6
0869:  GOTO   076
086A:  BSF    0A.3
....................    printf("SHT25 humidity and temperature sensor example \r\n",); 
086B:  MOVLW  04
086C:  BSF    03.6
086D:  MOVWF  0D
086E:  MOVLW  00
086F:  MOVWF  0F
0870:  BCF    0A.3
0871:  BCF    03.6
0872:  GOTO   0D2
0873:  BSF    0A.3
....................    printf("Temperature  Humidity[%%]  \r\n"); 
0874:  MOVLW  1D
0875:  BSF    03.6
0876:  MOVWF  0D
0877:  MOVLW  00
0878:  MOVWF  0F
0879:  BCF    03.0
087A:  MOVLW  16
087B:  BCF    03.6
087C:  MOVWF  2B
087D:  BCF    0A.3
087E:  CALL   11A
087F:  BSF    0A.3
0880:  MOVLW  25
0881:  MOVWF  39
0882:  BCF    0A.3
0883:  CALL   0AE
0884:  BSF    0A.3
0885:  MOVLW  29
0886:  BSF    03.6
0887:  MOVWF  0D
0888:  MOVLW  00
0889:  MOVWF  0F
088A:  BCF    03.0
088B:  MOVLW  05
088C:  BCF    03.6
088D:  MOVWF  2B
088E:  BCF    0A.3
088F:  CALL   11A
0890:  BSF    0A.3
....................    delay_ms (500); 
0891:  MOVLW  02
0892:  MOVWF  2B
0893:  MOVLW  FA
0894:  MOVWF  30
0895:  BCF    0A.3
0896:  CALL   169
0897:  BSF    0A.3
0898:  DECFSZ 2B,F
0899:  GOTO   093
....................  
....................  
....................   while(TRUE) 
....................   {  
....................     if (i<100) sht_config = SHT25_RH12_T14 | SHT25_HEATER_OFF; // loop alters on chip heater on and off to check correct function 
089A:  MOVF   21,W
089B:  SUBLW  63
089C:  BTFSS  03.0
089D:  GOTO   0A0
089E:  CLRF   22
....................     else 
089F:  GOTO   0A6
....................     { 
....................       sht_config = SHT25_RH12_T14 | SHT25_HEATER_ON; 
08A0:  MOVLW  04
08A1:  MOVWF  22
....................       if (i > 120) i = 0; 
08A2:  MOVF   21,W
08A3:  SUBLW  78
08A4:  BTFSS  03.0
08A5:  CLRF   21
....................     } 
....................     
....................     temperature = SHT25_get_temp(); 
08A6:  BCF    0A.3
08A7:  GOTO   45F
08A8:  BSF    0A.3
08A9:  MOVF   7A,W
08AA:  MOVWF  26
08AB:  MOVF   79,W
08AC:  MOVWF  25
08AD:  MOVF   78,W
08AE:  MOVWF  24
08AF:  MOVF   77,W
08B0:  MOVWF  23
....................     humidity = SHT25_get_hum(); 
08B1:  BCF    0A.3
08B2:  GOTO   52E
08B3:  BSF    0A.3
08B4:  MOVF   7A,W
08B5:  MOVWF  2A
08B6:  MOVF   79,W
08B7:  MOVWF  29
08B8:  MOVF   78,W
08B9:  MOVWF  28
08BA:  MOVF   77,W
08BB:  MOVWF  27
....................  
....................     printf("%f %f %X %X \r\n",temperature, humidity, SHT25_setup(sht_config),sht_config); 
08BC:  MOVF   22,W
08BD:  MOVWF  2B
08BE:  BCF    0A.3
08BF:  GOTO   5E4
08C0:  BSF    0A.3
08C1:  MOVF   78,W
08C2:  MOVWF  2B
08C3:  MOVLW  89
08C4:  MOVWF  04
08C5:  MOVF   26,W
08C6:  MOVWF  2F
08C7:  MOVF   25,W
08C8:  MOVWF  2E
08C9:  MOVF   24,W
08CA:  MOVWF  2D
08CB:  MOVF   23,W
08CC:  MOVWF  2C
08CD:  MOVLW  02
08CE:  MOVWF  30
08CF:  BCF    0A.3
08D0:  CALL   6EE
08D1:  BSF    0A.3
08D2:  MOVLW  20
08D3:  MOVWF  39
08D4:  BCF    0A.3
08D5:  CALL   0AE
08D6:  BSF    0A.3
08D7:  MOVLW  89
08D8:  MOVWF  04
08D9:  MOVF   2A,W
08DA:  MOVWF  2F
08DB:  MOVF   29,W
08DC:  MOVWF  2E
08DD:  MOVF   28,W
08DE:  MOVWF  2D
08DF:  MOVF   27,W
08E0:  MOVWF  2C
08E1:  MOVLW  02
08E2:  MOVWF  30
08E3:  BCF    0A.3
08E4:  CALL   6EE
08E5:  BSF    0A.3
08E6:  MOVLW  20
08E7:  MOVWF  39
08E8:  BCF    0A.3
08E9:  CALL   0AE
08EA:  BSF    0A.3
08EB:  MOVF   2B,W
08EC:  MOVWF  2C
08ED:  MOVLW  37
08EE:  MOVWF  2D
08EF:  BCF    0A.3
08F0:  CALL   7D5
08F1:  BSF    0A.3
08F2:  MOVLW  20
08F3:  MOVWF  39
08F4:  BCF    0A.3
08F5:  CALL   0AE
08F6:  BSF    0A.3
08F7:  MOVF   22,W
08F8:  MOVWF  2C
08F9:  MOVLW  37
08FA:  MOVWF  2D
08FB:  BCF    0A.3
08FC:  CALL   7D5
08FD:  BSF    0A.3
08FE:  MOVLW  20
08FF:  MOVWF  39
0900:  BCF    0A.3
0901:  CALL   0AE
0902:  BSF    0A.3
0903:  MOVLW  0D
0904:  MOVWF  39
0905:  BCF    0A.3
0906:  CALL   0AE
0907:  BSF    0A.3
0908:  MOVLW  0A
0909:  MOVWF  39
090A:  BCF    0A.3
090B:  CALL   0AE
090C:  BSF    0A.3
....................     i++; 
090D:  INCF   21,F
....................     delay_ms(1000); 
090E:  MOVLW  04
090F:  MOVWF  2B
0910:  MOVLW  FA
0911:  MOVWF  30
0912:  BCF    0A.3
0913:  CALL   169
0914:  BSF    0A.3
0915:  DECFSZ 2B,F
0916:  GOTO   110
....................   }  
0917:  GOTO   09A
.................... } 
....................  
0918:  SLEEP

Configuration Fuses:
   Word  1: 2CF4   INTRC_IO NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG
   Word  2: 3FFF   NOWRT BORV40
Subversion Repositories – MLAB

(root)/Modules/Sensors/SHT25V01A/SW/PIC16F887/main.lst @ 4856

Rev
