| 1,17 → 1,17 |
|---|
| CCS PCM C Compiler, Version 4.106, 47914 26-VIII-13 19:04 |
| CCS PCM C Compiler, Version 4.106, 47914 03-IX-13 00:32 |
| |
| Filename: Z:\home\kaklik\svnMLAB\Designs\Measuring_instruments\GeoMet01A\SW\PIC16F887\main.lst |
| Filename: D:\MLAB\Designs\Measuring_instruments\GeoMet01A\SW\PIC16F887\main.lst |
| |
| ROM used: 2940 words (36%) |
| ROM used: 3183 words (39%) |
| Largest free fragment is 2048 |
| RAM used: 21 (6%) at main() level |
| 46 (12%) worst case |
| RAM used: 27 (7%) at main() level |
| 52 (14%) worst case |
| Stack: 5 locations |
| |
| * |
| 0000: MOVLW 0A |
| 0001: MOVWF 0A |
| 0002: GOTO 228 |
| 0002: GOTO 2B7 |
| 0003: NOP |
| .................... #include "main.h" |
| .................... #include <16F887.h> |
| 37,171 → 37,172 |
|---|
| .................... |
| .................... #use delay(clock=8000000) |
| * |
| 0078: MOVLW 3D |
| 0079: MOVWF 04 |
| 007A: BCF 03.7 |
| 007B: MOVF 00,W |
| 007C: BTFSC 03.2 |
| 007D: GOTO 08B |
| 007E: MOVLW 02 |
| 007F: MOVWF 78 |
| 0080: CLRF 77 |
| 0081: DECFSZ 77,F |
| 0082: GOTO 081 |
| 0083: DECFSZ 78,F |
| 0084: GOTO 080 |
| 0085: MOVLW 97 |
| 0086: MOVWF 77 |
| 0087: DECFSZ 77,F |
| 0088: GOTO 087 |
| 0089: DECFSZ 00,F |
| 008A: GOTO 07E |
| 008B: RETURN |
| 00FB: MOVLW 43 |
| 00FC: MOVWF 04 |
| 00FD: BCF 03.7 |
| 00FE: MOVF 00,W |
| 00FF: BTFSC 03.2 |
| 0100: GOTO 10E |
| 0101: MOVLW 02 |
| 0102: MOVWF 78 |
| 0103: CLRF 77 |
| 0104: DECFSZ 77,F |
| 0105: GOTO 104 |
| 0106: DECFSZ 78,F |
| 0107: GOTO 103 |
| 0108: MOVLW 97 |
| 0109: MOVWF 77 |
| 010A: DECFSZ 77,F |
| 010B: GOTO 10A |
| 010C: DECFSZ 00,F |
| 010D: GOTO 101 |
| 010E: RETURN |
| .................... #use i2c(master, sda=PIN_C4, scl=PIN_C3) |
| * |
| 0202: MOVLW 08 |
| 0203: MOVWF 78 |
| 0204: NOP |
| 0205: BCF 07.3 |
| 0206: BCF 20.3 |
| 0207: MOVF 20,W |
| 0208: BSF 03.5 |
| 0209: MOVWF 07 |
| 020A: NOP |
| 020B: BCF 03.5 |
| 020C: RLF 34,F |
| 020D: BCF 07.4 |
| 020E: BTFSS 03.0 |
| 020F: GOTO 216 |
| 0210: BSF 20.4 |
| 0211: MOVF 20,W |
| 0212: BSF 03.5 |
| 0213: MOVWF 07 |
| 0214: GOTO 21A |
| 0215: BCF 03.5 |
| 0216: BCF 20.4 |
| 0217: MOVF 20,W |
| 0218: BSF 03.5 |
| 0219: MOVWF 07 |
| 021A: NOP |
| 021B: BCF 03.5 |
| 021C: BSF 20.3 |
| 021D: MOVF 20,W |
| 021E: BSF 03.5 |
| 021F: MOVWF 07 |
| 0220: BCF 03.5 |
| 0221: BTFSS 07.3 |
| 0222: GOTO 221 |
| 0223: DECFSZ 78,F |
| 0224: GOTO 204 |
| 0225: NOP |
| 0226: BCF 07.3 |
| 0227: BCF 20.3 |
| 0228: MOVF 20,W |
| 0229: BSF 03.5 |
| 022A: MOVWF 07 |
| 022B: NOP |
| 022C: BCF 03.5 |
| 022D: BSF 20.4 |
| 022E: MOVF 20,W |
| 022F: BSF 03.5 |
| 0230: MOVWF 07 |
| 0231: NOP |
| 0232: NOP |
| 0233: BCF 03.5 |
| 0234: BSF 20.3 |
| 0235: MOVF 20,W |
| 0236: BSF 03.5 |
| 0237: MOVWF 07 |
| 0238: BCF 03.5 |
| 0239: BTFSS 07.3 |
| 023A: GOTO 239 |
| 023B: CLRF 78 |
| 023C: NOP |
| 023D: BTFSC 07.4 |
| 023E: BSF 78.0 |
| 023F: BCF 07.3 |
| 0240: BCF 20.3 |
| 0241: MOVF 20,W |
| 0242: BSF 03.5 |
| 0243: MOVWF 07 |
| 0244: BCF 03.5 |
| 0245: BCF 07.4 |
| 0246: BCF 20.4 |
| 0247: MOVF 20,W |
| 0248: BSF 03.5 |
| 0249: MOVWF 07 |
| 024A: BCF 03.5 |
| 024B: RETURN |
| 024C: MOVLW 08 |
| 024D: MOVWF 35 |
| 024E: MOVF 77,W |
| 024F: MOVWF 36 |
| 0250: BSF 20.4 |
| 0251: MOVF 20,W |
| 0252: BSF 03.5 |
| 0253: MOVWF 07 |
| 0254: NOP |
| 0255: BCF 03.5 |
| 0256: BSF 20.3 |
| 0257: MOVF 20,W |
| 0258: BSF 03.5 |
| 0259: MOVWF 07 |
| 025A: BCF 03.5 |
| 025B: BTFSS 07.3 |
| 025C: GOTO 25B |
| 025D: BTFSC 07.4 |
| 025E: BSF 03.0 |
| 025F: BTFSS 07.4 |
| 0260: BCF 03.0 |
| 0261: RLF 78,F |
| 0262: NOP |
| 0263: BCF 20.3 |
| 0264: MOVF 20,W |
| 0265: BSF 03.5 |
| 0266: MOVWF 07 |
| 0267: BCF 03.5 |
| 0268: BCF 07.3 |
| 0269: DECFSZ 35,F |
| 026A: GOTO 250 |
| 026B: BSF 20.4 |
| 026C: MOVF 20,W |
| 026D: BSF 03.5 |
| 026E: MOVWF 07 |
| 026F: NOP |
| 0270: BCF 03.5 |
| 0271: BCF 07.4 |
| 0272: MOVF 36,W |
| 0273: BTFSC 03.2 |
| 0274: GOTO 27A |
| 0275: BCF 20.4 |
| 0276: MOVF 20,W |
| 0277: BSF 03.5 |
| 0278: MOVWF 07 |
| 0279: BCF 03.5 |
| 027A: NOP |
| 027B: BSF 20.3 |
| 027C: MOVF 20,W |
| 027D: BSF 03.5 |
| 027E: MOVWF 07 |
| 027F: BCF 03.5 |
| 0280: BTFSS 07.3 |
| 0281: GOTO 280 |
| 0282: NOP |
| 0283: BCF 07.3 |
| 0284: BCF 20.3 |
| 0285: MOVF 20,W |
| 0286: BSF 03.5 |
| 0287: MOVWF 07 |
| 0288: NOP |
| 0289: BCF 03.5 |
| 028A: BCF 07.4 |
| 028B: BCF 20.4 |
| 028C: MOVF 20,W |
| 028D: BSF 03.5 |
| 028E: MOVWF 07 |
| 028F: BCF 03.5 |
| 0290: RETURN |
| 0078: MOVLW 08 |
| 0079: MOVWF 78 |
| 007A: NOP |
| 007B: BCF 07.3 |
| 007C: BCF 20.3 |
| 007D: MOVF 20,W |
| 007E: BSF 03.5 |
| 007F: MOVWF 07 |
| 0080: NOP |
| 0081: BCF 03.5 |
| 0082: RLF 3B,F |
| 0083: BCF 07.4 |
| 0084: BTFSS 03.0 |
| 0085: GOTO 08C |
| 0086: BSF 20.4 |
| 0087: MOVF 20,W |
| 0088: BSF 03.5 |
| 0089: MOVWF 07 |
| 008A: GOTO 090 |
| 008B: BCF 03.5 |
| 008C: BCF 20.4 |
| 008D: MOVF 20,W |
| 008E: BSF 03.5 |
| 008F: MOVWF 07 |
| 0090: NOP |
| 0091: BCF 03.5 |
| 0092: BSF 20.3 |
| 0093: MOVF 20,W |
| 0094: BSF 03.5 |
| 0095: MOVWF 07 |
| 0096: BCF 03.5 |
| 0097: BTFSS 07.3 |
| 0098: GOTO 097 |
| 0099: DECFSZ 78,F |
| 009A: GOTO 07A |
| 009B: NOP |
| 009C: BCF 07.3 |
| 009D: BCF 20.3 |
| 009E: MOVF 20,W |
| 009F: BSF 03.5 |
| 00A0: MOVWF 07 |
| 00A1: NOP |
| 00A2: BCF 03.5 |
| 00A3: BSF 20.4 |
| 00A4: MOVF 20,W |
| 00A5: BSF 03.5 |
| 00A6: MOVWF 07 |
| 00A7: NOP |
| 00A8: NOP |
| 00A9: BCF 03.5 |
| 00AA: BSF 20.3 |
| 00AB: MOVF 20,W |
| 00AC: BSF 03.5 |
| 00AD: MOVWF 07 |
| 00AE: BCF 03.5 |
| 00AF: BTFSS 07.3 |
| 00B0: GOTO 0AF |
| 00B1: CLRF 78 |
| 00B2: NOP |
| 00B3: BTFSC 07.4 |
| 00B4: BSF 78.0 |
| 00B5: BCF 07.3 |
| 00B6: BCF 20.3 |
| 00B7: MOVF 20,W |
| 00B8: BSF 03.5 |
| 00B9: MOVWF 07 |
| 00BA: BCF 03.5 |
| 00BB: BCF 07.4 |
| 00BC: BCF 20.4 |
| 00BD: MOVF 20,W |
| 00BE: BSF 03.5 |
| 00BF: MOVWF 07 |
| 00C0: BCF 03.5 |
| 00C1: RETURN |
| * |
| 0285: MOVLW 08 |
| 0286: MOVWF 3C |
| 0287: MOVF 77,W |
| 0288: MOVWF 3D |
| 0289: BSF 20.4 |
| 028A: MOVF 20,W |
| 028B: BSF 03.5 |
| 028C: MOVWF 07 |
| 028D: NOP |
| 028E: BCF 03.5 |
| 028F: BSF 20.3 |
| 0290: MOVF 20,W |
| 0291: BSF 03.5 |
| 0292: MOVWF 07 |
| 0293: BCF 03.5 |
| 0294: BTFSS 07.3 |
| 0295: GOTO 294 |
| 0296: BTFSC 07.4 |
| 0297: BSF 03.0 |
| 0298: BTFSS 07.4 |
| 0299: BCF 03.0 |
| 029A: RLF 78,F |
| 029B: NOP |
| 029C: BCF 20.3 |
| 029D: MOVF 20,W |
| 029E: BSF 03.5 |
| 029F: MOVWF 07 |
| 02A0: BCF 03.5 |
| 02A1: BCF 07.3 |
| 02A2: DECFSZ 3C,F |
| 02A3: GOTO 289 |
| 02A4: BSF 20.4 |
| 02A5: MOVF 20,W |
| 02A6: BSF 03.5 |
| 02A7: MOVWF 07 |
| 02A8: NOP |
| 02A9: BCF 03.5 |
| 02AA: BCF 07.4 |
| 02AB: MOVF 3D,W |
| 02AC: BTFSC 03.2 |
| 02AD: GOTO 2B3 |
| 02AE: BCF 20.4 |
| 02AF: MOVF 20,W |
| 02B0: BSF 03.5 |
| 02B1: MOVWF 07 |
| 02B2: BCF 03.5 |
| 02B3: NOP |
| 02B4: BSF 20.3 |
| 02B5: MOVF 20,W |
| 02B6: BSF 03.5 |
| 02B7: MOVWF 07 |
| 02B8: BCF 03.5 |
| 02B9: BTFSS 07.3 |
| 02BA: GOTO 2B9 |
| 02BB: NOP |
| 02BC: BCF 07.3 |
| 02BD: BCF 20.3 |
| 02BE: MOVF 20,W |
| 02BF: BSF 03.5 |
| 02C0: MOVWF 07 |
| 02C1: NOP |
| 02C2: BCF 03.5 |
| 02C3: BCF 07.4 |
| 02C4: BCF 20.4 |
| 02C5: MOVF 20,W |
| 02C6: BSF 03.5 |
| 02C7: MOVWF 07 |
| 02C8: BCF 03.5 |
| 02C9: RETURN |
| .................... #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8) |
| .................... |
| .................... |
| 410,13 → 411,13 |
|---|
| .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
| .................... output_float(LCD_DATA4); |
| * |
| 00F1: BSF 08.4 |
| 0174: BSF 08.4 |
| .................... output_float(LCD_DATA5); |
| 00F2: BSF 08.5 |
| 0175: BSF 08.5 |
| .................... output_float(LCD_DATA6); |
| 00F3: BSF 08.6 |
| 0176: BSF 08.6 |
| .................... output_float(LCD_DATA7); |
| 00F4: BSF 08.7 |
| 0177: BSF 08.7 |
| .................... #else |
| .................... lcdtris.data = 0xF; |
| .................... #endif |
| 423,48 → 424,48 |
|---|
| .................... #endif |
| .................... |
| .................... lcd_output_rw(1); |
| 00F5: BCF 03.5 |
| 00F6: BSF 09.2 |
| 00F7: BSF 03.5 |
| 00F8: BCF 09.2 |
| 0178: BCF 03.5 |
| 0179: BSF 09.2 |
| 017A: BSF 03.5 |
| 017B: BCF 09.2 |
| .................... delay_cycles(1); |
| 00F9: NOP |
| 017C: NOP |
| .................... lcd_output_enable(1); |
| 00FA: BCF 03.5 |
| 00FB: BSF 09.0 |
| 00FC: BSF 03.5 |
| 00FD: BCF 09.0 |
| 017D: BCF 03.5 |
| 017E: BSF 09.0 |
| 017F: BSF 03.5 |
| 0180: BCF 09.0 |
| .................... delay_cycles(1); |
| 00FE: NOP |
| 0181: NOP |
| .................... high = lcd_read_nibble(); |
| 00FF: BCF 03.5 |
| 0100: CALL 0B8 |
| 0101: MOVF 78,W |
| 0102: MOVWF 44 |
| 0182: BCF 03.5 |
| 0183: CALL 13B |
| 0184: MOVF 78,W |
| 0185: MOVWF 4A |
| .................... |
| .................... lcd_output_enable(0); |
| 0103: BCF 09.0 |
| 0104: BSF 03.5 |
| 0105: BCF 09.0 |
| 0186: BCF 09.0 |
| 0187: BSF 03.5 |
| 0188: BCF 09.0 |
| .................... delay_cycles(1); |
| 0106: NOP |
| 0189: NOP |
| .................... lcd_output_enable(1); |
| 0107: BCF 03.5 |
| 0108: BSF 09.0 |
| 0109: BSF 03.5 |
| 010A: BCF 09.0 |
| 018A: BCF 03.5 |
| 018B: BSF 09.0 |
| 018C: BSF 03.5 |
| 018D: BCF 09.0 |
| .................... delay_us(1); |
| 010B: GOTO 10C |
| 018E: GOTO 18F |
| .................... low = lcd_read_nibble(); |
| 010C: BCF 03.5 |
| 010D: CALL 0B8 |
| 010E: MOVF 78,W |
| 010F: MOVWF 43 |
| 018F: BCF 03.5 |
| 0190: CALL 13B |
| 0191: MOVF 78,W |
| 0192: MOVWF 49 |
| .................... |
| .................... lcd_output_enable(0); |
| 0110: BCF 09.0 |
| 0111: BSF 03.5 |
| 0112: BCF 09.0 |
| 0193: BCF 09.0 |
| 0194: BSF 03.5 |
| 0195: BCF 09.0 |
| .................... |
| .................... #if defined(__PCB__) |
| .................... set_tris_lcd(LCD_OUTPUT_MAP); |
| 471,13 → 472,13 |
|---|
| .................... #else |
| .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
| .................... output_drive(LCD_DATA4); |
| 0113: BCF 08.4 |
| 0196: BCF 08.4 |
| .................... output_drive(LCD_DATA5); |
| 0114: BCF 08.5 |
| 0197: BCF 08.5 |
| .................... output_drive(LCD_DATA6); |
| 0115: BCF 08.6 |
| 0198: BCF 08.6 |
| .................... output_drive(LCD_DATA7); |
| 0116: BCF 08.7 |
| 0199: BCF 08.7 |
| .................... #else |
| .................... lcdtris.data = 0x0; |
| .................... #endif |
| 484,14 → 485,14 |
|---|
| .................... #endif |
| .................... |
| .................... return( (high<<4) | low); |
| 0117: BCF 03.5 |
| 0118: SWAPF 44,W |
| 0119: MOVWF 77 |
| 011A: MOVLW F0 |
| 011B: ANDWF 77,F |
| 011C: MOVF 77,W |
| 011D: IORWF 43,W |
| 011E: MOVWF 78 |
| 019A: BCF 03.5 |
| 019B: SWAPF 4A,W |
| 019C: MOVWF 77 |
| 019D: MOVLW F0 |
| 019E: ANDWF 77,F |
| 019F: MOVF 77,W |
| 01A0: IORWF 49,W |
| 01A1: MOVWF 78 |
| .................... } |
| .................... |
| .................... BYTE lcd_read_nibble(void) |
| 498,68 → 499,68 |
|---|
| .................... { |
| .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
| * |
| 00B8: CLRF 45 |
| 013B: CLRF 4B |
| .................... BYTE n = 0x00; |
| .................... |
| .................... /* Read the data port */ |
| .................... n |= input(LCD_DATA4); |
| 00B9: BSF 03.5 |
| 00BA: BSF 08.4 |
| 00BB: MOVLW 00 |
| 00BC: BCF 03.5 |
| 00BD: BTFSC 08.4 |
| 00BE: MOVLW 01 |
| 00BF: IORWF 45,F |
| 013C: BSF 03.5 |
| 013D: BSF 08.4 |
| 013E: MOVLW 00 |
| 013F: BCF 03.5 |
| 0140: BTFSC 08.4 |
| 0141: MOVLW 01 |
| 0142: IORWF 4B,F |
| .................... n |= input(LCD_DATA5) << 1; |
| 00C0: BSF 03.5 |
| 00C1: BSF 08.5 |
| 00C2: MOVLW 00 |
| 00C3: BCF 03.5 |
| 00C4: BTFSC 08.5 |
| 00C5: MOVLW 01 |
| 00C6: MOVWF 77 |
| 00C7: BCF 03.0 |
| 00C8: RLF 77,F |
| 00C9: MOVF 77,W |
| 00CA: IORWF 45,F |
| 0143: BSF 03.5 |
| 0144: BSF 08.5 |
| 0145: MOVLW 00 |
| 0146: BCF 03.5 |
| 0147: BTFSC 08.5 |
| 0148: MOVLW 01 |
| 0149: MOVWF 77 |
| 014A: BCF 03.0 |
| 014B: RLF 77,F |
| 014C: MOVF 77,W |
| 014D: IORWF 4B,F |
| .................... n |= input(LCD_DATA6) << 2; |
| 00CB: BSF 03.5 |
| 00CC: BSF 08.6 |
| 00CD: MOVLW 00 |
| 00CE: BCF 03.5 |
| 00CF: BTFSC 08.6 |
| 00D0: MOVLW 01 |
| 00D1: MOVWF 77 |
| 00D2: RLF 77,F |
| 00D3: RLF 77,F |
| 00D4: MOVLW FC |
| 00D5: ANDWF 77,F |
| 00D6: MOVF 77,W |
| 00D7: IORWF 45,F |
| 014E: BSF 03.5 |
| 014F: BSF 08.6 |
| 0150: MOVLW 00 |
| 0151: BCF 03.5 |
| 0152: BTFSC 08.6 |
| 0153: MOVLW 01 |
| 0154: MOVWF 77 |
| 0155: RLF 77,F |
| 0156: RLF 77,F |
| 0157: MOVLW FC |
| 0158: ANDWF 77,F |
| 0159: MOVF 77,W |
| 015A: IORWF 4B,F |
| .................... n |= input(LCD_DATA7) << 3; |
| 00D8: BSF 03.5 |
| 00D9: BSF 08.7 |
| 00DA: MOVLW 00 |
| 00DB: BCF 03.5 |
| 00DC: BTFSC 08.7 |
| 00DD: MOVLW 01 |
| 00DE: MOVWF 77 |
| 00DF: RLF 77,F |
| 00E0: RLF 77,F |
| 00E1: RLF 77,F |
| 00E2: MOVLW F8 |
| 00E3: ANDWF 77,F |
| 00E4: MOVF 77,W |
| 00E5: IORWF 45,F |
| 015B: BSF 03.5 |
| 015C: BSF 08.7 |
| 015D: MOVLW 00 |
| 015E: BCF 03.5 |
| 015F: BTFSC 08.7 |
| 0160: MOVLW 01 |
| 0161: MOVWF 77 |
| 0162: RLF 77,F |
| 0163: RLF 77,F |
| 0164: RLF 77,F |
| 0165: MOVLW F8 |
| 0166: ANDWF 77,F |
| 0167: MOVF 77,W |
| 0168: IORWF 4B,F |
| .................... |
| .................... return(n); |
| 00E6: MOVF 45,W |
| 00E7: MOVWF 78 |
| 0169: MOVF 4B,W |
| 016A: MOVWF 78 |
| .................... #else |
| .................... return(lcd.data); |
| .................... #endif |
| .................... } |
| 00E8: RETURN |
| 016B: RETURN |
| .................... |
| .................... void lcd_send_nibble(BYTE n) |
| .................... { |
| 567,62 → 568,62 |
|---|
| .................... /* Write to the data port */ |
| .................... output_bit(LCD_DATA4, bit_test(n, 0)); |
| * |
| 008C: BTFSC 44.0 |
| 008D: GOTO 090 |
| 008E: BCF 08.4 |
| 008F: GOTO 091 |
| 0090: BSF 08.4 |
| 0091: BSF 03.5 |
| 0092: BCF 08.4 |
| 010F: BTFSC 4A.0 |
| 0110: GOTO 113 |
| 0111: BCF 08.4 |
| 0112: GOTO 114 |
| 0113: BSF 08.4 |
| 0114: BSF 03.5 |
| 0115: BCF 08.4 |
| .................... output_bit(LCD_DATA5, bit_test(n, 1)); |
| 0093: BCF 03.5 |
| 0094: BTFSC 44.1 |
| 0095: GOTO 098 |
| 0096: BCF 08.5 |
| 0097: GOTO 099 |
| 0098: BSF 08.5 |
| 0099: BSF 03.5 |
| 009A: BCF 08.5 |
| 0116: BCF 03.5 |
| 0117: BTFSC 4A.1 |
| 0118: GOTO 11B |
| 0119: BCF 08.5 |
| 011A: GOTO 11C |
| 011B: BSF 08.5 |
| 011C: BSF 03.5 |
| 011D: BCF 08.5 |
| .................... output_bit(LCD_DATA6, bit_test(n, 2)); |
| 009B: BCF 03.5 |
| 009C: BTFSC 44.2 |
| 009D: GOTO 0A0 |
| 009E: BCF 08.6 |
| 009F: GOTO 0A1 |
| 00A0: BSF 08.6 |
| 00A1: BSF 03.5 |
| 00A2: BCF 08.6 |
| 011E: BCF 03.5 |
| 011F: BTFSC 4A.2 |
| 0120: GOTO 123 |
| 0121: BCF 08.6 |
| 0122: GOTO 124 |
| 0123: BSF 08.6 |
| 0124: BSF 03.5 |
| 0125: BCF 08.6 |
| .................... output_bit(LCD_DATA7, bit_test(n, 3)); |
| 00A3: BCF 03.5 |
| 00A4: BTFSC 44.3 |
| 00A5: GOTO 0A8 |
| 00A6: BCF 08.7 |
| 00A7: GOTO 0A9 |
| 00A8: BSF 08.7 |
| 00A9: BSF 03.5 |
| 00AA: BCF 08.7 |
| 0126: BCF 03.5 |
| 0127: BTFSC 4A.3 |
| 0128: GOTO 12B |
| 0129: BCF 08.7 |
| 012A: GOTO 12C |
| 012B: BSF 08.7 |
| 012C: BSF 03.5 |
| 012D: BCF 08.7 |
| .................... #else |
| .................... lcdlat.data = n; |
| .................... #endif |
| .................... |
| .................... delay_cycles(1); |
| 00AB: NOP |
| 012E: NOP |
| .................... lcd_output_enable(1); |
| 00AC: BCF 03.5 |
| 00AD: BSF 09.0 |
| 00AE: BSF 03.5 |
| 00AF: BCF 09.0 |
| 012F: BCF 03.5 |
| 0130: BSF 09.0 |
| 0131: BSF 03.5 |
| 0132: BCF 09.0 |
| .................... delay_us(2); |
| 00B0: GOTO 0B1 |
| 00B1: GOTO 0B2 |
| 0133: GOTO 134 |
| 0134: GOTO 135 |
| .................... lcd_output_enable(0); |
| 00B2: BCF 03.5 |
| 00B3: BCF 09.0 |
| 00B4: BSF 03.5 |
| 00B5: BCF 09.0 |
| 0135: BCF 03.5 |
| 0136: BCF 09.0 |
| 0137: BSF 03.5 |
| 0138: BCF 09.0 |
| .................... } |
| 00B6: BCF 03.5 |
| 00B7: RETURN |
| 0139: BCF 03.5 |
| 013A: RETURN |
| .................... |
| .................... void lcd_send_byte(BYTE address, BYTE n) |
| .................... { |
| 631,67 → 632,67 |
|---|
| .................... #else |
| .................... lcd_enable_tris(); |
| * |
| 00E9: BSF 03.5 |
| 00EA: BCF 09.0 |
| 016C: BSF 03.5 |
| 016D: BCF 09.0 |
| .................... lcd_rs_tris(); |
| 00EB: BCF 09.1 |
| 016E: BCF 09.1 |
| .................... lcd_rw_tris(); |
| 00EC: BCF 09.2 |
| 016F: BCF 09.2 |
| .................... #endif |
| .................... |
| .................... lcd_output_rs(0); |
| 00ED: BCF 03.5 |
| 00EE: BCF 09.1 |
| 00EF: BSF 03.5 |
| 00F0: BCF 09.1 |
| 0170: BCF 03.5 |
| 0171: BCF 09.1 |
| 0172: BSF 03.5 |
| 0173: BCF 09.1 |
| .................... while ( bit_test(lcd_read_byte(),7) ) ; |
| * |
| 011F: MOVF 78,W |
| 0120: MOVWF 43 |
| 0121: BTFSS 43.7 |
| 0122: GOTO 125 |
| 0123: BSF 03.5 |
| 0124: GOTO 0F1 |
| 01A2: MOVF 78,W |
| 01A3: MOVWF 49 |
| 01A4: BTFSS 49.7 |
| 01A5: GOTO 1A8 |
| 01A6: BSF 03.5 |
| 01A7: GOTO 174 |
| .................... lcd_output_rs(address); |
| 0125: MOVF 41,F |
| 0126: BTFSS 03.2 |
| 0127: GOTO 12A |
| 0128: BCF 09.1 |
| 0129: GOTO 12B |
| 012A: BSF 09.1 |
| 012B: BSF 03.5 |
| 012C: BCF 09.1 |
| 01A8: MOVF 47,F |
| 01A9: BTFSS 03.2 |
| 01AA: GOTO 1AD |
| 01AB: BCF 09.1 |
| 01AC: GOTO 1AE |
| 01AD: BSF 09.1 |
| 01AE: BSF 03.5 |
| 01AF: BCF 09.1 |
| .................... delay_cycles(1); |
| 012D: NOP |
| 01B0: NOP |
| .................... lcd_output_rw(0); |
| 012E: BCF 03.5 |
| 012F: BCF 09.2 |
| 0130: BSF 03.5 |
| 0131: BCF 09.2 |
| 01B1: BCF 03.5 |
| 01B2: BCF 09.2 |
| 01B3: BSF 03.5 |
| 01B4: BCF 09.2 |
| .................... delay_cycles(1); |
| 0132: NOP |
| 01B5: NOP |
| .................... lcd_output_enable(0); |
| 0133: BCF 03.5 |
| 0134: BCF 09.0 |
| 0135: BSF 03.5 |
| 0136: BCF 09.0 |
| 01B6: BCF 03.5 |
| 01B7: BCF 09.0 |
| 01B8: BSF 03.5 |
| 01B9: BCF 09.0 |
| .................... lcd_send_nibble(n >> 4); |
| 0137: BCF 03.5 |
| 0138: SWAPF 42,W |
| 0139: MOVWF 43 |
| 013A: MOVLW 0F |
| 013B: ANDWF 43,F |
| 013C: MOVF 43,W |
| 013D: MOVWF 44 |
| 013E: CALL 08C |
| 01BA: BCF 03.5 |
| 01BB: SWAPF 48,W |
| 01BC: MOVWF 49 |
| 01BD: MOVLW 0F |
| 01BE: ANDWF 49,F |
| 01BF: MOVF 49,W |
| 01C0: MOVWF 4A |
| 01C1: CALL 10F |
| .................... lcd_send_nibble(n & 0xf); |
| 013F: MOVF 42,W |
| 0140: ANDLW 0F |
| 0141: MOVWF 43 |
| 0142: MOVWF 44 |
| 0143: CALL 08C |
| 01C2: MOVF 48,W |
| 01C3: ANDLW 0F |
| 01C4: MOVWF 49 |
| 01C5: MOVWF 4A |
| 01C6: CALL 10F |
| .................... } |
| 0144: RETURN |
| 01C7: RETURN |
| .................... |
| .................... #if defined(LCD_EXTENDED_NEWLINE) |
| .................... unsigned int8 g_LcdX, g_LcdY; |
| 706,93 → 707,93 |
|---|
| .................... #else |
| .................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
| .................... output_drive(LCD_DATA4); |
| 0145: BSF 03.5 |
| 0146: BCF 08.4 |
| 01C8: BSF 03.5 |
| 01C9: BCF 08.4 |
| .................... output_drive(LCD_DATA5); |
| 0147: BCF 08.5 |
| 01CA: BCF 08.5 |
| .................... output_drive(LCD_DATA6); |
| 0148: BCF 08.6 |
| 01CB: BCF 08.6 |
| .................... output_drive(LCD_DATA7); |
| 0149: BCF 08.7 |
| 01CC: BCF 08.7 |
| .................... #else |
| .................... lcdtris.data = 0x0; |
| .................... #endif |
| .................... lcd_enable_tris(); |
| 014A: BCF 09.0 |
| 01CD: BCF 09.0 |
| .................... lcd_rs_tris(); |
| 014B: BCF 09.1 |
| 01CE: BCF 09.1 |
| .................... lcd_rw_tris(); |
| 014C: BCF 09.2 |
| 01CF: BCF 09.2 |
| .................... #endif |
| .................... |
| .................... lcd_output_rs(0); |
| 014D: BCF 03.5 |
| 014E: BCF 09.1 |
| 014F: BSF 03.5 |
| 0150: BCF 09.1 |
| 01D0: BCF 03.5 |
| 01D1: BCF 09.1 |
| 01D2: BSF 03.5 |
| 01D3: BCF 09.1 |
| .................... lcd_output_rw(0); |
| 0151: BCF 03.5 |
| 0152: BCF 09.2 |
| 0153: BSF 03.5 |
| 0154: BCF 09.2 |
| 01D4: BCF 03.5 |
| 01D5: BCF 09.2 |
| 01D6: BSF 03.5 |
| 01D7: BCF 09.2 |
| .................... lcd_output_enable(0); |
| 0155: BCF 03.5 |
| 0156: BCF 09.0 |
| 0157: BSF 03.5 |
| 0158: BCF 09.0 |
| 01D8: BCF 03.5 |
| 01D9: BCF 09.0 |
| 01DA: BSF 03.5 |
| 01DB: BCF 09.0 |
| .................... |
| .................... delay_ms(15); |
| 0159: MOVLW 0F |
| 015A: BCF 03.5 |
| 015B: MOVWF 3D |
| 015C: CALL 078 |
| 01DC: MOVLW 0F |
| 01DD: BCF 03.5 |
| 01DE: MOVWF 43 |
| 01DF: CALL 0FB |
| .................... for(i=1;i<=3;++i) |
| 015D: MOVLW 01 |
| 015E: MOVWF 2F |
| 015F: MOVF 2F,W |
| 0160: SUBLW 03 |
| 0161: BTFSS 03.0 |
| 0162: GOTO 16B |
| 01E0: MOVLW 01 |
| 01E1: MOVWF 35 |
| 01E2: MOVF 35,W |
| 01E3: SUBLW 03 |
| 01E4: BTFSS 03.0 |
| 01E5: GOTO 1EE |
| .................... { |
| .................... lcd_send_nibble(3); |
| 0163: MOVLW 03 |
| 0164: MOVWF 44 |
| 0165: CALL 08C |
| 01E6: MOVLW 03 |
| 01E7: MOVWF 4A |
| 01E8: CALL 10F |
| .................... delay_ms(5); |
| 0166: MOVLW 05 |
| 0167: MOVWF 3D |
| 0168: CALL 078 |
| 01E9: MOVLW 05 |
| 01EA: MOVWF 43 |
| 01EB: CALL 0FB |
| .................... } |
| 0169: INCF 2F,F |
| 016A: GOTO 15F |
| 01EC: INCF 35,F |
| 01ED: GOTO 1E2 |
| .................... |
| .................... lcd_send_nibble(2); |
| 016B: MOVLW 02 |
| 016C: MOVWF 44 |
| 016D: CALL 08C |
| 01EE: MOVLW 02 |
| 01EF: MOVWF 4A |
| 01F0: CALL 10F |
| .................... for(i=0;i<=3;++i) |
| 016E: CLRF 2F |
| 016F: MOVF 2F,W |
| 0170: SUBLW 03 |
| 0171: BTFSS 03.0 |
| 0172: GOTO 17C |
| 01F1: CLRF 35 |
| 01F2: MOVF 35,W |
| 01F3: SUBLW 03 |
| 01F4: BTFSS 03.0 |
| 01F5: GOTO 1FF |
| .................... lcd_send_byte(0,LCD_INIT_STRING[i]); |
| 0173: MOVF 2F,W |
| 0174: CALL 004 |
| 0175: MOVWF 30 |
| 0176: CLRF 41 |
| 0177: MOVF 30,W |
| 0178: MOVWF 42 |
| 0179: CALL 0E9 |
| 01F6: MOVF 35,W |
| 01F7: CALL 004 |
| 01F8: MOVWF 36 |
| 01F9: CLRF 47 |
| 01FA: MOVF 36,W |
| 01FB: MOVWF 48 |
| 01FC: CALL 16C |
| .................... |
| .................... #if defined(LCD_EXTENDED_NEWLINE) |
| 017A: INCF 2F,F |
| 017B: GOTO 16F |
| 01FD: INCF 35,F |
| 01FE: GOTO 1F2 |
| .................... g_LcdX = 0; |
| .................... g_LcdY = 0; |
| .................... #endif |
| .................... } |
| 017C: RETURN |
| 01FF: RETURN |
| .................... |
| .................... void lcd_gotoxy(BYTE x, BYTE y) |
| .................... { |
| 799,29 → 800,29 |
|---|
| .................... BYTE address; |
| .................... |
| .................... if(y!=1) |
| 017D: DECFSZ 3E,W |
| 017E: GOTO 180 |
| 017F: GOTO 183 |
| 0200: DECFSZ 44,W |
| 0201: GOTO 203 |
| 0202: GOTO 206 |
| .................... address=LCD_LINE_TWO; |
| 0180: MOVLW 40 |
| 0181: MOVWF 3F |
| 0203: MOVLW 40 |
| 0204: MOVWF 45 |
| .................... else |
| 0182: GOTO 184 |
| 0205: GOTO 207 |
| .................... address=0; |
| 0183: CLRF 3F |
| 0206: CLRF 45 |
| .................... |
| .................... address+=x-1; |
| 0184: MOVLW 01 |
| 0185: SUBWF 3D,W |
| 0186: ADDWF 3F,F |
| 0207: MOVLW 01 |
| 0208: SUBWF 43,W |
| 0209: ADDWF 45,F |
| .................... lcd_send_byte(0,0x80|address); |
| 0187: MOVF 3F,W |
| 0188: IORLW 80 |
| 0189: MOVWF 40 |
| 018A: CLRF 41 |
| 018B: MOVF 40,W |
| 018C: MOVWF 42 |
| 018D: CALL 0E9 |
| 020A: MOVF 45,W |
| 020B: IORLW 80 |
| 020C: MOVWF 46 |
| 020D: CLRF 47 |
| 020E: MOVF 46,W |
| 020F: MOVWF 48 |
| 0210: CALL 16C |
| .................... |
| .................... #if defined(LCD_EXTENDED_NEWLINE) |
| .................... g_LcdX = x - 1; |
| 828,48 → 829,48 |
|---|
| .................... g_LcdY = y - 1; |
| .................... #endif |
| .................... } |
| 018E: RETURN |
| 0211: RETURN |
| .................... |
| .................... void lcd_putc(char c) |
| .................... { |
| .................... switch (c) |
| .................... { |
| 018F: MOVF 3C,W |
| 0190: XORLW 07 |
| 0191: BTFSC 03.2 |
| 0192: GOTO 19D |
| 0193: XORLW 0B |
| 0194: BTFSC 03.2 |
| 0195: GOTO 1A2 |
| 0196: XORLW 06 |
| 0197: BTFSC 03.2 |
| 0198: GOTO 1AA |
| 0199: XORLW 02 |
| 019A: BTFSC 03.2 |
| 019B: GOTO 1B0 |
| 019C: GOTO 1B5 |
| 0212: MOVF 42,W |
| 0213: XORLW 07 |
| 0214: BTFSC 03.2 |
| 0215: GOTO 220 |
| 0216: XORLW 0B |
| 0217: BTFSC 03.2 |
| 0218: GOTO 225 |
| 0219: XORLW 06 |
| 021A: BTFSC 03.2 |
| 021B: GOTO 22D |
| 021C: XORLW 02 |
| 021D: BTFSC 03.2 |
| 021E: GOTO 233 |
| 021F: GOTO 238 |
| .................... case '\a' : lcd_gotoxy(1,1); break; |
| 019D: MOVLW 01 |
| 019E: MOVWF 3D |
| 019F: MOVWF 3E |
| 01A0: CALL 17D |
| 01A1: GOTO 1BB |
| 0220: MOVLW 01 |
| 0221: MOVWF 43 |
| 0222: MOVWF 44 |
| 0223: CALL 200 |
| 0224: GOTO 23E |
| .................... |
| .................... case '\f' : lcd_send_byte(0,1); |
| 01A2: CLRF 41 |
| 01A3: MOVLW 01 |
| 01A4: MOVWF 42 |
| 01A5: CALL 0E9 |
| 0225: CLRF 47 |
| 0226: MOVLW 01 |
| 0227: MOVWF 48 |
| 0228: CALL 16C |
| .................... delay_ms(2); |
| 01A6: MOVLW 02 |
| 01A7: MOVWF 3D |
| 01A8: CALL 078 |
| 0229: MOVLW 02 |
| 022A: MOVWF 43 |
| 022B: CALL 0FB |
| .................... #if defined(LCD_EXTENDED_NEWLINE) |
| .................... g_LcdX = 0; |
| .................... g_LcdY = 0; |
| .................... #endif |
| .................... break; |
| 01A9: GOTO 1BB |
| 022C: GOTO 23E |
| .................... |
| .................... #if defined(LCD_EXTENDED_NEWLINE) |
| .................... case '\r' : lcd_gotoxy(1, g_LcdY+1); break; |
| 882,20 → 883,20 |
|---|
| .................... break; |
| .................... #else |
| .................... case '\n' : lcd_gotoxy(1,2); break; |
| 01AA: MOVLW 01 |
| 01AB: MOVWF 3D |
| 01AC: MOVLW 02 |
| 01AD: MOVWF 3E |
| 01AE: CALL 17D |
| 01AF: GOTO 1BB |
| 022D: MOVLW 01 |
| 022E: MOVWF 43 |
| 022F: MOVLW 02 |
| 0230: MOVWF 44 |
| 0231: CALL 200 |
| 0232: GOTO 23E |
| .................... #endif |
| .................... |
| .................... case '\b' : lcd_send_byte(0,0x10); break; |
| 01B0: CLRF 41 |
| 01B1: MOVLW 10 |
| 01B2: MOVWF 42 |
| 01B3: CALL 0E9 |
| 01B4: GOTO 1BB |
| 0233: CLRF 47 |
| 0234: MOVLW 10 |
| 0235: MOVWF 48 |
| 0236: CALL 16C |
| 0237: GOTO 23E |
| .................... |
| .................... #if defined(LCD_EXTENDED_NEWLINE) |
| .................... default : |
| 907,16 → 908,16 |
|---|
| .................... break; |
| .................... #else |
| .................... default : lcd_send_byte(1,c); break; |
| 01B5: MOVLW 01 |
| 01B6: MOVWF 41 |
| 01B7: MOVF 3C,W |
| 01B8: MOVWF 42 |
| 01B9: CALL 0E9 |
| 01BA: GOTO 1BB |
| 0238: MOVLW 01 |
| 0239: MOVWF 47 |
| 023A: MOVF 42,W |
| 023B: MOVWF 48 |
| 023C: CALL 16C |
| 023D: GOTO 23E |
| .................... #endif |
| .................... } |
| .................... } |
| 01BB: RETURN |
| 023E: RETURN |
| .................... |
| .................... char lcd_getc(BYTE x, BYTE y) |
| .................... { |
| 994,231 → 995,231 |
|---|
| .................... |
| .................... i2c_start(); |
| * |
| 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: BTFSS 07.3 |
| 053B: GOTO 53A |
| 053C: BCF 07.4 |
| 053D: BCF 20.4 |
| 053E: MOVF 20,W |
| 053F: BSF 03.5 |
| 0540: MOVWF 07 |
| 0541: NOP |
| 0542: BCF 03.5 |
| 0543: BCF 07.3 |
| 0544: BCF 20.3 |
| 0545: MOVF 20,W |
| 0546: BSF 03.5 |
| 0547: MOVWF 07 |
| 0567: BSF 20.4 |
| 0568: MOVF 20,W |
| 0569: BSF 03.5 |
| 056A: MOVWF 07 |
| 056B: NOP |
| 056C: BCF 03.5 |
| 056D: BSF 20.3 |
| 056E: MOVF 20,W |
| 056F: BSF 03.5 |
| 0570: MOVWF 07 |
| 0571: NOP |
| 0572: BCF 03.5 |
| 0573: BTFSS 07.3 |
| 0574: GOTO 573 |
| 0575: BCF 07.4 |
| 0576: BCF 20.4 |
| 0577: MOVF 20,W |
| 0578: BSF 03.5 |
| 0579: MOVWF 07 |
| 057A: NOP |
| 057B: BCF 03.5 |
| 057C: BCF 07.3 |
| 057D: BCF 20.3 |
| 057E: MOVF 20,W |
| 057F: BSF 03.5 |
| 0580: MOVWF 07 |
| .................... I2C_Write(SHT25_ADDR); |
| 0548: MOVLW 80 |
| 0549: BCF 03.5 |
| 054A: MOVWF 34 |
| 054B: CALL 202 |
| 0581: MOVLW 80 |
| 0582: BCF 03.5 |
| 0583: MOVWF 3B |
| 0584: CALL 078 |
| .................... I2C_write(0xE3); |
| 054C: MOVLW E3 |
| 054D: MOVWF 34 |
| 054E: CALL 202 |
| 0585: MOVLW E3 |
| 0586: MOVWF 3B |
| 0587: CALL 078 |
| .................... i2c_stop(); |
| 054F: BCF 20.4 |
| 0550: MOVF 20,W |
| 0551: BSF 03.5 |
| 0552: MOVWF 07 |
| 0553: NOP |
| 0554: BCF 03.5 |
| 0555: BSF 20.3 |
| 0556: MOVF 20,W |
| 0557: BSF 03.5 |
| 0558: MOVWF 07 |
| 0559: BCF 03.5 |
| 055A: BTFSS 07.3 |
| 055B: GOTO 55A |
| 055C: NOP |
| 055D: GOTO 55E |
| 055E: NOP |
| 055F: BSF 20.4 |
| 0560: MOVF 20,W |
| 0561: BSF 03.5 |
| 0562: MOVWF 07 |
| 0563: NOP |
| 0588: BCF 20.4 |
| 0589: MOVF 20,W |
| 058A: BSF 03.5 |
| 058B: MOVWF 07 |
| 058C: NOP |
| 058D: BCF 03.5 |
| 058E: BSF 20.3 |
| 058F: MOVF 20,W |
| 0590: BSF 03.5 |
| 0591: MOVWF 07 |
| 0592: BCF 03.5 |
| 0593: BTFSS 07.3 |
| 0594: GOTO 593 |
| 0595: NOP |
| 0596: GOTO 597 |
| 0597: NOP |
| 0598: BSF 20.4 |
| 0599: MOVF 20,W |
| 059A: BSF 03.5 |
| 059B: MOVWF 07 |
| 059C: NOP |
| .................... |
| .................... delay_ms(100); |
| 0564: MOVLW 64 |
| 0565: BCF 03.5 |
| 0566: MOVWF 3D |
| 0567: CALL 078 |
| 059D: MOVLW 64 |
| 059E: BCF 03.5 |
| 059F: MOVWF 43 |
| 05A0: CALL 0FB |
| .................... |
| .................... i2c_start(); |
| 0568: BSF 20.4 |
| 0569: MOVF 20,W |
| 056A: BSF 03.5 |
| 056B: MOVWF 07 |
| 056C: NOP |
| 056D: BCF 03.5 |
| 056E: BSF 20.3 |
| 056F: MOVF 20,W |
| 0570: BSF 03.5 |
| 0571: MOVWF 07 |
| 0572: NOP |
| 0573: BCF 03.5 |
| 0574: BCF 07.4 |
| 0575: BCF 20.4 |
| 0576: MOVF 20,W |
| 0577: BSF 03.5 |
| 0578: MOVWF 07 |
| 0579: NOP |
| 057A: BCF 03.5 |
| 057B: BCF 07.3 |
| 057C: BCF 20.3 |
| 057D: MOVF 20,W |
| 057E: BSF 03.5 |
| 057F: MOVWF 07 |
| 05A1: BSF 20.4 |
| 05A2: MOVF 20,W |
| 05A3: BSF 03.5 |
| 05A4: MOVWF 07 |
| 05A5: NOP |
| 05A6: BCF 03.5 |
| 05A7: BSF 20.3 |
| 05A8: MOVF 20,W |
| 05A9: BSF 03.5 |
| 05AA: MOVWF 07 |
| 05AB: NOP |
| 05AC: BCF 03.5 |
| 05AD: BCF 07.4 |
| 05AE: BCF 20.4 |
| 05AF: MOVF 20,W |
| 05B0: BSF 03.5 |
| 05B1: MOVWF 07 |
| 05B2: NOP |
| 05B3: BCF 03.5 |
| 05B4: BCF 07.3 |
| 05B5: BCF 20.3 |
| 05B6: MOVF 20,W |
| 05B7: BSF 03.5 |
| 05B8: MOVWF 07 |
| .................... I2C_Write(SHT25_ADDR+1); |
| 0580: MOVLW 81 |
| 0581: BCF 03.5 |
| 0582: MOVWF 34 |
| 0583: CALL 202 |
| 05B9: MOVLW 81 |
| 05BA: BCF 03.5 |
| 05BB: MOVWF 3B |
| 05BC: CALL 078 |
| .................... MSB=i2c_read(1); |
| 0584: MOVLW 01 |
| 0585: MOVWF 77 |
| 0586: CALL 24C |
| 0587: MOVF 78,W |
| 0588: MOVWF 2F |
| 05BD: MOVLW 01 |
| 05BE: MOVWF 77 |
| 05BF: CALL 285 |
| 05C0: MOVF 78,W |
| 05C1: MOVWF 35 |
| .................... LSB=i2c_read(1); |
| 0589: MOVLW 01 |
| 058A: MOVWF 77 |
| 058B: CALL 24C |
| 058C: MOVF 78,W |
| 058D: MOVWF 30 |
| 05C2: MOVLW 01 |
| 05C3: MOVWF 77 |
| 05C4: CALL 285 |
| 05C5: MOVF 78,W |
| 05C6: MOVWF 36 |
| .................... Check=i2c_read(0); |
| 058E: CLRF 77 |
| 058F: CALL 24C |
| 0590: MOVF 78,W |
| 0591: MOVWF 31 |
| 05C7: CLRF 77 |
| 05C8: CALL 285 |
| 05C9: MOVF 78,W |
| 05CA: MOVWF 37 |
| .................... i2c_stop(); |
| 0592: BCF 20.4 |
| 0593: MOVF 20,W |
| 0594: BSF 03.5 |
| 0595: MOVWF 07 |
| 0596: NOP |
| 0597: BCF 03.5 |
| 0598: BSF 20.3 |
| 0599: MOVF 20,W |
| 059A: BSF 03.5 |
| 059B: MOVWF 07 |
| 059C: BCF 03.5 |
| 059D: BTFSS 07.3 |
| 059E: GOTO 59D |
| 059F: NOP |
| 05A0: GOTO 5A1 |
| 05A1: NOP |
| 05A2: BSF 20.4 |
| 05A3: MOVF 20,W |
| 05A4: BSF 03.5 |
| 05A5: MOVWF 07 |
| 05A6: NOP |
| 05CB: BCF 20.4 |
| 05CC: MOVF 20,W |
| 05CD: BSF 03.5 |
| 05CE: MOVWF 07 |
| 05CF: NOP |
| 05D0: BCF 03.5 |
| 05D1: BSF 20.3 |
| 05D2: MOVF 20,W |
| 05D3: BSF 03.5 |
| 05D4: MOVWF 07 |
| 05D5: BCF 03.5 |
| 05D6: BTFSS 07.3 |
| 05D7: GOTO 5D6 |
| 05D8: NOP |
| 05D9: GOTO 5DA |
| 05DA: NOP |
| 05DB: BSF 20.4 |
| 05DC: MOVF 20,W |
| 05DD: BSF 03.5 |
| 05DE: MOVWF 07 |
| 05DF: NOP |
| .................... |
| .................... LSB = LSB >> 2; // trow out status bits |
| 05A7: BCF 03.5 |
| 05A8: RRF 30,F |
| 05A9: RRF 30,F |
| 05AA: MOVLW 3F |
| 05AB: ANDWF 30,F |
| 05E0: BCF 03.5 |
| 05E1: RRF 36,F |
| 05E2: RRF 36,F |
| 05E3: MOVLW 3F |
| 05E4: ANDWF 36,F |
| .................... |
| .................... data = (((unsigned int16) MSB << 8) + (LSB << 4)); |
| 05AC: CLRF 35 |
| 05AD: MOVF 2F,W |
| 05AE: MOVWF 34 |
| 05AF: MOVWF 35 |
| 05B0: CLRF 34 |
| 05B1: SWAPF 30,W |
| 05B2: MOVWF 77 |
| 05B3: MOVLW F0 |
| 05B4: ANDWF 77,F |
| 05B5: MOVF 77,W |
| 05B6: ADDWF 34,W |
| 05B7: MOVWF 32 |
| 05B8: MOVF 35,W |
| 05B9: MOVWF 33 |
| 05BA: BTFSC 03.0 |
| 05BB: INCF 33,F |
| 05E5: CLRF 3B |
| 05E6: MOVF 35,W |
| 05E7: MOVWF 3A |
| 05E8: MOVWF 3B |
| 05E9: CLRF 3A |
| 05EA: SWAPF 36,W |
| 05EB: MOVWF 77 |
| 05EC: MOVLW F0 |
| 05ED: ANDWF 77,F |
| 05EE: MOVF 77,W |
| 05EF: ADDWF 3A,W |
| 05F0: MOVWF 38 |
| 05F1: MOVF 3B,W |
| 05F2: MOVWF 39 |
| 05F3: BTFSC 03.0 |
| 05F4: INCF 39,F |
| .................... return(-46.85 + 175.72*((float)data/0xFFFF)); |
| 05BC: MOVF 33,W |
| 05BD: MOVWF 35 |
| 05BE: MOVF 32,W |
| 05BF: MOVWF 34 |
| 05C0: CALL 291 |
| 05C1: MOVF 77,W |
| 05C2: MOVWF 34 |
| 05C3: MOVF 78,W |
| 05C4: MOVWF 35 |
| 05C5: MOVF 79,W |
| 05C6: MOVWF 36 |
| 05C7: MOVF 7A,W |
| 05C8: MOVWF 37 |
| 05C9: MOVWF 3B |
| 05CA: MOVF 79,W |
| 05CB: MOVWF 3A |
| 05CC: MOVF 78,W |
| 05CD: MOVWF 39 |
| 05CE: MOVF 77,W |
| 05CF: MOVWF 38 |
| 05D0: CLRF 3F |
| 05D1: MOVLW FF |
| 05D2: MOVWF 3E |
| 05D3: MOVLW 7F |
| 05D4: MOVWF 3D |
| 05D5: MOVLW 8E |
| 05D6: MOVWF 3C |
| 05D7: CALL 2AE |
| 05D8: MOVLW 52 |
| 05D9: MOVWF 3F |
| 05DA: MOVLW B8 |
| 05DB: MOVWF 3E |
| 05DC: MOVLW 2F |
| 05DD: MOVWF 3D |
| 05DE: MOVLW 86 |
| 05DF: MOVWF 3C |
| 05E0: MOVF 7A,W |
| 05E1: MOVWF 43 |
| 05E2: MOVF 79,W |
| 05E3: MOVWF 42 |
| 05E4: MOVF 78,W |
| 05E5: MOVWF 41 |
| 05E6: MOVF 77,W |
| 05E7: MOVWF 40 |
| 05E8: CALL 378 |
| 05E9: BCF 03.1 |
| 05EA: MOVLW 66 |
| 05EB: MOVWF 37 |
| 05EC: MOVWF 36 |
| 05ED: MOVLW BB |
| 05EE: MOVWF 35 |
| 05EF: MOVLW 84 |
| 05F0: MOVWF 34 |
| 05F1: MOVF 7A,W |
| 05F2: MOVWF 3B |
| 05F3: MOVF 79,W |
| 05F4: MOVWF 3A |
| 05F5: MOVF 78,W |
| 05F6: MOVWF 39 |
| 05F7: MOVF 77,W |
| 05F8: MOVWF 38 |
| 05F9: CALL 3ED |
| 05F5: MOVF 39,W |
| 05F6: MOVWF 3B |
| 05F7: MOVF 38,W |
| 05F8: MOVWF 3A |
| 05F9: CALL 2CA |
| 05FA: MOVF 77,W |
| 05FB: MOVWF 3A |
| 05FC: MOVF 78,W |
| 05FD: MOVWF 3B |
| 05FE: MOVF 79,W |
| 05FF: MOVWF 3C |
| 0600: MOVF 7A,W |
| 0601: MOVWF 3D |
| 0602: MOVWF 41 |
| 0603: MOVF 79,W |
| 0604: MOVWF 40 |
| 0605: MOVF 78,W |
| 0606: MOVWF 3F |
| 0607: MOVF 77,W |
| 0608: MOVWF 3E |
| 0609: CLRF 45 |
| 060A: MOVLW FF |
| 060B: MOVWF 44 |
| 060C: MOVLW 7F |
| 060D: MOVWF 43 |
| 060E: MOVLW 8E |
| 060F: MOVWF 42 |
| 0610: CALL 2E7 |
| 0611: MOVLW 52 |
| 0612: MOVWF 45 |
| 0613: MOVLW B8 |
| 0614: MOVWF 44 |
| 0615: MOVLW 2F |
| 0616: MOVWF 43 |
| 0617: MOVLW 86 |
| 0618: MOVWF 42 |
| 0619: MOVF 7A,W |
| 061A: MOVWF 49 |
| 061B: MOVF 79,W |
| 061C: MOVWF 48 |
| 061D: MOVF 78,W |
| 061E: MOVWF 47 |
| 061F: MOVF 77,W |
| 0620: MOVWF 46 |
| 0621: CALL 3B1 |
| 0622: BCF 03.1 |
| 0623: MOVLW 66 |
| 0624: MOVWF 3D |
| 0625: MOVWF 3C |
| 0626: MOVLW BB |
| 0627: MOVWF 3B |
| 0628: MOVLW 84 |
| 0629: MOVWF 3A |
| 062A: MOVF 7A,W |
| 062B: MOVWF 41 |
| 062C: MOVF 79,W |
| 062D: MOVWF 40 |
| 062E: MOVF 78,W |
| 062F: MOVWF 3F |
| 0630: MOVF 77,W |
| 0631: MOVWF 3E |
| 0632: CALL 426 |
| .................... } |
| 05FA: BSF 0A.3 |
| 05FB: BCF 0A.4 |
| 05FC: GOTO 2E4 (RETURN) |
| 0633: BSF 0A.3 |
| 0634: BCF 0A.4 |
| 0635: GOTO 38B (RETURN) |
| .................... |
| .................... float SHT25_get_hum() |
| .................... { |
| 1226,205 → 1227,205 |
|---|
| .................... unsigned int16 data; |
| .................... |
| .................... i2c_start(); //RH |
| 05FD: BSF 20.4 |
| 05FE: MOVF 20,W |
| 05FF: BSF 03.5 |
| 0600: MOVWF 07 |
| 0601: NOP |
| 0602: BCF 03.5 |
| 0603: BSF 20.3 |
| 0604: MOVF 20,W |
| 0605: BSF 03.5 |
| 0606: MOVWF 07 |
| 0607: NOP |
| 0608: BCF 03.5 |
| 0609: BCF 07.4 |
| 060A: BCF 20.4 |
| 060B: MOVF 20,W |
| 060C: BSF 03.5 |
| 060D: MOVWF 07 |
| 060E: NOP |
| 060F: BCF 03.5 |
| 0610: BCF 07.3 |
| 0611: BCF 20.3 |
| 0612: MOVF 20,W |
| 0613: BSF 03.5 |
| 0614: MOVWF 07 |
| 0636: BSF 20.4 |
| 0637: MOVF 20,W |
| 0638: BSF 03.5 |
| 0639: MOVWF 07 |
| 063A: NOP |
| 063B: BCF 03.5 |
| 063C: BSF 20.3 |
| 063D: MOVF 20,W |
| 063E: BSF 03.5 |
| 063F: MOVWF 07 |
| 0640: NOP |
| 0641: BCF 03.5 |
| 0642: BCF 07.4 |
| 0643: BCF 20.4 |
| 0644: MOVF 20,W |
| 0645: BSF 03.5 |
| 0646: MOVWF 07 |
| 0647: NOP |
| 0648: BCF 03.5 |
| 0649: BCF 07.3 |
| 064A: BCF 20.3 |
| 064B: MOVF 20,W |
| 064C: BSF 03.5 |
| 064D: MOVWF 07 |
| .................... I2C_Write(SHT25_ADDR); |
| 0615: MOVLW 80 |
| 0616: BCF 03.5 |
| 0617: MOVWF 34 |
| 0618: CALL 202 |
| 064E: MOVLW 80 |
| 064F: BCF 03.5 |
| 0650: MOVWF 3B |
| 0651: CALL 078 |
| .................... I2C_write(0xE5); |
| 0619: MOVLW E5 |
| 061A: MOVWF 34 |
| 061B: CALL 202 |
| 0652: MOVLW E5 |
| 0653: MOVWF 3B |
| 0654: CALL 078 |
| .................... |
| .................... delay_ms(100); |
| 061C: MOVLW 64 |
| 061D: MOVWF 3D |
| 061E: CALL 078 |
| 0655: MOVLW 64 |
| 0656: MOVWF 43 |
| 0657: CALL 0FB |
| .................... |
| .................... i2c_start(); |
| 061F: BSF 20.4 |
| 0620: MOVF 20,W |
| 0621: BSF 03.5 |
| 0622: MOVWF 07 |
| 0623: NOP |
| 0624: BCF 03.5 |
| 0625: BSF 20.3 |
| 0626: MOVF 20,W |
| 0627: BSF 03.5 |
| 0628: MOVWF 07 |
| 0629: NOP |
| 062A: BCF 03.5 |
| 062B: BTFSS 07.3 |
| 062C: GOTO 62B |
| 062D: BCF 07.4 |
| 062E: BCF 20.4 |
| 062F: MOVF 20,W |
| 0630: BSF 03.5 |
| 0631: MOVWF 07 |
| 0632: NOP |
| 0633: BCF 03.5 |
| 0634: BCF 07.3 |
| 0635: BCF 20.3 |
| 0636: MOVF 20,W |
| 0637: BSF 03.5 |
| 0638: MOVWF 07 |
| 0658: BSF 20.4 |
| 0659: MOVF 20,W |
| 065A: BSF 03.5 |
| 065B: MOVWF 07 |
| 065C: NOP |
| 065D: BCF 03.5 |
| 065E: BSF 20.3 |
| 065F: MOVF 20,W |
| 0660: BSF 03.5 |
| 0661: MOVWF 07 |
| 0662: NOP |
| 0663: BCF 03.5 |
| 0664: BTFSS 07.3 |
| 0665: GOTO 664 |
| 0666: BCF 07.4 |
| 0667: BCF 20.4 |
| 0668: MOVF 20,W |
| 0669: BSF 03.5 |
| 066A: MOVWF 07 |
| 066B: NOP |
| 066C: BCF 03.5 |
| 066D: BCF 07.3 |
| 066E: BCF 20.3 |
| 066F: MOVF 20,W |
| 0670: BSF 03.5 |
| 0671: MOVWF 07 |
| .................... I2C_Write(SHT25_ADDR+1); |
| 0639: MOVLW 81 |
| 063A: BCF 03.5 |
| 063B: MOVWF 34 |
| 063C: CALL 202 |
| 0672: MOVLW 81 |
| 0673: BCF 03.5 |
| 0674: MOVWF 3B |
| 0675: CALL 078 |
| .................... MSB=i2c_read(1); |
| 063D: MOVLW 01 |
| 063E: MOVWF 77 |
| 063F: CALL 24C |
| 0640: MOVF 78,W |
| 0641: MOVWF 2F |
| 0676: MOVLW 01 |
| 0677: MOVWF 77 |
| 0678: CALL 285 |
| 0679: MOVF 78,W |
| 067A: MOVWF 35 |
| .................... LSB=i2c_read(1); |
| 0642: MOVLW 01 |
| 0643: MOVWF 77 |
| 0644: CALL 24C |
| 0645: MOVF 78,W |
| 0646: MOVWF 30 |
| 067B: MOVLW 01 |
| 067C: MOVWF 77 |
| 067D: CALL 285 |
| 067E: MOVF 78,W |
| 067F: MOVWF 36 |
| .................... Check=i2c_read(0); |
| 0647: CLRF 77 |
| 0648: CALL 24C |
| 0649: MOVF 78,W |
| 064A: MOVWF 31 |
| 0680: CLRF 77 |
| 0681: CALL 285 |
| 0682: MOVF 78,W |
| 0683: MOVWF 37 |
| .................... i2c_stop(); |
| 064B: BCF 20.4 |
| 064C: MOVF 20,W |
| 064D: BSF 03.5 |
| 064E: MOVWF 07 |
| 064F: NOP |
| 0650: BCF 03.5 |
| 0651: BSF 20.3 |
| 0652: MOVF 20,W |
| 0653: BSF 03.5 |
| 0654: MOVWF 07 |
| 0655: BCF 03.5 |
| 0656: BTFSS 07.3 |
| 0657: GOTO 656 |
| 0658: NOP |
| 0659: GOTO 65A |
| 065A: NOP |
| 065B: BSF 20.4 |
| 065C: MOVF 20,W |
| 065D: BSF 03.5 |
| 065E: MOVWF 07 |
| 065F: NOP |
| 0684: BCF 20.4 |
| 0685: MOVF 20,W |
| 0686: BSF 03.5 |
| 0687: MOVWF 07 |
| 0688: NOP |
| 0689: BCF 03.5 |
| 068A: BSF 20.3 |
| 068B: MOVF 20,W |
| 068C: BSF 03.5 |
| 068D: MOVWF 07 |
| 068E: BCF 03.5 |
| 068F: BTFSS 07.3 |
| 0690: GOTO 68F |
| 0691: NOP |
| 0692: GOTO 693 |
| 0693: NOP |
| 0694: BSF 20.4 |
| 0695: MOVF 20,W |
| 0696: BSF 03.5 |
| 0697: MOVWF 07 |
| 0698: NOP |
| .................... |
| .................... LSB = LSB >> 2; // trow out status bits |
| 0660: BCF 03.5 |
| 0661: RRF 30,F |
| 0662: RRF 30,F |
| 0663: MOVLW 3F |
| 0664: ANDWF 30,F |
| 0699: BCF 03.5 |
| 069A: RRF 36,F |
| 069B: RRF 36,F |
| 069C: MOVLW 3F |
| 069D: ANDWF 36,F |
| .................... |
| .................... data = (((unsigned int16) MSB << 8) + (LSB << 4) ); |
| 0665: CLRF 35 |
| 0666: MOVF 2F,W |
| 0667: MOVWF 34 |
| 0668: MOVWF 35 |
| 0669: CLRF 34 |
| 066A: SWAPF 30,W |
| 066B: MOVWF 77 |
| 066C: MOVLW F0 |
| 066D: ANDWF 77,F |
| 066E: MOVF 77,W |
| 066F: ADDWF 34,W |
| 0670: MOVWF 32 |
| 0671: MOVF 35,W |
| 0672: MOVWF 33 |
| 0673: BTFSC 03.0 |
| 0674: INCF 33,F |
| 069E: CLRF 3B |
| 069F: MOVF 35,W |
| 06A0: MOVWF 3A |
| 06A1: MOVWF 3B |
| 06A2: CLRF 3A |
| 06A3: SWAPF 36,W |
| 06A4: MOVWF 77 |
| 06A5: MOVLW F0 |
| 06A6: ANDWF 77,F |
| 06A7: MOVF 77,W |
| 06A8: ADDWF 3A,W |
| 06A9: MOVWF 38 |
| 06AA: MOVF 3B,W |
| 06AB: MOVWF 39 |
| 06AC: BTFSC 03.0 |
| 06AD: INCF 39,F |
| .................... return( -6.0 + 125.0*((float)data/0xFFFF)); |
| 0675: MOVF 33,W |
| 0676: MOVWF 35 |
| 0677: MOVF 32,W |
| 0678: MOVWF 34 |
| 0679: CALL 291 |
| 067A: MOVF 77,W |
| 067B: MOVWF 34 |
| 067C: MOVF 78,W |
| 067D: MOVWF 35 |
| 067E: MOVF 79,W |
| 067F: MOVWF 36 |
| 0680: MOVF 7A,W |
| 0681: MOVWF 37 |
| 0682: MOVWF 3B |
| 0683: MOVF 79,W |
| 0684: MOVWF 3A |
| 0685: MOVF 78,W |
| 0686: MOVWF 39 |
| 0687: MOVF 77,W |
| 0688: MOVWF 38 |
| 0689: CLRF 3F |
| 068A: MOVLW FF |
| 068B: MOVWF 3E |
| 068C: MOVLW 7F |
| 068D: MOVWF 3D |
| 068E: MOVLW 8E |
| 068F: MOVWF 3C |
| 0690: CALL 2AE |
| 0691: CLRF 3F |
| 0692: CLRF 3E |
| 0693: MOVLW 7A |
| 0694: MOVWF 3D |
| 0695: MOVLW 85 |
| 0696: MOVWF 3C |
| 0697: MOVF 7A,W |
| 0698: MOVWF 43 |
| 0699: MOVF 79,W |
| 069A: MOVWF 42 |
| 069B: MOVF 78,W |
| 069C: MOVWF 41 |
| 069D: MOVF 77,W |
| 069E: MOVWF 40 |
| 069F: CALL 378 |
| 06A0: BCF 03.1 |
| 06A1: CLRF 37 |
| 06A2: CLRF 36 |
| 06A3: MOVLW C0 |
| 06A4: MOVWF 35 |
| 06A5: MOVLW 81 |
| 06A6: MOVWF 34 |
| 06A7: MOVF 7A,W |
| 06A8: MOVWF 3B |
| 06A9: MOVF 79,W |
| 06AA: MOVWF 3A |
| 06AB: MOVF 78,W |
| 06AC: MOVWF 39 |
| 06AD: MOVF 77,W |
| 06AE: MOVWF 38 |
| 06AF: CALL 3ED |
| 06AE: MOVF 39,W |
| 06AF: MOVWF 3B |
| 06B0: MOVF 38,W |
| 06B1: MOVWF 3A |
| 06B2: CALL 2CA |
| 06B3: MOVF 77,W |
| 06B4: MOVWF 3A |
| 06B5: MOVF 78,W |
| 06B6: MOVWF 3B |
| 06B7: MOVF 79,W |
| 06B8: MOVWF 3C |
| 06B9: MOVF 7A,W |
| 06BA: MOVWF 3D |
| 06BB: MOVWF 41 |
| 06BC: MOVF 79,W |
| 06BD: MOVWF 40 |
| 06BE: MOVF 78,W |
| 06BF: MOVWF 3F |
| 06C0: MOVF 77,W |
| 06C1: MOVWF 3E |
| 06C2: CLRF 45 |
| 06C3: MOVLW FF |
| 06C4: MOVWF 44 |
| 06C5: MOVLW 7F |
| 06C6: MOVWF 43 |
| 06C7: MOVLW 8E |
| 06C8: MOVWF 42 |
| 06C9: CALL 2E7 |
| 06CA: CLRF 45 |
| 06CB: CLRF 44 |
| 06CC: MOVLW 7A |
| 06CD: MOVWF 43 |
| 06CE: MOVLW 85 |
| 06CF: MOVWF 42 |
| 06D0: MOVF 7A,W |
| 06D1: MOVWF 49 |
| 06D2: MOVF 79,W |
| 06D3: MOVWF 48 |
| 06D4: MOVF 78,W |
| 06D5: MOVWF 47 |
| 06D6: MOVF 77,W |
| 06D7: MOVWF 46 |
| 06D8: CALL 3B1 |
| 06D9: BCF 03.1 |
| 06DA: CLRF 3D |
| 06DB: CLRF 3C |
| 06DC: MOVLW C0 |
| 06DD: MOVWF 3B |
| 06DE: MOVLW 81 |
| 06DF: MOVWF 3A |
| 06E0: MOVF 7A,W |
| 06E1: MOVWF 41 |
| 06E2: MOVF 79,W |
| 06E3: MOVWF 40 |
| 06E4: MOVF 78,W |
| 06E5: MOVWF 3F |
| 06E6: MOVF 77,W |
| 06E7: MOVWF 3E |
| 06E8: CALL 426 |
| .................... } |
| 06B0: BSF 0A.3 |
| 06B1: BCF 0A.4 |
| 06B2: GOTO 2EF (RETURN) |
| 06E9: BSF 0A.3 |
| 06EA: BCF 0A.4 |
| 06EB: GOTO 396 (RETURN) |
| .................... |
| .................... |
| .................... |
| 1443,607 → 1444,3139 |
|---|
| .................... signed int16 data; |
| .................... |
| .................... i2c_start(); |
| 06B3: BSF 20.4 |
| 06B4: MOVF 20,W |
| 06B5: BSF 03.5 |
| 06B6: MOVWF 07 |
| 06B7: NOP |
| 06B8: BCF 03.5 |
| 06B9: BSF 20.3 |
| 06BA: MOVF 20,W |
| 06BB: BSF 03.5 |
| 06BC: MOVWF 07 |
| 06BD: NOP |
| 06BE: BCF 03.5 |
| 06BF: BCF 07.4 |
| 06C0: BCF 20.4 |
| 06C1: MOVF 20,W |
| 06C2: BSF 03.5 |
| 06C3: MOVWF 07 |
| 06C4: NOP |
| 06C5: BCF 03.5 |
| 06C6: BCF 07.3 |
| 06C7: BCF 20.3 |
| 06C8: MOVF 20,W |
| 06C9: BSF 03.5 |
| 06CA: MOVWF 07 |
| 06EC: BSF 20.4 |
| 06ED: MOVF 20,W |
| 06EE: BSF 03.5 |
| 06EF: MOVWF 07 |
| 06F0: NOP |
| 06F1: BCF 03.5 |
| 06F2: BSF 20.3 |
| 06F3: MOVF 20,W |
| 06F4: BSF 03.5 |
| 06F5: MOVWF 07 |
| 06F6: NOP |
| 06F7: BCF 03.5 |
| 06F8: BCF 07.4 |
| 06F9: BCF 20.4 |
| 06FA: MOVF 20,W |
| 06FB: BSF 03.5 |
| 06FC: MOVWF 07 |
| 06FD: NOP |
| 06FE: BCF 03.5 |
| 06FF: BCF 07.3 |
| 0700: BCF 20.3 |
| 0701: MOVF 20,W |
| 0702: BSF 03.5 |
| 0703: MOVWF 07 |
| .................... I2C_Write(LTS01A_address); |
| 06CB: MOVLW 90 |
| 06CC: BCF 03.5 |
| 06CD: MOVWF 34 |
| 06CE: CALL 202 |
| 0704: MOVLW 90 |
| 0705: BCF 03.5 |
| 0706: MOVWF 3B |
| 0707: CALL 078 |
| .................... I2C_write(0x00); |
| 06CF: CLRF 34 |
| 06D0: CALL 202 |
| 0708: CLRF 3B |
| 0709: CALL 078 |
| .................... i2c_stop(); |
| 06D1: BCF 20.4 |
| 06D2: MOVF 20,W |
| 06D3: BSF 03.5 |
| 06D4: MOVWF 07 |
| 06D5: NOP |
| 06D6: BCF 03.5 |
| 06D7: BSF 20.3 |
| 06D8: MOVF 20,W |
| 06D9: BSF 03.5 |
| 06DA: MOVWF 07 |
| 06DB: BCF 03.5 |
| 06DC: BTFSS 07.3 |
| 06DD: GOTO 6DC |
| 06DE: NOP |
| 06DF: GOTO 6E0 |
| 06E0: NOP |
| 06E1: BSF 20.4 |
| 06E2: MOVF 20,W |
| 06E3: BSF 03.5 |
| 06E4: MOVWF 07 |
| 06E5: NOP |
| 070A: BCF 20.4 |
| 070B: MOVF 20,W |
| 070C: BSF 03.5 |
| 070D: MOVWF 07 |
| 070E: NOP |
| 070F: BCF 03.5 |
| 0710: BSF 20.3 |
| 0711: MOVF 20,W |
| 0712: BSF 03.5 |
| 0713: MOVWF 07 |
| 0714: BCF 03.5 |
| 0715: BTFSS 07.3 |
| 0716: GOTO 715 |
| 0717: NOP |
| 0718: GOTO 719 |
| 0719: NOP |
| 071A: BSF 20.4 |
| 071B: MOVF 20,W |
| 071C: BSF 03.5 |
| 071D: MOVWF 07 |
| 071E: NOP |
| .................... i2c_start(); |
| 06E6: BCF 03.5 |
| 06E7: BSF 20.4 |
| 06E8: MOVF 20,W |
| 06E9: BSF 03.5 |
| 06EA: MOVWF 07 |
| 06EB: NOP |
| 06EC: BCF 03.5 |
| 06ED: BSF 20.3 |
| 06EE: MOVF 20,W |
| 06EF: BSF 03.5 |
| 06F0: MOVWF 07 |
| 06F1: NOP |
| 06F2: BCF 03.5 |
| 06F3: BCF 07.4 |
| 06F4: BCF 20.4 |
| 06F5: MOVF 20,W |
| 06F6: BSF 03.5 |
| 06F7: MOVWF 07 |
| 06F8: NOP |
| 06F9: BCF 03.5 |
| 06FA: BCF 07.3 |
| 06FB: BCF 20.3 |
| 06FC: MOVF 20,W |
| 06FD: BSF 03.5 |
| 06FE: MOVWF 07 |
| 071F: BCF 03.5 |
| 0720: BSF 20.4 |
| 0721: MOVF 20,W |
| 0722: BSF 03.5 |
| 0723: MOVWF 07 |
| 0724: NOP |
| 0725: BCF 03.5 |
| 0726: BSF 20.3 |
| 0727: MOVF 20,W |
| 0728: BSF 03.5 |
| 0729: MOVWF 07 |
| 072A: NOP |
| 072B: BCF 03.5 |
| 072C: BCF 07.4 |
| 072D: BCF 20.4 |
| 072E: MOVF 20,W |
| 072F: BSF 03.5 |
| 0730: MOVWF 07 |
| 0731: NOP |
| 0732: BCF 03.5 |
| 0733: BCF 07.3 |
| 0734: BCF 20.3 |
| 0735: MOVF 20,W |
| 0736: BSF 03.5 |
| 0737: MOVWF 07 |
| .................... I2C_Write(LTS01A_address+1); |
| 06FF: MOVLW 91 |
| 0700: BCF 03.5 |
| 0701: MOVWF 34 |
| 0702: CALL 202 |
| 0738: MOVLW 91 |
| 0739: BCF 03.5 |
| 073A: MOVWF 3B |
| 073B: CALL 078 |
| .................... MSB=i2c_read(1); |
| 0703: MOVLW 01 |
| 0704: MOVWF 77 |
| 0705: CALL 24C |
| 0706: MOVF 78,W |
| 0707: MOVWF 2F |
| 073C: MOVLW 01 |
| 073D: MOVWF 77 |
| 073E: CALL 285 |
| 073F: MOVF 78,W |
| 0740: MOVWF 35 |
| .................... LSB=i2c_read(0); |
| 0708: CLRF 77 |
| 0709: CALL 24C |
| 070A: MOVF 78,W |
| 070B: MOVWF 30 |
| 0741: CLRF 77 |
| 0742: CALL 285 |
| 0743: MOVF 78,W |
| 0744: MOVWF 36 |
| .................... i2c_stop(); |
| 070C: BCF 20.4 |
| 070D: MOVF 20,W |
| 070E: BSF 03.5 |
| 070F: MOVWF 07 |
| 0710: NOP |
| 0711: BCF 03.5 |
| 0712: BSF 20.3 |
| 0713: MOVF 20,W |
| 0714: BSF 03.5 |
| 0715: MOVWF 07 |
| 0716: BCF 03.5 |
| 0717: BTFSS 07.3 |
| 0718: GOTO 717 |
| 0719: NOP |
| 071A: GOTO 71B |
| 071B: NOP |
| 071C: BSF 20.4 |
| 071D: MOVF 20,W |
| 071E: BSF 03.5 |
| 071F: MOVWF 07 |
| 0720: NOP |
| 0745: BCF 20.4 |
| 0746: MOVF 20,W |
| 0747: BSF 03.5 |
| 0748: MOVWF 07 |
| 0749: NOP |
| 074A: BCF 03.5 |
| 074B: BSF 20.3 |
| 074C: MOVF 20,W |
| 074D: BSF 03.5 |
| 074E: MOVWF 07 |
| 074F: BCF 03.5 |
| 0750: BTFSS 07.3 |
| 0751: GOTO 750 |
| 0752: NOP |
| 0753: GOTO 754 |
| 0754: NOP |
| 0755: BSF 20.4 |
| 0756: MOVF 20,W |
| 0757: BSF 03.5 |
| 0758: MOVWF 07 |
| 0759: NOP |
| .................... |
| .................... data = MAKE16(MSB,LSB); |
| 0721: BCF 03.5 |
| 0722: MOVF 2F,W |
| 0723: MOVWF 32 |
| 0724: MOVF 30,W |
| 0725: MOVWF 31 |
| 075A: BCF 03.5 |
| 075B: MOVF 35,W |
| 075C: MOVWF 38 |
| 075D: MOVF 36,W |
| 075E: MOVWF 37 |
| .................... |
| .................... return (data * 0.00390625 ); |
| 0726: MOVF 32,W |
| 0727: MOVWF 34 |
| 0728: MOVF 31,W |
| 0729: MOVWF 33 |
| 072A: MOVF 34,W |
| 072B: MOVWF 36 |
| 072C: MOVF 33,W |
| 072D: MOVWF 35 |
| 075F: MOVF 38,W |
| 0760: MOVWF 3A |
| 0761: MOVF 37,W |
| 0762: MOVWF 39 |
| 0763: MOVF 3A,W |
| 0764: MOVWF 3C |
| 0765: MOVF 39,W |
| 0766: MOVWF 3B |
| * |
| 0752: MOVF 7A,W |
| 0753: MOVWF 3F |
| 0754: MOVF 79,W |
| 0755: MOVWF 3E |
| 0756: MOVF 78,W |
| 0757: MOVWF 3D |
| 0758: MOVF 77,W |
| 0759: MOVWF 3C |
| 075A: CLRF 43 |
| 075B: CLRF 42 |
| 075C: CLRF 41 |
| 075D: MOVLW 77 |
| 075E: MOVWF 40 |
| 075F: CALL 378 |
| 078B: MOVF 7A,W |
| 078C: MOVWF 45 |
| 078D: MOVF 79,W |
| 078E: MOVWF 44 |
| 078F: MOVF 78,W |
| 0790: MOVWF 43 |
| 0791: MOVF 77,W |
| 0792: MOVWF 42 |
| 0793: CLRF 49 |
| 0794: CLRF 48 |
| 0795: CLRF 47 |
| 0796: MOVLW 77 |
| 0797: MOVWF 46 |
| 0798: CALL 3B1 |
| .................... |
| .................... } |
| 0760: BSF 0A.3 |
| 0761: BCF 0A.4 |
| 0762: GOTO 2FA (RETURN) |
| 0799: BSF 0A.3 |
| 079A: BCF 0A.4 |
| 079B: GOTO 3A1 (RETURN) |
| .................... |
| .................... |
| .................... |
| .................... #include "./HMC5883L.h" |
| .................... // i2c slave addresses |
| .................... #define HMC5883L_WRT_ADDR 0x3C |
| .................... #define HMC5883L_READ_ADDR 0x3D |
| .................... |
| .................... // Register addresses |
| .................... #define HMC5883L_CFG_A_REG 0x00 |
| .................... #define HMC5883L_CFG_B_REG 0x01 |
| .................... #define HMC5883L_MODE_REG 0x02 |
| .................... #define HMC5883L_X_MSB_REG 0x03 |
| .................... |
| .................... //Konstanty nastavujici rozsah |
| .................... //pro void set_mag_roz (unsigned int8 h) |
| .................... #define MAG_ROZ088 0x00 |
| .................... #define MAG_ROZ130 0x20 |
| .................... #define MAG_ROZ190 0x40 |
| .................... #define MAG_ROZ250 0x60 |
| .................... #define MAG_ROZ400 0x80 |
| .................... #define MAG_ROZ470 0xA0 |
| .................... #define MAG_ROZ560 0xC0 |
| .................... #define MAG_ROZ810 0xE0 |
| .................... |
| .................... |
| .................... #include "HMC5883L.c" |
| .................... //------------------------------ |
| .................... // Low level routines |
| .................... //------------------------------ |
| .................... void hmc5883l_write_reg(int8 reg, int8 data) |
| .................... { |
| .................... i2c_start(); |
| * |
| 00C2: BSF 20.4 |
| 00C3: MOVF 20,W |
| 00C4: BSF 03.5 |
| 00C5: MOVWF 07 |
| 00C6: NOP |
| 00C7: BCF 03.5 |
| 00C8: BSF 20.3 |
| 00C9: MOVF 20,W |
| 00CA: BSF 03.5 |
| 00CB: MOVWF 07 |
| 00CC: NOP |
| 00CD: BCF 03.5 |
| 00CE: BCF 07.4 |
| 00CF: BCF 20.4 |
| 00D0: MOVF 20,W |
| 00D1: BSF 03.5 |
| 00D2: MOVWF 07 |
| 00D3: NOP |
| 00D4: BCF 03.5 |
| 00D5: BCF 07.3 |
| 00D6: BCF 20.3 |
| 00D7: MOVF 20,W |
| 00D8: BSF 03.5 |
| 00D9: MOVWF 07 |
| .................... i2c_write(HMC5883L_WRT_ADDR); |
| 00DA: MOVLW 3C |
| 00DB: BCF 03.5 |
| 00DC: MOVWF 3B |
| 00DD: CALL 078 |
| .................... i2c_write(reg); |
| 00DE: MOVF 35,W |
| 00DF: MOVWF 3B |
| 00E0: CALL 078 |
| .................... i2c_write(data); |
| 00E1: MOVF 36,W |
| 00E2: MOVWF 3B |
| 00E3: CALL 078 |
| .................... i2c_stop(); |
| 00E4: BCF 20.4 |
| 00E5: MOVF 20,W |
| 00E6: BSF 03.5 |
| 00E7: MOVWF 07 |
| 00E8: NOP |
| 00E9: BCF 03.5 |
| 00EA: BSF 20.3 |
| 00EB: MOVF 20,W |
| 00EC: BSF 03.5 |
| 00ED: MOVWF 07 |
| 00EE: BCF 03.5 |
| 00EF: BTFSS 07.3 |
| 00F0: GOTO 0EF |
| 00F1: NOP |
| 00F2: GOTO 0F3 |
| 00F3: NOP |
| 00F4: BSF 20.4 |
| 00F5: MOVF 20,W |
| 00F6: BSF 03.5 |
| 00F7: MOVWF 07 |
| 00F8: NOP |
| .................... } |
| 00F9: BCF 03.5 |
| 00FA: RETURN |
| .................... |
| .................... //------------------------------ |
| .................... int8 hmc5883l_read_reg(int8 reg) |
| .................... { |
| .................... int8 retval; |
| .................... |
| .................... i2c_start(); |
| .................... i2c_write(HMC5883L_WRT_ADDR); |
| .................... i2c_write(reg); |
| .................... i2c_start(); |
| .................... i2c_write(HMC5883L_READ_ADDR); |
| .................... retval = i2c_read(0); |
| .................... i2c_stop(); |
| .................... |
| .................... return(retval); |
| .................... } |
| .................... |
| .................... //------------------------------ |
| .................... typedef struct |
| .................... { |
| .................... signed int16 x; |
| .................... signed int16 y; |
| .................... signed int16 z; |
| .................... }hmc5883l_result; |
| .................... |
| .................... // This global structure holds the values read |
| .................... // from the HMC5883L x,y,z registers. |
| .................... hmc5883l_result compass = {0,0,0}; |
| * |
| 0ADB: CLRF 21 |
| 0ADC: CLRF 22 |
| 0ADD: CLRF 23 |
| 0ADE: CLRF 24 |
| 0ADF: CLRF 25 |
| 0AE0: CLRF 26 |
| .................... |
| .................... //------------------------------ |
| .................... void hmc5883l_read_data(void) |
| .................... { |
| .................... unsigned int8 x_lsb; |
| .................... unsigned int8 x_msb; |
| .................... |
| .................... unsigned int8 y_lsb; |
| .................... unsigned int8 y_msb; |
| .................... |
| .................... unsigned int8 z_lsb; |
| .................... unsigned int8 z_msb; |
| .................... |
| .................... i2c_start(); |
| * |
| 0800: BSF 20.4 |
| 0801: MOVF 20,W |
| 0802: BSF 03.5 |
| 0803: MOVWF 07 |
| 0804: NOP |
| 0805: BCF 03.5 |
| 0806: BSF 20.3 |
| 0807: MOVF 20,W |
| 0808: BSF 03.5 |
| 0809: MOVWF 07 |
| 080A: NOP |
| 080B: BCF 03.5 |
| 080C: BCF 07.4 |
| 080D: BCF 20.4 |
| 080E: MOVF 20,W |
| 080F: BSF 03.5 |
| 0810: MOVWF 07 |
| 0811: NOP |
| 0812: BCF 03.5 |
| 0813: BCF 07.3 |
| 0814: BCF 20.3 |
| 0815: MOVF 20,W |
| 0816: BSF 03.5 |
| 0817: MOVWF 07 |
| .................... i2c_write(HMC5883L_WRT_ADDR); |
| 0818: MOVLW 3C |
| 0819: BCF 03.5 |
| 081A: MOVWF 3B |
| 081B: BCF 0A.3 |
| 081C: CALL 078 |
| 081D: BSF 0A.3 |
| .................... i2c_write(HMC5883L_X_MSB_REG); // Point to X-msb register |
| 081E: MOVLW 03 |
| 081F: MOVWF 3B |
| 0820: BCF 0A.3 |
| 0821: CALL 078 |
| 0822: BSF 0A.3 |
| .................... i2c_start(); |
| 0823: BSF 20.4 |
| 0824: MOVF 20,W |
| 0825: BSF 03.5 |
| 0826: MOVWF 07 |
| 0827: NOP |
| 0828: BCF 03.5 |
| 0829: BSF 20.3 |
| 082A: MOVF 20,W |
| 082B: BSF 03.5 |
| 082C: MOVWF 07 |
| 082D: NOP |
| 082E: BCF 03.5 |
| 082F: BTFSS 07.3 |
| 0830: GOTO 02F |
| 0831: BCF 07.4 |
| 0832: BCF 20.4 |
| 0833: MOVF 20,W |
| 0834: BSF 03.5 |
| 0835: MOVWF 07 |
| 0836: NOP |
| 0837: BCF 03.5 |
| 0838: BCF 07.3 |
| 0839: BCF 20.3 |
| 083A: MOVF 20,W |
| 083B: BSF 03.5 |
| 083C: MOVWF 07 |
| .................... i2c_write(HMC5883L_READ_ADDR); |
| 083D: MOVLW 3D |
| 083E: BCF 03.5 |
| 083F: MOVWF 3B |
| 0840: BCF 0A.3 |
| 0841: CALL 078 |
| 0842: BSF 0A.3 |
| .................... |
| .................... x_msb = i2c_read(); |
| 0843: MOVLW 01 |
| 0844: MOVWF 77 |
| 0845: BCF 0A.3 |
| 0846: CALL 285 |
| 0847: BSF 0A.3 |
| 0848: MOVF 78,W |
| 0849: MOVWF 36 |
| .................... x_lsb = i2c_read(); |
| 084A: MOVLW 01 |
| 084B: MOVWF 77 |
| 084C: BCF 0A.3 |
| 084D: CALL 285 |
| 084E: BSF 0A.3 |
| 084F: MOVF 78,W |
| 0850: MOVWF 35 |
| .................... |
| .................... z_msb = i2c_read(); |
| 0851: MOVLW 01 |
| 0852: MOVWF 77 |
| 0853: BCF 0A.3 |
| 0854: CALL 285 |
| 0855: BSF 0A.3 |
| 0856: MOVF 78,W |
| 0857: MOVWF 3A |
| .................... z_lsb = i2c_read(); |
| 0858: MOVLW 01 |
| 0859: MOVWF 77 |
| 085A: BCF 0A.3 |
| 085B: CALL 285 |
| 085C: BSF 0A.3 |
| 085D: MOVF 78,W |
| 085E: MOVWF 39 |
| .................... |
| .................... y_msb = i2c_read(); |
| 085F: MOVLW 01 |
| 0860: MOVWF 77 |
| 0861: BCF 0A.3 |
| 0862: CALL 285 |
| 0863: BSF 0A.3 |
| 0864: MOVF 78,W |
| 0865: MOVWF 38 |
| .................... y_lsb = i2c_read(0); // do a NACK on last read |
| 0866: CLRF 77 |
| 0867: BCF 0A.3 |
| 0868: CALL 285 |
| 0869: BSF 0A.3 |
| 086A: MOVF 78,W |
| 086B: MOVWF 37 |
| .................... |
| .................... i2c_stop(); |
| 086C: BCF 20.4 |
| 086D: MOVF 20,W |
| 086E: BSF 03.5 |
| 086F: MOVWF 07 |
| 0870: NOP |
| 0871: BCF 03.5 |
| 0872: BSF 20.3 |
| 0873: MOVF 20,W |
| 0874: BSF 03.5 |
| 0875: MOVWF 07 |
| 0876: BCF 03.5 |
| 0877: BTFSS 07.3 |
| 0878: GOTO 077 |
| 0879: NOP |
| 087A: GOTO 07B |
| 087B: NOP |
| 087C: BSF 20.4 |
| 087D: MOVF 20,W |
| 087E: BSF 03.5 |
| 087F: MOVWF 07 |
| 0880: NOP |
| .................... |
| .................... // Combine high and low bytes into 16-bit values. |
| .................... compass.x = make16(x_msb, x_lsb); |
| 0881: BCF 03.5 |
| 0882: MOVF 36,W |
| 0883: MOVWF 22 |
| 0884: MOVF 35,W |
| 0885: MOVWF 21 |
| .................... compass.y = make16(y_msb, y_lsb); |
| 0886: MOVF 38,W |
| 0887: MOVWF 24 |
| 0888: MOVF 37,W |
| 0889: MOVWF 23 |
| .................... compass.z = make16(z_msb, z_lsb); |
| 088A: MOVF 3A,W |
| 088B: MOVWF 26 |
| 088C: MOVF 39,W |
| 088D: MOVWF 25 |
| .................... } |
| 088E: BSF 0A.3 |
| 088F: BCF 0A.4 |
| 0890: GOTO 3AB (RETURN) |
| .................... |
| .................... |
| .................... |
| .................... |
| .................... #include <math.h> |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... //// (C) Copyright 1996,2008 Custom Computer Services //// |
| .................... //// This source code may only be used by licensed users of the CCS C //// |
| .................... //// compiler. This source code may only be distributed to other //// |
| .................... //// licensed users of the CCS C compiler. No other use, reproduction //// |
| .................... //// or distribution is permitted without written permission. //// |
| .................... //// Derivative programs created using this software in object code //// |
| .................... //// form are not restricted in any way. //// |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... //// //// |
| .................... //// History: //// |
| .................... //// * 9/20/2001 : Improvments are made to sin/cos code. //// |
| .................... //// The code now is small, much faster, //// |
| .................... //// and more accurate. //// |
| .................... //// * 2/21/2007 : Compiler handles & operator differently and does |
| .................... //// not return generic (int8 *) so type cast is done //// |
| .................... //// //// |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... |
| .................... #ifndef MATH_H |
| .................... #define MATH_H |
| .................... |
| .................... #ifdef PI |
| .................... #undef PI |
| .................... #endif |
| .................... #define PI 3.1415926535897932 |
| .................... |
| .................... |
| .................... #define SQRT2 1.4142135623730950 |
| .................... |
| .................... //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279}; |
| .................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718}; |
| .................... |
| .................... ///////////////////////////// Round Functions ////////////////////////////// |
| .................... |
| .................... float32 CEIL_FLOOR(float32 x, unsigned int8 n) |
| .................... { |
| .................... float32 y, res; |
| .................... unsigned int16 l; |
| .................... int1 s; |
| .................... |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y <= 32768.0) |
| .................... res = (float32)(unsigned int16)y; |
| .................... |
| .................... else if (y < 10000000.0) |
| .................... { |
| .................... l = (unsigned int16)(y/32768.0); |
| .................... y = 32768.0*(y/32768.0 - (float32)l); |
| .................... res = 32768.0*(float32)l; |
| .................... res += (float32)(unsigned int16)y; |
| .................... } |
| .................... |
| .................... else |
| .................... res = y; |
| .................... |
| .................... y = y - (float32)(unsigned int16)y; |
| .................... |
| .................... if (s) |
| .................... res = -res; |
| .................... |
| .................... if (y != 0) |
| .................... { |
| .................... if (s == 1 && n == 0) |
| .................... res -= 1.0; |
| .................... |
| .................... if (s == 0 && n == 1) |
| .................... res += 1.0; |
| .................... } |
| .................... if (x == 0) |
| .................... res = 0; |
| .................... |
| .................... return (res); |
| .................... } |
| .................... |
| .................... // Overloaded Functions to take care for new Data types in PCD |
| .................... // Overloaded function CEIL_FLOOR() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 CEIL_FLOOR(float48 x, unsigned int8 n) |
| .................... { |
| .................... float48 y, res; |
| .................... unsigned int16 l; |
| .................... int1 s; |
| .................... |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y <= 32768.0) |
| .................... res = (float48)(unsigned int16)y; |
| .................... |
| .................... else if (y < 10000000.0) |
| .................... { |
| .................... l = (unsigned int16)(y/32768.0); |
| .................... y = 32768.0*(y/32768.0 - (float48)l); |
| .................... res = 32768.0*(float32)l; |
| .................... res += (float48)(unsigned int16)y; |
| .................... } |
| .................... |
| .................... else |
| .................... res = y; |
| .................... |
| .................... y = y - (float48)(unsigned int16)y; |
| .................... |
| .................... if (s) |
| .................... res = -res; |
| .................... |
| .................... if (y != 0) |
| .................... { |
| .................... if (s == 1 && n == 0) |
| .................... res -= 1.0; |
| .................... |
| .................... if (s == 0 && n == 1) |
| .................... res += 1.0; |
| .................... } |
| .................... if (x == 0) |
| .................... res = 0; |
| .................... |
| .................... return (res); |
| .................... } |
| .................... |
| .................... |
| .................... // Overloaded function CEIL_FLOOR() for data type - Float64 |
| .................... float64 CEIL_FLOOR(float64 x, unsigned int8 n) |
| .................... { |
| .................... float64 y, res; |
| .................... unsigned int16 l; |
| .................... int1 s; |
| .................... |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y <= 32768.0) |
| .................... res = (float64)(unsigned int16)y; |
| .................... |
| .................... else if (y < 10000000.0) |
| .................... { |
| .................... l = (unsigned int16)(y/32768.0); |
| .................... y = 32768.0*(y/32768.0 - (float64)l); |
| .................... res = 32768.0*(float64)l; |
| .................... res += (float64)(unsigned int16)y; |
| .................... } |
| .................... |
| .................... else |
| .................... res = y; |
| .................... |
| .................... y = y - (float64)(unsigned int16)y; |
| .................... |
| .................... if (s) |
| .................... res = -res; |
| .................... |
| .................... if (y != 0) |
| .................... { |
| .................... if (s == 1 && n == 0) |
| .................... res -= 1.0; |
| .................... |
| .................... if (s == 0 && n == 1) |
| .................... res += 1.0; |
| .................... } |
| .................... if (x == 0) |
| .................... res = 0; |
| .................... |
| .................... return (res); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float floor(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : rounds down the number x. |
| .................... // Date : N/A |
| .................... // |
| .................... float32 floor(float32 x) |
| .................... { |
| .................... return CEIL_FLOOR(x, 0); |
| .................... } |
| .................... // Following 2 functions are overloaded functions of floor() for PCD |
| .................... // Overloaded function floor() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 floor(float48 x) |
| .................... { |
| .................... return CEIL_FLOOR(x, 0); |
| .................... } |
| .................... |
| .................... // Overloaded function floor() for data type - Float64 |
| .................... float64 floor(float64 x) |
| .................... { |
| .................... return CEIL_FLOOR(x, 0); |
| .................... } |
| .................... #endif |
| .................... |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float ceil(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : rounds up the number x. |
| .................... // Date : N/A |
| .................... // |
| .................... float32 ceil(float32 x) |
| .................... { |
| .................... return CEIL_FLOOR(x, 1); |
| .................... } |
| .................... // Following 2 functions are overloaded functions of ceil() for PCD |
| .................... // Overloaded function ceil() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 ceil(float48 x) |
| .................... { |
| .................... return CEIL_FLOOR(x, 1); |
| .................... } |
| .................... |
| .................... // Overloaded function ceil() for data type - Float64 |
| .................... float64 ceil(float64 x) |
| .................... { |
| .................... return CEIL_FLOOR(x, 1); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float fabs(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : Computes the absolute value of floating point number x |
| .................... // Returns : returns the absolute value of x |
| .................... // Date : N/A |
| .................... // |
| .................... #define fabs abs |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float fmod(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : Computes the floating point remainder of x/y |
| .................... // Returns : returns the value of x= i*y, for some integer i such that, if y |
| .................... // is non zero, the result has the same isgn of x na dmagnitude less than the |
| .................... // magnitude of y. If y is zero then a domain error occurs. |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float fmod(float32 x,float32 y) |
| .................... { |
| .................... float32 i; |
| .................... if (y!=0.0) |
| .................... { |
| .................... i=(x/y < 0.0)? ceil(x/y): floor(x/y); |
| .................... return(x-(i*y)); |
| .................... } |
| .................... else |
| .................... { |
| .................... #ifdef _ERRNO |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... } |
| .................... } |
| .................... //Overloaded function for fmod() for PCD |
| .................... // Overloaded function fmod() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 fmod(float48 x,float48 y) |
| .................... { |
| .................... float48 i; |
| .................... if (y!=0.0) |
| .................... { |
| .................... i=(x/y < 0.0)? ceil(x/y): floor(x/y); |
| .................... return(x-(i*y)); |
| .................... } |
| .................... else |
| .................... { |
| .................... #ifdef _ERRNO |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... } |
| .................... } |
| .................... // Overloaded function fmod() for data type - Float64 |
| .................... float64 fmod(float64 x,float64 y) |
| .................... { |
| .................... float64 i; |
| .................... if (y!=0.0) |
| .................... { |
| .................... i=(x/y < 0.0)? ceil(x/y): floor(x/y); |
| .................... return(x-(i*y)); |
| .................... } |
| .................... else |
| .................... { |
| .................... #ifdef _ERRNO |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... } |
| .................... } |
| .................... #endif |
| .................... //////////////////// Exponential and logarithmic functions //////////////////// |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float exp(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the value (e^x) |
| .................... // Date : N/A |
| .................... // |
| .................... #define LN2 0.6931471805599453 |
| .................... |
| .................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093, |
| .................... 0.0554965651, 0.240227138, 0.693147172}; |
| .................... |
| .................... |
| .................... float32 exp(float32 x) |
| .................... { |
| .................... float32 y, res, r; |
| .................... #if defined(__PCD__) |
| .................... int8 data1; |
| .................... #endif |
| .................... signed int8 n; |
| .................... int1 s; |
| .................... #ifdef _ERRNO |
| .................... if(x > 88.722838) |
| .................... { |
| .................... errno=ERANGE; |
| .................... return(0); |
| .................... } |
| .................... #endif |
| .................... n = (signed int16)(x/LN2); |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... n = -n; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... res = 0.0; |
| .................... #if !defined(__PCD__) |
| .................... *((unsigned int8 *)(&res)) = n + 0x7F; |
| .................... #endif |
| .................... |
| .................... #if defined(__PCD__) // Takes care of IEEE format for PCD |
| .................... data1 = n+0x7F; |
| .................... if(bit_test(data1,0)) |
| .................... bit_set(*(((unsigned int8 *)(&res)+2)),7); |
| .................... rotate_right(&data1,1); |
| .................... bit_clear(data1,7); |
| .................... *(((unsigned int8 *)(&res)+3)) = data1; |
| .................... #endif |
| .................... |
| .................... y = y/LN2 - (float32)n; |
| .................... |
| .................... r = pe[0]*y + pe[1]; |
| .................... r = r*y + pe[2]; |
| .................... r = r*y + pe[3]; |
| .................... r = r*y + pe[4]; |
| .................... r = r*y + pe[5]; |
| .................... |
| .................... res = res*(1.0 + y*r); |
| .................... |
| .................... if (s) |
| .................... res = 1.0/res; |
| .................... return(res); |
| .................... } |
| .................... |
| .................... |
| .................... //Overloaded function for exp() for PCD |
| .................... // Overloaded function exp() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 exp(float48 x) |
| .................... { |
| .................... float48 y, res, r; |
| .................... int8 data1; |
| .................... signed int8 n; |
| .................... int1 s; |
| .................... #ifdef _ERRNO |
| .................... if(x > 88.722838) |
| .................... { |
| .................... errno=ERANGE; |
| .................... return(0); |
| .................... } |
| .................... #endif |
| .................... n = (signed int16)(x/LN2); |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... n = -n; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... res = 0.0; |
| .................... |
| .................... data1 = n+0x7F; |
| .................... if(bit_test(data1,0)) |
| .................... bit_set(*(((unsigned int8 *)(&res)+4)),7); |
| .................... rotate_right(&data1,1); |
| .................... bit_clear(data1,7); |
| .................... *(((unsigned int8 *)(&res)+5)) = data1; |
| .................... |
| .................... y = y/LN2 - (float48)n; |
| .................... |
| .................... r = pe[0]*y + pe[1]; |
| .................... r = r*y + pe[2]; |
| .................... r = r*y + pe[3]; |
| .................... r = r*y + pe[4]; |
| .................... r = r*y + pe[5]; |
| .................... |
| .................... res = res*(1.0 + y*r); |
| .................... |
| .................... if (s) |
| .................... res = 1.0/res; |
| .................... return(res); |
| .................... } |
| .................... |
| .................... // Overloaded function exp() for data type - Float64 |
| .................... float64 exp(float64 x) |
| .................... { |
| .................... float64 y, res, r; |
| .................... unsigned int16 data1, data2; |
| .................... unsigned int16 *p; |
| .................... signed int16 n; |
| .................... int1 s; |
| .................... #ifdef _ERRNO |
| .................... if(x > 709.7827128) |
| .................... { |
| .................... errno=ERANGE; |
| .................... return(0); |
| .................... } |
| .................... #endif |
| .................... n = (signed int16)(x/LN2); |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... n = -n; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... res = 0.0; |
| .................... |
| .................... #if !defined(__PCD__) |
| .................... *((unsigned int16 *)(&res)) = n + 0x7F; |
| .................... #endif |
| .................... p= (((unsigned int16 *)(&res))+3); |
| .................... data1 = *p; |
| .................... data2 = *p; |
| .................... data1 = n + 0x3FF; |
| .................... data1 = data1 <<4; |
| .................... if(bit_test(data2,15)) |
| .................... bit_set(data1,15); |
| .................... data2 = data2 & 0x000F; |
| .................... data1 ^= data2; |
| .................... |
| .................... *(((unsigned int16 *)(&res)+3)) = data1; |
| .................... |
| .................... |
| .................... y = y/LN2 - (float64)n; |
| .................... |
| .................... r = pe[0]*y + pe[1]; |
| .................... r = r*y + pe[2]; |
| .................... r = r*y + pe[3]; |
| .................... r = r*y + pe[4]; |
| .................... r = r*y + pe[5]; |
| .................... |
| .................... res = res*(1.0 + y*r); |
| .................... |
| .................... if (s) |
| .................... res = 1.0/res; |
| .................... return(res); |
| .................... } |
| .................... |
| .................... #ENDIF |
| .................... |
| .................... |
| .................... /************************************************************/ |
| .................... |
| .................... float32 const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189}; |
| .................... float32 const ql[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943}; |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float log(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the the natural log of x |
| .................... // Date : N/A |
| .................... // |
| .................... float32 log(float32 x) |
| .................... { |
| .................... float32 y, res, r, y2; |
| .................... #if defined(__PCD__) |
| .................... unsigned int8 data1,data2; |
| .................... #endif |
| .................... signed int8 n; |
| .................... #ifdef _ERRNO |
| .................... if(x <0) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... if(x ==0) |
| .................... { |
| .................... errno=ERANGE; |
| .................... return(0); |
| .................... } |
| .................... #endif |
| .................... y = x; |
| .................... |
| .................... if (y != 1.0) |
| .................... { |
| .................... #if !defined(__PCD__) |
| .................... *((unsigned int8 *)(&y)) = 0x7E; |
| .................... #endif |
| .................... |
| .................... #if defined(__PCD__) // Takes care of IEEE format |
| .................... data2 = *(((unsigned int8 *)(&y))+3); |
| .................... *(((unsigned int8 *)(&y))+3) = 0x3F; |
| .................... data1 = *(((unsigned int8 *)(&y))+2); |
| .................... bit_clear(data1,7); |
| .................... *(((unsigned int8 *)(&y))+2) = data1; |
| .................... if(bit_test(data2,7)) |
| .................... bit_set(*(((unsigned int8 *)(&y))+3),7); |
| .................... #endif |
| .................... |
| .................... y = (y - 1.0)/(y + 1.0); |
| .................... |
| .................... y2=y*y; |
| .................... |
| .................... res = pl[0]*y2 + pl[1]; |
| .................... res = res*y2 + pl[2]; |
| .................... res = res*y2 + pl[3]; |
| .................... |
| .................... r = ql[0]*y2 + ql[1]; |
| .................... r = r*y2 + ql[2]; |
| .................... r = r*y2 + ql[3]; |
| .................... |
| .................... res = y*res/r; |
| .................... #if !defined(__PCD__) |
| .................... n = *((unsigned int8 *)(&x)) - 0x7E; |
| .................... #endif |
| .................... #if defined(__PCD__) |
| .................... data1 = *(((unsigned int8 *)(&x)+3)); |
| .................... rotate_left(&data1,1); |
| .................... data2 = *(((unsigned int8 *)(&x)+2)); |
| .................... if(bit_test (data2,7)) |
| .................... bit_set(data1,0); |
| .................... n = data1 - 0x7E; |
| .................... #endif |
| .................... |
| .................... if (n<0) |
| .................... r = -(float32)-n; |
| .................... else |
| .................... r = (float32)n; |
| .................... |
| .................... res += r*LN2; |
| .................... } |
| .................... |
| .................... else |
| .................... res = 0.0; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... |
| .................... //Overloaded function for log() for PCD |
| .................... // Overloaded function log() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 log(float48 x) |
| .................... { |
| .................... float48 y, res, r, y2; |
| .................... unsigned int8 data1,data2; |
| .................... signed int8 n; |
| .................... #ifdef _ERRNO |
| .................... if(x <0) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... if(x ==0) |
| .................... { |
| .................... errno=ERANGE; |
| .................... return(0); |
| .................... } |
| .................... #endif |
| .................... y = x; |
| .................... |
| .................... if (y != 1.0) |
| .................... { |
| .................... |
| .................... #if !defined(__PCD__) |
| .................... *((unsigned int8 *)(&y)) = 0x7E; |
| .................... #endif |
| .................... data2 = *(((unsigned int8 *)(&y))+5); |
| .................... *(((unsigned int8 *)(&y))+5) = 0x3F; |
| .................... data1 = *(((unsigned int8 *)(&y))+4); |
| .................... bit_clear(data1,7); |
| .................... *(((unsigned int8 *)(&y))+4) = data1; |
| .................... |
| .................... if(bit_test(data2,7)) |
| .................... bit_set(*(((unsigned int8 *)(&y))+4),7); |
| .................... y = (y - 1.0)/(y + 1.0); |
| .................... |
| .................... y2=y*y; |
| .................... |
| .................... res = pl[0]*y2 + pl[1]; |
| .................... res = res*y2 + pl[2]; |
| .................... res = res*y2 + pl[3]; |
| .................... |
| .................... r = ql[0]*y2 + ql[1]; |
| .................... r = r*y2 + ql[2]; |
| .................... r = r*y2 + ql[3]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... data1 = *(((unsigned int8 *)(&x)+5)); |
| .................... rotate_left(&data1,1); |
| .................... data2 = *(((unsigned int8 *)(&x)+4)); |
| .................... if(bit_test (data2,7)) |
| .................... bit_set(data1,0); |
| .................... |
| .................... n = data1 - 0x7E; |
| .................... |
| .................... if (n<0) |
| .................... r = -(float48)-n; |
| .................... else |
| .................... r = (float48)n; |
| .................... |
| .................... res += r*LN2; |
| .................... } |
| .................... |
| .................... else |
| .................... res = 0.0; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... |
| .................... // Overloaded function log() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float32 const pl_64[4] = {0.45145214, -9.0558803, 26.940971, -19.860189}; |
| .................... float32 const ql_64[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943}; |
| .................... #endif |
| .................... float64 log(float64 x) |
| .................... { |
| .................... float64 y, res, r, y2; |
| .................... unsigned int16 data1,data2; |
| .................... unsigned int16 *p; |
| .................... signed int16 n; |
| .................... #ifdef _ERRNO |
| .................... if(x <0) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... if(x ==0) |
| .................... { |
| .................... errno=ERANGE; |
| .................... return(0); |
| .................... } |
| .................... #endif |
| .................... y = x; |
| .................... |
| .................... if (y != 1.0) |
| .................... { |
| .................... #if !defined(__PCD__) |
| .................... *((unsigned int8 *)(&y)) = 0x7E; |
| .................... #endif |
| .................... p= (((unsigned int16 *)(&y))+3); |
| .................... data1 = *p; |
| .................... data2 = *p; |
| .................... data1 = 0x3FE; |
| .................... data1 = data1 <<4; |
| .................... if(bit_test (data2,15)) |
| .................... bit_set(data1,15); |
| .................... data2 = data2 & 0x000F; |
| .................... data1 ^=data2; |
| .................... |
| .................... *p = data1; |
| .................... |
| .................... y = (y - 1.0)/(y + 1.0); |
| .................... |
| .................... y2=y*y; |
| .................... |
| .................... res = pl_64[0]*y2 + pl_64[1]; |
| .................... res = res*y2 + pl_64[2]; |
| .................... res = res*y2 + pl_64[3]; |
| .................... |
| .................... r = ql_64[0]*y2 + ql_64[1]; |
| .................... r = r*y2 + ql_64[2]; |
| .................... r = r*y2 + ql_64[3]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... p= (((unsigned int16 *)(&x))+3); |
| .................... data1 = *p; |
| .................... bit_clear(data1,15); |
| .................... data1 = data1 >>4; |
| .................... n = data1 - 0x3FE; |
| .................... |
| .................... |
| .................... if (n<0) |
| .................... r = -(float64)-n; |
| .................... else |
| .................... r = (float64)n; |
| .................... |
| .................... res += r*LN2; |
| .................... } |
| .................... |
| .................... else |
| .................... res = 0.0; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... #endif |
| .................... |
| .................... |
| .................... #define LN10 2.3025850929940456 |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float log10(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the the log base 10 of x |
| .................... // Date : N/A |
| .................... // |
| .................... float32 log10(float32 x) |
| .................... { |
| .................... float32 r; |
| .................... |
| .................... r = log(x); |
| .................... r = r/LN10; |
| .................... return(r); |
| .................... } |
| .................... |
| .................... //Overloaded functions for log10() for PCD |
| .................... // Overloaded function log10() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 log10(float48 x) |
| .................... { |
| .................... float48 r; |
| .................... |
| .................... r = log(x); |
| .................... r = r/LN10; |
| .................... return(r); |
| .................... } |
| .................... |
| .................... // Overloaded function log10() for data type - Float64 |
| .................... float64 log10(float64 x) |
| .................... { |
| .................... float64 r; |
| .................... |
| .................... r = log(x); |
| .................... r = r/LN10; |
| .................... return(r); |
| .................... } |
| .................... #endif |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float modf(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description :breaks the argument value int integral and fractional parts, |
| .................... // ach of which have the same sign as the argument. It stores the integral part |
| .................... // as a float in the object pointed to by the iptr |
| .................... // Returns : returns the signed fractional part of value. |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float32 modf(float32 value,float32 *iptr) |
| .................... { |
| .................... *iptr=(value < 0.0)? ceil(value): floor(value); |
| .................... return(value - *iptr); |
| .................... } |
| .................... //Overloaded functions for modf() for PCD |
| .................... // Overloaded function modf() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 modf(float48 value,float48 *iptr) |
| .................... { |
| .................... *iptr=(value < 0.0)? ceil(value): floor(value); |
| .................... return(value - *iptr); |
| .................... } |
| .................... // Overloaded function modf() for data type - Float64 |
| .................... float64 modf(float64 value,float64 *iptr) |
| .................... { |
| .................... *iptr=(value < 0.0)? ceil(value): floor(value); |
| .................... return(value - *iptr); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float pwr(float x,float y) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the value (x^y) |
| .................... // Date : N/A |
| .................... // Note : 0 is returned when the function will generate an imaginary number |
| .................... // |
| .................... float32 pwr(float32 x,float32 y) |
| .................... { |
| .................... if(0 > x && fmod(y, 1) == 0) { |
| .................... if(fmod(y, 2) == 0) { |
| .................... return (exp(log(-x) * y)); |
| .................... } else { |
| .................... return (-exp(log(-x) * y)); |
| .................... } |
| .................... } else if(0 > x && fmod(y, 1) != 0) { |
| .................... return 0; |
| .................... } else { |
| .................... if(x != 0 || 0 >= y) { |
| .................... return (exp(log(x) * y)); |
| .................... } |
| .................... } |
| .................... } |
| .................... //Overloaded functions for pwr() for PCD |
| .................... // Overloaded function pwr() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 pwr(float48 x,float48 y) |
| .................... { |
| .................... if(0 > x && fmod(y, 1) == 0) { |
| .................... if(fmod(y, 2) == 0) { |
| .................... return (exp(log(-x) * y)); |
| .................... } else { |
| .................... return (-exp(log(-x) * y)); |
| .................... } |
| .................... } else if(0 > x && fmod(y, 1) != 0) { |
| .................... return 0; |
| .................... } else { |
| .................... if(x != 0 || 0 >= y) { |
| .................... return (exp(log(x) * y)); |
| .................... } |
| .................... } |
| .................... } |
| .................... // Overloaded function pwr() for data type - Float64 |
| .................... float64 pwr(float64 x,float64 y) |
| .................... { |
| .................... if(0 > x && fmod(y, 1) == 0) { |
| .................... if(fmod(y, 2) == 0) { |
| .................... return (exp(log(-x) * y)); |
| .................... } else { |
| .................... return (-exp(log(-x) * y)); |
| .................... } |
| .................... } else if(0 > x && fmod(y, 1) != 0) { |
| .................... return 0; |
| .................... } else { |
| .................... if(x != 0 || 0 >= y) { |
| .................... return (exp(log(x) * y)); |
| .................... } |
| .................... } |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////// Power functions //////////////////// |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float pow(float x,float y) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the value (x^y) |
| .................... // Date : N/A |
| .................... // Note : 0 is returned when the function will generate an imaginary number |
| .................... // |
| .................... float32 pow(float32 x,float32 y) |
| .................... { |
| .................... if(0 > x && fmod(y, 1) == 0) { |
| .................... if(fmod(y, 2) == 0) { |
| .................... return (exp(log(-x) * y)); |
| .................... } else { |
| .................... return (-exp(log(-x) * y)); |
| .................... } |
| .................... } else if(0 > x && fmod(y, 1) != 0) { |
| .................... return 0; |
| .................... } else { |
| .................... if(x != 0 || 0 >= y) { |
| .................... return (exp(log(x) * y)); |
| .................... } |
| .................... } |
| .................... } |
| .................... //Overloaded functions for pow() for PCD |
| .................... // Overloaded function for pow() data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 pow(float48 x,float48 y) |
| .................... { |
| .................... if(0 > x && fmod(y, 1) == 0) { |
| .................... if(fmod(y, 2) == 0) { |
| .................... return (exp(log(-x) * y)); |
| .................... } else { |
| .................... return (-exp(log(-x) * y)); |
| .................... } |
| .................... } else if(0 > x && fmod(y, 1) != 0) { |
| .................... return 0; |
| .................... } else { |
| .................... if(x != 0 || 0 >= y) { |
| .................... return (exp(log(x) * y)); |
| .................... } |
| .................... } |
| .................... } |
| .................... |
| .................... // Overloaded function pow() for data type - Float64 |
| .................... float64 pow(float64 x,float64 y) |
| .................... { |
| .................... if(0 > x && fmod(y, 1) == 0) { |
| .................... if(fmod(y, 2) == 0) { |
| .................... return (exp(log(-x) * y)); |
| .................... } else { |
| .................... return (-exp(log(-x) * y)); |
| .................... } |
| .................... } else if(0 > x && fmod(y, 1) != 0) { |
| .................... return 0; |
| .................... } else { |
| .................... if(x != 0 || 0 >= y) { |
| .................... return (exp(log(x) * y)); |
| .................... } |
| .................... } |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float sqrt(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the square root of x |
| .................... // Date : N/A |
| .................... // |
| .................... float32 sqrt(float32 x) |
| .................... { |
| .................... float32 y, res; |
| .................... #if defined(__PCD__) |
| .................... unsigned int16 data1,data2; |
| .................... #endif |
| .................... BYTE *p; |
| .................... |
| .................... #ifdef _ERRNO |
| .................... if(x < 0) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... |
| .................... if( x<=0.0) |
| .................... return(0.0); |
| .................... |
| .................... y=x; |
| .................... |
| .................... #if !defined(__PCD__) |
| .................... p=&y; |
| .................... (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1); |
| .................... #endif |
| .................... |
| .................... #if defined(__PCD__) |
| .................... p = (((unsigned int8 *)(&y))+3); |
| .................... data1 = *(((unsigned int8 *)(&y))+3); |
| .................... data2 = *(((unsigned int8 *)(&y))+2); |
| .................... rotate_left(&data1,1); |
| .................... if(bit_test(data2,7)) |
| .................... bit_set(data1,0); |
| .................... data1 = ((data1+127) >>1); |
| .................... bit_clear(data2,7); |
| .................... if(bit_test(data1,0)) |
| .................... bit_set(data2,7); |
| .................... data1 = data1 >>1; |
| .................... *(((unsigned int8 *)(&y))+3) = data1; |
| .................... *(((unsigned int8 *)(&y))+2) = data2; |
| .................... |
| .................... #endif |
| .................... |
| .................... do { |
| .................... res=y; |
| .................... y+=(x/y); |
| .................... |
| .................... #if !defined(__PCD__) |
| .................... (*p)--; |
| .................... #endif |
| .................... |
| .................... #if defined(__PCD__) |
| .................... data1 = *(((unsigned int8 *)(&y))+3); |
| .................... data2 = *(((unsigned int8 *)(&y))+2); |
| .................... rotate_left(&data1,1); |
| .................... if(bit_test(data2,7)) |
| .................... bit_set(data1,0); |
| .................... data1--; |
| .................... bit_clear(data2,7); |
| .................... if(bit_test(data1,0)) |
| .................... bit_set(data2,7); |
| .................... data1 = data1 >>1; |
| .................... *(((unsigned int8 *)(&y))+3) = data1; |
| .................... *(((unsigned int8 *)(&y))+2) = data2; |
| .................... |
| .................... #endif |
| .................... } while(res != y); |
| .................... |
| .................... return(res); |
| .................... } |
| .................... //Overloaded functions for sqrt() for PCD |
| .................... // Overloaded function sqrt() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 sqrt(float48 x) |
| .................... { |
| .................... float48 y, res; |
| .................... unsigned int16 data1,data2; |
| .................... BYTE *p; |
| .................... |
| .................... #ifdef _ERRNO |
| .................... if(x < 0) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... |
| .................... if( x<=0.0) |
| .................... return(0.0); |
| .................... |
| .................... y=x; |
| .................... |
| .................... #if !defined(__PCD__) |
| .................... p=&y; |
| .................... (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1); |
| .................... #endif |
| .................... |
| .................... #if defined(__PCD__) |
| .................... p = (((unsigned int8 *)(&y))+5); |
| .................... data1 = *(((unsigned int8 *)(&y))+5); |
| .................... data2 = *(((unsigned int8 *)(&y))+4); |
| .................... rotate_left(&data1,1); |
| .................... if(bit_test(data2,7)) |
| .................... bit_set(data1,0); |
| .................... data1 = ((data1+127) >>1); |
| .................... bit_clear(data2,7); |
| .................... if(bit_test(data1,0)) |
| .................... bit_set(data2,7); |
| .................... data1 = data1 >>1; |
| .................... *(((unsigned int8 *)(&y))+5) = data1; |
| .................... *(((unsigned int8 *)(&y))+4) = data2; |
| .................... |
| .................... #endif |
| .................... |
| .................... do { |
| .................... res=y; |
| .................... y+=(x/y); |
| .................... |
| .................... #if !defined(__PCD__) |
| .................... (*p)--; |
| .................... #endif |
| .................... |
| .................... data1 = *(((unsigned int8 *)(&y))+5); |
| .................... data2 = *(((unsigned int8 *)(&y))+4); |
| .................... rotate_left(&data1,1); |
| .................... if(bit_test(data2,7)) |
| .................... bit_set(data1,0); |
| .................... data1--; |
| .................... bit_clear(data2,7); |
| .................... if(bit_test(data1,0)) |
| .................... bit_set(data2,7); |
| .................... data1 = data1 >>1; |
| .................... *(((unsigned int8 *)(&y))+5) = data1; |
| .................... *(((unsigned int8 *)(&y))+4) = data2; |
| .................... |
| .................... } while(res != y); |
| .................... |
| .................... return(res); |
| .................... } |
| .................... |
| .................... // Overloaded function sqrt() for data type - Float64 |
| .................... float64 sqrt(float64 x) |
| .................... { |
| .................... float64 y, res; |
| .................... unsigned int16 *p; |
| .................... unsigned int16 temp1,temp2; |
| .................... |
| .................... #ifdef _ERRNO |
| .................... if(x < 0) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... |
| .................... if( x<=0.0) |
| .................... return(0.0); |
| .................... |
| .................... y=x; |
| .................... p= (((unsigned int16 *)(&y))+3); |
| .................... temp1 = *p; |
| .................... temp2 = *p; |
| .................... bit_clear(temp1,15); |
| .................... temp1 = (temp1>>4)+1023; |
| .................... temp1 = temp1 >> 1; |
| .................... temp1 = (temp1<<4) & 0xFFF0; |
| .................... if(bit_test(temp2,15)) |
| .................... bit_set(temp1,15); |
| .................... temp2 = temp2 & 0x000F; |
| .................... temp1 ^= temp2; |
| .................... |
| .................... (*p) = temp1; |
| .................... |
| .................... do { |
| .................... res=y; |
| .................... y+=(x/y); |
| .................... temp1 = *p; |
| .................... temp2 = *p; |
| .................... bit_clear(temp1,15); |
| .................... temp1 = (temp1>>4); |
| .................... temp1--; |
| .................... temp1 = (temp1<<4) & 0xFFF0; |
| .................... if(bit_test(temp2,15)) |
| .................... bit_set(temp1,15); |
| .................... temp2 = temp2 & 0x000F; |
| .................... temp1 ^= temp2; |
| .................... (*p) = temp1; |
| .................... |
| .................... } while(res != y); |
| .................... |
| .................... return(res); |
| .................... } |
| .................... #endif |
| .................... |
| .................... ////////////////////////////// Trig Functions ////////////////////////////// |
| .................... #ifdef PI_DIV_BY_TWO |
| .................... #undef PI_DIV_BY_TWO |
| .................... #endif |
| .................... #define PI_DIV_BY_TWO 1.5707963267948966 |
| .................... #ifdef TWOBYPI |
| .................... #undef TWOBYPI |
| .................... #define TWOBYPI 0.6366197723675813 |
| .................... #endif |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float cos(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the cosine value of the angle x, which is in radian |
| .................... // Date : 9/20/2001 |
| .................... // |
| .................... float32 cos(float32 x) |
| .................... { |
| .................... float32 y, t, t2 = 1.0; |
| .................... unsigned int8 quad, i; |
| .................... float32 frac; |
| .................... float32 p[6] = { //by the series definition for cosine |
| .................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! ) |
| .................... 0.04166666666667, |
| .................... -0.00138888888889, |
| .................... 0.00002480158730, |
| .................... -0.00000027557319, |
| .................... 0.00000000208767, |
| .................... //-0.00000000001147, |
| .................... // 0.00000000000005 |
| .................... }; |
| .................... |
| .................... if (x < 0) x = -x; // absolute value of input |
| .................... |
| .................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant |
| .................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input |
| .................... quad = quad % 4; // quadrant (0 to 3) |
| .................... |
| .................... if (quad == 0 || quad == 2) |
| .................... t = frac * PI_DIV_BY_TWO; |
| .................... else if (quad == 1) |
| .................... t = (1-frac) * PI_DIV_BY_TWO; |
| .................... else // should be 3 |
| .................... t = (frac-1) * PI_DIV_BY_TWO; |
| .................... |
| .................... y = 1.0; |
| .................... t = t * t; |
| .................... for (i = 0; i <= 5; i++) |
| .................... { |
| .................... t2 = t2 * t; |
| .................... y = y + p[i] * t2; |
| .................... } |
| .................... |
| .................... if (quad == 2 || quad == 1) |
| .................... y = -y; // correct sign |
| .................... |
| .................... return (y); |
| .................... } |
| .................... |
| .................... |
| .................... //Overloaded functions for cos() for PCD |
| .................... // Overloaded function cos() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 cos(float48 x) |
| .................... { |
| .................... float48 y, t, t2 = 1.0; |
| .................... unsigned int8 quad, i; |
| .................... float48 frac; |
| .................... float48 p[6] = { //by the series definition for cosine |
| .................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! ) |
| .................... 0.04166666666667, |
| .................... -0.00138888888889, |
| .................... 0.00002480158730, |
| .................... -0.00000027557319, |
| .................... 0.00000000208767, |
| .................... //-0.00000000001147, |
| .................... // 0.00000000000005 |
| .................... }; |
| .................... |
| .................... if (x < 0) x = -x; // absolute value of input |
| .................... |
| .................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant |
| .................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input |
| .................... quad = quad % 4; // quadrant (0 to 3) |
| .................... |
| .................... if (quad == 0 || quad == 2) |
| .................... t = frac * PI_DIV_BY_TWO; |
| .................... else if (quad == 1) |
| .................... t = (1-frac) * PI_DIV_BY_TWO; |
| .................... else // should be 3 |
| .................... t = (frac-1) * PI_DIV_BY_TWO; |
| .................... |
| .................... y = 0.999999999781; |
| .................... t = t * t; |
| .................... for (i = 0; i <= 5; i++) |
| .................... { |
| .................... t2 = t2 * t; |
| .................... y = y + p[i] * t2; |
| .................... } |
| .................... |
| .................... if (quad == 2 || quad == 1) |
| .................... y = -y; // correct sign |
| .................... |
| .................... return (y); |
| .................... } |
| .................... |
| .................... // Overloaded function cos() for data type - Float48 |
| .................... float64 cos(float64 x) |
| .................... { |
| .................... float64 y, t, t2 = 1.0; |
| .................... unsigned int8 quad, i; |
| .................... float64 frac; |
| .................... float64 p[6] = { //by the series definition for cosine |
| .................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! ) |
| .................... 0.04166666666667, |
| .................... -0.00138888888889, |
| .................... 0.00002480158730, |
| .................... -0.00000027557319, |
| .................... 0.00000000208767, |
| .................... //-0.00000000001147, |
| .................... // 0.00000000000005 |
| .................... }; |
| .................... |
| .................... if (x < 0) x = -x; // absolute value of input |
| .................... |
| .................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant |
| .................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input |
| .................... quad = quad % 4; // quadrant (0 to 3) |
| .................... |
| .................... if (quad == 0 || quad == 2) |
| .................... t = frac * PI_DIV_BY_TWO; |
| .................... else if (quad == 1) |
| .................... t = (1-frac) * PI_DIV_BY_TWO; |
| .................... else // should be 3 |
| .................... t = (frac-1) * PI_DIV_BY_TWO; |
| .................... |
| .................... y = 0.999999999781; |
| .................... t = t * t; |
| .................... for (i = 0; i <= 5; i++) |
| .................... { |
| .................... t2 = t2 * t; |
| .................... y = y + p[i] * t2; |
| .................... } |
| .................... |
| .................... if (quad == 2 || quad == 1) |
| .................... y = -y; // correct sign |
| .................... |
| .................... return (y); |
| .................... } |
| .................... |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float sin(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the sine value of the angle x, which is in radian |
| .................... // Date : 9/20/2001 |
| .................... // |
| .................... float32 sin(float32 x) |
| .................... { |
| .................... return cos(x - PI_DIV_BY_TWO); |
| .................... } |
| .................... |
| .................... //Overloaded functions for sin() for PCD |
| .................... // Overloaded function sin() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 sin(float48 x) |
| .................... { |
| .................... return cos(x - PI_DIV_BY_TWO); |
| .................... } |
| .................... |
| .................... // Overloaded function sin() for data type - Float48 |
| .................... float64 sin(float64 x) |
| .................... { |
| .................... return cos(x - PI_DIV_BY_TWO); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float tan(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the tangent value of the angle x, which is in radian |
| .................... // Date : 9/20/2001 |
| .................... // |
| .................... float32 tan(float32 x) |
| .................... { |
| .................... float32 c, s; |
| .................... |
| .................... c = cos(x); |
| .................... if (c == 0.0) |
| .................... return (1.0e+36); |
| .................... |
| .................... s = sin(x); |
| .................... return(s/c); |
| .................... } |
| .................... //Overloaded functions for tan() for PCD |
| .................... // Overloaded function tan() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 tan(float48 x) |
| .................... { |
| .................... float48 c, s; |
| .................... |
| .................... c = cos(x); |
| .................... if (c == 0.0) |
| .................... return (1.0e+36); |
| .................... |
| .................... s = sin(x); |
| .................... return(s/c); |
| .................... } |
| .................... |
| .................... // Overloaded function tan() for data type - Float48 |
| .................... float64 tan(float64 x) |
| .................... { |
| .................... float64 c, s; |
| .................... |
| .................... c = cos(x); |
| .................... if (c == 0.0) |
| .................... return (1.0e+36); |
| .................... |
| .................... s = sin(x); |
| .................... return(s/c); |
| .................... } |
| .................... #endif |
| .................... |
| .................... float32 const pas[3] = {0.49559947, -4.6145309, 5.6036290}; |
| .................... float32 const qas[3] = {1.0000000, -5.5484666, 5.6036290}; |
| .................... |
| .................... float32 ASIN_COS(float32 x, unsigned int8 n) |
| .................... { |
| .................... float32 y, res, r, y2; |
| .................... int1 s; |
| .................... #ifdef _ERRNO |
| .................... if(x <-1 || x > 1) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y > 0.5) |
| .................... { |
| .................... y = sqrt((1.0 - y)/2.0); |
| .................... n += 2; |
| .................... } |
| .................... |
| .................... y2=y*y; |
| .................... |
| .................... res = pas[0]*y2 + pas[1]; |
| .................... res = res*y2 + pas[2]; |
| .................... |
| .................... r = qas[0]*y2 + qas[1]; |
| .................... r = r*y2 + qas[2]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... if (n & 2) // |x| > 0.5 |
| .................... res = PI_DIV_BY_TWO - 2.0*res; |
| .................... if (s) |
| .................... res = -res; |
| .................... if (n & 1) // take arccos |
| .................... res = PI_DIV_BY_TWO - res; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... |
| .................... //Overloaded functions for ASIN_COS() for PCD |
| .................... // Overloaded function ASIN_COS() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 ASIN_COS(float48 x, unsigned int8 n) |
| .................... { |
| .................... float48 y, res, r, y2; |
| .................... int1 s; |
| .................... #ifdef _ERRNO |
| .................... if(x <-1 || x > 1) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y > 0.5) |
| .................... { |
| .................... y = sqrt((1.0 - y)/2.0); |
| .................... n += 2; |
| .................... } |
| .................... |
| .................... y2=y*y; |
| .................... |
| .................... res = pas[0]*y2 + pas[1]; |
| .................... res = res*y2 + pas[2]; |
| .................... |
| .................... r = qas[0]*y2 + qas[1]; |
| .................... r = r*y2 + qas[2]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... if (n & 2) // |x| > 0.5 |
| .................... res = PI_DIV_BY_TWO - 2.0*res; |
| .................... if (s) |
| .................... res = -res; |
| .................... if (n & 1) // take arccos |
| .................... res = PI_DIV_BY_TWO - res; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... |
| .................... // Overloaded function ASIN_COS() for data type - Float64 |
| .................... float64 ASIN_COS(float64 x, unsigned int8 n) |
| .................... { |
| .................... float64 y, res, r, y2; |
| .................... int1 s; |
| .................... #ifdef _ERRNO |
| .................... if(x <-1 || x > 1) |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... s = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y > 0.5) |
| .................... { |
| .................... y = sqrt((1.0 - y)/2.0); |
| .................... n += 2; |
| .................... } |
| .................... |
| .................... y2=y*y; |
| .................... |
| .................... res = pas[0]*y2 + pas[1]; |
| .................... res = res*y2 + pas[2]; |
| .................... |
| .................... r = qas[0]*y2 + qas[1]; |
| .................... r = r*y2 + qas[2]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... if (n & 2) // |x| > 0.5 |
| .................... res = PI_DIV_BY_TWO - 2.0*res; |
| .................... if (s) |
| .................... res = -res; |
| .................... if (n & 1) // take arccos |
| .................... res = PI_DIV_BY_TWO - res; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float asin(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the arcsine value of the value x. |
| .................... // Date : N/A |
| .................... // |
| .................... float32 asin(float32 x) |
| .................... { |
| .................... float32 r; |
| .................... |
| .................... r = ASIN_COS(x, 0); |
| .................... return(r); |
| .................... } |
| .................... //Overloaded functions for asin() for PCD |
| .................... // Overloaded function asin() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 asin(float48 x) |
| .................... { |
| .................... float48 r; |
| .................... |
| .................... r = ASIN_COS(x, 0); |
| .................... return(r); |
| .................... } |
| .................... |
| .................... // Overloaded function asin() for data type - Float64 |
| .................... float64 asin(float64 x) |
| .................... { |
| .................... float64 r; |
| .................... |
| .................... r = ASIN_COS(x, 0); |
| .................... return(r); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float acos(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the arccosine value of the value x. |
| .................... // Date : N/A |
| .................... // |
| .................... float32 acos(float32 x) |
| .................... { |
| .................... float32 r; |
| .................... |
| .................... r = ASIN_COS(x, 1); |
| .................... return(r); |
| .................... } |
| .................... //Overloaded functions for acos() for PCD |
| .................... // Overloaded function acos() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 acos(float48 x) |
| .................... { |
| .................... float48 r; |
| .................... |
| .................... r = ASIN_COS(x, 1); |
| .................... return(r); |
| .................... } |
| .................... |
| .................... // Overloaded function acos() for data type - Float64 |
| .................... float64 acos(float64 x) |
| .................... { |
| .................... float64 r; |
| .................... |
| .................... r = ASIN_COS(x, 1); |
| .................... return(r); |
| .................... } |
| .................... #endif |
| .................... |
| .................... float32 const pat[4] = {0.17630401, 5.6710795, 22.376096, 19.818457}; |
| .................... float32 const qat[4] = {1.0000000, 11.368190, 28.982246, 19.818457}; |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float atan(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : returns the arctangent value of the value x. |
| .................... // Date : N/A |
| .................... // |
| .................... float32 atan(float32 x) |
| .................... { |
| .................... float32 y, res, r; |
| .................... int1 s, flag; |
| .................... |
| .................... s = 0; |
| .................... flag = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y > 1.0) |
| .................... { |
| .................... y = 1.0/y; |
| .................... flag = 1; |
| .................... } |
| .................... |
| .................... res = pat[0]*y*y + pat[1]; |
| .................... res = res*y*y + pat[2]; |
| .................... res = res*y*y + pat[3]; |
| .................... |
| .................... r = qat[0]*y*y + qat[1]; |
| .................... r = r*y*y + qat[2]; |
| .................... r = r*y*y + qat[3]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... |
| .................... if (flag) // for |x| > 1 |
| .................... res = PI_DIV_BY_TWO - res; |
| .................... if (s) |
| .................... res = -res; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... //Overloaded functions for atan() for PCD |
| .................... // Overloaded function atan() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 atan(float48 x) |
| .................... { |
| .................... float48 y, res, r; |
| .................... int1 s, flag; |
| .................... |
| .................... s = 0; |
| .................... flag = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y > 1.0) |
| .................... { |
| .................... y = 1.0/y; |
| .................... flag = 1; |
| .................... } |
| .................... |
| .................... res = pat[0]*y*y + pat[1]; |
| .................... res = res*y*y + pat[2]; |
| .................... res = res*y*y + pat[3]; |
| .................... |
| .................... r = qat[0]*y*y + qat[1]; |
| .................... r = r*y*y + qat[2]; |
| .................... r = r*y*y + qat[3]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... |
| .................... if (flag) // for |x| > 1 |
| .................... res = PI_DIV_BY_TWO - res; |
| .................... if (s) |
| .................... res = -res; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... |
| .................... // Overloaded function atan() for data type - Float64 |
| .................... float64 atan(float64 x) |
| .................... { |
| .................... float64 y, res, r; |
| .................... int1 s, flag; |
| .................... |
| .................... s = 0; |
| .................... flag = 0; |
| .................... y = x; |
| .................... |
| .................... if (x < 0) |
| .................... { |
| .................... s = 1; |
| .................... y = -y; |
| .................... } |
| .................... |
| .................... if (y > 1.0) |
| .................... { |
| .................... y = 1.0/y; |
| .................... flag = 1; |
| .................... } |
| .................... |
| .................... res = pat[0]*y*y + pat[1]; |
| .................... res = res*y*y + pat[2]; |
| .................... res = res*y*y + pat[3]; |
| .................... |
| .................... r = qat[0]*y*y + qat[1]; |
| .................... r = r*y*y + qat[2]; |
| .................... r = r*y*y + qat[3]; |
| .................... |
| .................... res = y*res/r; |
| .................... |
| .................... |
| .................... if (flag) // for |x| > 1 |
| .................... res = PI_DIV_BY_TWO - res; |
| .................... if (s) |
| .................... res = -res; |
| .................... |
| .................... return(res); |
| .................... } |
| .................... #endif |
| .................... |
| .................... ///////////////////////////////////////////////////////////////////////////// |
| .................... // float atan2(float y, float x) |
| .................... ///////////////////////////////////////////////////////////////////////////// |
| .................... // Description :computes the principal value of arc tangent of y/x, using the |
| .................... // signs of both the arguments to determine the quadrant of the return value |
| .................... // Returns : returns the arc tangent of y/x. |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float32 atan2(float32 y,float32 x) |
| .................... { |
| .................... float32 z; |
| .................... int1 sign; |
| .................... unsigned int8 quad; |
| .................... sign=0; |
| .................... quad=0; //quadrant |
| .................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1)); |
| .................... if(y<0.0) |
| .................... { |
| .................... sign=1; |
| .................... y=-y; |
| .................... } |
| .................... if(x<0.0) |
| .................... { |
| .................... x=-x; |
| .................... } |
| .................... if (x==0.0) |
| .................... { |
| .................... if(y==0.0) |
| .................... { |
| .................... #ifdef _ERRNO |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... } |
| .................... else |
| .................... { |
| .................... if(sign) |
| .................... { |
| .................... return (-(PI_DIV_BY_TWO)); |
| .................... } |
| .................... else |
| .................... { |
| .................... return (PI_DIV_BY_TWO); |
| .................... } |
| .................... } |
| .................... } |
| .................... else |
| .................... { |
| .................... z=y/x; |
| .................... switch(quad) |
| .................... { |
| .................... case 1: |
| .................... { |
| .................... return atan(z); |
| .................... break; |
| .................... } |
| .................... case 2: |
| .................... { |
| .................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122 |
| .................... return (PI-atan(z)); |
| .................... break; |
| .................... } |
| .................... case 3: |
| .................... { |
| .................... return (atan(z)-PI); |
| .................... break; |
| .................... } |
| .................... case 4: |
| .................... { |
| .................... return (-atan(z)); |
| .................... break; |
| .................... } |
| .................... } |
| .................... } |
| .................... } |
| .................... |
| .................... //Overloaded functions for atan2() for PCD |
| .................... // Overloaded function atan2() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 atan2(float48 y,float48 x) |
| .................... { |
| .................... float48 z; |
| .................... int1 sign; |
| .................... unsigned int8 quad; |
| .................... sign=0; |
| .................... quad=0; //quadrant |
| .................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1)); |
| .................... if(y<0.0) |
| .................... { |
| .................... sign=1; |
| .................... y=-y; |
| .................... } |
| .................... if(x<0.0) |
| .................... { |
| .................... x=-x; |
| .................... } |
| .................... if (x==0.0) |
| .................... { |
| .................... if(y==0.0) |
| .................... { |
| .................... #ifdef _ERRNO |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... } |
| .................... else |
| .................... { |
| .................... if(sign) |
| .................... { |
| .................... return (-(PI_DIV_BY_TWO)); |
| .................... } |
| .................... else |
| .................... { |
| .................... return (PI_DIV_BY_TWO); |
| .................... } |
| .................... } |
| .................... } |
| .................... else |
| .................... { |
| .................... z=y/x; |
| .................... switch(quad) |
| .................... { |
| .................... case 1: |
| .................... { |
| .................... return atan(z); |
| .................... break; |
| .................... } |
| .................... case 2: |
| .................... { |
| .................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122 |
| .................... return (PI-atan(z)); |
| .................... break; |
| .................... } |
| .................... case 3: |
| .................... { |
| .................... return (atan(z)-PI); |
| .................... break; |
| .................... } |
| .................... case 4: |
| .................... { |
| .................... return (-atan(z)); |
| .................... break; |
| .................... } |
| .................... } |
| .................... } |
| .................... } |
| .................... |
| .................... // Overloaded function atan2() for data type - Float64 |
| .................... float64 atan2(float64 y,float64 x) |
| .................... { |
| .................... float64 z; |
| .................... int1 sign; |
| .................... unsigned int8 quad; |
| .................... sign=0; |
| .................... quad=0; //quadrant |
| .................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1)); |
| .................... if(y<0.0) |
| .................... { |
| .................... sign=1; |
| .................... y=-y; |
| .................... } |
| .................... if(x<0.0) |
| .................... { |
| .................... x=-x; |
| .................... } |
| .................... if (x==0.0) |
| .................... { |
| .................... if(y==0.0) |
| .................... { |
| .................... #ifdef _ERRNO |
| .................... { |
| .................... errno=EDOM; |
| .................... } |
| .................... #endif |
| .................... } |
| .................... else |
| .................... { |
| .................... if(sign) |
| .................... { |
| .................... return (-(PI_DIV_BY_TWO)); |
| .................... } |
| .................... else |
| .................... { |
| .................... return (PI_DIV_BY_TWO); |
| .................... } |
| .................... } |
| .................... } |
| .................... else |
| .................... { |
| .................... z=y/x; |
| .................... switch(quad) |
| .................... { |
| .................... case 1: |
| .................... { |
| .................... return atan(z); |
| .................... break; |
| .................... } |
| .................... case 2: |
| .................... { |
| .................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122 |
| .................... return (PI-atan(z)); |
| .................... break; |
| .................... } |
| .................... case 3: |
| .................... { |
| .................... return (atan(z)-PI); |
| .................... break; |
| .................... } |
| .................... case 4: |
| .................... { |
| .................... return (-atan(z)); |
| .................... break; |
| .................... } |
| .................... } |
| .................... } |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////// Hyperbolic functions //////////////////// |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float cosh(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : Computes the hyperbolic cosine value of x |
| .................... // Returns : returns the hyperbolic cosine value of x |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float32 cosh(float32 x) |
| .................... { |
| .................... return ((exp(x)+exp(-x))/2); |
| .................... } |
| .................... //Overloaded functions for cosh() for PCD |
| .................... // Overloaded function cosh() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 cosh(float48 x) |
| .................... { |
| .................... return ((exp(x)+exp(-x))/2); |
| .................... } |
| .................... |
| .................... // Overloaded function cosh() for data type - Float64 |
| .................... float64 cosh(float64 x) |
| .................... { |
| .................... return ((exp(x)+exp(-x))/2); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float sinh(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : Computes the hyperbolic sine value of x |
| .................... // Returns : returns the hyperbolic sine value of x |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float32 sinh(float32 x) |
| .................... { |
| .................... |
| .................... return ((exp(x) - exp(-x))/2); |
| .................... } |
| .................... //Overloaded functions for sinh() for PCD |
| .................... // Overloaded function sinh() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 sinh(float48 x) |
| .................... { |
| .................... |
| .................... return ((exp(x) - exp(-x))/2); |
| .................... } |
| .................... |
| .................... // Overloaded function sinh() for data type - Float48 |
| .................... float64 sinh(float64 x) |
| .................... { |
| .................... |
| .................... return ((exp(x) - exp(-x))/2); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float tanh(float x) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : Computes the hyperbolic tangent value of x |
| .................... // Returns : returns the hyperbolic tangent value of x |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float32 tanh(float32 x) |
| .................... { |
| .................... return(sinh(x)/cosh(x)); |
| .................... } |
| .................... //Overloaded functions for tanh() for PCD |
| .................... // Overloaded function tanh() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 tanh(float48 x) |
| .................... { |
| .................... return(sinh(x)/cosh(x)); |
| .................... } |
| .................... |
| .................... // Overloaded function tanh() for data type - Float64 |
| .................... float64 tanh(float64 x) |
| .................... { |
| .................... return(sinh(x)/cosh(x)); |
| .................... } |
| .................... #endif |
| .................... |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // float frexp(float x, signed int *exp) |
| .................... //////////////////////////////////////////////////////////////////////////// |
| .................... // Description : breaks a floating point number into a normalized fraction and an integral |
| .................... // power of 2. It stores the integer in the signed int object pointed to by exp. |
| .................... // Returns : returns the value x, such that x is a double with magnitude in the interval |
| .................... // [1/2,1) or zero, and value equals x times 2 raised to the power *exp.If value is zero, |
| .................... // both parts of the result are zero. |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... #define LOG2 .30102999566398119521 |
| .................... float32 frexp(float32 x, signed int8 *exp) |
| .................... { |
| .................... float32 res; |
| .................... int1 sign = 0; |
| .................... if(x == 0.0) |
| .................... { |
| .................... *exp=0; |
| .................... return (0.0); |
| .................... } |
| .................... if(x < 0.0) |
| .................... { |
| .................... x=-x; |
| .................... sign=1; |
| .................... } |
| .................... if (x > 1.0) |
| .................... { |
| .................... *exp=(ceil(log10(x)/LOG2)); |
| .................... res=x/(pow(2, *exp)); |
| .................... if (res == 1) |
| .................... { |
| .................... *exp=*exp+1; |
| .................... res=.5; |
| .................... } |
| .................... } |
| .................... else |
| .................... { |
| .................... if(x < 0.5) |
| .................... { |
| .................... *exp=-1; |
| .................... res=x*2; |
| .................... } |
| .................... else |
| .................... { |
| .................... *exp=0; |
| .................... res=x; |
| .................... } |
| .................... } |
| .................... if(sign) |
| .................... { |
| .................... res=-res; |
| .................... } |
| .................... return res; |
| .................... } |
| .................... |
| .................... //Overloaded functions for frexp() for PCD |
| .................... // Overloaded function frexp() for data type - Float48 |
| .................... #if defined(__PCD__) |
| .................... float48 frexp(float48 x, signed int8 *exp) |
| .................... { |
| .................... float48 res; |
| .................... int1 sign = 0; |
| .................... if(x == 0.0) |
| .................... { |
| .................... *exp=0; |
| .................... return (0.0); |
| .................... } |
| .................... if(x < 0.0) |
| .................... { |
| .................... x=-x; |
| .................... sign=1; |
| .................... } |
| .................... if (x > 1.0) |
| .................... { |
| .................... *exp=(ceil(log10(x)/LOG2)); |
| .................... res=x/(pow(2, *exp)); |
| .................... if (res == 1) |
| .................... { |
| .................... *exp=*exp+1; |
| .................... res=.5; |
| .................... } |
| .................... } |
| .................... else |
| .................... { |
| .................... if(x < 0.5) |
| .................... { |
| .................... *exp=-1; |
| .................... res=x*2; |
| .................... } |
| .................... else |
| .................... { |
| .................... *exp=0; |
| .................... res=x; |
| .................... } |
| .................... } |
| .................... if(sign) |
| .................... { |
| .................... res=-res; |
| .................... } |
| .................... return res; |
| .................... } |
| .................... |
| .................... // Overloaded function frexp() for data type - Float64 |
| .................... float64 frexp(float64 x, signed int8 *exp) |
| .................... { |
| .................... float64 res; |
| .................... int1 sign = 0; |
| .................... if(x == 0.0) |
| .................... { |
| .................... *exp=0; |
| .................... return (0.0); |
| .................... } |
| .................... if(x < 0.0) |
| .................... { |
| .................... x=-x; |
| .................... sign=1; |
| .................... } |
| .................... if (x > 1.0) |
| .................... { |
| .................... *exp=(ceil(log10(x)/LOG2)); |
| .................... res=x/(pow(2, *exp)); |
| .................... if (res == 1) |
| .................... { |
| .................... *exp=*exp+1; |
| .................... res=.5; |
| .................... } |
| .................... } |
| .................... else |
| .................... { |
| .................... if(x < 0.5) |
| .................... { |
| .................... *exp=-1; |
| .................... res=x*2; |
| .................... } |
| .................... else |
| .................... { |
| .................... *exp=0; |
| .................... res=x; |
| .................... } |
| .................... } |
| .................... if(sign) |
| .................... { |
| .................... res=-res; |
| .................... } |
| .................... return res; |
| .................... } |
| .................... #endif |
| .................... |
| .................... ////////////////////////////////////////////////////////////////////////////// |
| .................... // float ldexp(float x, signed int *exp) |
| .................... ////////////////////////////////////////////////////////////////////////////// |
| .................... // Description : multiplies a floating point number by an integral power of 2. |
| .................... // Returns : returns the value of x times 2 raised to the power exp. |
| .................... // Date : N/A |
| .................... // |
| .................... |
| .................... float32 ldexp(float32 value, signed int8 exp) |
| .................... { |
| .................... return (value * pow(2,exp)); |
| .................... } |
| .................... //Overloaded functions for ldexp() for PCD |
| .................... // Overloaded function ldexp() for data type - Float48 |
| .................... |
| .................... #if defined(__PCD__) |
| .................... float48 ldexp(float48 value, signed int8 exp) |
| .................... { |
| .................... return (value * pow(2,exp)); |
| .................... } |
| .................... // Overloaded function ldexp() for data type - Float64 |
| .................... float64 ldexp(float64 value, signed int8 exp) |
| .................... { |
| .................... return (value * pow(2,exp)); |
| .................... } |
| .................... #endif |
| .................... |
| .................... #endif |
| .................... |
| .................... |
| .................... |
| .................... void main() |
| .................... { |
| * |
| 0A28: CLRF 04 |
| 0A29: BCF 03.7 |
| 0A2A: MOVLW 1F |
| 0A2B: ANDWF 03,F |
| 0A2C: MOVLW 71 |
| 0A2D: BSF 03.5 |
| 0A2E: MOVWF 0F |
| 0A2F: MOVF 0F,W |
| 0A30: BSF 03.6 |
| 0A31: BCF 07.3 |
| 0A32: MOVLW 0C |
| 0A33: BCF 03.6 |
| 0A34: MOVWF 19 |
| 0A35: MOVLW A2 |
| 0A36: MOVWF 18 |
| 0A37: MOVLW 90 |
| 0A38: BCF 03.5 |
| 0A39: MOVWF 18 |
| 0A3A: BSF 03.5 |
| 0A3B: BSF 03.6 |
| 0A3C: MOVF 09,W |
| 0A3D: ANDLW C0 |
| 0A3E: MOVWF 09 |
| 0A3F: BCF 03.6 |
| 0A40: BCF 1F.4 |
| 0A41: BCF 1F.5 |
| 0A42: MOVLW 00 |
| 0A43: BSF 03.6 |
| 0A44: MOVWF 08 |
| 0A45: BCF 03.5 |
| 0A46: CLRF 07 |
| 0A47: CLRF 08 |
| 0A48: CLRF 09 |
| 0AB7: CLRF 04 |
| 0AB8: BCF 03.7 |
| 0AB9: MOVLW 1F |
| 0ABA: ANDWF 03,F |
| 0ABB: MOVLW 71 |
| 0ABC: BSF 03.5 |
| 0ABD: MOVWF 0F |
| 0ABE: MOVF 0F,W |
| 0ABF: BSF 03.6 |
| 0AC0: BCF 07.3 |
| 0AC1: MOVLW 0C |
| 0AC2: BCF 03.6 |
| 0AC3: MOVWF 19 |
| 0AC4: MOVLW A2 |
| 0AC5: MOVWF 18 |
| 0AC6: MOVLW 90 |
| 0AC7: BCF 03.5 |
| 0AC8: MOVWF 18 |
| 0AC9: BSF 03.5 |
| 0ACA: BSF 03.6 |
| 0ACB: MOVF 09,W |
| 0ACC: ANDLW C0 |
| 0ACD: MOVWF 09 |
| 0ACE: BCF 03.6 |
| 0ACF: BCF 1F.4 |
| 0AD0: BCF 1F.5 |
| 0AD1: MOVLW 00 |
| 0AD2: BSF 03.6 |
| 0AD3: MOVWF 08 |
| 0AD4: BCF 03.5 |
| 0AD5: CLRF 07 |
| 0AD6: CLRF 08 |
| 0AD7: CLRF 09 |
| * |
| 0A4C: CLRF 2E |
| 0A4D: CLRF 2D |
| 0AE1: CLRF 34 |
| 0AE2: CLRF 33 |
| .................... float temp1, temp2, humidity; |
| .................... int16 i=0; |
| .................... |
| .................... setup_adc_ports(NO_ANALOGS|VSS_VDD); |
| 0A4E: BSF 03.5 |
| 0A4F: BSF 03.6 |
| 0A50: MOVF 09,W |
| 0A51: ANDLW C0 |
| 0A52: MOVWF 09 |
| 0A53: BCF 03.6 |
| 0A54: BCF 1F.4 |
| 0A55: BCF 1F.5 |
| 0A56: MOVLW 00 |
| 0A57: BSF 03.6 |
| 0A58: MOVWF 08 |
| 0AE3: BSF 03.5 |
| 0AE4: BSF 03.6 |
| 0AE5: MOVF 09,W |
| 0AE6: ANDLW C0 |
| 0AE7: MOVWF 09 |
| 0AE8: BCF 03.6 |
| 0AE9: BCF 1F.4 |
| 0AEA: BCF 1F.5 |
| 0AEB: MOVLW 00 |
| 0AEC: BSF 03.6 |
| 0AED: MOVWF 08 |
| .................... setup_adc(ADC_CLOCK_DIV_2); |
| 0A59: BCF 03.5 |
| 0A5A: BCF 03.6 |
| 0A5B: BCF 1F.6 |
| 0A5C: BCF 1F.7 |
| 0A5D: BSF 03.5 |
| 0A5E: BSF 1F.7 |
| 0A5F: BCF 03.5 |
| 0A60: BSF 1F.0 |
| 0AEE: BCF 03.5 |
| 0AEF: BCF 03.6 |
| 0AF0: BCF 1F.6 |
| 0AF1: BCF 1F.7 |
| 0AF2: BSF 03.5 |
| 0AF3: BSF 1F.7 |
| 0AF4: BCF 03.5 |
| 0AF5: BSF 1F.0 |
| .................... setup_spi(SPI_SS_DISABLED); |
| 0A61: BCF 14.5 |
| 0A62: BCF 20.5 |
| 0A63: MOVF 20,W |
| 0A64: BSF 03.5 |
| 0A65: MOVWF 07 |
| 0A66: BCF 03.5 |
| 0A67: BSF 20.4 |
| 0A68: MOVF 20,W |
| 0A69: BSF 03.5 |
| 0A6A: MOVWF 07 |
| 0A6B: BCF 03.5 |
| 0A6C: BCF 20.3 |
| 0A6D: MOVF 20,W |
| 0A6E: BSF 03.5 |
| 0A6F: MOVWF 07 |
| 0A70: MOVLW 01 |
| 0A71: BCF 03.5 |
| 0A72: MOVWF 14 |
| 0A73: MOVLW 00 |
| 0A74: BSF 03.5 |
| 0A75: MOVWF 14 |
| 0AF6: BCF 14.5 |
| 0AF7: BCF 20.5 |
| 0AF8: MOVF 20,W |
| 0AF9: BSF 03.5 |
| 0AFA: MOVWF 07 |
| 0AFB: BCF 03.5 |
| 0AFC: BSF 20.4 |
| 0AFD: MOVF 20,W |
| 0AFE: BSF 03.5 |
| 0AFF: MOVWF 07 |
| 0B00: BCF 03.5 |
| 0B01: BCF 20.3 |
| 0B02: MOVF 20,W |
| 0B03: BSF 03.5 |
| 0B04: MOVWF 07 |
| 0B05: MOVLW 01 |
| 0B06: BCF 03.5 |
| 0B07: MOVWF 14 |
| 0B08: MOVLW 00 |
| 0B09: BSF 03.5 |
| 0B0A: MOVWF 14 |
| .................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); |
| 0A76: MOVF 01,W |
| 0A77: ANDLW C7 |
| 0A78: IORLW 08 |
| 0A79: MOVWF 01 |
| 0B0B: MOVF 01,W |
| 0B0C: ANDLW C7 |
| 0B0D: IORLW 08 |
| 0B0E: MOVWF 01 |
| .................... setup_timer_1(T1_DISABLED); |
| 0A7A: BCF 03.5 |
| 0A7B: CLRF 10 |
| 0B0F: BCF 03.5 |
| 0B10: CLRF 10 |
| .................... setup_timer_2(T2_DISABLED,0,1); |
| 0A7C: MOVLW 00 |
| 0A7D: MOVWF 78 |
| 0A7E: MOVWF 12 |
| 0A7F: MOVLW 00 |
| 0A80: BSF 03.5 |
| 0A81: MOVWF 12 |
| 0B11: MOVLW 00 |
| 0B12: MOVWF 78 |
| 0B13: MOVWF 12 |
| 0B14: MOVLW 00 |
| 0B15: BSF 03.5 |
| 0B16: MOVWF 12 |
| .................... setup_ccp1(CCP_OFF); |
| 0A82: BCF 03.5 |
| 0A83: BSF 20.2 |
| 0A84: MOVF 20,W |
| 0A85: BSF 03.5 |
| 0A86: MOVWF 07 |
| 0A87: BCF 03.5 |
| 0A88: CLRF 17 |
| 0A89: BSF 03.5 |
| 0A8A: CLRF 1B |
| 0A8B: CLRF 1C |
| 0A8C: MOVLW 01 |
| 0A8D: MOVWF 1D |
| 0B17: BCF 03.5 |
| 0B18: BSF 20.2 |
| 0B19: MOVF 20,W |
| 0B1A: BSF 03.5 |
| 0B1B: MOVWF 07 |
| 0B1C: BCF 03.5 |
| 0B1D: CLRF 17 |
| 0B1E: BSF 03.5 |
| 0B1F: CLRF 1B |
| 0B20: CLRF 1C |
| 0B21: MOVLW 01 |
| 0B22: MOVWF 1D |
| .................... setup_comparator(NC_NC_NC_NC); // This device COMP currently not supported by the PICWizard |
| 0A8E: BCF 03.5 |
| 0A8F: BSF 03.6 |
| 0A90: CLRF 07 |
| 0A91: CLRF 08 |
| 0A92: CLRF 09 |
| 0B23: BCF 03.5 |
| 0B24: BSF 03.6 |
| 0B25: CLRF 07 |
| 0B26: CLRF 08 |
| 0B27: CLRF 09 |
| .................... setup_oscillator(OSC_8MHZ); |
| 0A93: MOVLW 71 |
| 0A94: BSF 03.5 |
| 0A95: BCF 03.6 |
| 0A96: MOVWF 0F |
| 0A97: MOVF 0F,W |
| 0B28: MOVLW 71 |
| 0B29: BSF 03.5 |
| 0B2A: BCF 03.6 |
| 0B2B: MOVWF 0F |
| 0B2C: MOVF 0F,W |
| .................... |
| .................... |
| .................... printf("GeoMet01A\r\n",); |
| 0A98: MOVLW 0C |
| 0A99: BCF 03.5 |
| 0A9A: BSF 03.6 |
| 0A9B: MOVWF 0D |
| 0A9C: MOVLW 00 |
| 0A9D: MOVWF 0F |
| 0A9E: BCF 0A.3 |
| 0A9F: BCF 03.6 |
| 0AA0: CALL 030 |
| 0AA1: BSF 0A.3 |
| .................... printf("GeoMet01A\r\n"); |
| 0B2D: MOVLW 0C |
| 0B2E: BCF 03.5 |
| 0B2F: BSF 03.6 |
| 0B30: MOVWF 0D |
| 0B31: MOVLW 00 |
| 0B32: MOVWF 0F |
| 0B33: BCF 0A.3 |
| 0B34: BCF 03.6 |
| 0B35: CALL 030 |
| 0B36: BSF 0A.3 |
| .................... printf("(c) Kaklik 2013\r\n"); |
| 0AA2: MOVLW 12 |
| 0AA3: BSF 03.6 |
| 0AA4: MOVWF 0D |
| 0AA5: MOVLW 00 |
| 0AA6: MOVWF 0F |
| 0AA7: BCF 0A.3 |
| 0AA8: BCF 03.6 |
| 0AA9: CALL 030 |
| 0AAA: BSF 0A.3 |
| 0B37: MOVLW 12 |
| 0B38: BSF 03.6 |
| 0B39: MOVWF 0D |
| 0B3A: MOVLW 00 |
| 0B3B: MOVWF 0F |
| 0B3C: BCF 0A.3 |
| 0B3D: BCF 03.6 |
| 0B3E: CALL 030 |
| 0B3F: BSF 0A.3 |
| .................... printf("www.mlab.cz\r\n"); |
| 0AAB: MOVLW 1B |
| 0AAC: BSF 03.6 |
| 0AAD: MOVWF 0D |
| 0AAE: MOVLW 00 |
| 0AAF: MOVWF 0F |
| 0AB0: BCF 0A.3 |
| 0AB1: BCF 03.6 |
| 0AB2: CALL 030 |
| 0AB3: BSF 0A.3 |
| 0B40: MOVLW 1B |
| 0B41: BSF 03.6 |
| 0B42: MOVWF 0D |
| 0B43: MOVLW 00 |
| 0B44: MOVWF 0F |
| 0B45: BCF 0A.3 |
| 0B46: BCF 03.6 |
| 0B47: CALL 030 |
| 0B48: BSF 0A.3 |
| .................... |
| .................... // Init the HMC5883L. Set Mode register for |
| .................... // continuous measurements. |
| .................... hmc5883l_write_reg(HMC5883L_CFG_A_REG, 0x18); // no average, maximal update range |
| 0B49: CLRF 35 |
| 0B4A: MOVLW 18 |
| 0B4B: MOVWF 36 |
| 0B4C: BCF 0A.3 |
| 0B4D: CALL 0C2 |
| 0B4E: BSF 0A.3 |
| .................... hmc5883l_write_reg(HMC5883L_CFG_B_REG, 0x00); // minimal range |
| 0B4F: MOVLW 01 |
| 0B50: MOVWF 35 |
| 0B51: CLRF 36 |
| 0B52: BCF 0A.3 |
| 0B53: CALL 0C2 |
| 0B54: BSF 0A.3 |
| .................... hmc5883l_write_reg(HMC5883L_MODE_REG, 0x00); |
| 0B55: MOVLW 02 |
| 0B56: MOVWF 35 |
| 0B57: CLRF 36 |
| 0B58: BCF 0A.3 |
| 0B59: CALL 0C2 |
| 0B5A: BSF 0A.3 |
| .................... |
| .................... lcd_init(); |
| 0AB4: BCF 0A.3 |
| 0AB5: CALL 145 |
| 0AB6: BSF 0A.3 |
| 0B5B: BCF 0A.3 |
| 0B5C: CALL 1C8 |
| 0B5D: BSF 0A.3 |
| .................... lcd_putc("(c) Kaklik 2013"); |
| 0AB7: MOVLW 22 |
| 0AB8: BSF 03.6 |
| 0AB9: MOVWF 0D |
| 0ABA: MOVLW 00 |
| 0ABB: MOVWF 0F |
| 0ABC: BCF 0A.3 |
| 0ABD: BCF 03.6 |
| 0ABE: CALL 1BC |
| 0ABF: BSF 0A.3 |
| 0B5E: MOVLW 22 |
| 0B5F: BSF 03.6 |
| 0B60: MOVWF 0D |
| 0B61: MOVLW 00 |
| 0B62: MOVWF 0F |
| 0B63: BCF 0A.3 |
| 0B64: BCF 03.6 |
| 0B65: CALL 23F |
| 0B66: BSF 0A.3 |
| .................... lcd_gotoxy(3,2); |
| 0AC0: MOVLW 03 |
| 0AC1: MOVWF 3D |
| 0AC2: MOVLW 02 |
| 0AC3: MOVWF 3E |
| 0AC4: BCF 0A.3 |
| 0AC5: CALL 17D |
| 0AC6: BSF 0A.3 |
| 0B67: MOVLW 03 |
| 0B68: MOVWF 43 |
| 0B69: MOVLW 02 |
| 0B6A: MOVWF 44 |
| 0B6B: BCF 0A.3 |
| 0B6C: CALL 200 |
| 0B6D: BSF 0A.3 |
| .................... lcd_putc("www.mlab.cz"); |
| 0AC7: MOVLW 2A |
| 0AC8: BSF 03.6 |
| 0AC9: MOVWF 0D |
| 0ACA: MOVLW 00 |
| 0ACB: MOVWF 0F |
| 0ACC: BCF 0A.3 |
| 0ACD: BCF 03.6 |
| 0ACE: CALL 1BC |
| 0ACF: BSF 0A.3 |
| 0B6E: MOVLW 2A |
| 0B6F: BSF 03.6 |
| 0B70: MOVWF 0D |
| 0B71: MOVLW 00 |
| 0B72: MOVWF 0F |
| 0B73: BCF 0A.3 |
| 0B74: BCF 03.6 |
| 0B75: CALL 23F |
| 0B76: BSF 0A.3 |
| .................... Delay_ms(2000); |
| 0AD0: MOVLW 08 |
| 0AD1: MOVWF 2F |
| 0AD2: MOVLW FA |
| 0AD3: MOVWF 3D |
| 0AD4: BCF 0A.3 |
| 0AD5: CALL 078 |
| 0AD6: BSF 0A.3 |
| 0AD7: DECFSZ 2F,F |
| 0AD8: GOTO 2D2 |
| 0B77: MOVLW 08 |
| 0B78: MOVWF 35 |
| 0B79: MOVLW FA |
| 0B7A: MOVWF 43 |
| 0B7B: BCF 0A.3 |
| 0B7C: CALL 0FB |
| 0B7D: BSF 0A.3 |
| 0B7E: DECFSZ 35,F |
| 0B7F: GOTO 379 |
| .................... lcd_init(); |
| 0AD9: BCF 0A.3 |
| 0ADA: CALL 145 |
| 0ADB: BSF 0A.3 |
| 0B80: BCF 0A.3 |
| 0B81: CALL 1C8 |
| 0B82: BSF 0A.3 |
| .................... |
| .................... while (TRUE) |
| .................... { |
| .................... lcd_gotoxy(1,1); |
| 0ADC: MOVLW 01 |
| 0ADD: MOVWF 3D |
| 0ADE: MOVWF 3E |
| 0ADF: BCF 0A.3 |
| 0AE0: CALL 17D |
| 0AE1: BSF 0A.3 |
| 0B83: MOVLW 01 |
| 0B84: MOVWF 43 |
| 0B85: MOVWF 44 |
| 0B86: BCF 0A.3 |
| 0B87: CALL 200 |
| 0B88: BSF 0A.3 |
| .................... temp1 = SHT25_get_temp(); |
| 0AE2: BCF 0A.3 |
| 0AE3: GOTO 52E |
| 0AE4: BSF 0A.3 |
| 0AE5: MOVF 7A,W |
| 0AE6: MOVWF 24 |
| 0AE7: MOVF 79,W |
| 0AE8: MOVWF 23 |
| 0AE9: MOVF 78,W |
| 0AEA: MOVWF 22 |
| 0AEB: MOVF 77,W |
| 0AEC: MOVWF 21 |
| 0B89: BCF 0A.3 |
| 0B8A: GOTO 567 |
| 0B8B: BSF 0A.3 |
| 0B8C: MOVF 7A,W |
| 0B8D: MOVWF 2A |
| 0B8E: MOVF 79,W |
| 0B8F: MOVWF 29 |
| 0B90: MOVF 78,W |
| 0B91: MOVWF 28 |
| 0B92: MOVF 77,W |
| 0B93: MOVWF 27 |
| .................... humidity = SHT25_get_hum(); |
| 0AED: BCF 0A.3 |
| 0AEE: GOTO 5FD |
| 0AEF: BSF 0A.3 |
| 0AF0: MOVF 7A,W |
| 0AF1: MOVWF 2C |
| 0AF2: MOVF 79,W |
| 0AF3: MOVWF 2B |
| 0AF4: MOVF 78,W |
| 0AF5: MOVWF 2A |
| 0AF6: MOVF 77,W |
| 0AF7: MOVWF 29 |
| .................... temp2= LTS01_get_temp(); |
| 0AF8: BCF 0A.3 |
| 0AF9: GOTO 6B3 |
| 0AFA: BSF 0A.3 |
| 0AFB: MOVF 7A,W |
| 0AFC: MOVWF 28 |
| 0AFD: MOVF 79,W |
| 0AFE: MOVWF 27 |
| 0AFF: MOVF 78,W |
| 0B00: MOVWF 26 |
| 0B01: MOVF 77,W |
| 0B02: MOVWF 25 |
| .................... |
| .................... printf(lcd_putc,"%f C %f \%% \r\n",temp1, humidity); |
| 0B03: MOVLW 89 |
| 0B04: MOVWF 04 |
| 0B05: MOVF 24,W |
| 0B06: MOVWF 32 |
| 0B07: MOVF 23,W |
| 0B08: MOVWF 31 |
| 0B09: MOVF 22,W |
| 0B0A: MOVWF 30 |
| 0B0B: MOVF 21,W |
| 0B0C: MOVWF 2F |
| 0B0D: MOVLW 02 |
| 0B0E: MOVWF 33 |
| 0B0F: CALL 000 |
| 0B10: MOVLW 20 |
| 0B11: MOVWF 3C |
| 0B12: BCF 0A.3 |
| 0B13: CALL 18F |
| 0B14: BSF 0A.3 |
| 0B15: MOVLW 43 |
| 0B16: MOVWF 3C |
| 0B17: BCF 0A.3 |
| 0B18: CALL 18F |
| 0B19: BSF 0A.3 |
| 0B1A: MOVLW 20 |
| 0B1B: MOVWF 3C |
| 0B1C: BCF 0A.3 |
| 0B1D: CALL 18F |
| 0B1E: BSF 0A.3 |
| 0B1F: MOVLW 89 |
| 0B20: MOVWF 04 |
| 0B21: MOVF 2C,W |
| 0B22: MOVWF 32 |
| 0B23: MOVF 2B,W |
| 0B24: MOVWF 31 |
| 0B25: MOVF 2A,W |
| 0B26: MOVWF 30 |
| 0B27: MOVF 29,W |
| 0B28: MOVWF 2F |
| 0B29: MOVLW 02 |
| 0B2A: MOVWF 33 |
| 0B2B: CALL 000 |
| 0B2C: MOVLW 20 |
| 0B2D: MOVWF 3C |
| 0B2E: BCF 0A.3 |
| 0B2F: CALL 18F |
| 0B30: BSF 0A.3 |
| 0B31: MOVLW 25 |
| 0B32: MOVWF 3C |
| 0B33: BCF 0A.3 |
| 0B34: CALL 18F |
| 0B35: BSF 0A.3 |
| 0B36: MOVLW 20 |
| 0B37: MOVWF 3C |
| 0B38: BCF 0A.3 |
| 0B39: CALL 18F |
| 0B3A: BSF 0A.3 |
| 0B3B: MOVLW 0D |
| 0B3C: MOVWF 3C |
| 0B3D: BCF 0A.3 |
| 0B3E: CALL 18F |
| 0B3F: BSF 0A.3 |
| 0B40: MOVLW 0A |
| 0B41: MOVWF 3C |
| 0B42: BCF 0A.3 |
| 0B43: CALL 18F |
| 0B44: BSF 0A.3 |
| .................... lcd_gotoxy(1,2); |
| 0B45: MOVLW 01 |
| 0B46: MOVWF 3D |
| 0B47: MOVLW 02 |
| 0B48: MOVWF 3E |
| 0B49: BCF 0A.3 |
| 0B4A: CALL 17D |
| 0B4B: BSF 0A.3 |
| .................... printf(lcd_putc," %f C",temp2); |
| 0B4C: MOVLW 20 |
| 0B4D: MOVWF 3C |
| 0B4E: BCF 0A.3 |
| 0B4F: CALL 18F |
| 0B50: BSF 0A.3 |
| 0B51: MOVLW 89 |
| 0B52: MOVWF 04 |
| 0B53: MOVF 28,W |
| 0B54: MOVWF 32 |
| 0B55: MOVF 27,W |
| 0B56: MOVWF 31 |
| 0B57: MOVF 26,W |
| 0B58: MOVWF 30 |
| 0B59: MOVF 25,W |
| 0B5A: MOVWF 2F |
| 0B5B: MOVLW 02 |
| 0B5C: MOVWF 33 |
| 0B5D: CALL 000 |
| 0B5E: MOVLW 20 |
| 0B5F: MOVWF 3C |
| 0B60: BCF 0A.3 |
| 0B61: CALL 18F |
| 0B62: BSF 0A.3 |
| 0B63: MOVLW 43 |
| 0B64: MOVWF 3C |
| 0B65: BCF 0A.3 |
| 0B66: CALL 18F |
| 0B67: BSF 0A.3 |
| .................... printf("%ld %f %f %f \r\n",i, temp1, humidity, temp2); |
| 0B68: MOVLW 10 |
| 0B69: MOVWF 04 |
| 0B6A: MOVF 2E,W |
| 0B6B: MOVWF 30 |
| 0B6C: MOVF 2D,W |
| 0B6D: MOVWF 2F |
| 0B6E: GOTO 0DA |
| 0B6F: MOVLW 20 |
| 0B70: BTFSS 0C.4 |
| 0B71: GOTO 370 |
| 0B72: MOVWF 19 |
| 0B73: MOVLW 89 |
| 0B74: MOVWF 04 |
| 0B75: MOVF 24,W |
| 0B76: MOVWF 32 |
| 0B77: MOVF 23,W |
| 0B78: MOVWF 31 |
| 0B79: MOVF 22,W |
| 0B7A: MOVWF 30 |
| 0B7B: MOVF 21,W |
| 0B7C: MOVWF 2F |
| 0B7D: MOVLW 02 |
| 0B7E: MOVWF 33 |
| 0B7F: CALL 152 |
| 0B80: MOVLW 20 |
| 0B81: BTFSS 0C.4 |
| 0B82: GOTO 381 |
| 0B83: MOVWF 19 |
| 0B84: MOVLW 89 |
| 0B85: MOVWF 04 |
| 0B86: MOVF 2C,W |
| 0B87: MOVWF 32 |
| 0B88: MOVF 2B,W |
| 0B89: MOVWF 31 |
| 0B8A: MOVF 2A,W |
| 0B8B: MOVWF 30 |
| 0B8C: MOVF 29,W |
| 0B8D: MOVWF 2F |
| 0B8E: MOVLW 02 |
| 0B8F: MOVWF 33 |
| 0B90: CALL 152 |
| 0B91: MOVLW 20 |
| 0B92: BTFSS 0C.4 |
| 0B93: GOTO 392 |
| 0B94: MOVWF 19 |
| 0B95: MOVLW 89 |
| 0B96: MOVWF 04 |
| 0B97: MOVF 28,W |
| 0B94: BCF 0A.3 |
| 0B95: GOTO 636 |
| 0B96: BSF 0A.3 |
| 0B97: MOVF 7A,W |
| 0B98: MOVWF 32 |
| 0B99: MOVF 27,W |
| 0B99: MOVF 79,W |
| 0B9A: MOVWF 31 |
| 0B9B: MOVF 26,W |
| 0B9B: MOVF 78,W |
| 0B9C: MOVWF 30 |
| 0B9D: MOVF 25,W |
| 0B9D: MOVF 77,W |
| 0B9E: MOVWF 2F |
| 0B9F: MOVLW 02 |
| 0BA0: MOVWF 33 |
| 0BA1: CALL 152 |
| 0BA2: MOVLW 20 |
| 0BA3: BTFSS 0C.4 |
| 0BA4: GOTO 3A3 |
| 0BA5: MOVWF 19 |
| 0BA6: MOVLW 0D |
| 0BA7: BTFSS 0C.4 |
| 0BA8: GOTO 3A7 |
| 0BA9: MOVWF 19 |
| 0BAA: MOVLW 0A |
| 0BAB: BTFSS 0C.4 |
| 0BAC: GOTO 3AB |
| 0BAD: MOVWF 19 |
| .................... temp2= LTS01_get_temp(); |
| 0B9F: BCF 0A.3 |
| 0BA0: GOTO 6EC |
| 0BA1: BSF 0A.3 |
| 0BA2: MOVF 7A,W |
| 0BA3: MOVWF 2E |
| 0BA4: MOVF 79,W |
| 0BA5: MOVWF 2D |
| 0BA6: MOVF 78,W |
| 0BA7: MOVWF 2C |
| 0BA8: MOVF 77,W |
| 0BA9: MOVWF 2B |
| .................... hmc5883l_read_data(); |
| 0BAA: GOTO 000 |
| .................... |
| .................... printf(lcd_putc,"%f C %f \%%",temp1, humidity); |
| 0BAB: MOVLW 89 |
| 0BAC: MOVWF 04 |
| 0BAD: MOVF 2A,W |
| 0BAE: MOVWF 38 |
| 0BAF: MOVF 29,W |
| 0BB0: MOVWF 37 |
| 0BB1: MOVF 28,W |
| 0BB2: MOVWF 36 |
| 0BB3: MOVF 27,W |
| 0BB4: MOVWF 35 |
| 0BB5: MOVLW 02 |
| 0BB6: MOVWF 39 |
| 0BB7: CALL 091 |
| 0BB8: MOVLW 20 |
| 0BB9: MOVWF 42 |
| 0BBA: BCF 0A.3 |
| 0BBB: CALL 212 |
| 0BBC: BSF 0A.3 |
| 0BBD: MOVLW 43 |
| 0BBE: MOVWF 42 |
| 0BBF: BCF 0A.3 |
| 0BC0: CALL 212 |
| 0BC1: BSF 0A.3 |
| 0BC2: MOVLW 20 |
| 0BC3: MOVWF 42 |
| 0BC4: BCF 0A.3 |
| 0BC5: CALL 212 |
| 0BC6: BSF 0A.3 |
| 0BC7: MOVLW 89 |
| 0BC8: MOVWF 04 |
| 0BC9: MOVF 32,W |
| 0BCA: MOVWF 38 |
| 0BCB: MOVF 31,W |
| 0BCC: MOVWF 37 |
| 0BCD: MOVF 30,W |
| 0BCE: MOVWF 36 |
| 0BCF: MOVF 2F,W |
| 0BD0: MOVWF 35 |
| 0BD1: MOVLW 02 |
| 0BD2: MOVWF 39 |
| 0BD3: CALL 091 |
| 0BD4: MOVLW 20 |
| 0BD5: MOVWF 42 |
| 0BD6: BCF 0A.3 |
| 0BD7: CALL 212 |
| 0BD8: BSF 0A.3 |
| 0BD9: MOVLW 25 |
| 0BDA: MOVWF 42 |
| 0BDB: BCF 0A.3 |
| 0BDC: CALL 212 |
| 0BDD: BSF 0A.3 |
| .................... lcd_gotoxy(1,2); |
| 0BDE: MOVLW 01 |
| 0BDF: MOVWF 43 |
| 0BE0: MOVLW 02 |
| 0BE1: MOVWF 44 |
| 0BE2: BCF 0A.3 |
| 0BE3: CALL 200 |
| 0BE4: BSF 0A.3 |
| .................... printf(lcd_putc," %f C",temp2); |
| 0BE5: MOVLW 20 |
| 0BE6: MOVWF 42 |
| 0BE7: BCF 0A.3 |
| 0BE8: CALL 212 |
| 0BE9: BSF 0A.3 |
| 0BEA: MOVLW 89 |
| 0BEB: MOVWF 04 |
| 0BEC: MOVF 2E,W |
| 0BED: MOVWF 38 |
| 0BEE: MOVF 2D,W |
| 0BEF: MOVWF 37 |
| 0BF0: MOVF 2C,W |
| 0BF1: MOVWF 36 |
| 0BF2: MOVF 2B,W |
| 0BF3: MOVWF 35 |
| 0BF4: MOVLW 02 |
| 0BF5: MOVWF 39 |
| 0BF6: CALL 091 |
| 0BF7: MOVLW 20 |
| 0BF8: MOVWF 42 |
| 0BF9: BCF 0A.3 |
| 0BFA: CALL 212 |
| 0BFB: BSF 0A.3 |
| 0BFC: MOVLW 43 |
| 0BFD: MOVWF 42 |
| 0BFE: BCF 0A.3 |
| 0BFF: CALL 212 |
| 0C00: BSF 0A.3 |
| .................... printf("%ld %f %f %f ",i, temp1, humidity, temp2); |
| 0C01: MOVLW 10 |
| 0C02: MOVWF 04 |
| 0C03: MOVF 34,W |
| 0C04: MOVWF 36 |
| 0C05: MOVF 33,W |
| 0C06: MOVWF 35 |
| 0C07: CALL 16B |
| 0C08: MOVLW 20 |
| 0C09: BTFSS 0C.4 |
| 0C0A: GOTO 409 |
| 0C0B: MOVWF 19 |
| 0C0C: MOVLW 89 |
| 0C0D: MOVWF 04 |
| 0C0E: MOVF 2A,W |
| 0C0F: MOVWF 38 |
| 0C10: MOVF 29,W |
| 0C11: MOVWF 37 |
| 0C12: MOVF 28,W |
| 0C13: MOVWF 36 |
| 0C14: MOVF 27,W |
| 0C15: MOVWF 35 |
| 0C16: MOVLW 02 |
| 0C17: MOVWF 39 |
| 0C18: CALL 1E1 |
| 0C19: MOVLW 20 |
| 0C1A: BTFSS 0C.4 |
| 0C1B: GOTO 41A |
| 0C1C: MOVWF 19 |
| 0C1D: MOVLW 89 |
| 0C1E: MOVWF 04 |
| 0C1F: MOVF 32,W |
| 0C20: MOVWF 38 |
| 0C21: MOVF 31,W |
| 0C22: MOVWF 37 |
| 0C23: MOVF 30,W |
| 0C24: MOVWF 36 |
| 0C25: MOVF 2F,W |
| 0C26: MOVWF 35 |
| 0C27: MOVLW 02 |
| 0C28: MOVWF 39 |
| 0C29: CALL 1E1 |
| 0C2A: MOVLW 20 |
| 0C2B: BTFSS 0C.4 |
| 0C2C: GOTO 42B |
| 0C2D: MOVWF 19 |
| 0C2E: MOVLW 89 |
| 0C2F: MOVWF 04 |
| 0C30: MOVF 2E,W |
| 0C31: MOVWF 38 |
| 0C32: MOVF 2D,W |
| 0C33: MOVWF 37 |
| 0C34: MOVF 2C,W |
| 0C35: MOVWF 36 |
| 0C36: MOVF 2B,W |
| 0C37: MOVWF 35 |
| 0C38: MOVLW 02 |
| 0C39: MOVWF 39 |
| 0C3A: CALL 1E1 |
| 0C3B: MOVLW 20 |
| 0C3C: BTFSS 0C.4 |
| 0C3D: GOTO 43C |
| 0C3E: MOVWF 19 |
| .................... printf("%Ld %Ld %Ld \n\r", compass.x, compass.y, compass.z); |
| 0C3F: MOVLW 10 |
| 0C40: MOVWF 04 |
| 0C41: MOVF 22,W |
| 0C42: MOVWF 36 |
| 0C43: MOVF 21,W |
| 0C44: MOVWF 35 |
| 0C45: CALL 16B |
| 0C46: MOVLW 20 |
| 0C47: BTFSS 0C.4 |
| 0C48: GOTO 447 |
| 0C49: MOVWF 19 |
| 0C4A: MOVLW 10 |
| 0C4B: MOVWF 04 |
| 0C4C: MOVF 24,W |
| 0C4D: MOVWF 36 |
| 0C4E: MOVF 23,W |
| 0C4F: MOVWF 35 |
| 0C50: CALL 16B |
| 0C51: MOVLW 20 |
| 0C52: BTFSS 0C.4 |
| 0C53: GOTO 452 |
| 0C54: MOVWF 19 |
| 0C55: MOVLW 10 |
| 0C56: MOVWF 04 |
| 0C57: MOVF 26,W |
| 0C58: MOVWF 36 |
| 0C59: MOVF 25,W |
| 0C5A: MOVWF 35 |
| 0C5B: CALL 16B |
| 0C5C: MOVLW 20 |
| 0C5D: BTFSS 0C.4 |
| 0C5E: GOTO 45D |
| 0C5F: MOVWF 19 |
| 0C60: MOVLW 0A |
| 0C61: BTFSS 0C.4 |
| 0C62: GOTO 461 |
| 0C63: MOVWF 19 |
| 0C64: MOVLW 0D |
| 0C65: BTFSS 0C.4 |
| 0C66: GOTO 465 |
| 0C67: MOVWF 19 |
| .................... i++; |
| 0BAE: INCF 2D,F |
| 0BAF: BTFSC 03.2 |
| 0BB0: INCF 2E,F |
| 0C68: INCF 33,F |
| 0C69: BTFSC 03.2 |
| 0C6A: INCF 34,F |
| .................... Delay_ms(100); |
| 0BB1: MOVLW 64 |
| 0BB2: MOVWF 3D |
| 0BB3: BCF 0A.3 |
| 0BB4: CALL 078 |
| 0BB5: BSF 0A.3 |
| 0C6B: MOVLW 64 |
| 0C6C: MOVWF 43 |
| 0C6D: BCF 0A.3 |
| 0C6E: CALL 0FB |
| 0C6F: BSF 0A.3 |
| .................... } |
| 0BB6: GOTO 2DC |
| 0C70: GOTO 383 |
| .................... |
| .................... } |
| 0BB7: SLEEP |
| 0C71: SLEEP |
| |
| Configuration Fuses: |
| Word 1: 2CF5 INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG |