0,0 → 1,5327 |
CCS PCM C Compiler, Version 4.106, 47914 10-IX-13 13:59 |
|
Filename: Z:\home\kaklik\svnMLAB\Designs\Measuring_instruments\GeoMet01A\SW\PIC16F887\main.lst |
|
ROM used: 3809 words (46%) |
Largest free fragment is 2048 |
RAM used: 35 (10%) at main() level |
72 (20%) worst case |
Stack: 5 locations |
|
* |
0000: MOVLW 0C |
0001: MOVWF 0A |
0002: GOTO 4E5 |
0003: NOP |
.................... #include "main.h" |
.................... #include <16F887.h> |
.................... //////// Standard Header file for the PIC16F887 device //////////////// |
.................... #device PIC16F887 |
.................... #list |
.................... |
.................... #device adc=10 |
.................... |
.................... #FUSES NOWDT //No Watch Dog Timer |
.................... #FUSES INTRC //Internal RC Osc |
.................... #FUSES NOPUT //No Power Up Timer |
.................... #FUSES MCLR //Master Clear pin enabled |
.................... #FUSES NOPROTECT //Code not protected from reading |
.................... #FUSES NOCPD //No EE protection |
.................... #FUSES NOBROWNOUT //No brownout reset |
.................... #FUSES IESO //Internal External Switch Over mode enabled |
.................... #FUSES FCMEN //Fail-safe clock monitor enabled |
.................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O |
.................... #FUSES NODEBUG //No Debug mode for ICD |
.................... #FUSES NOWRT //Program memory not write protected |
.................... #FUSES BORV40 //Brownout reset at 4.0V |
.................... |
.................... #use delay(clock=8000000) |
* |
00FB: MOVLW 4B |
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) |
* |
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 4E,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 4F |
0287: MOVF 77,W |
0288: MOVWF 50 |
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 4F,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 50,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) |
.................... |
.................... |
.................... |
.................... #define LCD_ENABLE_PIN PIN_E0 //// |
.................... #define LCD_RS_PIN PIN_E1 //// |
.................... #define LCD_RW_PIN PIN_E2 //// |
.................... #define LCD_DATA4 PIN_D4 //// |
.................... #define LCD_DATA5 PIN_D5 //// |
.................... #define LCD_DATA6 PIN_D6 //// |
.................... #define LCD_DATA7 PIN_D7 |
.................... #include <lcd.c> |
.................... /////////////////////////////////////////////////////////////////////////////// |
.................... //// LCD.C //// |
.................... //// Driver for common LCD modules //// |
.................... //// //// |
.................... //// lcd_init() Must be called before any other function. //// |
.................... //// //// |
.................... //// lcd_putc(c) Will display c on the next position of the LCD. //// |
.................... //// \a Set cursor position to upper left //// |
.................... //// \f Clear display, set cursor to upper left //// |
.................... //// \n Go to start of second line //// |
.................... //// \b Move back one position //// |
.................... //// If LCD_EXTENDED_NEWLINE is defined, the \n character //// |
.................... //// will erase all remanining characters on the current //// |
.................... //// line, and move the cursor to the beginning of the next //// |
.................... //// line. //// |
.................... //// If LCD_EXTENDED_NEWLINE is defined, the \r character //// |
.................... //// will move the cursor to the start of the current //// |
.................... //// line. //// |
.................... //// //// |
.................... //// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) //// |
.................... //// //// |
.................... //// lcd_getc(x,y) Returns character at position x,y on LCD //// |
.................... //// //// |
.................... //// CONFIGURATION //// |
.................... //// The LCD can be configured in one of two ways: a.) port access or //// |
.................... //// b.) pin access. Port access requires the entire 7 bit interface //// |
.................... //// connected to one GPIO port, and the data bits (D4:D7 of the LCD) //// |
.................... //// connected to sequential pins on the GPIO. Pin access //// |
.................... //// has no requirements, all 7 bits of the control interface can //// |
.................... //// can be connected to any GPIO using several ports. //// |
.................... //// //// |
.................... //// To use port access, #define LCD_DATA_PORT to the SFR location of //// |
.................... //// of the GPIO port that holds the interface, -AND- edit LCD_PIN_MAP //// |
.................... //// of this file to configure the pin order. If you are using a //// |
.................... //// baseline PIC (PCB), then LCD_OUTPUT_MAP and LCD_INPUT_MAP also must //// |
.................... //// be defined. //// |
.................... //// //// |
.................... //// Example of port access: //// |
.................... //// #define LCD_DATA_PORT getenv("SFR:PORTD") //// |
.................... //// //// |
.................... //// To use pin access, the following pins must be defined: //// |
.................... //// LCD_ENABLE_PIN //// |
.................... //// LCD_RS_PIN //// |
.................... //// LCD_RW_PIN //// |
.................... //// LCD_DATA4 //// |
.................... //// LCD_DATA5 //// |
.................... //// LCD_DATA6 //// |
.................... //// LCD_DATA7 //// |
.................... //// //// |
.................... //// Example of pin access: //// |
.................... //// #define LCD_ENABLE_PIN PIN_E0 //// |
.................... //// #define LCD_RS_PIN PIN_E1 //// |
.................... //// #define LCD_RW_PIN PIN_E2 //// |
.................... //// #define LCD_DATA4 PIN_D4 //// |
.................... //// #define LCD_DATA5 PIN_D5 //// |
.................... //// #define LCD_DATA6 PIN_D6 //// |
.................... //// #define LCD_DATA7 PIN_D7 //// |
.................... //// //// |
.................... /////////////////////////////////////////////////////////////////////////////// |
.................... //// (C) Copyright 1996,2010 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. //// |
.................... /////////////////////////////////////////////////////////////////////////// |
.................... |
.................... // define the pinout. |
.................... // only required if port access is being used. |
.................... typedef struct |
.................... { // This structure is overlayed |
.................... BOOLEAN enable; // on to an I/O port to gain |
.................... BOOLEAN rs; // access to the LCD pins. |
.................... BOOLEAN rw; // The bits are allocated from |
.................... BOOLEAN unused; // low order up. ENABLE will |
.................... int data : 4; // be LSB pin of that port. |
.................... #if defined(__PCD__) // The port used will be LCD_DATA_PORT. |
.................... int reserved: 8; |
.................... #endif |
.................... } LCD_PIN_MAP; |
.................... |
.................... // this is to improve compatability with previous LCD drivers that accepted |
.................... // a define labeled 'use_portb_lcd' that configured the LCD onto port B. |
.................... #if ((defined(use_portb_lcd)) && (use_portb_lcd==TRUE)) |
.................... #define LCD_DATA_PORT getenv("SFR:PORTB") |
.................... #endif |
.................... |
.................... #if defined(__PCB__) |
.................... // these definitions only need to be modified for baseline PICs. |
.................... // all other PICs use LCD_PIN_MAP or individual LCD_xxx pin definitions. |
.................... /* EN, RS, RW, UNUSED, DATA */ |
.................... const LCD_PIN_MAP LCD_OUTPUT_MAP = {0, 0, 0, 0, 0}; |
.................... const LCD_PIN_MAP LCD_INPUT_MAP = {0, 0, 0, 0, 0xF}; |
.................... #endif |
.................... |
.................... ////////////////////// END CONFIGURATION /////////////////////////////////// |
.................... |
.................... #ifndef LCD_ENABLE_PIN |
.................... #define lcd_output_enable(x) lcdlat.enable=x |
.................... #define lcd_enable_tris() lcdtris.enable=0 |
.................... #else |
.................... #define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x) |
.................... #define lcd_enable_tris() output_drive(LCD_ENABLE_PIN) |
.................... #endif |
.................... |
.................... #ifndef LCD_RS_PIN |
.................... #define lcd_output_rs(x) lcdlat.rs=x |
.................... #define lcd_rs_tris() lcdtris.rs=0 |
.................... #else |
.................... #define lcd_output_rs(x) output_bit(LCD_RS_PIN, x) |
.................... #define lcd_rs_tris() output_drive(LCD_RS_PIN) |
.................... #endif |
.................... |
.................... #ifndef LCD_RW_PIN |
.................... #define lcd_output_rw(x) lcdlat.rw=x |
.................... #define lcd_rw_tris() lcdtris.rw=0 |
.................... #else |
.................... #define lcd_output_rw(x) output_bit(LCD_RW_PIN, x) |
.................... #define lcd_rw_tris() output_drive(LCD_RW_PIN) |
.................... #endif |
.................... |
.................... // original version of this library incorrectly labeled LCD_DATA0 as LCD_DATA4, |
.................... // LCD_DATA1 as LCD_DATA5, and so on. this block of code makes the driver |
.................... // compatible with any code written for the original library |
.................... #if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3) && !defined(LCD_DATA4) && !defined(LCD_DATA5) && !defined(LCD_DATA6) && !defined(LCD_DATA7)) |
.................... #define LCD_DATA4 LCD_DATA0 |
.................... #define LCD_DATA5 LCD_DATA1 |
.................... #define LCD_DATA6 LCD_DATA2 |
.................... #define LCD_DATA7 LCD_DATA3 |
.................... #endif |
.................... |
.................... #ifndef LCD_DATA4 |
.................... #ifndef LCD_DATA_PORT |
.................... #if defined(__PCB__) |
.................... #define LCD_DATA_PORT 0x06 //portb |
.................... #define set_tris_lcd(x) set_tris_b(x) |
.................... #else |
.................... #if defined(PIN_D0) |
.................... #define LCD_DATA_PORT getenv("SFR:PORTD") //portd |
.................... #else |
.................... #define LCD_DATA_PORT getenv("SFR:PORTB") //portb |
.................... #endif |
.................... #endif |
.................... #endif |
.................... |
.................... #if defined(__PCB__) |
.................... LCD_PIN_MAP lcd, lcdlat; |
.................... #byte lcd = LCD_DATA_PORT |
.................... #byte lcdlat = LCD_DATA_PORT |
.................... #elif defined(__PCM__) |
.................... LCD_PIN_MAP lcd, lcdlat, lcdtris; |
.................... #byte lcd = LCD_DATA_PORT |
.................... #byte lcdlat = LCD_DATA_PORT |
.................... #byte lcdtris = LCD_DATA_PORT+0x80 |
.................... #elif defined(__PCH__) |
.................... LCD_PIN_MAP lcd, lcdlat, lcdtris; |
.................... #byte lcd = LCD_DATA_PORT |
.................... #byte lcdlat = LCD_DATA_PORT+9 |
.................... #byte lcdtris = LCD_DATA_PORT+0x12 |
.................... #elif defined(__PCD__) |
.................... LCD_PIN_MAP lcd, lcdlat, lcdtris; |
.................... #word lcd = LCD_DATA_PORT |
.................... #word lcdlat = LCD_DATA_PORT+2 |
.................... #word lcdtris = LCD_DATA_PORT-0x02 |
.................... #endif |
.................... #endif //LCD_DATA4 not defined |
.................... |
.................... #ifndef LCD_TYPE |
.................... #define LCD_TYPE 2 // 0=5x7, 1=5x10, 2=2 lines |
.................... #endif |
.................... |
.................... #ifndef LCD_LINE_TWO |
.................... #define LCD_LINE_TWO 0x40 // LCD RAM address for the second line |
.................... #endif |
.................... |
.................... #ifndef LCD_LINE_LENGTH |
.................... #define LCD_LINE_LENGTH 20 |
.................... #endif |
.................... |
.................... BYTE const LCD_INIT_STRING[4] = {0x20 | (LCD_TYPE << 2), 0xc, 1, 6}; |
.................... // These bytes need to be sent to the LCD |
.................... // to start it up. |
.................... |
.................... BYTE lcd_read_nibble(void); |
.................... |
.................... BYTE lcd_read_byte(void) |
.................... { |
.................... BYTE low,high; |
.................... |
.................... #if defined(__PCB__) |
.................... set_tris_lcd(LCD_INPUT_MAP); |
.................... #else |
.................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
.................... output_float(LCD_DATA4); |
* |
0174: BSF 08.4 |
.................... output_float(LCD_DATA5); |
0175: BSF 08.5 |
.................... output_float(LCD_DATA6); |
0176: BSF 08.6 |
.................... output_float(LCD_DATA7); |
0177: BSF 08.7 |
.................... #else |
.................... lcdtris.data = 0xF; |
.................... #endif |
.................... #endif |
.................... |
.................... lcd_output_rw(1); |
0178: BCF 03.5 |
0179: BSF 09.2 |
017A: BSF 03.5 |
017B: BCF 09.2 |
.................... delay_cycles(1); |
017C: NOP |
.................... lcd_output_enable(1); |
017D: BCF 03.5 |
017E: BSF 09.0 |
017F: BSF 03.5 |
0180: BCF 09.0 |
.................... delay_cycles(1); |
0181: NOP |
.................... high = lcd_read_nibble(); |
0182: BCF 03.5 |
0183: CALL 13B |
0184: MOVF 78,W |
0185: MOVWF 52 |
.................... |
.................... lcd_output_enable(0); |
0186: BCF 09.0 |
0187: BSF 03.5 |
0188: BCF 09.0 |
.................... delay_cycles(1); |
0189: NOP |
.................... lcd_output_enable(1); |
018A: BCF 03.5 |
018B: BSF 09.0 |
018C: BSF 03.5 |
018D: BCF 09.0 |
.................... delay_us(1); |
018E: GOTO 18F |
.................... low = lcd_read_nibble(); |
018F: BCF 03.5 |
0190: CALL 13B |
0191: MOVF 78,W |
0192: MOVWF 51 |
.................... |
.................... lcd_output_enable(0); |
0193: BCF 09.0 |
0194: BSF 03.5 |
0195: BCF 09.0 |
.................... |
.................... #if defined(__PCB__) |
.................... set_tris_lcd(LCD_OUTPUT_MAP); |
.................... #else |
.................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
.................... output_drive(LCD_DATA4); |
0196: BCF 08.4 |
.................... output_drive(LCD_DATA5); |
0197: BCF 08.5 |
.................... output_drive(LCD_DATA6); |
0198: BCF 08.6 |
.................... output_drive(LCD_DATA7); |
0199: BCF 08.7 |
.................... #else |
.................... lcdtris.data = 0x0; |
.................... #endif |
.................... #endif |
.................... |
.................... return( (high<<4) | low); |
019A: BCF 03.5 |
019B: SWAPF 52,W |
019C: MOVWF 77 |
019D: MOVLW F0 |
019E: ANDWF 77,F |
019F: MOVF 77,W |
01A0: IORWF 51,W |
01A1: MOVWF 78 |
.................... } |
.................... |
.................... BYTE lcd_read_nibble(void) |
.................... { |
.................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
* |
013B: CLRF 53 |
.................... BYTE n = 0x00; |
.................... |
.................... /* Read the data port */ |
.................... n |= input(LCD_DATA4); |
013C: BSF 03.5 |
013D: BSF 08.4 |
013E: MOVLW 00 |
013F: BCF 03.5 |
0140: BTFSC 08.4 |
0141: MOVLW 01 |
0142: IORWF 53,F |
.................... n |= input(LCD_DATA5) << 1; |
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 53,F |
.................... n |= input(LCD_DATA6) << 2; |
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 53,F |
.................... n |= input(LCD_DATA7) << 3; |
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 53,F |
.................... |
.................... return(n); |
0169: MOVF 53,W |
016A: MOVWF 78 |
.................... #else |
.................... return(lcd.data); |
.................... #endif |
.................... } |
016B: RETURN |
.................... |
.................... void lcd_send_nibble(BYTE n) |
.................... { |
.................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
.................... /* Write to the data port */ |
.................... output_bit(LCD_DATA4, bit_test(n, 0)); |
* |
010F: BTFSC 52.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)); |
0116: BCF 03.5 |
0117: BTFSC 52.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)); |
011E: BCF 03.5 |
011F: BTFSC 52.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)); |
0126: BCF 03.5 |
0127: BTFSC 52.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); |
012E: NOP |
.................... lcd_output_enable(1); |
012F: BCF 03.5 |
0130: BSF 09.0 |
0131: BSF 03.5 |
0132: BCF 09.0 |
.................... delay_us(2); |
0133: GOTO 134 |
0134: GOTO 135 |
.................... lcd_output_enable(0); |
0135: BCF 03.5 |
0136: BCF 09.0 |
0137: BSF 03.5 |
0138: BCF 09.0 |
.................... } |
0139: BCF 03.5 |
013A: RETURN |
.................... |
.................... void lcd_send_byte(BYTE address, BYTE n) |
.................... { |
.................... #if defined(__PCB__) |
.................... set_tris_lcd(LCD_OUTPUT_MAP); |
.................... #else |
.................... lcd_enable_tris(); |
* |
016C: BSF 03.5 |
016D: BCF 09.0 |
.................... lcd_rs_tris(); |
016E: BCF 09.1 |
.................... lcd_rw_tris(); |
016F: BCF 09.2 |
.................... #endif |
.................... |
.................... lcd_output_rs(0); |
0170: BCF 03.5 |
0171: BCF 09.1 |
0172: BSF 03.5 |
0173: BCF 09.1 |
.................... while ( bit_test(lcd_read_byte(),7) ) ; |
* |
01A2: MOVF 78,W |
01A3: MOVWF 51 |
01A4: BTFSS 51.7 |
01A5: GOTO 1A8 |
01A6: BSF 03.5 |
01A7: GOTO 174 |
.................... lcd_output_rs(address); |
01A8: MOVF 4F,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); |
01B0: NOP |
.................... lcd_output_rw(0); |
01B1: BCF 03.5 |
01B2: BCF 09.2 |
01B3: BSF 03.5 |
01B4: BCF 09.2 |
.................... delay_cycles(1); |
01B5: NOP |
.................... lcd_output_enable(0); |
01B6: BCF 03.5 |
01B7: BCF 09.0 |
01B8: BSF 03.5 |
01B9: BCF 09.0 |
.................... lcd_send_nibble(n >> 4); |
01BA: BCF 03.5 |
01BB: SWAPF 50,W |
01BC: MOVWF 51 |
01BD: MOVLW 0F |
01BE: ANDWF 51,F |
01BF: MOVF 51,W |
01C0: MOVWF 52 |
01C1: CALL 10F |
.................... lcd_send_nibble(n & 0xf); |
01C2: MOVF 50,W |
01C3: ANDLW 0F |
01C4: MOVWF 51 |
01C5: MOVWF 52 |
01C6: CALL 10F |
.................... } |
01C7: RETURN |
.................... |
.................... #if defined(LCD_EXTENDED_NEWLINE) |
.................... unsigned int8 g_LcdX, g_LcdY; |
.................... #endif |
.................... |
.................... void lcd_init(void) |
.................... { |
.................... BYTE i; |
.................... |
.................... #if defined(__PCB__) |
.................... set_tris_lcd(LCD_OUTPUT_MAP); |
.................... #else |
.................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7)) |
.................... output_drive(LCD_DATA4); |
01C8: BSF 03.5 |
01C9: BCF 08.4 |
.................... output_drive(LCD_DATA5); |
01CA: BCF 08.5 |
.................... output_drive(LCD_DATA6); |
01CB: BCF 08.6 |
.................... output_drive(LCD_DATA7); |
01CC: BCF 08.7 |
.................... #else |
.................... lcdtris.data = 0x0; |
.................... #endif |
.................... lcd_enable_tris(); |
01CD: BCF 09.0 |
.................... lcd_rs_tris(); |
01CE: BCF 09.1 |
.................... lcd_rw_tris(); |
01CF: BCF 09.2 |
.................... #endif |
.................... |
.................... lcd_output_rs(0); |
01D0: BCF 03.5 |
01D1: BCF 09.1 |
01D2: BSF 03.5 |
01D3: BCF 09.1 |
.................... lcd_output_rw(0); |
01D4: BCF 03.5 |
01D5: BCF 09.2 |
01D6: BSF 03.5 |
01D7: BCF 09.2 |
.................... lcd_output_enable(0); |
01D8: BCF 03.5 |
01D9: BCF 09.0 |
01DA: BSF 03.5 |
01DB: BCF 09.0 |
.................... |
.................... delay_ms(15); |
01DC: MOVLW 0F |
01DD: BCF 03.5 |
01DE: MOVWF 4B |
01DF: CALL 0FB |
.................... for(i=1;i<=3;++i) |
01E0: MOVLW 01 |
01E1: MOVWF 3D |
01E2: MOVF 3D,W |
01E3: SUBLW 03 |
01E4: BTFSS 03.0 |
01E5: GOTO 1EE |
.................... { |
.................... lcd_send_nibble(3); |
01E6: MOVLW 03 |
01E7: MOVWF 52 |
01E8: CALL 10F |
.................... delay_ms(5); |
01E9: MOVLW 05 |
01EA: MOVWF 4B |
01EB: CALL 0FB |
.................... } |
01EC: INCF 3D,F |
01ED: GOTO 1E2 |
.................... |
.................... lcd_send_nibble(2); |
01EE: MOVLW 02 |
01EF: MOVWF 52 |
01F0: CALL 10F |
.................... for(i=0;i<=3;++i) |
01F1: CLRF 3D |
01F2: MOVF 3D,W |
01F3: SUBLW 03 |
01F4: BTFSS 03.0 |
01F5: GOTO 1FF |
.................... lcd_send_byte(0,LCD_INIT_STRING[i]); |
01F6: MOVF 3D,W |
01F7: CALL 004 |
01F8: MOVWF 3E |
01F9: CLRF 4F |
01FA: MOVF 3E,W |
01FB: MOVWF 50 |
01FC: CALL 16C |
.................... |
.................... #if defined(LCD_EXTENDED_NEWLINE) |
01FD: INCF 3D,F |
01FE: GOTO 1F2 |
.................... g_LcdX = 0; |
.................... g_LcdY = 0; |
.................... #endif |
.................... } |
01FF: RETURN |
.................... |
.................... void lcd_gotoxy(BYTE x, BYTE y) |
.................... { |
.................... BYTE address; |
.................... |
.................... if(y!=1) |
0200: DECFSZ 4C,W |
0201: GOTO 203 |
0202: GOTO 206 |
.................... address=LCD_LINE_TWO; |
0203: MOVLW 40 |
0204: MOVWF 4D |
.................... else |
0205: GOTO 207 |
.................... address=0; |
0206: CLRF 4D |
.................... |
.................... address+=x-1; |
0207: MOVLW 01 |
0208: SUBWF 4B,W |
0209: ADDWF 4D,F |
.................... lcd_send_byte(0,0x80|address); |
020A: MOVF 4D,W |
020B: IORLW 80 |
020C: MOVWF 4E |
020D: CLRF 4F |
020E: MOVF 4E,W |
020F: MOVWF 50 |
0210: CALL 16C |
.................... |
.................... #if defined(LCD_EXTENDED_NEWLINE) |
.................... g_LcdX = x - 1; |
.................... g_LcdY = y - 1; |
.................... #endif |
.................... } |
0211: RETURN |
.................... |
.................... void lcd_putc(char c) |
.................... { |
.................... switch (c) |
.................... { |
0212: MOVF 4A,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; |
0220: MOVLW 01 |
0221: MOVWF 4B |
0222: MOVWF 4C |
0223: CALL 200 |
0224: GOTO 23E |
.................... |
.................... case '\f' : lcd_send_byte(0,1); |
0225: CLRF 4F |
0226: MOVLW 01 |
0227: MOVWF 50 |
0228: CALL 16C |
.................... delay_ms(2); |
0229: MOVLW 02 |
022A: MOVWF 4B |
022B: CALL 0FB |
.................... #if defined(LCD_EXTENDED_NEWLINE) |
.................... g_LcdX = 0; |
.................... g_LcdY = 0; |
.................... #endif |
.................... break; |
022C: GOTO 23E |
.................... |
.................... #if defined(LCD_EXTENDED_NEWLINE) |
.................... case '\r' : lcd_gotoxy(1, g_LcdY+1); break; |
.................... case '\n' : |
.................... while (g_LcdX++ < LCD_LINE_LENGTH) |
.................... { |
.................... lcd_send_byte(1, ' '); |
.................... } |
.................... lcd_gotoxy(1, g_LcdY+2); |
.................... break; |
.................... #else |
.................... case '\n' : lcd_gotoxy(1,2); break; |
022D: MOVLW 01 |
022E: MOVWF 4B |
022F: MOVLW 02 |
0230: MOVWF 4C |
0231: CALL 200 |
0232: GOTO 23E |
.................... #endif |
.................... |
.................... case '\b' : lcd_send_byte(0,0x10); break; |
0233: CLRF 4F |
0234: MOVLW 10 |
0235: MOVWF 50 |
0236: CALL 16C |
0237: GOTO 23E |
.................... |
.................... #if defined(LCD_EXTENDED_NEWLINE) |
.................... default : |
.................... if (g_LcdX < LCD_LINE_LENGTH) |
.................... { |
.................... lcd_send_byte(1, c); |
.................... g_LcdX++; |
.................... } |
.................... break; |
.................... #else |
.................... default : lcd_send_byte(1,c); break; |
0238: MOVLW 01 |
0239: MOVWF 4F |
023A: MOVF 4A,W |
023B: MOVWF 50 |
023C: CALL 16C |
023D: GOTO 23E |
.................... #endif |
.................... } |
.................... } |
023E: RETURN |
.................... |
.................... char lcd_getc(BYTE x, BYTE y) |
.................... { |
.................... char value; |
.................... |
.................... lcd_gotoxy(x,y); |
.................... while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low |
.................... lcd_output_rs(1); |
.................... value = lcd_read_byte(); |
.................... lcd_output_rs(0); |
.................... |
.................... return(value); |
.................... } |
.................... |
.................... |
.................... #include "../SHT25.h" |
.................... |
.................... #define SHT25_HEATER_ON 0x04 |
.................... #define SHT25_HEATER_OFF 0x00 |
.................... #define SHT25_OTP_reload_off 0x02 |
.................... #define SHT25_RH12_T14 0x00 |
.................... #define SHT25_RH8_T12 0x01 |
.................... #define SHT25_RH10_T13 0x80 |
.................... #define SHT25_RH11_T11 0x81 |
.................... |
.................... #define SHT25_ADDR 0x80 |
.................... |
.................... #include "SHT25.c" |
.................... void SHT25_soft_reset() |
.................... { |
.................... i2c_start(); // Start condition |
.................... i2c_write(0x80); // Device address |
.................... i2c_write(0xFE); // Device command |
.................... i2c_stop(); // Stop condition |
.................... } |
.................... |
.................... unsigned int8 SHT25_setup(unsigned int8 setup_reg ) // writes to status register and returns its value |
.................... { |
.................... unsigned int8 reg; |
.................... |
.................... i2c_start(); // Start condition |
.................... i2c_write(SHT25_ADDR); // Device address |
.................... i2c_write(0xE7); // Device command |
.................... |
.................... i2c_start(); // Start condition |
.................... i2c_write(SHT25_ADDR+1); // Device address |
.................... reg=i2c_read(0); // Read status actual status register |
.................... |
.................... reg = (reg & 0x3A) | setup_reg; |
.................... |
.................... i2c_start(); // Start condition |
.................... i2c_write(SHT25_ADDR); // Device address |
.................... i2c_write(0xE6); // Write to status register |
.................... i2c_write(reg); // Device command |
.................... i2c_stop(); // Stop condition |
.................... |
.................... delay_ms(10); |
.................... |
.................... i2c_start(); // Start condition |
.................... i2c_write(SHT25_ADDR); // Device address |
.................... i2c_write(0xE7); // Device command |
.................... |
.................... i2c_start(); // Start condition |
.................... i2c_write(SHT25_ADDR+1); // Device address |
.................... reg=i2c_read(0); // Read status actual status register |
.................... |
.................... return (reg); |
.................... } |
.................... |
.................... |
.................... float SHT25_get_temp() |
.................... { |
.................... unsigned int8 MSB, LSB, Check; |
.................... unsigned int16 data; |
.................... |
.................... i2c_start(); |
* |
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); |
0581: MOVLW 80 |
0582: BCF 03.5 |
0583: MOVWF 4E |
0584: CALL 078 |
.................... I2C_write(0xE3); |
0585: MOVLW E3 |
0586: MOVWF 4E |
0587: CALL 078 |
.................... i2c_stop(); |
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); |
059D: MOVLW 64 |
059E: BCF 03.5 |
059F: MOVWF 4B |
05A0: CALL 0FB |
.................... |
.................... i2c_start(); |
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); |
05B9: MOVLW 81 |
05BA: BCF 03.5 |
05BB: MOVWF 4E |
05BC: CALL 078 |
.................... MSB=i2c_read(1); |
05BD: MOVLW 01 |
05BE: MOVWF 77 |
05BF: CALL 285 |
05C0: MOVF 78,W |
05C1: MOVWF 3D |
.................... LSB=i2c_read(1); |
05C2: MOVLW 01 |
05C3: MOVWF 77 |
05C4: CALL 285 |
05C5: MOVF 78,W |
05C6: MOVWF 3E |
.................... Check=i2c_read(0); |
05C7: CLRF 77 |
05C8: CALL 285 |
05C9: MOVF 78,W |
05CA: MOVWF 3F |
.................... i2c_stop(); |
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 |
05E0: BCF 03.5 |
05E1: RRF 3E,F |
05E2: RRF 3E,F |
05E3: MOVLW 3F |
05E4: ANDWF 3E,F |
.................... |
.................... data = (((unsigned int16) MSB << 8) + (LSB << 4)); |
05E5: CLRF 43 |
05E6: MOVF 3D,W |
05E7: MOVWF 42 |
05E8: MOVWF 43 |
05E9: CLRF 42 |
05EA: SWAPF 3E,W |
05EB: MOVWF 77 |
05EC: MOVLW F0 |
05ED: ANDWF 77,F |
05EE: MOVF 77,W |
05EF: ADDWF 42,W |
05F0: MOVWF 40 |
05F1: MOVF 43,W |
05F2: MOVWF 41 |
05F3: BTFSC 03.0 |
05F4: INCF 41,F |
.................... return(-46.85 + 175.72*((float)data/0xFFFF)); |
05F5: MOVF 41,W |
05F6: MOVWF 4E |
05F7: MOVF 40,W |
05F8: MOVWF 4D |
05F9: CALL 2CA |
05FA: MOVF 77,W |
05FB: MOVWF 42 |
05FC: MOVF 78,W |
05FD: MOVWF 43 |
05FE: MOVF 79,W |
05FF: MOVWF 44 |
0600: MOVF 7A,W |
0601: MOVWF 45 |
0602: MOVWF 54 |
0603: MOVF 79,W |
0604: MOVWF 53 |
0605: MOVF 78,W |
0606: MOVWF 52 |
0607: MOVF 77,W |
0608: MOVWF 51 |
0609: CLRF 58 |
060A: MOVLW FF |
060B: MOVWF 57 |
060C: MOVLW 7F |
060D: MOVWF 56 |
060E: MOVLW 8E |
060F: MOVWF 55 |
0610: CALL 2E7 |
0611: MOVLW 52 |
0612: MOVWF 4D |
0613: MOVLW B8 |
0614: MOVWF 4C |
0615: MOVLW 2F |
0616: MOVWF 4B |
0617: MOVLW 86 |
0618: MOVWF 4A |
0619: MOVF 7A,W |
061A: MOVWF 51 |
061B: MOVF 79,W |
061C: MOVWF 50 |
061D: MOVF 78,W |
061E: MOVWF 4F |
061F: MOVF 77,W |
0620: MOVWF 4E |
0621: CALL 3B1 |
0622: BCF 03.1 |
0623: MOVLW 66 |
0624: MOVWF 56 |
0625: MOVWF 55 |
0626: MOVLW BB |
0627: MOVWF 54 |
0628: MOVLW 84 |
0629: MOVWF 53 |
062A: MOVF 7A,W |
062B: MOVWF 5A |
062C: MOVF 79,W |
062D: MOVWF 59 |
062E: MOVF 78,W |
062F: MOVWF 58 |
0630: MOVF 77,W |
0631: MOVWF 57 |
0632: CALL 426 |
.................... } |
0633: BSF 0A.3 |
0634: BCF 0A.4 |
0635: GOTO 5B9 (RETURN) |
.................... |
.................... float SHT25_get_hum() |
.................... { |
.................... unsigned int8 MSB, LSB, Check; |
.................... unsigned int16 data; |
.................... |
.................... i2c_start(); //RH |
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); |
064E: MOVLW 80 |
064F: BCF 03.5 |
0650: MOVWF 4E |
0651: CALL 078 |
.................... I2C_write(0xE5); |
0652: MOVLW E5 |
0653: MOVWF 4E |
0654: CALL 078 |
.................... |
.................... delay_ms(100); |
0655: MOVLW 64 |
0656: MOVWF 4B |
0657: CALL 0FB |
.................... |
.................... i2c_start(); |
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); |
0672: MOVLW 81 |
0673: BCF 03.5 |
0674: MOVWF 4E |
0675: CALL 078 |
.................... MSB=i2c_read(1); |
0676: MOVLW 01 |
0677: MOVWF 77 |
0678: CALL 285 |
0679: MOVF 78,W |
067A: MOVWF 3D |
.................... LSB=i2c_read(1); |
067B: MOVLW 01 |
067C: MOVWF 77 |
067D: CALL 285 |
067E: MOVF 78,W |
067F: MOVWF 3E |
.................... Check=i2c_read(0); |
0680: CLRF 77 |
0681: CALL 285 |
0682: MOVF 78,W |
0683: MOVWF 3F |
.................... i2c_stop(); |
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 |
0699: BCF 03.5 |
069A: RRF 3E,F |
069B: RRF 3E,F |
069C: MOVLW 3F |
069D: ANDWF 3E,F |
.................... |
.................... data = (((unsigned int16) MSB << 8) + (LSB << 4) ); |
069E: CLRF 43 |
069F: MOVF 3D,W |
06A0: MOVWF 42 |
06A1: MOVWF 43 |
06A2: CLRF 42 |
06A3: SWAPF 3E,W |
06A4: MOVWF 77 |
06A5: MOVLW F0 |
06A6: ANDWF 77,F |
06A7: MOVF 77,W |
06A8: ADDWF 42,W |
06A9: MOVWF 40 |
06AA: MOVF 43,W |
06AB: MOVWF 41 |
06AC: BTFSC 03.0 |
06AD: INCF 41,F |
.................... return( -6.0 + 125.0*((float)data/0xFFFF)); |
06AE: MOVF 41,W |
06AF: MOVWF 4E |
06B0: MOVF 40,W |
06B1: MOVWF 4D |
06B2: CALL 2CA |
06B3: MOVF 77,W |
06B4: MOVWF 42 |
06B5: MOVF 78,W |
06B6: MOVWF 43 |
06B7: MOVF 79,W |
06B8: MOVWF 44 |
06B9: MOVF 7A,W |
06BA: MOVWF 45 |
06BB: MOVWF 54 |
06BC: MOVF 79,W |
06BD: MOVWF 53 |
06BE: MOVF 78,W |
06BF: MOVWF 52 |
06C0: MOVF 77,W |
06C1: MOVWF 51 |
06C2: CLRF 58 |
06C3: MOVLW FF |
06C4: MOVWF 57 |
06C5: MOVLW 7F |
06C6: MOVWF 56 |
06C7: MOVLW 8E |
06C8: MOVWF 55 |
06C9: CALL 2E7 |
06CA: CLRF 4D |
06CB: CLRF 4C |
06CC: MOVLW 7A |
06CD: MOVWF 4B |
06CE: MOVLW 85 |
06CF: MOVWF 4A |
06D0: MOVF 7A,W |
06D1: MOVWF 51 |
06D2: MOVF 79,W |
06D3: MOVWF 50 |
06D4: MOVF 78,W |
06D5: MOVWF 4F |
06D6: MOVF 77,W |
06D7: MOVWF 4E |
06D8: CALL 3B1 |
06D9: BCF 03.1 |
06DA: CLRF 56 |
06DB: CLRF 55 |
06DC: MOVLW C0 |
06DD: MOVWF 54 |
06DE: MOVLW 81 |
06DF: MOVWF 53 |
06E0: MOVF 7A,W |
06E1: MOVWF 5A |
06E2: MOVF 79,W |
06E3: MOVWF 59 |
06E4: MOVF 78,W |
06E5: MOVWF 58 |
06E6: MOVF 77,W |
06E7: MOVWF 57 |
06E8: CALL 426 |
.................... } |
06E9: BSF 0A.3 |
06EA: BCF 0A.4 |
06EB: GOTO 5C4 (RETURN) |
.................... |
.................... |
.................... |
.................... |
.................... #include "../LTS01.h" |
.................... //Adresa pro VDD, VDD, VDD W 0x9E R 0x9F |
.................... //Adresa pro GND GND GND W 0x90 R 0x91 |
.................... |
.................... #define LTS01A_address 0x90 |
.................... |
.................... #include "LTS01.c" |
.................... float LTS01_get_temp() |
.................... { |
.................... unsigned int8 MSB; |
.................... unsigned int8 LSB; |
.................... signed int16 data; |
.................... |
.................... i2c_start(); |
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); |
0704: MOVLW 90 |
0705: BCF 03.5 |
0706: MOVWF 4E |
0707: CALL 078 |
.................... I2C_write(0x00); |
0708: CLRF 4E |
0709: CALL 078 |
.................... i2c_stop(); |
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(); |
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); |
0738: MOVLW 91 |
0739: BCF 03.5 |
073A: MOVWF 4E |
073B: CALL 078 |
.................... MSB=i2c_read(1); |
073C: MOVLW 01 |
073D: MOVWF 77 |
073E: CALL 285 |
073F: MOVF 78,W |
0740: MOVWF 3D |
.................... LSB=i2c_read(0); |
0741: CLRF 77 |
0742: CALL 285 |
0743: MOVF 78,W |
0744: MOVWF 3E |
.................... i2c_stop(); |
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); |
075A: BCF 03.5 |
075B: MOVF 3D,W |
075C: MOVWF 40 |
075D: MOVF 3E,W |
075E: MOVWF 3F |
.................... |
.................... return (data * 0.00390625 ); |
075F: MOVF 40,W |
0760: MOVWF 42 |
0761: MOVF 3F,W |
0762: MOVWF 41 |
0763: MOVF 42,W |
0764: MOVWF 44 |
0765: MOVF 41,W |
0766: MOVWF 43 |
* |
078B: MOVF 7A,W |
078C: MOVWF 4D |
078D: MOVF 79,W |
078E: MOVWF 4C |
078F: MOVF 78,W |
0790: MOVWF 4B |
0791: MOVF 77,W |
0792: MOVWF 4A |
0793: CLRF 51 |
0794: CLRF 50 |
0795: CLRF 4F |
0796: MOVLW 77 |
0797: MOVWF 4E |
0798: CALL 3B1 |
.................... |
.................... } |
0799: BSF 0A.3 |
079A: BCF 0A.4 |
079B: GOTO 5CF (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 4E |
00DD: CALL 078 |
.................... i2c_write(reg); |
00DE: MOVF 3D,W |
00DF: MOVWF 4E |
00E0: CALL 078 |
.................... i2c_write(data); |
00E1: MOVF 3E,W |
00E2: MOVWF 4E |
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}; |
* |
0D09: CLRF 21 |
0D0A: CLRF 22 |
0D0B: CLRF 23 |
0D0C: CLRF 24 |
0D0D: CLRF 25 |
0D0E: 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 4E |
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 4E |
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 4E |
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 3E |
.................... 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 3D |
.................... |
.................... 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 42 |
.................... 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 41 |
.................... |
.................... 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 40 |
.................... 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 3F |
.................... |
.................... 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 3E,W |
0883: MOVWF 22 |
0884: MOVF 3D,W |
0885: MOVWF 21 |
.................... compass.y = make16(y_msb, y_lsb); |
0886: MOVF 40,W |
0887: MOVWF 24 |
0888: MOVF 3F,W |
0889: MOVWF 23 |
.................... compass.z = make16(z_msb, z_lsb); |
088A: MOVF 42,W |
088B: MOVWF 26 |
088C: MOVF 41,W |
088D: MOVWF 25 |
.................... } |
088E: BSF 0A.3 |
088F: BCF 0A.4 |
0890: GOTO 5D9 (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 |
.................... |
.................... |
.................... #define MPL3115_ADDR_R 0xC1 //addresa pro cteni |
.................... #define MPL3115_ADDR_W 0xC0 |
.................... |
.................... #include "../MPL3115.h" |
.................... //microchip pic library for Freescale MPL3115 I2C barometer sensor |
.................... |
.................... /*void mpl3115_setA (void) //setup sensor for altitude measurement |
.................... void mpl3115_setP (void) //setup sensor for preasure measurement |
.................... float mpl3115_T (void) //temperature in Celsius degrees |
.................... float mpl3115_A (void) //altitude in metres |
.................... float mpl3115_P (void) //preassure in pascals |
.................... */ |
.................... |
.................... #include "MPL3115.c" |
.................... void mpl3115_setA (void) //setup for altitude measurement |
.................... { |
.................... |
.................... |
.................... i2c_start(); //STANDBY mode |
.................... I2C_Write(MPL3115_ADDR_W); |
.................... I2C_write(0x26); |
.................... I2C_write(0xB8); |
.................... i2c_stop(); |
.................... |
.................... i2c_start(); //PT_DATA_CFG set |
.................... I2C_Write(MPL3115_ADDR_W); |
.................... I2C_write(0x13); |
.................... I2C_write(0x07); //hodnota |
.................... i2c_stop(); |
.................... |
.................... i2c_start(); //ACTIVE mode |
.................... I2C_Write(MPL3115_ADDR_W); |
.................... I2C_write(0x26); |
.................... I2C_write(0xB9); |
.................... i2c_stop(); |
.................... } |
.................... |
.................... void mpl3115_setP (void) //nastavení pro tlak |
.................... { |
.................... |
.................... |
.................... i2c_start(); //STANDBY mode |
* |
09AD: BSF 20.4 |
09AE: MOVF 20,W |
09AF: BSF 03.5 |
09B0: MOVWF 07 |
09B1: NOP |
09B2: BCF 03.5 |
09B3: BSF 20.3 |
09B4: MOVF 20,W |
09B5: BSF 03.5 |
09B6: MOVWF 07 |
09B7: NOP |
09B8: BCF 03.5 |
09B9: BCF 07.4 |
09BA: BCF 20.4 |
09BB: MOVF 20,W |
09BC: BSF 03.5 |
09BD: MOVWF 07 |
09BE: NOP |
09BF: BCF 03.5 |
09C0: BCF 07.3 |
09C1: BCF 20.3 |
09C2: MOVF 20,W |
09C3: BSF 03.5 |
09C4: MOVWF 07 |
.................... I2C_Write(MPL3115_ADDR_W); |
09C5: MOVLW C0 |
09C6: BCF 03.5 |
09C7: MOVWF 4E |
09C8: BCF 0A.3 |
09C9: CALL 078 |
09CA: BSF 0A.3 |
.................... I2C_write(0x26); |
09CB: MOVLW 26 |
09CC: MOVWF 4E |
09CD: BCF 0A.3 |
09CE: CALL 078 |
09CF: BSF 0A.3 |
.................... I2C_write(0xB8); |
09D0: MOVLW B8 |
09D1: MOVWF 4E |
09D2: BCF 0A.3 |
09D3: CALL 078 |
09D4: BSF 0A.3 |
.................... i2c_stop(); |
09D5: BCF 20.4 |
09D6: MOVF 20,W |
09D7: BSF 03.5 |
09D8: MOVWF 07 |
09D9: NOP |
09DA: BCF 03.5 |
09DB: BSF 20.3 |
09DC: MOVF 20,W |
09DD: BSF 03.5 |
09DE: MOVWF 07 |
09DF: BCF 03.5 |
09E0: BTFSS 07.3 |
09E1: GOTO 1E0 |
09E2: NOP |
09E3: GOTO 1E4 |
09E4: NOP |
09E5: BSF 20.4 |
09E6: MOVF 20,W |
09E7: BSF 03.5 |
09E8: MOVWF 07 |
09E9: NOP |
.................... |
.................... i2c_start(); //PT_DATA_CFG set |
09EA: BCF 03.5 |
09EB: BSF 20.4 |
09EC: MOVF 20,W |
09ED: BSF 03.5 |
09EE: MOVWF 07 |
09EF: NOP |
09F0: BCF 03.5 |
09F1: BSF 20.3 |
09F2: MOVF 20,W |
09F3: BSF 03.5 |
09F4: MOVWF 07 |
09F5: NOP |
09F6: BCF 03.5 |
09F7: BCF 07.4 |
09F8: BCF 20.4 |
09F9: MOVF 20,W |
09FA: BSF 03.5 |
09FB: MOVWF 07 |
09FC: NOP |
09FD: BCF 03.5 |
09FE: BCF 07.3 |
09FF: BCF 20.3 |
0A00: MOVF 20,W |
0A01: BSF 03.5 |
0A02: MOVWF 07 |
.................... I2C_Write(MPL3115_ADDR_W); |
0A03: MOVLW C0 |
0A04: BCF 03.5 |
0A05: MOVWF 4E |
0A06: BCF 0A.3 |
0A07: CALL 078 |
0A08: BSF 0A.3 |
.................... I2C_write(0x13); |
0A09: MOVLW 13 |
0A0A: MOVWF 4E |
0A0B: BCF 0A.3 |
0A0C: CALL 078 |
0A0D: BSF 0A.3 |
.................... I2C_write(0x07); //hodnota |
0A0E: MOVLW 07 |
0A0F: MOVWF 4E |
0A10: BCF 0A.3 |
0A11: CALL 078 |
0A12: BSF 0A.3 |
.................... i2c_stop(); |
0A13: BCF 20.4 |
0A14: MOVF 20,W |
0A15: BSF 03.5 |
0A16: MOVWF 07 |
0A17: NOP |
0A18: BCF 03.5 |
0A19: BSF 20.3 |
0A1A: MOVF 20,W |
0A1B: BSF 03.5 |
0A1C: MOVWF 07 |
0A1D: BCF 03.5 |
0A1E: BTFSS 07.3 |
0A1F: GOTO 21E |
0A20: NOP |
0A21: GOTO 222 |
0A22: NOP |
0A23: BSF 20.4 |
0A24: MOVF 20,W |
0A25: BSF 03.5 |
0A26: MOVWF 07 |
0A27: NOP |
.................... |
.................... i2c_start(); //ACTIVE mode |
0A28: BCF 03.5 |
0A29: BSF 20.4 |
0A2A: MOVF 20,W |
0A2B: BSF 03.5 |
0A2C: MOVWF 07 |
0A2D: NOP |
0A2E: BCF 03.5 |
0A2F: BSF 20.3 |
0A30: MOVF 20,W |
0A31: BSF 03.5 |
0A32: MOVWF 07 |
0A33: NOP |
0A34: BCF 03.5 |
0A35: BCF 07.4 |
0A36: BCF 20.4 |
0A37: MOVF 20,W |
0A38: BSF 03.5 |
0A39: MOVWF 07 |
0A3A: NOP |
0A3B: BCF 03.5 |
0A3C: BCF 07.3 |
0A3D: BCF 20.3 |
0A3E: MOVF 20,W |
0A3F: BSF 03.5 |
0A40: MOVWF 07 |
.................... I2C_Write(MPL3115_ADDR_W); |
0A41: MOVLW C0 |
0A42: BCF 03.5 |
0A43: MOVWF 4E |
0A44: BCF 0A.3 |
0A45: CALL 078 |
0A46: BSF 0A.3 |
.................... I2C_write(0x26); |
0A47: MOVLW 26 |
0A48: MOVWF 4E |
0A49: BCF 0A.3 |
0A4A: CALL 078 |
0A4B: BSF 0A.3 |
.................... I2C_write(0x39); |
0A4C: MOVLW 39 |
0A4D: MOVWF 4E |
0A4E: BCF 0A.3 |
0A4F: CALL 078 |
0A50: BSF 0A.3 |
.................... i2c_stop(); |
0A51: BCF 20.4 |
0A52: MOVF 20,W |
0A53: BSF 03.5 |
0A54: MOVWF 07 |
0A55: NOP |
0A56: BCF 03.5 |
0A57: BSF 20.3 |
0A58: MOVF 20,W |
0A59: BSF 03.5 |
0A5A: MOVWF 07 |
0A5B: BCF 03.5 |
0A5C: BTFSS 07.3 |
0A5D: GOTO 25C |
0A5E: NOP |
0A5F: GOTO 260 |
0A60: NOP |
0A61: BSF 20.4 |
0A62: MOVF 20,W |
0A63: BSF 03.5 |
0A64: MOVWF 07 |
0A65: NOP |
.................... } |
0A66: BCF 03.5 |
0A67: BSF 0A.3 |
0A68: BCF 0A.4 |
0A69: GOTO 5EC (RETURN) |
.................... |
.................... |
.................... byte mpl3115_read (byte reg) |
.................... { |
.................... byte i; |
.................... |
.................... i2c_start(); |
* |
079C: BSF 20.4 |
079D: MOVF 20,W |
079E: BSF 03.5 |
079F: MOVWF 07 |
07A0: NOP |
07A1: BCF 03.5 |
07A2: BSF 20.3 |
07A3: MOVF 20,W |
07A4: BSF 03.5 |
07A5: MOVWF 07 |
07A6: NOP |
07A7: BCF 03.5 |
07A8: BCF 07.4 |
07A9: BCF 20.4 |
07AA: MOVF 20,W |
07AB: BSF 03.5 |
07AC: MOVWF 07 |
07AD: NOP |
07AE: BCF 03.5 |
07AF: BCF 07.3 |
07B0: BCF 20.3 |
07B1: MOVF 20,W |
07B2: BSF 03.5 |
07B3: MOVWF 07 |
.................... I2C_Write(MPL3115_ADDR_W); |
07B4: MOVLW C0 |
07B5: BCF 03.5 |
07B6: MOVWF 4E |
07B7: CALL 078 |
.................... I2C_write(reg); |
07B8: MOVF 4C,W |
07B9: MOVWF 4E |
07BA: CALL 078 |
.................... i2c_start(); |
07BB: BSF 20.4 |
07BC: MOVF 20,W |
07BD: BSF 03.5 |
07BE: MOVWF 07 |
07BF: NOP |
07C0: BCF 03.5 |
07C1: BSF 20.3 |
07C2: MOVF 20,W |
07C3: BSF 03.5 |
07C4: MOVWF 07 |
07C5: NOP |
07C6: BCF 03.5 |
07C7: BTFSS 07.3 |
07C8: GOTO 7C7 |
07C9: BCF 07.4 |
07CA: BCF 20.4 |
07CB: MOVF 20,W |
07CC: BSF 03.5 |
07CD: MOVWF 07 |
07CE: NOP |
07CF: BCF 03.5 |
07D0: BCF 07.3 |
07D1: BCF 20.3 |
07D2: MOVF 20,W |
07D3: BSF 03.5 |
07D4: MOVWF 07 |
.................... I2C_Write(MPL3115_ADDR_R); |
07D5: MOVLW C1 |
07D6: BCF 03.5 |
07D7: MOVWF 4E |
07D8: CALL 078 |
.................... i=i2c_read(0); |
07D9: CLRF 77 |
07DA: CALL 285 |
07DB: MOVF 78,W |
07DC: MOVWF 4D |
.................... i2c_stop(); |
07DD: BCF 20.4 |
07DE: MOVF 20,W |
07DF: BSF 03.5 |
07E0: MOVWF 07 |
07E1: NOP |
07E2: BCF 03.5 |
07E3: BSF 20.3 |
07E4: MOVF 20,W |
07E5: BSF 03.5 |
07E6: MOVWF 07 |
07E7: BCF 03.5 |
07E8: BTFSS 07.3 |
07E9: GOTO 7E8 |
07EA: NOP |
07EB: GOTO 7EC |
07EC: NOP |
07ED: BSF 20.4 |
07EE: MOVF 20,W |
07EF: BSF 03.5 |
07F0: MOVWF 07 |
07F1: NOP |
.................... |
.................... return i; |
07F2: BCF 03.5 |
07F3: MOVF 4D,W |
07F4: MOVWF 78 |
.................... } |
07F5: RETURN |
.................... |
.................... |
.................... float mpl3115_T (void) //teplota ve stupnich |
.................... { |
.................... int m; |
.................... float l, t; |
.................... |
.................... m = mpl3115_read (0x04); |
* |
0891: MOVLW 04 |
0892: MOVWF 4C |
0893: BCF 0A.3 |
0894: CALL 79C |
0895: BSF 0A.3 |
0896: MOVF 78,W |
0897: MOVWF 3D |
.................... l = (float)(mpl3115_read(0x05)>>4)/16.0; |
0898: MOVLW 05 |
0899: MOVWF 4C |
089A: BCF 0A.3 |
089B: CALL 79C |
089C: BSF 0A.3 |
089D: SWAPF 78,W |
089E: MOVWF 77 |
089F: MOVLW 0F |
08A0: ANDWF 77,F |
08A1: MOVF 77,W |
08A2: CLRF 4E |
08A3: MOVWF 4D |
08A4: BCF 0A.3 |
08A5: CALL 2CA |
08A6: BSF 0A.3 |
08A7: MOVF 77,W |
08A8: MOVWF 46 |
08A9: MOVF 78,W |
08AA: MOVWF 47 |
08AB: MOVF 79,W |
08AC: MOVWF 48 |
08AD: MOVF 7A,W |
08AE: MOVWF 49 |
08AF: MOVWF 54 |
08B0: MOVF 48,W |
08B1: MOVWF 53 |
08B2: MOVF 47,W |
08B3: MOVWF 52 |
08B4: MOVF 46,W |
08B5: MOVWF 51 |
08B6: CLRF 58 |
08B7: CLRF 57 |
08B8: CLRF 56 |
08B9: MOVLW 83 |
08BA: MOVWF 55 |
08BB: BCF 0A.3 |
08BC: CALL 2E7 |
08BD: BSF 0A.3 |
08BE: MOVF 7A,W |
08BF: MOVWF 41 |
08C0: MOVF 79,W |
08C1: MOVWF 40 |
08C2: MOVF 78,W |
08C3: MOVWF 3F |
08C4: MOVF 77,W |
08C5: MOVWF 3E |
.................... t = (float)(M + L); |
08C6: CLRF 4E |
08C7: MOVF 3D,W |
08C8: MOVWF 4D |
08C9: BCF 0A.3 |
08CA: CALL 2CA |
08CB: BSF 0A.3 |
08CC: BCF 03.1 |
08CD: MOVF 7A,W |
08CE: MOVWF 56 |
08CF: MOVF 79,W |
08D0: MOVWF 55 |
08D1: MOVF 78,W |
08D2: MOVWF 54 |
08D3: MOVF 77,W |
08D4: MOVWF 53 |
08D5: MOVF 41,W |
08D6: MOVWF 5A |
08D7: MOVF 40,W |
08D8: MOVWF 59 |
08D9: MOVF 3F,W |
08DA: MOVWF 58 |
08DB: MOVF 3E,W |
08DC: MOVWF 57 |
08DD: BCF 0A.3 |
08DE: CALL 426 |
08DF: BSF 0A.3 |
08E0: MOVF 7A,W |
08E1: MOVWF 45 |
08E2: MOVF 79,W |
08E3: MOVWF 44 |
08E4: MOVF 78,W |
08E5: MOVWF 43 |
08E6: MOVF 77,W |
08E7: MOVWF 42 |
.................... return t; |
08E8: MOVF 42,W |
08E9: MOVWF 77 |
08EA: MOVF 43,W |
08EB: MOVWF 78 |
08EC: MOVF 44,W |
08ED: MOVWF 79 |
08EE: MOVF 45,W |
08EF: MOVWF 7A |
.................... } |
08F0: BSF 0A.3 |
08F1: BCF 0A.4 |
08F2: GOTO 5DA (RETURN) |
.................... |
.................... float mpl3115_A (void) //vyska v m |
.................... { |
.................... |
.................... int16 m, c; |
.................... float l, a; |
.................... |
.................... m = mpl3115_read (0x01); |
.................... c = mpl3115_read (0x02); |
.................... l = (float)(mpl3115_read(0x03)>>4)/16.0; |
.................... a = (float)((m << 8)|c) + l; |
.................... return a; |
.................... } |
.................... |
.................... |
.................... float mpl3115_P (void) //tlak v Pa |
.................... { |
.................... unsigned int32 m; |
.................... unsigned int16 c; |
.................... unsigned int l; |
.................... float p, l1; |
.................... |
.................... m = mpl3115_read (0x01); |
08F3: MOVLW 01 |
08F4: MOVWF 4C |
08F5: BCF 0A.3 |
08F6: CALL 79C |
08F7: BSF 0A.3 |
08F8: CLRF 40 |
08F9: CLRF 3F |
08FA: CLRF 3E |
08FB: MOVF 78,W |
08FC: MOVWF 3D |
.................... c = mpl3115_read (0x02); |
08FD: MOVLW 02 |
08FE: MOVWF 4C |
08FF: BCF 0A.3 |
0900: CALL 79C |
0901: BSF 0A.3 |
0902: CLRF 42 |
0903: MOVF 78,W |
0904: MOVWF 41 |
.................... l = mpl3115_read(0x03); |
0905: MOVLW 03 |
0906: MOVWF 4C |
0907: BCF 0A.3 |
0908: CALL 79C |
0909: BSF 0A.3 |
090A: MOVF 78,W |
090B: MOVWF 43 |
.................... |
.................... l1= (float)(l>>4)/4.0; |
090C: SWAPF 43,W |
090D: MOVWF 77 |
090E: MOVLW 0F |
090F: ANDWF 77,F |
0910: MOVF 77,W |
0911: CLRF 4E |
0912: MOVWF 4D |
0913: BCF 0A.3 |
0914: CALL 2CA |
0915: BSF 0A.3 |
0916: MOVF 77,W |
0917: MOVWF 4D |
0918: MOVF 78,W |
0919: MOVWF 4E |
091A: MOVF 79,W |
091B: MOVWF 4F |
091C: MOVF 7A,W |
091D: MOVWF 50 |
091E: MOVWF 54 |
091F: MOVF 79,W |
0920: MOVWF 53 |
0921: MOVF 78,W |
0922: MOVWF 52 |
0923: MOVF 77,W |
0924: MOVWF 51 |
0925: CLRF 58 |
0926: CLRF 57 |
0927: CLRF 56 |
0928: MOVLW 81 |
0929: MOVWF 55 |
092A: BCF 0A.3 |
092B: CALL 2E7 |
092C: BSF 0A.3 |
092D: MOVF 7A,W |
092E: MOVWF 4B |
092F: MOVF 79,W |
0930: MOVWF 4A |
0931: MOVF 78,W |
0932: MOVWF 49 |
0933: MOVF 77,W |
0934: MOVWF 48 |
.................... p = (float)((m << 10)|(c<<2)|(l>>6)) + l1; |
0935: CLRF 4D |
0936: RLF 3D,W |
0937: MOVWF 4E |
0938: RLF 3E,W |
0939: MOVWF 4F |
093A: RLF 3F,W |
093B: MOVWF 50 |
093C: RLF 4E,F |
093D: RLF 4F,F |
093E: RLF 50,F |
093F: MOVLW FC |
0940: ANDWF 4E,F |
0941: RLF 41,W |
0942: MOVWF 79 |
0943: RLF 42,W |
0944: MOVWF 7A |
0945: RLF 79,F |
0946: RLF 7A,F |
0947: MOVLW FC |
0948: ANDWF 79,F |
0949: MOVF 79,W |
094A: IORWF 4D,F |
094B: MOVF 7A,W |
094C: IORWF 4E,F |
094D: SWAPF 43,W |
094E: MOVWF 77 |
094F: RRF 77,F |
0950: RRF 77,F |
0951: MOVLW 03 |
0952: ANDWF 77,F |
0953: MOVF 77,W |
0954: IORWF 4D,W |
0955: MOVWF 77 |
0956: MOVF 4E,W |
0957: MOVWF 78 |
0958: MOVF 4F,W |
0959: MOVWF 79 |
095A: MOVF 50,W |
095B: MOVWF 7A |
095C: MOVF 7A,W |
095D: MOVWF 56 |
095E: MOVF 79,W |
095F: MOVWF 55 |
0960: MOVF 78,W |
0961: MOVWF 54 |
0962: MOVF 77,W |
0963: MOVWF 53 |
* |
097E: MOVF 77,W |
097F: MOVWF 4D |
0980: MOVF 78,W |
0981: MOVWF 4E |
0982: MOVF 79,W |
0983: MOVWF 4F |
0984: MOVF 7A,W |
0985: MOVWF 50 |
0986: BCF 03.1 |
0987: MOVF 7A,W |
0988: MOVWF 56 |
0989: MOVF 79,W |
098A: MOVWF 55 |
098B: MOVF 78,W |
098C: MOVWF 54 |
098D: MOVF 77,W |
098E: MOVWF 53 |
098F: MOVF 4B,W |
0990: MOVWF 5A |
0991: MOVF 4A,W |
0992: MOVWF 59 |
0993: MOVF 49,W |
0994: MOVWF 58 |
0995: MOVF 48,W |
0996: MOVWF 57 |
0997: BCF 0A.3 |
0998: CALL 426 |
0999: BSF 0A.3 |
099A: MOVF 7A,W |
099B: MOVWF 47 |
099C: MOVF 79,W |
099D: MOVWF 46 |
099E: MOVF 78,W |
099F: MOVWF 45 |
09A0: MOVF 77,W |
09A1: MOVWF 44 |
.................... |
.................... return p; |
09A2: MOVF 44,W |
09A3: MOVWF 77 |
09A4: MOVF 45,W |
09A5: MOVWF 78 |
09A6: MOVF 46,W |
09A7: MOVWF 79 |
09A8: MOVF 47,W |
09A9: MOVWF 7A |
.................... } |
09AA: BSF 0A.3 |
09AB: BCF 0A.4 |
09AC: GOTO 5E3 (RETURN) |
.................... |
.................... |
.................... |
.................... |
.................... |
.................... |
.................... void main() |
.................... { |
* |
0CE5: CLRF 04 |
0CE6: BCF 03.7 |
0CE7: MOVLW 1F |
0CE8: ANDWF 03,F |
0CE9: MOVLW 71 |
0CEA: BSF 03.5 |
0CEB: MOVWF 0F |
0CEC: MOVF 0F,W |
0CED: BSF 03.6 |
0CEE: BCF 07.3 |
0CEF: MOVLW 0C |
0CF0: BCF 03.6 |
0CF1: MOVWF 19 |
0CF2: MOVLW A2 |
0CF3: MOVWF 18 |
0CF4: MOVLW 90 |
0CF5: BCF 03.5 |
0CF6: MOVWF 18 |
0CF7: BSF 03.5 |
0CF8: BSF 03.6 |
0CF9: MOVF 09,W |
0CFA: ANDLW C0 |
0CFB: MOVWF 09 |
0CFC: BCF 03.6 |
0CFD: BCF 1F.4 |
0CFE: BCF 1F.5 |
0CFF: MOVLW 00 |
0D00: BSF 03.6 |
0D01: MOVWF 08 |
0D02: BCF 03.5 |
0D03: CLRF 07 |
0D04: CLRF 08 |
0D05: CLRF 09 |
* |
0D0F: CLRF 3C |
0D10: CLRF 3B |
.................... float temp1, temp2, temp3, humidity, preasure; |
.................... int16 i=0; |
.................... |
.................... setup_adc_ports(NO_ANALOGS|VSS_VDD); |
0D11: BSF 03.5 |
0D12: BSF 03.6 |
0D13: MOVF 09,W |
0D14: ANDLW C0 |
0D15: MOVWF 09 |
0D16: BCF 03.6 |
0D17: BCF 1F.4 |
0D18: BCF 1F.5 |
0D19: MOVLW 00 |
0D1A: BSF 03.6 |
0D1B: MOVWF 08 |
.................... setup_adc(ADC_CLOCK_DIV_2); |
0D1C: BCF 03.5 |
0D1D: BCF 03.6 |
0D1E: BCF 1F.6 |
0D1F: BCF 1F.7 |
0D20: BSF 03.5 |
0D21: BSF 1F.7 |
0D22: BCF 03.5 |
0D23: BSF 1F.0 |
.................... setup_spi(SPI_SS_DISABLED); |
0D24: BCF 14.5 |
0D25: BCF 20.5 |
0D26: MOVF 20,W |
0D27: BSF 03.5 |
0D28: MOVWF 07 |
0D29: BCF 03.5 |
0D2A: BSF 20.4 |
0D2B: MOVF 20,W |
0D2C: BSF 03.5 |
0D2D: MOVWF 07 |
0D2E: BCF 03.5 |
0D2F: BCF 20.3 |
0D30: MOVF 20,W |
0D31: BSF 03.5 |
0D32: MOVWF 07 |
0D33: MOVLW 01 |
0D34: BCF 03.5 |
0D35: MOVWF 14 |
0D36: MOVLW 00 |
0D37: BSF 03.5 |
0D38: MOVWF 14 |
.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1); |
0D39: MOVF 01,W |
0D3A: ANDLW C7 |
0D3B: IORLW 08 |
0D3C: MOVWF 01 |
.................... setup_timer_1(T1_DISABLED); |
0D3D: BCF 03.5 |
0D3E: CLRF 10 |
.................... setup_timer_2(T2_DISABLED,0,1); |
0D3F: MOVLW 00 |
0D40: MOVWF 78 |
0D41: MOVWF 12 |
0D42: MOVLW 00 |
0D43: BSF 03.5 |
0D44: MOVWF 12 |
.................... setup_ccp1(CCP_OFF); |
0D45: BCF 03.5 |
0D46: BSF 20.2 |
0D47: MOVF 20,W |
0D48: BSF 03.5 |
0D49: MOVWF 07 |
0D4A: BCF 03.5 |
0D4B: CLRF 17 |
0D4C: BSF 03.5 |
0D4D: CLRF 1B |
0D4E: CLRF 1C |
0D4F: MOVLW 01 |
0D50: MOVWF 1D |
.................... setup_comparator(NC_NC_NC_NC); // This device COMP currently not supported by the PICWizard |
0D51: BCF 03.5 |
0D52: BSF 03.6 |
0D53: CLRF 07 |
0D54: CLRF 08 |
0D55: CLRF 09 |
.................... setup_oscillator(OSC_8MHZ); |
0D56: MOVLW 71 |
0D57: BSF 03.5 |
0D58: BCF 03.6 |
0D59: MOVWF 0F |
0D5A: MOVF 0F,W |
.................... |
.................... |
.................... printf("GeoMet01A\r\n"); |
0D5B: MOVLW 0C |
0D5C: BCF 03.5 |
0D5D: BSF 03.6 |
0D5E: MOVWF 0D |
0D5F: MOVLW 00 |
0D60: MOVWF 0F |
0D61: BCF 0A.3 |
0D62: BCF 03.6 |
0D63: CALL 030 |
0D64: BSF 0A.3 |
.................... printf("(c) Kaklik 2013\r\n"); |
0D65: MOVLW 12 |
0D66: BSF 03.6 |
0D67: MOVWF 0D |
0D68: MOVLW 00 |
0D69: MOVWF 0F |
0D6A: BCF 0A.3 |
0D6B: BCF 03.6 |
0D6C: CALL 030 |
0D6D: BSF 0A.3 |
.................... printf("www.mlab.cz\r\n"); |
0D6E: MOVLW 1B |
0D6F: BSF 03.6 |
0D70: MOVWF 0D |
0D71: MOVLW 00 |
0D72: MOVWF 0F |
0D73: BCF 0A.3 |
0D74: BCF 03.6 |
0D75: CALL 030 |
0D76: 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 |
0D77: CLRF 3D |
0D78: MOVLW 18 |
0D79: MOVWF 3E |
0D7A: BCF 0A.3 |
0D7B: CALL 0C2 |
0D7C: BSF 0A.3 |
.................... hmc5883l_write_reg(HMC5883L_CFG_B_REG, 0x00); // minimal range |
0D7D: MOVLW 01 |
0D7E: MOVWF 3D |
0D7F: CLRF 3E |
0D80: BCF 0A.3 |
0D81: CALL 0C2 |
0D82: BSF 0A.3 |
.................... hmc5883l_write_reg(HMC5883L_MODE_REG, 0x00); |
0D83: MOVLW 02 |
0D84: MOVWF 3D |
0D85: CLRF 3E |
0D86: BCF 0A.3 |
0D87: CALL 0C2 |
0D88: BSF 0A.3 |
.................... |
.................... lcd_init(); |
0D89: BCF 0A.3 |
0D8A: CALL 1C8 |
0D8B: BSF 0A.3 |
.................... lcd_putc("(c) Kaklik 2013"); |
0D8C: MOVLW 22 |
0D8D: BSF 03.6 |
0D8E: MOVWF 0D |
0D8F: MOVLW 00 |
0D90: MOVWF 0F |
0D91: BCF 0A.3 |
0D92: BCF 03.6 |
0D93: CALL 23F |
0D94: BSF 0A.3 |
.................... lcd_gotoxy(3,2); |
0D95: MOVLW 03 |
0D96: MOVWF 4B |
0D97: MOVLW 02 |
0D98: MOVWF 4C |
0D99: BCF 0A.3 |
0D9A: CALL 200 |
0D9B: BSF 0A.3 |
.................... lcd_putc("www.mlab.cz"); |
0D9C: MOVLW 2A |
0D9D: BSF 03.6 |
0D9E: MOVWF 0D |
0D9F: MOVLW 00 |
0DA0: MOVWF 0F |
0DA1: BCF 0A.3 |
0DA2: BCF 03.6 |
0DA3: CALL 23F |
0DA4: BSF 0A.3 |
.................... Delay_ms(2000); |
0DA5: MOVLW 08 |
0DA6: MOVWF 3D |
0DA7: MOVLW FA |
0DA8: MOVWF 4B |
0DA9: BCF 0A.3 |
0DAA: CALL 0FB |
0DAB: BSF 0A.3 |
0DAC: DECFSZ 3D,F |
0DAD: GOTO 5A7 |
.................... lcd_init(); |
0DAE: BCF 0A.3 |
0DAF: CALL 1C8 |
0DB0: BSF 0A.3 |
.................... |
.................... while (TRUE) |
.................... { |
.................... lcd_gotoxy(1,1); |
0DB1: MOVLW 01 |
0DB2: MOVWF 4B |
0DB3: MOVWF 4C |
0DB4: BCF 0A.3 |
0DB5: CALL 200 |
0DB6: BSF 0A.3 |
.................... temp1 = SHT25_get_temp(); |
0DB7: BCF 0A.3 |
0DB8: GOTO 567 |
0DB9: BSF 0A.3 |
0DBA: MOVF 7A,W |
0DBB: MOVWF 2A |
0DBC: MOVF 79,W |
0DBD: MOVWF 29 |
0DBE: MOVF 78,W |
0DBF: MOVWF 28 |
0DC0: MOVF 77,W |
0DC1: MOVWF 27 |
.................... humidity = SHT25_get_hum(); |
0DC2: BCF 0A.3 |
0DC3: GOTO 636 |
0DC4: BSF 0A.3 |
0DC5: MOVF 7A,W |
0DC6: MOVWF 36 |
0DC7: MOVF 79,W |
0DC8: MOVWF 35 |
0DC9: MOVF 78,W |
0DCA: MOVWF 34 |
0DCB: MOVF 77,W |
0DCC: MOVWF 33 |
.................... temp2= LTS01_get_temp(); |
0DCD: BCF 0A.3 |
0DCE: GOTO 6EC |
0DCF: BSF 0A.3 |
0DD0: MOVF 7A,W |
0DD1: MOVWF 2E |
0DD2: MOVF 79,W |
0DD3: MOVWF 2D |
0DD4: MOVF 78,W |
0DD5: MOVWF 2C |
0DD6: MOVF 77,W |
0DD7: MOVWF 2B |
.................... hmc5883l_read_data(); |
0DD8: GOTO 000 |
.................... |
.................... temp3=mpl3115_T(); |
0DD9: GOTO 091 |
0DDA: MOVF 7A,W |
0DDB: MOVWF 32 |
0DDC: MOVF 79,W |
0DDD: MOVWF 31 |
0DDE: MOVF 78,W |
0DDF: MOVWF 30 |
0DE0: MOVF 77,W |
0DE1: MOVWF 2F |
.................... preasure=mpl3115_P(); |
0DE2: GOTO 0F3 |
0DE3: MOVF 7A,W |
0DE4: MOVWF 3A |
0DE5: MOVF 79,W |
0DE6: MOVWF 39 |
0DE7: MOVF 78,W |
0DE8: MOVWF 38 |
0DE9: MOVF 77,W |
0DEA: MOVWF 37 |
.................... mpl3115_setP(); //nastaveni pro tlak a teplotu |
0DEB: GOTO 1AD |
.................... |
.................... printf(lcd_putc,"%2.2f%cC %2.2f\%%",temp1, 0xb2, humidity); |
0DEC: MOVLW 89 |
0DED: MOVWF 04 |
0DEE: MOVF 2A,W |
0DEF: MOVWF 40 |
0DF0: MOVF 29,W |
0DF1: MOVWF 3F |
0DF2: MOVF 28,W |
0DF3: MOVWF 3E |
0DF4: MOVF 27,W |
0DF5: MOVWF 3D |
0DF6: MOVLW 02 |
0DF7: MOVWF 41 |
0DF8: CALL 2CB |
0DF9: MOVLW B2 |
0DFA: MOVWF 4A |
0DFB: BCF 0A.3 |
0DFC: CALL 212 |
0DFD: BSF 0A.3 |
0DFE: MOVLW 43 |
0DFF: MOVWF 4A |
0E00: BCF 0A.3 |
0E01: CALL 212 |
0E02: BSF 0A.3 |
0E03: MOVLW 20 |
0E04: MOVWF 4A |
0E05: BCF 0A.3 |
0E06: CALL 212 |
0E07: BSF 0A.3 |
0E08: MOVLW 89 |
0E09: MOVWF 04 |
0E0A: MOVF 36,W |
0E0B: MOVWF 40 |
0E0C: MOVF 35,W |
0E0D: MOVWF 3F |
0E0E: MOVF 34,W |
0E0F: MOVWF 3E |
0E10: MOVF 33,W |
0E11: MOVWF 3D |
0E12: MOVLW 02 |
0E13: MOVWF 41 |
0E14: CALL 2CB |
0E15: MOVLW 25 |
0E16: MOVWF 4A |
0E17: BCF 0A.3 |
0E18: CALL 212 |
0E19: BSF 0A.3 |
.................... lcd_gotoxy(1,2); |
0E1A: MOVLW 01 |
0E1B: MOVWF 4B |
0E1C: MOVLW 02 |
0E1D: MOVWF 4C |
0E1E: BCF 0A.3 |
0E1F: CALL 200 |
0E20: BSF 0A.3 |
.................... printf(lcd_putc,"%2.2f%cC %6.0fPa ",temp2, 0xb2, preasure); |
0E21: MOVLW 89 |
0E22: MOVWF 04 |
0E23: MOVF 2E,W |
0E24: MOVWF 40 |
0E25: MOVF 2D,W |
0E26: MOVWF 3F |
0E27: MOVF 2C,W |
0E28: MOVWF 3E |
0E29: MOVF 2B,W |
0E2A: MOVWF 3D |
0E2B: MOVLW 02 |
0E2C: MOVWF 41 |
0E2D: CALL 2CB |
0E2E: MOVLW B2 |
0E2F: MOVWF 4A |
0E30: BCF 0A.3 |
0E31: CALL 212 |
0E32: BSF 0A.3 |
0E33: MOVLW 43 |
0E34: MOVWF 4A |
0E35: BCF 0A.3 |
0E36: CALL 212 |
0E37: BSF 0A.3 |
0E38: MOVLW 20 |
0E39: MOVWF 4A |
0E3A: BCF 0A.3 |
0E3B: CALL 212 |
0E3C: BSF 0A.3 |
0E3D: MOVLW 05 |
0E3E: MOVWF 04 |
0E3F: MOVF 3A,W |
0E40: MOVWF 40 |
0E41: MOVF 39,W |
0E42: MOVWF 3F |
0E43: MOVF 38,W |
0E44: MOVWF 3E |
0E45: MOVF 37,W |
0E46: MOVWF 3D |
0E47: CLRF 41 |
0E48: CALL 2CB |
0E49: MOVLW 50 |
0E4A: MOVWF 4A |
0E4B: BCF 0A.3 |
0E4C: CALL 212 |
0E4D: BSF 0A.3 |
0E4E: MOVLW 61 |
0E4F: MOVWF 4A |
0E50: BCF 0A.3 |
0E51: CALL 212 |
0E52: BSF 0A.3 |
0E53: MOVLW 20 |
0E54: MOVWF 4A |
0E55: BCF 0A.3 |
0E56: CALL 212 |
0E57: BSF 0A.3 |
.................... |
.................... printf("%ld %f %f %f %6.2f %3.2f %Ld %Ld %Ld \n\r",i, temp1, humidity, temp2, preasure, temp3, compass.x, compass.y, compass.z); |
0E58: MOVLW 10 |
0E59: MOVWF 04 |
0E5A: MOVF 3C,W |
0E5B: MOVWF 3E |
0E5C: MOVF 3B,W |
0E5D: MOVWF 3D |
0E5E: CALL 39F |
0E5F: MOVLW 20 |
0E60: BTFSS 0C.4 |
0E61: GOTO 660 |
0E62: MOVWF 19 |
0E63: MOVLW 89 |
0E64: MOVWF 04 |
0E65: MOVF 2A,W |
0E66: MOVWF 40 |
0E67: MOVF 29,W |
0E68: MOVWF 3F |
0E69: MOVF 28,W |
0E6A: MOVWF 3E |
0E6B: MOVF 27,W |
0E6C: MOVWF 3D |
0E6D: MOVLW 02 |
0E6E: MOVWF 41 |
0E6F: CALL 415 |
0E70: MOVLW 20 |
0E71: BTFSS 0C.4 |
0E72: GOTO 671 |
0E73: MOVWF 19 |
0E74: MOVLW 89 |
0E75: MOVWF 04 |
0E76: MOVF 36,W |
0E77: MOVWF 40 |
0E78: MOVF 35,W |
0E79: MOVWF 3F |
0E7A: MOVF 34,W |
0E7B: MOVWF 3E |
0E7C: MOVF 33,W |
0E7D: MOVWF 3D |
0E7E: MOVLW 02 |
0E7F: MOVWF 41 |
0E80: CALL 415 |
0E81: MOVLW 20 |
0E82: BTFSS 0C.4 |
0E83: GOTO 682 |
0E84: MOVWF 19 |
0E85: MOVLW 89 |
0E86: MOVWF 04 |
0E87: MOVF 2E,W |
0E88: MOVWF 40 |
0E89: MOVF 2D,W |
0E8A: MOVWF 3F |
0E8B: MOVF 2C,W |
0E8C: MOVWF 3E |
0E8D: MOVF 2B,W |
0E8E: MOVWF 3D |
0E8F: MOVLW 02 |
0E90: MOVWF 41 |
0E91: CALL 415 |
0E92: MOVLW 20 |
0E93: BTFSS 0C.4 |
0E94: GOTO 693 |
0E95: MOVWF 19 |
0E96: MOVLW 05 |
0E97: MOVWF 04 |
0E98: MOVF 3A,W |
0E99: MOVWF 40 |
0E9A: MOVF 39,W |
0E9B: MOVWF 3F |
0E9C: MOVF 38,W |
0E9D: MOVWF 3E |
0E9E: MOVF 37,W |
0E9F: MOVWF 3D |
0EA0: MOVLW 02 |
0EA1: MOVWF 41 |
0EA2: CALL 415 |
0EA3: MOVLW 20 |
0EA4: BTFSS 0C.4 |
0EA5: GOTO 6A4 |
0EA6: MOVWF 19 |
0EA7: MOVLW 02 |
0EA8: MOVWF 04 |
0EA9: MOVF 32,W |
0EAA: MOVWF 40 |
0EAB: MOVF 31,W |
0EAC: MOVWF 3F |
0EAD: MOVF 30,W |
0EAE: MOVWF 3E |
0EAF: MOVF 2F,W |
0EB0: MOVWF 3D |
0EB1: MOVLW 02 |
0EB2: MOVWF 41 |
0EB3: CALL 415 |
0EB4: MOVLW 20 |
0EB5: BTFSS 0C.4 |
0EB6: GOTO 6B5 |
0EB7: MOVWF 19 |
0EB8: MOVLW 10 |
0EB9: MOVWF 04 |
0EBA: MOVF 22,W |
0EBB: MOVWF 3E |
0EBC: MOVF 21,W |
0EBD: MOVWF 3D |
0EBE: CALL 39F |
0EBF: MOVLW 20 |
0EC0: BTFSS 0C.4 |
0EC1: GOTO 6C0 |
0EC2: MOVWF 19 |
0EC3: MOVLW 10 |
0EC4: MOVWF 04 |
0EC5: MOVF 24,W |
0EC6: MOVWF 3E |
0EC7: MOVF 23,W |
0EC8: MOVWF 3D |
0EC9: CALL 39F |
0ECA: MOVLW 20 |
0ECB: BTFSS 0C.4 |
0ECC: GOTO 6CB |
0ECD: MOVWF 19 |
0ECE: MOVLW 10 |
0ECF: MOVWF 04 |
0ED0: MOVF 26,W |
0ED1: MOVWF 3E |
0ED2: MOVF 25,W |
0ED3: MOVWF 3D |
0ED4: CALL 39F |
0ED5: MOVLW 20 |
0ED6: BTFSS 0C.4 |
0ED7: GOTO 6D6 |
0ED8: MOVWF 19 |
0ED9: MOVLW 0A |
0EDA: BTFSS 0C.4 |
0EDB: GOTO 6DA |
0EDC: MOVWF 19 |
0EDD: MOVLW 0D |
0EDE: BTFSS 0C.4 |
0EDF: GOTO 6DE |
0EE0: MOVWF 19 |
.................... i++; |
0EE1: INCF 3B,F |
0EE2: BTFSC 03.2 |
0EE3: INCF 3C,F |
.................... |
.................... Delay_ms(100); |
0EE4: MOVLW 64 |
0EE5: MOVWF 4B |
0EE6: BCF 0A.3 |
0EE7: CALL 0FB |
0EE8: BSF 0A.3 |
.................... } |
0EE9: GOTO 5B1 |
.................... |
.................... } |
0EEA: SLEEP |
|
Configuration Fuses: |
Word 1: 2CF5 INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG |
Word 2: 3FFF NOWRT BORV40 |