CCS PCM C Compiler, Version 4.106, 47914 03-IX-13 00:32Filename: D:\MLAB\Designs\Measuring_instruments\GeoMet01A\SW\PIC16F887\main.lstROM used: 3183 words (39%)Largest free fragment is 2048RAM used: 27 (7%) at main() level52 (14%) worst caseStack: 5 locations*0000: MOVLW 0A0001: MOVWF 0A0002: GOTO 2B70003: 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 4300FC: MOVWF 0400FD: BCF 03.700FE: MOVF 00,W00FF: BTFSC 03.20100: GOTO 10E0101: MOVLW 020102: MOVWF 780103: CLRF 770104: DECFSZ 77,F0105: GOTO 1040106: DECFSZ 78,F0107: GOTO 1030108: MOVLW 970109: MOVWF 77010A: DECFSZ 77,F010B: GOTO 10A010C: DECFSZ 00,F010D: GOTO 101010E: RETURN.................... #use i2c(master, sda=PIN_C4, scl=PIN_C3)*0078: MOVLW 080079: MOVWF 78007A: NOP007B: BCF 07.3007C: BCF 20.3007D: MOVF 20,W007E: BSF 03.5007F: MOVWF 070080: NOP0081: BCF 03.50082: RLF 3B,F0083: BCF 07.40084: BTFSS 03.00085: GOTO 08C0086: BSF 20.40087: MOVF 20,W0088: BSF 03.50089: MOVWF 07008A: GOTO 090008B: BCF 03.5008C: BCF 20.4008D: MOVF 20,W008E: BSF 03.5008F: MOVWF 070090: NOP0091: BCF 03.50092: BSF 20.30093: MOVF 20,W0094: BSF 03.50095: MOVWF 070096: BCF 03.50097: BTFSS 07.30098: GOTO 0970099: DECFSZ 78,F009A: GOTO 07A009B: NOP009C: BCF 07.3009D: BCF 20.3009E: MOVF 20,W009F: BSF 03.500A0: MOVWF 0700A1: NOP00A2: BCF 03.500A3: BSF 20.400A4: MOVF 20,W00A5: BSF 03.500A6: MOVWF 0700A7: NOP00A8: NOP00A9: BCF 03.500AA: BSF 20.300AB: MOVF 20,W00AC: BSF 03.500AD: MOVWF 0700AE: BCF 03.500AF: BTFSS 07.300B0: GOTO 0AF00B1: CLRF 7800B2: NOP00B3: BTFSC 07.400B4: BSF 78.000B5: BCF 07.300B6: BCF 20.300B7: MOVF 20,W00B8: BSF 03.500B9: MOVWF 0700BA: BCF 03.500BB: BCF 07.400BC: BCF 20.400BD: MOVF 20,W00BE: BSF 03.500BF: MOVWF 0700C0: BCF 03.500C1: RETURN*0285: MOVLW 080286: MOVWF 3C0287: MOVF 77,W0288: MOVWF 3D0289: BSF 20.4028A: MOVF 20,W028B: BSF 03.5028C: MOVWF 07028D: NOP028E: BCF 03.5028F: BSF 20.30290: MOVF 20,W0291: BSF 03.50292: MOVWF 070293: BCF 03.50294: BTFSS 07.30295: GOTO 2940296: BTFSC 07.40297: BSF 03.00298: BTFSS 07.40299: BCF 03.0029A: RLF 78,F029B: NOP029C: BCF 20.3029D: MOVF 20,W029E: BSF 03.5029F: MOVWF 0702A0: BCF 03.502A1: BCF 07.302A2: DECFSZ 3C,F02A3: GOTO 28902A4: BSF 20.402A5: MOVF 20,W02A6: BSF 03.502A7: MOVWF 0702A8: NOP02A9: BCF 03.502AA: BCF 07.402AB: MOVF 3D,W02AC: BTFSC 03.202AD: GOTO 2B302AE: BCF 20.402AF: MOVF 20,W02B0: BSF 03.502B1: MOVWF 0702B2: BCF 03.502B3: NOP02B4: BSF 20.302B5: MOVF 20,W02B6: BSF 03.502B7: MOVWF 0702B8: BCF 03.502B9: BTFSS 07.302BA: GOTO 2B902BB: NOP02BC: BCF 07.302BD: BCF 20.302BE: MOVF 20,W02BF: BSF 03.502C0: MOVWF 0702C1: NOP02C2: BCF 03.502C3: BCF 07.402C4: BCF 20.402C5: MOVF 20,W02C6: BSF 03.502C7: MOVWF 0702C8: BCF 03.502C9: 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.50179: BSF 09.2017A: BSF 03.5017B: BCF 09.2.................... delay_cycles(1);017C: NOP.................... lcd_output_enable(1);017D: BCF 03.5017E: BSF 09.0017F: BSF 03.50180: BCF 09.0.................... delay_cycles(1);0181: NOP.................... high = lcd_read_nibble();0182: BCF 03.50183: CALL 13B0184: MOVF 78,W0185: MOVWF 4A........................................ lcd_output_enable(0);0186: BCF 09.00187: BSF 03.50188: BCF 09.0.................... delay_cycles(1);0189: NOP.................... lcd_output_enable(1);018A: BCF 03.5018B: BSF 09.0018C: BSF 03.5018D: BCF 09.0.................... delay_us(1);018E: GOTO 18F.................... low = lcd_read_nibble();018F: BCF 03.50190: CALL 13B0191: MOVF 78,W0192: MOVWF 49........................................ lcd_output_enable(0);0193: BCF 09.00194: BSF 03.50195: 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.5019B: SWAPF 4A,W019C: MOVWF 77019D: MOVLW F0019E: ANDWF 77,F019F: MOVF 77,W01A0: IORWF 49,W01A1: MOVWF 78.................... }........................................ BYTE lcd_read_nibble(void).................... {.................... #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))*013B: CLRF 4B.................... BYTE n = 0x00;........................................ /* Read the data port */.................... n |= input(LCD_DATA4);013C: BSF 03.5013D: BSF 08.4013E: MOVLW 00013F: BCF 03.50140: BTFSC 08.40141: MOVLW 010142: IORWF 4B,F.................... n |= input(LCD_DATA5) << 1;0143: BSF 03.50144: BSF 08.50145: MOVLW 000146: BCF 03.50147: BTFSC 08.50148: MOVLW 010149: MOVWF 77014A: BCF 03.0014B: RLF 77,F014C: MOVF 77,W014D: IORWF 4B,F.................... n |= input(LCD_DATA6) << 2;014E: BSF 03.5014F: BSF 08.60150: MOVLW 000151: BCF 03.50152: BTFSC 08.60153: MOVLW 010154: MOVWF 770155: RLF 77,F0156: RLF 77,F0157: MOVLW FC0158: ANDWF 77,F0159: MOVF 77,W015A: IORWF 4B,F.................... n |= input(LCD_DATA7) << 3;015B: BSF 03.5015C: BSF 08.7015D: MOVLW 00015E: BCF 03.5015F: BTFSC 08.70160: MOVLW 010161: MOVWF 770162: RLF 77,F0163: RLF 77,F0164: RLF 77,F0165: MOVLW F80166: ANDWF 77,F0167: MOVF 77,W0168: IORWF 4B,F........................................ return(n);0169: MOVF 4B,W016A: 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 4A.00110: GOTO 1130111: BCF 08.40112: GOTO 1140113: BSF 08.40114: BSF 03.50115: BCF 08.4.................... output_bit(LCD_DATA5, bit_test(n, 1));0116: BCF 03.50117: BTFSC 4A.10118: GOTO 11B0119: BCF 08.5011A: GOTO 11C011B: BSF 08.5011C: BSF 03.5011D: BCF 08.5.................... output_bit(LCD_DATA6, bit_test(n, 2));011E: BCF 03.5011F: BTFSC 4A.20120: GOTO 1230121: BCF 08.60122: GOTO 1240123: BSF 08.60124: BSF 03.50125: BCF 08.6.................... output_bit(LCD_DATA7, bit_test(n, 3));0126: BCF 03.50127: BTFSC 4A.30128: GOTO 12B0129: BCF 08.7012A: GOTO 12C012B: BSF 08.7012C: BSF 03.5012D: BCF 08.7.................... #else.................... lcdlat.data = n;.................... #endif........................................ delay_cycles(1);012E: NOP.................... lcd_output_enable(1);012F: BCF 03.50130: BSF 09.00131: BSF 03.50132: BCF 09.0.................... delay_us(2);0133: GOTO 1340134: GOTO 135.................... lcd_output_enable(0);0135: BCF 03.50136: BCF 09.00137: BSF 03.50138: BCF 09.0.................... }0139: BCF 03.5013A: 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.5016D: 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.50171: BCF 09.10172: BSF 03.50173: BCF 09.1.................... while ( bit_test(lcd_read_byte(),7) ) ;*01A2: MOVF 78,W01A3: MOVWF 4901A4: BTFSS 49.701A5: GOTO 1A801A6: BSF 03.501A7: GOTO 174.................... lcd_output_rs(address);01A8: MOVF 47,F01A9: BTFSS 03.201AA: GOTO 1AD01AB: BCF 09.101AC: GOTO 1AE01AD: BSF 09.101AE: BSF 03.501AF: BCF 09.1.................... delay_cycles(1);01B0: NOP.................... lcd_output_rw(0);01B1: BCF 03.501B2: BCF 09.201B3: BSF 03.501B4: BCF 09.2.................... delay_cycles(1);01B5: NOP.................... lcd_output_enable(0);01B6: BCF 03.501B7: BCF 09.001B8: BSF 03.501B9: BCF 09.0.................... lcd_send_nibble(n >> 4);01BA: BCF 03.501BB: SWAPF 48,W01BC: MOVWF 4901BD: MOVLW 0F01BE: ANDWF 49,F01BF: MOVF 49,W01C0: MOVWF 4A01C1: CALL 10F.................... lcd_send_nibble(n & 0xf);01C2: MOVF 48,W01C3: ANDLW 0F01C4: MOVWF 4901C5: MOVWF 4A01C6: 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.501C9: 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.501D1: BCF 09.101D2: BSF 03.501D3: BCF 09.1.................... lcd_output_rw(0);01D4: BCF 03.501D5: BCF 09.201D6: BSF 03.501D7: BCF 09.2.................... lcd_output_enable(0);01D8: BCF 03.501D9: BCF 09.001DA: BSF 03.501DB: BCF 09.0........................................ delay_ms(15);01DC: MOVLW 0F01DD: BCF 03.501DE: MOVWF 4301DF: CALL 0FB.................... for(i=1;i<=3;++i)01E0: MOVLW 0101E1: MOVWF 3501E2: MOVF 35,W01E3: SUBLW 0301E4: BTFSS 03.001E5: GOTO 1EE.................... {.................... lcd_send_nibble(3);01E6: MOVLW 0301E7: MOVWF 4A01E8: CALL 10F.................... delay_ms(5);01E9: MOVLW 0501EA: MOVWF 4301EB: CALL 0FB.................... }01EC: INCF 35,F01ED: GOTO 1E2........................................ lcd_send_nibble(2);01EE: MOVLW 0201EF: MOVWF 4A01F0: CALL 10F.................... for(i=0;i<=3;++i)01F1: CLRF 3501F2: MOVF 35,W01F3: SUBLW 0301F4: BTFSS 03.001F5: GOTO 1FF.................... lcd_send_byte(0,LCD_INIT_STRING[i]);01F6: MOVF 35,W01F7: CALL 00401F8: MOVWF 3601F9: CLRF 4701FA: MOVF 36,W01FB: MOVWF 4801FC: CALL 16C........................................ #if defined(LCD_EXTENDED_NEWLINE)01FD: INCF 35,F01FE: 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 44,W0201: GOTO 2030202: GOTO 206.................... address=LCD_LINE_TWO;0203: MOVLW 400204: MOVWF 45.................... else0205: GOTO 207.................... address=0;0206: CLRF 45........................................ address+=x-1;0207: MOVLW 010208: SUBWF 43,W0209: ADDWF 45,F.................... lcd_send_byte(0,0x80|address);020A: MOVF 45,W020B: IORLW 80020C: MOVWF 46020D: CLRF 47020E: MOVF 46,W020F: MOVWF 480210: 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 42,W0213: XORLW 070214: BTFSC 03.20215: GOTO 2200216: XORLW 0B0217: BTFSC 03.20218: GOTO 2250219: XORLW 06021A: BTFSC 03.2021B: GOTO 22D021C: XORLW 02021D: BTFSC 03.2021E: GOTO 233021F: GOTO 238.................... case '\a' : lcd_gotoxy(1,1); break;0220: MOVLW 010221: MOVWF 430222: MOVWF 440223: CALL 2000224: GOTO 23E........................................ case '\f' : lcd_send_byte(0,1);0225: CLRF 470226: MOVLW 010227: MOVWF 480228: CALL 16C.................... delay_ms(2);0229: MOVLW 02022A: MOVWF 43022B: 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 01022E: MOVWF 43022F: MOVLW 020230: MOVWF 440231: CALL 2000232: GOTO 23E.................... #endif........................................ case '\b' : lcd_send_byte(0,0x10); break;0233: CLRF 470234: MOVLW 100235: MOVWF 480236: CALL 16C0237: 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 010239: MOVWF 47023A: MOVF 42,W023B: MOVWF 48023C: CALL 16C023D: 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.40568: MOVF 20,W0569: BSF 03.5056A: MOVWF 07056B: NOP056C: BCF 03.5056D: BSF 20.3056E: MOVF 20,W056F: BSF 03.50570: MOVWF 070571: NOP0572: BCF 03.50573: BTFSS 07.30574: GOTO 5730575: BCF 07.40576: BCF 20.40577: MOVF 20,W0578: BSF 03.50579: MOVWF 07057A: NOP057B: BCF 03.5057C: BCF 07.3057D: BCF 20.3057E: MOVF 20,W057F: BSF 03.50580: MOVWF 07.................... I2C_Write(SHT25_ADDR);0581: MOVLW 800582: BCF 03.50583: MOVWF 3B0584: CALL 078.................... I2C_write(0xE3);0585: MOVLW E30586: MOVWF 3B0587: CALL 078.................... i2c_stop();0588: BCF 20.40589: MOVF 20,W058A: BSF 03.5058B: MOVWF 07058C: NOP058D: BCF 03.5058E: BSF 20.3058F: MOVF 20,W0590: BSF 03.50591: MOVWF 070592: BCF 03.50593: BTFSS 07.30594: GOTO 5930595: NOP0596: GOTO 5970597: NOP0598: BSF 20.40599: MOVF 20,W059A: BSF 03.5059B: MOVWF 07059C: NOP........................................ delay_ms(100);059D: MOVLW 64059E: BCF 03.5059F: MOVWF 4305A0: CALL 0FB........................................ i2c_start();05A1: BSF 20.405A2: MOVF 20,W05A3: BSF 03.505A4: MOVWF 0705A5: NOP05A6: BCF 03.505A7: BSF 20.305A8: MOVF 20,W05A9: BSF 03.505AA: MOVWF 0705AB: NOP05AC: BCF 03.505AD: BCF 07.405AE: BCF 20.405AF: MOVF 20,W05B0: BSF 03.505B1: MOVWF 0705B2: NOP05B3: BCF 03.505B4: BCF 07.305B5: BCF 20.305B6: MOVF 20,W05B7: BSF 03.505B8: MOVWF 07.................... I2C_Write(SHT25_ADDR+1);05B9: MOVLW 8105BA: BCF 03.505BB: MOVWF 3B05BC: CALL 078.................... MSB=i2c_read(1);05BD: MOVLW 0105BE: MOVWF 7705BF: CALL 28505C0: MOVF 78,W05C1: MOVWF 35.................... LSB=i2c_read(1);05C2: MOVLW 0105C3: MOVWF 7705C4: CALL 28505C5: MOVF 78,W05C6: MOVWF 36.................... Check=i2c_read(0);05C7: CLRF 7705C8: CALL 28505C9: MOVF 78,W05CA: MOVWF 37.................... i2c_stop();05CB: BCF 20.405CC: MOVF 20,W05CD: BSF 03.505CE: MOVWF 0705CF: NOP05D0: BCF 03.505D1: BSF 20.305D2: MOVF 20,W05D3: BSF 03.505D4: MOVWF 0705D5: BCF 03.505D6: BTFSS 07.305D7: GOTO 5D605D8: NOP05D9: GOTO 5DA05DA: NOP05DB: BSF 20.405DC: MOVF 20,W05DD: BSF 03.505DE: MOVWF 0705DF: NOP........................................ LSB = LSB >> 2; // trow out status bits05E0: BCF 03.505E1: RRF 36,F05E2: RRF 36,F05E3: MOVLW 3F05E4: ANDWF 36,F........................................ data = (((unsigned int16) MSB << 8) + (LSB << 4));05E5: CLRF 3B05E6: MOVF 35,W05E7: MOVWF 3A05E8: MOVWF 3B05E9: CLRF 3A05EA: SWAPF 36,W05EB: MOVWF 7705EC: MOVLW F005ED: ANDWF 77,F05EE: MOVF 77,W05EF: ADDWF 3A,W05F0: MOVWF 3805F1: MOVF 3B,W05F2: MOVWF 3905F3: BTFSC 03.005F4: INCF 39,F.................... return(-46.85 + 175.72*((float)data/0xFFFF));05F5: MOVF 39,W05F6: MOVWF 3B05F7: MOVF 38,W05F8: MOVWF 3A05F9: CALL 2CA05FA: MOVF 77,W05FB: MOVWF 3A05FC: MOVF 78,W05FD: MOVWF 3B05FE: MOVF 79,W05FF: MOVWF 3C0600: MOVF 7A,W0601: MOVWF 3D0602: MOVWF 410603: MOVF 79,W0604: MOVWF 400605: MOVF 78,W0606: MOVWF 3F0607: MOVF 77,W0608: MOVWF 3E0609: CLRF 45060A: MOVLW FF060B: MOVWF 44060C: MOVLW 7F060D: MOVWF 43060E: MOVLW 8E060F: MOVWF 420610: CALL 2E70611: MOVLW 520612: MOVWF 450613: MOVLW B80614: MOVWF 440615: MOVLW 2F0616: MOVWF 430617: MOVLW 860618: MOVWF 420619: MOVF 7A,W061A: MOVWF 49061B: MOVF 79,W061C: MOVWF 48061D: MOVF 78,W061E: MOVWF 47061F: MOVF 77,W0620: MOVWF 460621: CALL 3B10622: BCF 03.10623: MOVLW 660624: MOVWF 3D0625: MOVWF 3C0626: MOVLW BB0627: MOVWF 3B0628: MOVLW 840629: MOVWF 3A062A: MOVF 7A,W062B: MOVWF 41062C: MOVF 79,W062D: MOVWF 40062E: MOVF 78,W062F: MOVWF 3F0630: MOVF 77,W0631: MOVWF 3E0632: CALL 426.................... }0633: BSF 0A.30634: BCF 0A.40635: GOTO 38B (RETURN)........................................ float SHT25_get_hum().................... {.................... unsigned int8 MSB, LSB, Check;.................... unsigned int16 data;........................................ i2c_start(); //RH0636: BSF 20.40637: MOVF 20,W0638: BSF 03.50639: MOVWF 07063A: NOP063B: BCF 03.5063C: BSF 20.3063D: MOVF 20,W063E: BSF 03.5063F: MOVWF 070640: NOP0641: BCF 03.50642: BCF 07.40643: BCF 20.40644: MOVF 20,W0645: BSF 03.50646: MOVWF 070647: NOP0648: BCF 03.50649: BCF 07.3064A: BCF 20.3064B: MOVF 20,W064C: BSF 03.5064D: MOVWF 07.................... I2C_Write(SHT25_ADDR);064E: MOVLW 80064F: BCF 03.50650: MOVWF 3B0651: CALL 078.................... I2C_write(0xE5);0652: MOVLW E50653: MOVWF 3B0654: CALL 078........................................ delay_ms(100);0655: MOVLW 640656: MOVWF 430657: CALL 0FB........................................ i2c_start();0658: BSF 20.40659: MOVF 20,W065A: BSF 03.5065B: MOVWF 07065C: NOP065D: BCF 03.5065E: BSF 20.3065F: MOVF 20,W0660: BSF 03.50661: MOVWF 070662: NOP0663: BCF 03.50664: BTFSS 07.30665: GOTO 6640666: BCF 07.40667: BCF 20.40668: MOVF 20,W0669: BSF 03.5066A: MOVWF 07066B: NOP066C: BCF 03.5066D: BCF 07.3066E: BCF 20.3066F: MOVF 20,W0670: BSF 03.50671: MOVWF 07.................... I2C_Write(SHT25_ADDR+1);0672: MOVLW 810673: BCF 03.50674: MOVWF 3B0675: CALL 078.................... MSB=i2c_read(1);0676: MOVLW 010677: MOVWF 770678: CALL 2850679: MOVF 78,W067A: MOVWF 35.................... LSB=i2c_read(1);067B: MOVLW 01067C: MOVWF 77067D: CALL 285067E: MOVF 78,W067F: MOVWF 36.................... Check=i2c_read(0);0680: CLRF 770681: CALL 2850682: MOVF 78,W0683: MOVWF 37.................... i2c_stop();0684: BCF 20.40685: MOVF 20,W0686: BSF 03.50687: MOVWF 070688: NOP0689: BCF 03.5068A: BSF 20.3068B: MOVF 20,W068C: BSF 03.5068D: MOVWF 07068E: BCF 03.5068F: BTFSS 07.30690: GOTO 68F0691: NOP0692: GOTO 6930693: NOP0694: BSF 20.40695: MOVF 20,W0696: BSF 03.50697: MOVWF 070698: NOP........................................ LSB = LSB >> 2; // trow out status bits0699: BCF 03.5069A: RRF 36,F069B: RRF 36,F069C: MOVLW 3F069D: ANDWF 36,F........................................ data = (((unsigned int16) MSB << 8) + (LSB << 4) );069E: CLRF 3B069F: MOVF 35,W06A0: MOVWF 3A06A1: MOVWF 3B06A2: CLRF 3A06A3: SWAPF 36,W06A4: MOVWF 7706A5: MOVLW F006A6: ANDWF 77,F06A7: MOVF 77,W06A8: ADDWF 3A,W06A9: MOVWF 3806AA: MOVF 3B,W06AB: MOVWF 3906AC: BTFSC 03.006AD: INCF 39,F.................... return( -6.0 + 125.0*((float)data/0xFFFF));06AE: MOVF 39,W06AF: MOVWF 3B06B0: MOVF 38,W06B1: MOVWF 3A06B2: CALL 2CA06B3: MOVF 77,W06B4: MOVWF 3A06B5: MOVF 78,W06B6: MOVWF 3B06B7: MOVF 79,W06B8: MOVWF 3C06B9: MOVF 7A,W06BA: MOVWF 3D06BB: MOVWF 4106BC: MOVF 79,W06BD: MOVWF 4006BE: MOVF 78,W06BF: MOVWF 3F06C0: MOVF 77,W06C1: MOVWF 3E06C2: CLRF 4506C3: MOVLW FF06C4: MOVWF 4406C5: MOVLW 7F06C6: MOVWF 4306C7: MOVLW 8E06C8: MOVWF 4206C9: CALL 2E706CA: CLRF 4506CB: CLRF 4406CC: MOVLW 7A06CD: MOVWF 4306CE: MOVLW 8506CF: MOVWF 4206D0: MOVF 7A,W06D1: MOVWF 4906D2: MOVF 79,W06D3: MOVWF 4806D4: MOVF 78,W06D5: MOVWF 4706D6: MOVF 77,W06D7: MOVWF 4606D8: CALL 3B106D9: BCF 03.106DA: CLRF 3D06DB: CLRF 3C06DC: MOVLW C006DD: MOVWF 3B06DE: MOVLW 8106DF: MOVWF 3A06E0: MOVF 7A,W06E1: MOVWF 4106E2: MOVF 79,W06E3: MOVWF 4006E4: MOVF 78,W06E5: MOVWF 3F06E6: MOVF 77,W06E7: MOVWF 3E06E8: CALL 426.................... }06E9: BSF 0A.306EA: BCF 0A.406EB: GOTO 396 (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.406ED: MOVF 20,W06EE: BSF 03.506EF: MOVWF 0706F0: NOP06F1: BCF 03.506F2: BSF 20.306F3: MOVF 20,W06F4: BSF 03.506F5: MOVWF 0706F6: NOP06F7: BCF 03.506F8: BCF 07.406F9: BCF 20.406FA: MOVF 20,W06FB: BSF 03.506FC: MOVWF 0706FD: NOP06FE: BCF 03.506FF: BCF 07.30700: BCF 20.30701: MOVF 20,W0702: BSF 03.50703: MOVWF 07.................... I2C_Write(LTS01A_address);0704: MOVLW 900705: BCF 03.50706: MOVWF 3B0707: CALL 078.................... I2C_write(0x00);0708: CLRF 3B0709: CALL 078.................... i2c_stop();070A: BCF 20.4070B: MOVF 20,W070C: BSF 03.5070D: MOVWF 07070E: NOP070F: BCF 03.50710: BSF 20.30711: MOVF 20,W0712: BSF 03.50713: MOVWF 070714: BCF 03.50715: BTFSS 07.30716: GOTO 7150717: NOP0718: GOTO 7190719: NOP071A: BSF 20.4071B: MOVF 20,W071C: BSF 03.5071D: MOVWF 07071E: NOP.................... i2c_start();071F: BCF 03.50720: BSF 20.40721: MOVF 20,W0722: BSF 03.50723: MOVWF 070724: NOP0725: BCF 03.50726: BSF 20.30727: MOVF 20,W0728: BSF 03.50729: MOVWF 07072A: NOP072B: BCF 03.5072C: BCF 07.4072D: BCF 20.4072E: MOVF 20,W072F: BSF 03.50730: MOVWF 070731: NOP0732: BCF 03.50733: BCF 07.30734: BCF 20.30735: MOVF 20,W0736: BSF 03.50737: MOVWF 07.................... I2C_Write(LTS01A_address+1);0738: MOVLW 910739: BCF 03.5073A: MOVWF 3B073B: CALL 078.................... MSB=i2c_read(1);073C: MOVLW 01073D: MOVWF 77073E: CALL 285073F: MOVF 78,W0740: MOVWF 35.................... LSB=i2c_read(0);0741: CLRF 770742: CALL 2850743: MOVF 78,W0744: MOVWF 36.................... i2c_stop();0745: BCF 20.40746: MOVF 20,W0747: BSF 03.50748: MOVWF 070749: NOP074A: BCF 03.5074B: BSF 20.3074C: MOVF 20,W074D: BSF 03.5074E: MOVWF 07074F: BCF 03.50750: BTFSS 07.30751: GOTO 7500752: NOP0753: GOTO 7540754: NOP0755: BSF 20.40756: MOVF 20,W0757: BSF 03.50758: MOVWF 070759: NOP........................................ data = MAKE16(MSB,LSB);075A: BCF 03.5075B: MOVF 35,W075C: MOVWF 38075D: MOVF 36,W075E: MOVWF 37........................................ return (data * 0.00390625 );075F: MOVF 38,W0760: MOVWF 3A0761: MOVF 37,W0762: MOVWF 390763: MOVF 3A,W0764: MOVWF 3C0765: MOVF 39,W0766: MOVWF 3B*078B: MOVF 7A,W078C: MOVWF 45078D: MOVF 79,W078E: MOVWF 44078F: MOVF 78,W0790: MOVWF 430791: MOVF 77,W0792: MOVWF 420793: CLRF 490794: CLRF 480795: CLRF 470796: MOVLW 770797: MOVWF 460798: CALL 3B1........................................ }0799: BSF 0A.3079A: BCF 0A.4079B: GOTO 3A1 (RETURN)................................................................................ #include "./HMC5883L.h".................... // i2c slave addresses.................... #define HMC5883L_WRT_ADDR 0x3C.................... #define HMC5883L_READ_ADDR 0x3D........................................ // Register addresses.................... #define HMC5883L_CFG_A_REG 0x00.................... #define HMC5883L_CFG_B_REG 0x01.................... #define HMC5883L_MODE_REG 0x02.................... #define HMC5883L_X_MSB_REG 0x03........................................ //Konstanty nastavujici rozsah.................... //pro void set_mag_roz (unsigned int8 h).................... #define MAG_ROZ088 0x00.................... #define MAG_ROZ130 0x20.................... #define MAG_ROZ190 0x40.................... #define MAG_ROZ250 0x60.................... #define MAG_ROZ400 0x80.................... #define MAG_ROZ470 0xA0.................... #define MAG_ROZ560 0xC0.................... #define MAG_ROZ810 0xE0............................................................ #include "HMC5883L.c".................... //------------------------------.................... // Low level routines.................... //------------------------------.................... void hmc5883l_write_reg(int8 reg, int8 data).................... {.................... i2c_start();*00C2: BSF 20.400C3: MOVF 20,W00C4: BSF 03.500C5: MOVWF 0700C6: NOP00C7: BCF 03.500C8: BSF 20.300C9: MOVF 20,W00CA: BSF 03.500CB: MOVWF 0700CC: NOP00CD: BCF 03.500CE: BCF 07.400CF: BCF 20.400D0: MOVF 20,W00D1: BSF 03.500D2: MOVWF 0700D3: NOP00D4: BCF 03.500D5: BCF 07.300D6: BCF 20.300D7: MOVF 20,W00D8: BSF 03.500D9: MOVWF 07.................... i2c_write(HMC5883L_WRT_ADDR);00DA: MOVLW 3C00DB: BCF 03.500DC: MOVWF 3B00DD: CALL 078.................... i2c_write(reg);00DE: MOVF 35,W00DF: MOVWF 3B00E0: CALL 078.................... i2c_write(data);00E1: MOVF 36,W00E2: MOVWF 3B00E3: CALL 078.................... i2c_stop();00E4: BCF 20.400E5: MOVF 20,W00E6: BSF 03.500E7: MOVWF 0700E8: NOP00E9: BCF 03.500EA: BSF 20.300EB: MOVF 20,W00EC: BSF 03.500ED: MOVWF 0700EE: BCF 03.500EF: BTFSS 07.300F0: GOTO 0EF00F1: NOP00F2: GOTO 0F300F3: NOP00F4: BSF 20.400F5: MOVF 20,W00F6: BSF 03.500F7: MOVWF 0700F8: NOP.................... }00F9: BCF 03.500FA: RETURN........................................ //------------------------------.................... int8 hmc5883l_read_reg(int8 reg).................... {.................... int8 retval;........................................ i2c_start();.................... i2c_write(HMC5883L_WRT_ADDR);.................... i2c_write(reg);.................... i2c_start();.................... i2c_write(HMC5883L_READ_ADDR);.................... retval = i2c_read(0);.................... i2c_stop();........................................ return(retval);.................... }........................................ //------------------------------.................... typedef struct.................... {.................... signed int16 x;.................... signed int16 y;.................... signed int16 z;.................... }hmc5883l_result;........................................ // This global structure holds the values read.................... // from the HMC5883L x,y,z registers..................... hmc5883l_result compass = {0,0,0};*0ADB: CLRF 210ADC: CLRF 220ADD: CLRF 230ADE: CLRF 240ADF: CLRF 250AE0: 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.40801: MOVF 20,W0802: BSF 03.50803: MOVWF 070804: NOP0805: BCF 03.50806: BSF 20.30807: MOVF 20,W0808: BSF 03.50809: MOVWF 07080A: NOP080B: BCF 03.5080C: BCF 07.4080D: BCF 20.4080E: MOVF 20,W080F: BSF 03.50810: MOVWF 070811: NOP0812: BCF 03.50813: BCF 07.30814: BCF 20.30815: MOVF 20,W0816: BSF 03.50817: MOVWF 07.................... i2c_write(HMC5883L_WRT_ADDR);0818: MOVLW 3C0819: BCF 03.5081A: MOVWF 3B081B: BCF 0A.3081C: CALL 078081D: BSF 0A.3.................... i2c_write(HMC5883L_X_MSB_REG); // Point to X-msb register081E: MOVLW 03081F: MOVWF 3B0820: BCF 0A.30821: CALL 0780822: BSF 0A.3.................... i2c_start();0823: BSF 20.40824: MOVF 20,W0825: BSF 03.50826: MOVWF 070827: NOP0828: BCF 03.50829: BSF 20.3082A: MOVF 20,W082B: BSF 03.5082C: MOVWF 07082D: NOP082E: BCF 03.5082F: BTFSS 07.30830: GOTO 02F0831: BCF 07.40832: BCF 20.40833: MOVF 20,W0834: BSF 03.50835: MOVWF 070836: NOP0837: BCF 03.50838: BCF 07.30839: BCF 20.3083A: MOVF 20,W083B: BSF 03.5083C: MOVWF 07.................... i2c_write(HMC5883L_READ_ADDR);083D: MOVLW 3D083E: BCF 03.5083F: MOVWF 3B0840: BCF 0A.30841: CALL 0780842: BSF 0A.3........................................ x_msb = i2c_read();0843: MOVLW 010844: MOVWF 770845: BCF 0A.30846: CALL 2850847: BSF 0A.30848: MOVF 78,W0849: MOVWF 36.................... x_lsb = i2c_read();084A: MOVLW 01084B: MOVWF 77084C: BCF 0A.3084D: CALL 285084E: BSF 0A.3084F: MOVF 78,W0850: MOVWF 35........................................ z_msb = i2c_read();0851: MOVLW 010852: MOVWF 770853: BCF 0A.30854: CALL 2850855: BSF 0A.30856: MOVF 78,W0857: MOVWF 3A.................... z_lsb = i2c_read();0858: MOVLW 010859: MOVWF 77085A: BCF 0A.3085B: CALL 285085C: BSF 0A.3085D: MOVF 78,W085E: MOVWF 39........................................ y_msb = i2c_read();085F: MOVLW 010860: MOVWF 770861: BCF 0A.30862: CALL 2850863: BSF 0A.30864: MOVF 78,W0865: MOVWF 38.................... y_lsb = i2c_read(0); // do a NACK on last read0866: CLRF 770867: BCF 0A.30868: CALL 2850869: BSF 0A.3086A: MOVF 78,W086B: MOVWF 37........................................ i2c_stop();086C: BCF 20.4086D: MOVF 20,W086E: BSF 03.5086F: MOVWF 070870: NOP0871: BCF 03.50872: BSF 20.30873: MOVF 20,W0874: BSF 03.50875: MOVWF 070876: BCF 03.50877: BTFSS 07.30878: GOTO 0770879: NOP087A: GOTO 07B087B: NOP087C: BSF 20.4087D: MOVF 20,W087E: BSF 03.5087F: MOVWF 070880: NOP........................................ // Combine high and low bytes into 16-bit values..................... compass.x = make16(x_msb, x_lsb);0881: BCF 03.50882: MOVF 36,W0883: MOVWF 220884: MOVF 35,W0885: MOVWF 21.................... compass.y = make16(y_msb, y_lsb);0886: MOVF 38,W0887: MOVWF 240888: MOVF 37,W0889: MOVWF 23.................... compass.z = make16(z_msb, z_lsb);088A: MOVF 3A,W088B: MOVWF 26088C: MOVF 39,W088D: MOVWF 25.................... }088E: BSF 0A.3088F: BCF 0A.40890: GOTO 3AB (RETURN).................................................................................................... #include <math.h>.................... ////////////////////////////////////////////////////////////////////////////.................... //// (C) Copyright 1996,2008 Custom Computer Services ////.................... //// This source code may only be used by licensed users of the CCS C ////.................... //// compiler. This source code may only be distributed to other ////.................... //// licensed users of the CCS C compiler. No other use, reproduction ////.................... //// or distribution is permitted without written permission. ////.................... //// Derivative programs created using this software in object code ////.................... //// form are not restricted in any way. ////.................... ////////////////////////////////////////////////////////////////////////////.................... //// ////.................... //// History: ////.................... //// * 9/20/2001 : Improvments are made to sin/cos code. ////.................... //// The code now is small, much faster, ////.................... //// and more accurate. ////.................... //// * 2/21/2007 : Compiler handles & operator differently and does.................... //// not return generic (int8 *) so type cast is done ////.................... //// ////.................... ////////////////////////////////////////////////////////////////////////////........................................ #ifndef MATH_H.................... #define MATH_H........................................ #ifdef PI.................... #undef PI.................... #endif.................... #define PI 3.1415926535897932............................................................ #define SQRT2 1.4142135623730950........................................ //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279};.................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718};........................................ ///////////////////////////// Round Functions //////////////////////////////........................................ float32 CEIL_FLOOR(float32 x, unsigned int8 n).................... {.................... float32 y, res;.................... unsigned int16 l;.................... int1 s;........................................ s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y <= 32768.0).................... res = (float32)(unsigned int16)y;........................................ else if (y < 10000000.0).................... {.................... l = (unsigned int16)(y/32768.0);.................... y = 32768.0*(y/32768.0 - (float32)l);.................... res = 32768.0*(float32)l;.................... res += (float32)(unsigned int16)y;.................... }........................................ else.................... res = y;........................................ y = y - (float32)(unsigned int16)y;........................................ if (s).................... res = -res;........................................ if (y != 0).................... {.................... if (s == 1 && n == 0).................... res -= 1.0;........................................ if (s == 0 && n == 1).................... res += 1.0;.................... }.................... if (x == 0).................... res = 0;........................................ return (res);.................... }........................................ // Overloaded Functions to take care for new Data types in PCD.................... // Overloaded function CEIL_FLOOR() for data type - Float48.................... #if defined(__PCD__).................... float48 CEIL_FLOOR(float48 x, unsigned int8 n).................... {.................... float48 y, res;.................... unsigned int16 l;.................... int1 s;........................................ s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y <= 32768.0).................... res = (float48)(unsigned int16)y;........................................ else if (y < 10000000.0).................... {.................... l = (unsigned int16)(y/32768.0);.................... y = 32768.0*(y/32768.0 - (float48)l);.................... res = 32768.0*(float32)l;.................... res += (float48)(unsigned int16)y;.................... }........................................ else.................... res = y;........................................ y = y - (float48)(unsigned int16)y;........................................ if (s).................... res = -res;........................................ if (y != 0).................... {.................... if (s == 1 && n == 0).................... res -= 1.0;........................................ if (s == 0 && n == 1).................... res += 1.0;.................... }.................... if (x == 0).................... res = 0;........................................ return (res);.................... }............................................................ // Overloaded function CEIL_FLOOR() for data type - Float64.................... float64 CEIL_FLOOR(float64 x, unsigned int8 n).................... {.................... float64 y, res;.................... unsigned int16 l;.................... int1 s;........................................ s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y <= 32768.0).................... res = (float64)(unsigned int16)y;........................................ else if (y < 10000000.0).................... {.................... l = (unsigned int16)(y/32768.0);.................... y = 32768.0*(y/32768.0 - (float64)l);.................... res = 32768.0*(float64)l;.................... res += (float64)(unsigned int16)y;.................... }........................................ else.................... res = y;........................................ y = y - (float64)(unsigned int16)y;........................................ if (s).................... res = -res;........................................ if (y != 0).................... {.................... if (s == 1 && n == 0).................... res -= 1.0;........................................ if (s == 0 && n == 1).................... res += 1.0;.................... }.................... if (x == 0).................... res = 0;........................................ return (res);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float floor(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : rounds down the number x..................... // Date : N/A.................... //.................... float32 floor(float32 x).................... {.................... return CEIL_FLOOR(x, 0);.................... }.................... // Following 2 functions are overloaded functions of floor() for PCD.................... // Overloaded function floor() for data type - Float48.................... #if defined(__PCD__).................... float48 floor(float48 x).................... {.................... return CEIL_FLOOR(x, 0);.................... }........................................ // Overloaded function floor() for data type - Float64.................... float64 floor(float64 x).................... {.................... return CEIL_FLOOR(x, 0);.................... }.................... #endif............................................................ ////////////////////////////////////////////////////////////////////////////.................... // float ceil(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : rounds up the number x..................... // Date : N/A.................... //.................... float32 ceil(float32 x).................... {.................... return CEIL_FLOOR(x, 1);.................... }.................... // Following 2 functions are overloaded functions of ceil() for PCD.................... // Overloaded function ceil() for data type - Float48.................... #if defined(__PCD__).................... float48 ceil(float48 x).................... {.................... return CEIL_FLOOR(x, 1);.................... }........................................ // Overloaded function ceil() for data type - Float64.................... float64 ceil(float64 x).................... {.................... return CEIL_FLOOR(x, 1);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float fabs(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : Computes the absolute value of floating point number x.................... // Returns : returns the absolute value of x.................... // Date : N/A.................... //.................... #define fabs abs........................................ ////////////////////////////////////////////////////////////////////////////.................... // float fmod(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : Computes the floating point remainder of x/y.................... // Returns : returns the value of x= i*y, for some integer i such that, if y.................... // is non zero, the result has the same isgn of x na dmagnitude less than the.................... // magnitude of y. If y is zero then a domain error occurs..................... // Date : N/A.................... //........................................ float fmod(float32 x,float32 y).................... {.................... float32 i;.................... if (y!=0.0).................... {.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);.................... return(x-(i*y));.................... }.................... else.................... {.................... #ifdef _ERRNO.................... {.................... errno=EDOM;.................... }.................... #endif.................... }.................... }.................... //Overloaded function for fmod() for PCD.................... // Overloaded function fmod() for data type - Float48.................... #if defined(__PCD__).................... float48 fmod(float48 x,float48 y).................... {.................... float48 i;.................... if (y!=0.0).................... {.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);.................... return(x-(i*y));.................... }.................... else.................... {.................... #ifdef _ERRNO.................... {.................... errno=EDOM;.................... }.................... #endif.................... }.................... }.................... // Overloaded function fmod() for data type - Float64.................... float64 fmod(float64 x,float64 y).................... {.................... float64 i;.................... if (y!=0.0).................... {.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);.................... return(x-(i*y));.................... }.................... else.................... {.................... #ifdef _ERRNO.................... {.................... errno=EDOM;.................... }.................... #endif.................... }.................... }.................... #endif.................... //////////////////// Exponential and logarithmic functions ////////////////////.................... ////////////////////////////////////////////////////////////////////////////.................... // float exp(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the value (e^x).................... // Date : N/A.................... //.................... #define LN2 0.6931471805599453........................................ float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,.................... 0.0554965651, 0.240227138, 0.693147172};............................................................ float32 exp(float32 x).................... {.................... float32 y, res, r;.................... #if defined(__PCD__).................... int8 data1;.................... #endif.................... signed int8 n;.................... int1 s;.................... #ifdef _ERRNO.................... if(x > 88.722838).................... {.................... errno=ERANGE;.................... return(0);.................... }.................... #endif.................... n = (signed int16)(x/LN2);.................... s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... n = -n;.................... y = -y;.................... }........................................ res = 0.0;.................... #if !defined(__PCD__).................... *((unsigned int8 *)(&res)) = n + 0x7F;.................... #endif........................................ #if defined(__PCD__) // Takes care of IEEE format for PCD.................... data1 = n+0x7F;.................... if(bit_test(data1,0)).................... bit_set(*(((unsigned int8 *)(&res)+2)),7);.................... rotate_right(&data1,1);.................... bit_clear(data1,7);.................... *(((unsigned int8 *)(&res)+3)) = data1;.................... #endif........................................ y = y/LN2 - (float32)n;........................................ r = pe[0]*y + pe[1];.................... r = r*y + pe[2];.................... r = r*y + pe[3];.................... r = r*y + pe[4];.................... r = r*y + pe[5];........................................ res = res*(1.0 + y*r);........................................ if (s).................... res = 1.0/res;.................... return(res);.................... }............................................................ //Overloaded function for exp() for PCD.................... // Overloaded function exp() for data type - Float48.................... #if defined(__PCD__).................... float48 exp(float48 x).................... {.................... float48 y, res, r;.................... int8 data1;.................... signed int8 n;.................... int1 s;.................... #ifdef _ERRNO.................... if(x > 88.722838).................... {.................... errno=ERANGE;.................... return(0);.................... }.................... #endif.................... n = (signed int16)(x/LN2);.................... s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... n = -n;.................... y = -y;.................... }........................................ res = 0.0;........................................ data1 = n+0x7F;.................... if(bit_test(data1,0)).................... bit_set(*(((unsigned int8 *)(&res)+4)),7);.................... rotate_right(&data1,1);.................... bit_clear(data1,7);.................... *(((unsigned int8 *)(&res)+5)) = data1;........................................ y = y/LN2 - (float48)n;........................................ r = pe[0]*y + pe[1];.................... r = r*y + pe[2];.................... r = r*y + pe[3];.................... r = r*y + pe[4];.................... r = r*y + pe[5];........................................ res = res*(1.0 + y*r);........................................ if (s).................... res = 1.0/res;.................... return(res);.................... }........................................ // Overloaded function exp() for data type - Float64.................... float64 exp(float64 x).................... {.................... float64 y, res, r;.................... unsigned int16 data1, data2;.................... unsigned int16 *p;.................... signed int16 n;.................... int1 s;.................... #ifdef _ERRNO.................... if(x > 709.7827128).................... {.................... errno=ERANGE;.................... return(0);.................... }.................... #endif.................... n = (signed int16)(x/LN2);.................... s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... n = -n;.................... y = -y;.................... }........................................ res = 0.0;........................................ #if !defined(__PCD__).................... *((unsigned int16 *)(&res)) = n + 0x7F;.................... #endif.................... p= (((unsigned int16 *)(&res))+3);.................... data1 = *p;.................... data2 = *p;.................... data1 = n + 0x3FF;.................... data1 = data1 <<4;.................... if(bit_test(data2,15)).................... bit_set(data1,15);.................... data2 = data2 & 0x000F;.................... data1 ^= data2;........................................ *(((unsigned int16 *)(&res)+3)) = data1;............................................................ y = y/LN2 - (float64)n;........................................ r = pe[0]*y + pe[1];.................... r = r*y + pe[2];.................... r = r*y + pe[3];.................... r = r*y + pe[4];.................... r = r*y + pe[5];........................................ res = res*(1.0 + y*r);........................................ if (s).................... res = 1.0/res;.................... return(res);.................... }........................................ #ENDIF............................................................ /************************************************************/........................................ float32 const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};.................... float32 const ql[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943};........................................ ////////////////////////////////////////////////////////////////////////////.................... // float log(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the the natural log of x.................... // Date : N/A.................... //.................... float32 log(float32 x).................... {.................... float32 y, res, r, y2;.................... #if defined(__PCD__).................... unsigned int8 data1,data2;.................... #endif.................... signed int8 n;.................... #ifdef _ERRNO.................... if(x <0).................... {.................... errno=EDOM;.................... }.................... if(x ==0).................... {.................... errno=ERANGE;.................... return(0);.................... }.................... #endif.................... y = x;........................................ if (y != 1.0).................... {.................... #if !defined(__PCD__).................... *((unsigned int8 *)(&y)) = 0x7E;.................... #endif........................................ #if defined(__PCD__) // Takes care of IEEE format.................... data2 = *(((unsigned int8 *)(&y))+3);.................... *(((unsigned int8 *)(&y))+3) = 0x3F;.................... data1 = *(((unsigned int8 *)(&y))+2);.................... bit_clear(data1,7);.................... *(((unsigned int8 *)(&y))+2) = data1;.................... if(bit_test(data2,7)).................... bit_set(*(((unsigned int8 *)(&y))+3),7);.................... #endif........................................ y = (y - 1.0)/(y + 1.0);........................................ y2=y*y;........................................ res = pl[0]*y2 + pl[1];.................... res = res*y2 + pl[2];.................... res = res*y2 + pl[3];........................................ r = ql[0]*y2 + ql[1];.................... r = r*y2 + ql[2];.................... r = r*y2 + ql[3];........................................ res = y*res/r;.................... #if !defined(__PCD__).................... n = *((unsigned int8 *)(&x)) - 0x7E;.................... #endif.................... #if defined(__PCD__).................... data1 = *(((unsigned int8 *)(&x)+3));.................... rotate_left(&data1,1);.................... data2 = *(((unsigned int8 *)(&x)+2));.................... if(bit_test (data2,7)).................... bit_set(data1,0);.................... n = data1 - 0x7E;.................... #endif........................................ if (n<0).................... r = -(float32)-n;.................... else.................... r = (float32)n;........................................ res += r*LN2;.................... }........................................ else.................... res = 0.0;........................................ return(res);.................... }........................................ //Overloaded function for log() for PCD.................... // Overloaded function log() for data type - Float48.................... #if defined(__PCD__).................... float48 log(float48 x).................... {.................... float48 y, res, r, y2;.................... unsigned int8 data1,data2;.................... signed int8 n;.................... #ifdef _ERRNO.................... if(x <0).................... {.................... errno=EDOM;.................... }.................... if(x ==0).................... {.................... errno=ERANGE;.................... return(0);.................... }.................... #endif.................... y = x;........................................ if (y != 1.0).................... {........................................ #if !defined(__PCD__).................... *((unsigned int8 *)(&y)) = 0x7E;.................... #endif.................... data2 = *(((unsigned int8 *)(&y))+5);.................... *(((unsigned int8 *)(&y))+5) = 0x3F;.................... data1 = *(((unsigned int8 *)(&y))+4);.................... bit_clear(data1,7);.................... *(((unsigned int8 *)(&y))+4) = data1;........................................ if(bit_test(data2,7)).................... bit_set(*(((unsigned int8 *)(&y))+4),7);.................... y = (y - 1.0)/(y + 1.0);........................................ y2=y*y;........................................ res = pl[0]*y2 + pl[1];.................... res = res*y2 + pl[2];.................... res = res*y2 + pl[3];........................................ r = ql[0]*y2 + ql[1];.................... r = r*y2 + ql[2];.................... r = r*y2 + ql[3];........................................ res = y*res/r;........................................ data1 = *(((unsigned int8 *)(&x)+5));.................... rotate_left(&data1,1);.................... data2 = *(((unsigned int8 *)(&x)+4));.................... if(bit_test (data2,7)).................... bit_set(data1,0);........................................ n = data1 - 0x7E;........................................ if (n<0).................... r = -(float48)-n;.................... else.................... r = (float48)n;........................................ res += r*LN2;.................... }........................................ else.................... res = 0.0;........................................ return(res);.................... }........................................ // Overloaded function log() for data type - Float48.................... #if defined(__PCD__).................... float32 const pl_64[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};.................... float32 const ql_64[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943};.................... #endif.................... float64 log(float64 x).................... {.................... float64 y, res, r, y2;.................... unsigned int16 data1,data2;.................... unsigned int16 *p;.................... signed int16 n;.................... #ifdef _ERRNO.................... if(x <0).................... {.................... errno=EDOM;.................... }.................... if(x ==0).................... {.................... errno=ERANGE;.................... return(0);.................... }.................... #endif.................... y = x;........................................ if (y != 1.0).................... {.................... #if !defined(__PCD__).................... *((unsigned int8 *)(&y)) = 0x7E;.................... #endif.................... p= (((unsigned int16 *)(&y))+3);.................... data1 = *p;.................... data2 = *p;.................... data1 = 0x3FE;.................... data1 = data1 <<4;.................... if(bit_test (data2,15)).................... bit_set(data1,15);.................... data2 = data2 & 0x000F;.................... data1 ^=data2;........................................ *p = data1;........................................ y = (y - 1.0)/(y + 1.0);........................................ y2=y*y;........................................ res = pl_64[0]*y2 + pl_64[1];.................... res = res*y2 + pl_64[2];.................... res = res*y2 + pl_64[3];........................................ r = ql_64[0]*y2 + ql_64[1];.................... r = r*y2 + ql_64[2];.................... r = r*y2 + ql_64[3];........................................ res = y*res/r;........................................ p= (((unsigned int16 *)(&x))+3);.................... data1 = *p;.................... bit_clear(data1,15);.................... data1 = data1 >>4;.................... n = data1 - 0x3FE;............................................................ if (n<0).................... r = -(float64)-n;.................... else.................... r = (float64)n;........................................ res += r*LN2;.................... }........................................ else.................... res = 0.0;........................................ return(res);.................... }.................... #endif............................................................ #define LN10 2.3025850929940456........................................ ////////////////////////////////////////////////////////////////////////////.................... // float log10(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the the log base 10 of x.................... // Date : N/A.................... //.................... float32 log10(float32 x).................... {.................... float32 r;........................................ r = log(x);.................... r = r/LN10;.................... return(r);.................... }........................................ //Overloaded functions for log10() for PCD.................... // Overloaded function log10() for data type - Float48.................... #if defined(__PCD__).................... float48 log10(float48 x).................... {.................... float48 r;........................................ r = log(x);.................... r = r/LN10;.................... return(r);.................... }........................................ // Overloaded function log10() for data type - Float64.................... float64 log10(float64 x).................... {.................... float64 r;........................................ r = log(x);.................... r = r/LN10;.................... return(r);.................... }.................... #endif.................... ////////////////////////////////////////////////////////////////////////////.................... // float modf(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description :breaks the argument value int integral and fractional parts,.................... // ach of which have the same sign as the argument. It stores the integral part.................... // as a float in the object pointed to by the iptr.................... // Returns : returns the signed fractional part of value..................... // Date : N/A.................... //........................................ float32 modf(float32 value,float32 *iptr).................... {.................... *iptr=(value < 0.0)? ceil(value): floor(value);.................... return(value - *iptr);.................... }.................... //Overloaded functions for modf() for PCD.................... // Overloaded function modf() for data type - Float48.................... #if defined(__PCD__).................... float48 modf(float48 value,float48 *iptr).................... {.................... *iptr=(value < 0.0)? ceil(value): floor(value);.................... return(value - *iptr);.................... }.................... // Overloaded function modf() for data type - Float64.................... float64 modf(float64 value,float64 *iptr).................... {.................... *iptr=(value < 0.0)? ceil(value): floor(value);.................... return(value - *iptr);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float pwr(float x,float y).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the value (x^y).................... // Date : N/A.................... // Note : 0 is returned when the function will generate an imaginary number.................... //.................... float32 pwr(float32 x,float32 y).................... {.................... if(0 > x && fmod(y, 1) == 0) {.................... if(fmod(y, 2) == 0) {.................... return (exp(log(-x) * y));.................... } else {.................... return (-exp(log(-x) * y));.................... }.................... } else if(0 > x && fmod(y, 1) != 0) {.................... return 0;.................... } else {.................... if(x != 0 || 0 >= y) {.................... return (exp(log(x) * y));.................... }.................... }.................... }.................... //Overloaded functions for pwr() for PCD.................... // Overloaded function pwr() for data type - Float48.................... #if defined(__PCD__).................... float48 pwr(float48 x,float48 y).................... {.................... if(0 > x && fmod(y, 1) == 0) {.................... if(fmod(y, 2) == 0) {.................... return (exp(log(-x) * y));.................... } else {.................... return (-exp(log(-x) * y));.................... }.................... } else if(0 > x && fmod(y, 1) != 0) {.................... return 0;.................... } else {.................... if(x != 0 || 0 >= y) {.................... return (exp(log(x) * y));.................... }.................... }.................... }.................... // Overloaded function pwr() for data type - Float64.................... float64 pwr(float64 x,float64 y).................... {.................... if(0 > x && fmod(y, 1) == 0) {.................... if(fmod(y, 2) == 0) {.................... return (exp(log(-x) * y));.................... } else {.................... return (-exp(log(-x) * y));.................... }.................... } else if(0 > x && fmod(y, 1) != 0) {.................... return 0;.................... } else {.................... if(x != 0 || 0 >= y) {.................... return (exp(log(x) * y));.................... }.................... }.................... }.................... #endif........................................ //////////////////// Power functions ////////////////////........................................ ////////////////////////////////////////////////////////////////////////////.................... // float pow(float x,float y).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the value (x^y).................... // Date : N/A.................... // Note : 0 is returned when the function will generate an imaginary number.................... //.................... float32 pow(float32 x,float32 y).................... {.................... if(0 > x && fmod(y, 1) == 0) {.................... if(fmod(y, 2) == 0) {.................... return (exp(log(-x) * y));.................... } else {.................... return (-exp(log(-x) * y));.................... }.................... } else if(0 > x && fmod(y, 1) != 0) {.................... return 0;.................... } else {.................... if(x != 0 || 0 >= y) {.................... return (exp(log(x) * y));.................... }.................... }.................... }.................... //Overloaded functions for pow() for PCD.................... // Overloaded function for pow() data type - Float48.................... #if defined(__PCD__).................... float48 pow(float48 x,float48 y).................... {.................... if(0 > x && fmod(y, 1) == 0) {.................... if(fmod(y, 2) == 0) {.................... return (exp(log(-x) * y));.................... } else {.................... return (-exp(log(-x) * y));.................... }.................... } else if(0 > x && fmod(y, 1) != 0) {.................... return 0;.................... } else {.................... if(x != 0 || 0 >= y) {.................... return (exp(log(x) * y));.................... }.................... }.................... }........................................ // Overloaded function pow() for data type - Float64.................... float64 pow(float64 x,float64 y).................... {.................... if(0 > x && fmod(y, 1) == 0) {.................... if(fmod(y, 2) == 0) {.................... return (exp(log(-x) * y));.................... } else {.................... return (-exp(log(-x) * y));.................... }.................... } else if(0 > x && fmod(y, 1) != 0) {.................... return 0;.................... } else {.................... if(x != 0 || 0 >= y) {.................... return (exp(log(x) * y));.................... }.................... }.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float sqrt(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the square root of x.................... // Date : N/A.................... //.................... float32 sqrt(float32 x).................... {.................... float32 y, res;.................... #if defined(__PCD__).................... unsigned int16 data1,data2;.................... #endif.................... BYTE *p;........................................ #ifdef _ERRNO.................... if(x < 0).................... {.................... errno=EDOM;.................... }.................... #endif........................................ if( x<=0.0).................... return(0.0);........................................ y=x;........................................ #if !defined(__PCD__).................... p=&y;.................... (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1);.................... #endif........................................ #if defined(__PCD__).................... p = (((unsigned int8 *)(&y))+3);.................... data1 = *(((unsigned int8 *)(&y))+3);.................... data2 = *(((unsigned int8 *)(&y))+2);.................... rotate_left(&data1,1);.................... if(bit_test(data2,7)).................... bit_set(data1,0);.................... data1 = ((data1+127) >>1);.................... bit_clear(data2,7);.................... if(bit_test(data1,0)).................... bit_set(data2,7);.................... data1 = data1 >>1;.................... *(((unsigned int8 *)(&y))+3) = data1;.................... *(((unsigned int8 *)(&y))+2) = data2;........................................ #endif........................................ do {.................... res=y;.................... y+=(x/y);........................................ #if !defined(__PCD__).................... (*p)--;.................... #endif........................................ #if defined(__PCD__).................... data1 = *(((unsigned int8 *)(&y))+3);.................... data2 = *(((unsigned int8 *)(&y))+2);.................... rotate_left(&data1,1);.................... if(bit_test(data2,7)).................... bit_set(data1,0);.................... data1--;.................... bit_clear(data2,7);.................... if(bit_test(data1,0)).................... bit_set(data2,7);.................... data1 = data1 >>1;.................... *(((unsigned int8 *)(&y))+3) = data1;.................... *(((unsigned int8 *)(&y))+2) = data2;........................................ #endif.................... } while(res != y);........................................ return(res);.................... }.................... //Overloaded functions for sqrt() for PCD.................... // Overloaded function sqrt() for data type - Float48.................... #if defined(__PCD__).................... float48 sqrt(float48 x).................... {.................... float48 y, res;.................... unsigned int16 data1,data2;.................... BYTE *p;........................................ #ifdef _ERRNO.................... if(x < 0).................... {.................... errno=EDOM;.................... }.................... #endif........................................ if( x<=0.0).................... return(0.0);........................................ y=x;........................................ #if !defined(__PCD__).................... p=&y;.................... (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1);.................... #endif........................................ #if defined(__PCD__).................... p = (((unsigned int8 *)(&y))+5);.................... data1 = *(((unsigned int8 *)(&y))+5);.................... data2 = *(((unsigned int8 *)(&y))+4);.................... rotate_left(&data1,1);.................... if(bit_test(data2,7)).................... bit_set(data1,0);.................... data1 = ((data1+127) >>1);.................... bit_clear(data2,7);.................... if(bit_test(data1,0)).................... bit_set(data2,7);.................... data1 = data1 >>1;.................... *(((unsigned int8 *)(&y))+5) = data1;.................... *(((unsigned int8 *)(&y))+4) = data2;........................................ #endif........................................ do {.................... res=y;.................... y+=(x/y);........................................ #if !defined(__PCD__).................... (*p)--;.................... #endif........................................ data1 = *(((unsigned int8 *)(&y))+5);.................... data2 = *(((unsigned int8 *)(&y))+4);.................... rotate_left(&data1,1);.................... if(bit_test(data2,7)).................... bit_set(data1,0);.................... data1--;.................... bit_clear(data2,7);.................... if(bit_test(data1,0)).................... bit_set(data2,7);.................... data1 = data1 >>1;.................... *(((unsigned int8 *)(&y))+5) = data1;.................... *(((unsigned int8 *)(&y))+4) = data2;........................................ } while(res != y);........................................ return(res);.................... }........................................ // Overloaded function sqrt() for data type - Float64.................... float64 sqrt(float64 x).................... {.................... float64 y, res;.................... unsigned int16 *p;.................... unsigned int16 temp1,temp2;........................................ #ifdef _ERRNO.................... if(x < 0).................... {.................... errno=EDOM;.................... }.................... #endif........................................ if( x<=0.0).................... return(0.0);........................................ y=x;.................... p= (((unsigned int16 *)(&y))+3);.................... temp1 = *p;.................... temp2 = *p;.................... bit_clear(temp1,15);.................... temp1 = (temp1>>4)+1023;.................... temp1 = temp1 >> 1;.................... temp1 = (temp1<<4) & 0xFFF0;.................... if(bit_test(temp2,15)).................... bit_set(temp1,15);.................... temp2 = temp2 & 0x000F;.................... temp1 ^= temp2;........................................ (*p) = temp1;........................................ do {.................... res=y;.................... y+=(x/y);.................... temp1 = *p;.................... temp2 = *p;.................... bit_clear(temp1,15);.................... temp1 = (temp1>>4);.................... temp1--;.................... temp1 = (temp1<<4) & 0xFFF0;.................... if(bit_test(temp2,15)).................... bit_set(temp1,15);.................... temp2 = temp2 & 0x000F;.................... temp1 ^= temp2;.................... (*p) = temp1;........................................ } while(res != y);........................................ return(res);.................... }.................... #endif........................................ ////////////////////////////// Trig Functions //////////////////////////////.................... #ifdef PI_DIV_BY_TWO.................... #undef PI_DIV_BY_TWO.................... #endif.................... #define PI_DIV_BY_TWO 1.5707963267948966.................... #ifdef TWOBYPI.................... #undef TWOBYPI.................... #define TWOBYPI 0.6366197723675813.................... #endif.................... ////////////////////////////////////////////////////////////////////////////.................... // float cos(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the cosine value of the angle x, which is in radian.................... // Date : 9/20/2001.................... //.................... float32 cos(float32 x).................... {.................... float32 y, t, t2 = 1.0;.................... unsigned int8 quad, i;.................... float32 frac;.................... float32 p[6] = { //by the series definition for cosine.................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! ).................... 0.04166666666667,.................... -0.00138888888889,.................... 0.00002480158730,.................... -0.00000027557319,.................... 0.00000000208767,.................... //-0.00000000001147,.................... // 0.00000000000005.................... };........................................ if (x < 0) x = -x; // absolute value of input........................................ quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input.................... quad = quad % 4; // quadrant (0 to 3)........................................ if (quad == 0 || quad == 2).................... t = frac * PI_DIV_BY_TWO;.................... else if (quad == 1).................... t = (1-frac) * PI_DIV_BY_TWO;.................... else // should be 3.................... t = (frac-1) * PI_DIV_BY_TWO;........................................ y = 1.0;.................... t = t * t;.................... for (i = 0; i <= 5; i++).................... {.................... t2 = t2 * t;.................... y = y + p[i] * t2;.................... }........................................ if (quad == 2 || quad == 1).................... y = -y; // correct sign........................................ return (y);.................... }............................................................ //Overloaded functions for cos() for PCD.................... // Overloaded function cos() for data type - Float48.................... #if defined(__PCD__).................... float48 cos(float48 x).................... {.................... float48 y, t, t2 = 1.0;.................... unsigned int8 quad, i;.................... float48 frac;.................... float48 p[6] = { //by the series definition for cosine.................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! ).................... 0.04166666666667,.................... -0.00138888888889,.................... 0.00002480158730,.................... -0.00000027557319,.................... 0.00000000208767,.................... //-0.00000000001147,.................... // 0.00000000000005.................... };........................................ if (x < 0) x = -x; // absolute value of input........................................ quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input.................... quad = quad % 4; // quadrant (0 to 3)........................................ if (quad == 0 || quad == 2).................... t = frac * PI_DIV_BY_TWO;.................... else if (quad == 1).................... t = (1-frac) * PI_DIV_BY_TWO;.................... else // should be 3.................... t = (frac-1) * PI_DIV_BY_TWO;........................................ y = 0.999999999781;.................... t = t * t;.................... for (i = 0; i <= 5; i++).................... {.................... t2 = t2 * t;.................... y = y + p[i] * t2;.................... }........................................ if (quad == 2 || quad == 1).................... y = -y; // correct sign........................................ return (y);.................... }........................................ // Overloaded function cos() for data type - Float48.................... float64 cos(float64 x).................... {.................... float64 y, t, t2 = 1.0;.................... unsigned int8 quad, i;.................... float64 frac;.................... float64 p[6] = { //by the series definition for cosine.................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! ).................... 0.04166666666667,.................... -0.00138888888889,.................... 0.00002480158730,.................... -0.00000027557319,.................... 0.00000000208767,.................... //-0.00000000001147,.................... // 0.00000000000005.................... };........................................ if (x < 0) x = -x; // absolute value of input........................................ quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input.................... quad = quad % 4; // quadrant (0 to 3)........................................ if (quad == 0 || quad == 2).................... t = frac * PI_DIV_BY_TWO;.................... else if (quad == 1).................... t = (1-frac) * PI_DIV_BY_TWO;.................... else // should be 3.................... t = (frac-1) * PI_DIV_BY_TWO;........................................ y = 0.999999999781;.................... t = t * t;.................... for (i = 0; i <= 5; i++).................... {.................... t2 = t2 * t;.................... y = y + p[i] * t2;.................... }........................................ if (quad == 2 || quad == 1).................... y = -y; // correct sign........................................ return (y);.................... }........................................ #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float sin(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the sine value of the angle x, which is in radian.................... // Date : 9/20/2001.................... //.................... float32 sin(float32 x).................... {.................... return cos(x - PI_DIV_BY_TWO);.................... }........................................ //Overloaded functions for sin() for PCD.................... // Overloaded function sin() for data type - Float48.................... #if defined(__PCD__).................... float48 sin(float48 x).................... {.................... return cos(x - PI_DIV_BY_TWO);.................... }........................................ // Overloaded function sin() for data type - Float48.................... float64 sin(float64 x).................... {.................... return cos(x - PI_DIV_BY_TWO);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float tan(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the tangent value of the angle x, which is in radian.................... // Date : 9/20/2001.................... //.................... float32 tan(float32 x).................... {.................... float32 c, s;........................................ c = cos(x);.................... if (c == 0.0).................... return (1.0e+36);........................................ s = sin(x);.................... return(s/c);.................... }.................... //Overloaded functions for tan() for PCD.................... // Overloaded function tan() for data type - Float48.................... #if defined(__PCD__).................... float48 tan(float48 x).................... {.................... float48 c, s;........................................ c = cos(x);.................... if (c == 0.0).................... return (1.0e+36);........................................ s = sin(x);.................... return(s/c);.................... }........................................ // Overloaded function tan() for data type - Float48.................... float64 tan(float64 x).................... {.................... float64 c, s;........................................ c = cos(x);.................... if (c == 0.0).................... return (1.0e+36);........................................ s = sin(x);.................... return(s/c);.................... }.................... #endif........................................ float32 const pas[3] = {0.49559947, -4.6145309, 5.6036290};.................... float32 const qas[3] = {1.0000000, -5.5484666, 5.6036290};........................................ float32 ASIN_COS(float32 x, unsigned int8 n).................... {.................... float32 y, res, r, y2;.................... int1 s;.................... #ifdef _ERRNO.................... if(x <-1 || x > 1).................... {.................... errno=EDOM;.................... }.................... #endif.................... s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y > 0.5).................... {.................... y = sqrt((1.0 - y)/2.0);.................... n += 2;.................... }........................................ y2=y*y;........................................ res = pas[0]*y2 + pas[1];.................... res = res*y2 + pas[2];........................................ r = qas[0]*y2 + qas[1];.................... r = r*y2 + qas[2];........................................ res = y*res/r;........................................ if (n & 2) // |x| > 0.5.................... res = PI_DIV_BY_TWO - 2.0*res;.................... if (s).................... res = -res;.................... if (n & 1) // take arccos.................... res = PI_DIV_BY_TWO - res;........................................ return(res);.................... }........................................ //Overloaded functions for ASIN_COS() for PCD.................... // Overloaded function ASIN_COS() for data type - Float48.................... #if defined(__PCD__).................... float48 ASIN_COS(float48 x, unsigned int8 n).................... {.................... float48 y, res, r, y2;.................... int1 s;.................... #ifdef _ERRNO.................... if(x <-1 || x > 1).................... {.................... errno=EDOM;.................... }.................... #endif.................... s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y > 0.5).................... {.................... y = sqrt((1.0 - y)/2.0);.................... n += 2;.................... }........................................ y2=y*y;........................................ res = pas[0]*y2 + pas[1];.................... res = res*y2 + pas[2];........................................ r = qas[0]*y2 + qas[1];.................... r = r*y2 + qas[2];........................................ res = y*res/r;........................................ if (n & 2) // |x| > 0.5.................... res = PI_DIV_BY_TWO - 2.0*res;.................... if (s).................... res = -res;.................... if (n & 1) // take arccos.................... res = PI_DIV_BY_TWO - res;........................................ return(res);.................... }........................................ // Overloaded function ASIN_COS() for data type - Float64.................... float64 ASIN_COS(float64 x, unsigned int8 n).................... {.................... float64 y, res, r, y2;.................... int1 s;.................... #ifdef _ERRNO.................... if(x <-1 || x > 1).................... {.................... errno=EDOM;.................... }.................... #endif.................... s = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y > 0.5).................... {.................... y = sqrt((1.0 - y)/2.0);.................... n += 2;.................... }........................................ y2=y*y;........................................ res = pas[0]*y2 + pas[1];.................... res = res*y2 + pas[2];........................................ r = qas[0]*y2 + qas[1];.................... r = r*y2 + qas[2];........................................ res = y*res/r;........................................ if (n & 2) // |x| > 0.5.................... res = PI_DIV_BY_TWO - 2.0*res;.................... if (s).................... res = -res;.................... if (n & 1) // take arccos.................... res = PI_DIV_BY_TWO - res;........................................ return(res);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float asin(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the arcsine value of the value x..................... // Date : N/A.................... //.................... float32 asin(float32 x).................... {.................... float32 r;........................................ r = ASIN_COS(x, 0);.................... return(r);.................... }.................... //Overloaded functions for asin() for PCD.................... // Overloaded function asin() for data type - Float48.................... #if defined(__PCD__).................... float48 asin(float48 x).................... {.................... float48 r;........................................ r = ASIN_COS(x, 0);.................... return(r);.................... }........................................ // Overloaded function asin() for data type - Float64.................... float64 asin(float64 x).................... {.................... float64 r;........................................ r = ASIN_COS(x, 0);.................... return(r);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float acos(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the arccosine value of the value x..................... // Date : N/A.................... //.................... float32 acos(float32 x).................... {.................... float32 r;........................................ r = ASIN_COS(x, 1);.................... return(r);.................... }.................... //Overloaded functions for acos() for PCD.................... // Overloaded function acos() for data type - Float48.................... #if defined(__PCD__).................... float48 acos(float48 x).................... {.................... float48 r;........................................ r = ASIN_COS(x, 1);.................... return(r);.................... }........................................ // Overloaded function acos() for data type - Float64.................... float64 acos(float64 x).................... {.................... float64 r;........................................ r = ASIN_COS(x, 1);.................... return(r);.................... }.................... #endif........................................ float32 const pat[4] = {0.17630401, 5.6710795, 22.376096, 19.818457};.................... float32 const qat[4] = {1.0000000, 11.368190, 28.982246, 19.818457};........................................ ////////////////////////////////////////////////////////////////////////////.................... // float atan(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : returns the arctangent value of the value x..................... // Date : N/A.................... //.................... float32 atan(float32 x).................... {.................... float32 y, res, r;.................... int1 s, flag;........................................ s = 0;.................... flag = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y > 1.0).................... {.................... y = 1.0/y;.................... flag = 1;.................... }........................................ res = pat[0]*y*y + pat[1];.................... res = res*y*y + pat[2];.................... res = res*y*y + pat[3];........................................ r = qat[0]*y*y + qat[1];.................... r = r*y*y + qat[2];.................... r = r*y*y + qat[3];........................................ res = y*res/r;............................................................ if (flag) // for |x| > 1.................... res = PI_DIV_BY_TWO - res;.................... if (s).................... res = -res;........................................ return(res);.................... }.................... //Overloaded functions for atan() for PCD.................... // Overloaded function atan() for data type - Float48.................... #if defined(__PCD__).................... float48 atan(float48 x).................... {.................... float48 y, res, r;.................... int1 s, flag;........................................ s = 0;.................... flag = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y > 1.0).................... {.................... y = 1.0/y;.................... flag = 1;.................... }........................................ res = pat[0]*y*y + pat[1];.................... res = res*y*y + pat[2];.................... res = res*y*y + pat[3];........................................ r = qat[0]*y*y + qat[1];.................... r = r*y*y + qat[2];.................... r = r*y*y + qat[3];........................................ res = y*res/r;............................................................ if (flag) // for |x| > 1.................... res = PI_DIV_BY_TWO - res;.................... if (s).................... res = -res;........................................ return(res);.................... }........................................ // Overloaded function atan() for data type - Float64.................... float64 atan(float64 x).................... {.................... float64 y, res, r;.................... int1 s, flag;........................................ s = 0;.................... flag = 0;.................... y = x;........................................ if (x < 0).................... {.................... s = 1;.................... y = -y;.................... }........................................ if (y > 1.0).................... {.................... y = 1.0/y;.................... flag = 1;.................... }........................................ res = pat[0]*y*y + pat[1];.................... res = res*y*y + pat[2];.................... res = res*y*y + pat[3];........................................ r = qat[0]*y*y + qat[1];.................... r = r*y*y + qat[2];.................... r = r*y*y + qat[3];........................................ res = y*res/r;............................................................ if (flag) // for |x| > 1.................... res = PI_DIV_BY_TWO - res;.................... if (s).................... res = -res;........................................ return(res);.................... }.................... #endif........................................ /////////////////////////////////////////////////////////////////////////////.................... // float atan2(float y, float x).................... /////////////////////////////////////////////////////////////////////////////.................... // Description :computes the principal value of arc tangent of y/x, using the.................... // signs of both the arguments to determine the quadrant of the return value.................... // Returns : returns the arc tangent of y/x..................... // Date : N/A.................... //........................................ float32 atan2(float32 y,float32 x).................... {.................... float32 z;.................... int1 sign;.................... unsigned int8 quad;.................... sign=0;.................... quad=0; //quadrant.................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));.................... if(y<0.0).................... {.................... sign=1;.................... y=-y;.................... }.................... if(x<0.0).................... {.................... x=-x;.................... }.................... if (x==0.0).................... {.................... if(y==0.0).................... {.................... #ifdef _ERRNO.................... {.................... errno=EDOM;.................... }.................... #endif.................... }.................... else.................... {.................... if(sign).................... {.................... return (-(PI_DIV_BY_TWO));.................... }.................... else.................... {.................... return (PI_DIV_BY_TWO);.................... }.................... }.................... }.................... else.................... {.................... z=y/x;.................... switch(quad).................... {.................... case 1:.................... {.................... return atan(z);.................... break;.................... }.................... case 2:.................... {.................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122.................... return (PI-atan(z));.................... break;.................... }.................... case 3:.................... {.................... return (atan(z)-PI);.................... break;.................... }.................... case 4:.................... {.................... return (-atan(z));.................... break;.................... }.................... }.................... }.................... }........................................ //Overloaded functions for atan2() for PCD.................... // Overloaded function atan2() for data type - Float48.................... #if defined(__PCD__).................... float48 atan2(float48 y,float48 x).................... {.................... float48 z;.................... int1 sign;.................... unsigned int8 quad;.................... sign=0;.................... quad=0; //quadrant.................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));.................... if(y<0.0).................... {.................... sign=1;.................... y=-y;.................... }.................... if(x<0.0).................... {.................... x=-x;.................... }.................... if (x==0.0).................... {.................... if(y==0.0).................... {.................... #ifdef _ERRNO.................... {.................... errno=EDOM;.................... }.................... #endif.................... }.................... else.................... {.................... if(sign).................... {.................... return (-(PI_DIV_BY_TWO));.................... }.................... else.................... {.................... return (PI_DIV_BY_TWO);.................... }.................... }.................... }.................... else.................... {.................... z=y/x;.................... switch(quad).................... {.................... case 1:.................... {.................... return atan(z);.................... break;.................... }.................... case 2:.................... {.................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122.................... return (PI-atan(z));.................... break;.................... }.................... case 3:.................... {.................... return (atan(z)-PI);.................... break;.................... }.................... case 4:.................... {.................... return (-atan(z));.................... break;.................... }.................... }.................... }.................... }........................................ // Overloaded function atan2() for data type - Float64.................... float64 atan2(float64 y,float64 x).................... {.................... float64 z;.................... int1 sign;.................... unsigned int8 quad;.................... sign=0;.................... quad=0; //quadrant.................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));.................... if(y<0.0).................... {.................... sign=1;.................... y=-y;.................... }.................... if(x<0.0).................... {.................... x=-x;.................... }.................... if (x==0.0).................... {.................... if(y==0.0).................... {.................... #ifdef _ERRNO.................... {.................... errno=EDOM;.................... }.................... #endif.................... }.................... else.................... {.................... if(sign).................... {.................... return (-(PI_DIV_BY_TWO));.................... }.................... else.................... {.................... return (PI_DIV_BY_TWO);.................... }.................... }.................... }.................... else.................... {.................... z=y/x;.................... switch(quad).................... {.................... case 1:.................... {.................... return atan(z);.................... break;.................... }.................... case 2:.................... {.................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122.................... return (PI-atan(z));.................... break;.................... }.................... case 3:.................... {.................... return (atan(z)-PI);.................... break;.................... }.................... case 4:.................... {.................... return (-atan(z));.................... break;.................... }.................... }.................... }.................... }.................... #endif........................................ //////////////////// Hyperbolic functions ////////////////////........................................ ////////////////////////////////////////////////////////////////////////////.................... // float cosh(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : Computes the hyperbolic cosine value of x.................... // Returns : returns the hyperbolic cosine value of x.................... // Date : N/A.................... //........................................ float32 cosh(float32 x).................... {.................... return ((exp(x)+exp(-x))/2);.................... }.................... //Overloaded functions for cosh() for PCD.................... // Overloaded function cosh() for data type - Float48.................... #if defined(__PCD__).................... float48 cosh(float48 x).................... {.................... return ((exp(x)+exp(-x))/2);.................... }........................................ // Overloaded function cosh() for data type - Float64.................... float64 cosh(float64 x).................... {.................... return ((exp(x)+exp(-x))/2);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float sinh(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : Computes the hyperbolic sine value of x.................... // Returns : returns the hyperbolic sine value of x.................... // Date : N/A.................... //........................................ float32 sinh(float32 x).................... {........................................ return ((exp(x) - exp(-x))/2);.................... }.................... //Overloaded functions for sinh() for PCD.................... // Overloaded function sinh() for data type - Float48.................... #if defined(__PCD__).................... float48 sinh(float48 x).................... {........................................ return ((exp(x) - exp(-x))/2);.................... }........................................ // Overloaded function sinh() for data type - Float48.................... float64 sinh(float64 x).................... {........................................ return ((exp(x) - exp(-x))/2);.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float tanh(float x).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : Computes the hyperbolic tangent value of x.................... // Returns : returns the hyperbolic tangent value of x.................... // Date : N/A.................... //........................................ float32 tanh(float32 x).................... {.................... return(sinh(x)/cosh(x));.................... }.................... //Overloaded functions for tanh() for PCD.................... // Overloaded function tanh() for data type - Float48.................... #if defined(__PCD__).................... float48 tanh(float48 x).................... {.................... return(sinh(x)/cosh(x));.................... }........................................ // Overloaded function tanh() for data type - Float64.................... float64 tanh(float64 x).................... {.................... return(sinh(x)/cosh(x));.................... }.................... #endif........................................ ////////////////////////////////////////////////////////////////////////////.................... // float frexp(float x, signed int *exp).................... ////////////////////////////////////////////////////////////////////////////.................... // Description : breaks a floating point number into a normalized fraction and an integral.................... // power of 2. It stores the integer in the signed int object pointed to by exp..................... // Returns : returns the value x, such that x is a double with magnitude in the interval.................... // [1/2,1) or zero, and value equals x times 2 raised to the power *exp.If value is zero,.................... // both parts of the result are zero..................... // Date : N/A.................... //........................................ #define LOG2 .30102999566398119521.................... float32 frexp(float32 x, signed int8 *exp).................... {.................... float32 res;.................... int1 sign = 0;.................... if(x == 0.0).................... {.................... *exp=0;.................... return (0.0);.................... }.................... if(x < 0.0).................... {.................... x=-x;.................... sign=1;.................... }.................... if (x > 1.0).................... {.................... *exp=(ceil(log10(x)/LOG2));.................... res=x/(pow(2, *exp));.................... if (res == 1).................... {.................... *exp=*exp+1;.................... res=.5;.................... }.................... }.................... else.................... {.................... if(x < 0.5).................... {.................... *exp=-1;.................... res=x*2;.................... }.................... else.................... {.................... *exp=0;.................... res=x;.................... }.................... }.................... if(sign).................... {.................... res=-res;.................... }.................... return res;.................... }........................................ //Overloaded functions for frexp() for PCD.................... // Overloaded function frexp() for data type - Float48.................... #if defined(__PCD__).................... float48 frexp(float48 x, signed int8 *exp).................... {.................... float48 res;.................... int1 sign = 0;.................... if(x == 0.0).................... {.................... *exp=0;.................... return (0.0);.................... }.................... if(x < 0.0).................... {.................... x=-x;.................... sign=1;.................... }.................... if (x > 1.0).................... {.................... *exp=(ceil(log10(x)/LOG2));.................... res=x/(pow(2, *exp));.................... if (res == 1).................... {.................... *exp=*exp+1;.................... res=.5;.................... }.................... }.................... else.................... {.................... if(x < 0.5).................... {.................... *exp=-1;.................... res=x*2;.................... }.................... else.................... {.................... *exp=0;.................... res=x;.................... }.................... }.................... if(sign).................... {.................... res=-res;.................... }.................... return res;.................... }........................................ // Overloaded function frexp() for data type - Float64.................... float64 frexp(float64 x, signed int8 *exp).................... {.................... float64 res;.................... int1 sign = 0;.................... if(x == 0.0).................... {.................... *exp=0;.................... return (0.0);.................... }.................... if(x < 0.0).................... {.................... x=-x;.................... sign=1;.................... }.................... if (x > 1.0).................... {.................... *exp=(ceil(log10(x)/LOG2));.................... res=x/(pow(2, *exp));.................... if (res == 1).................... {.................... *exp=*exp+1;.................... res=.5;.................... }.................... }.................... else.................... {.................... if(x < 0.5).................... {.................... *exp=-1;.................... res=x*2;.................... }.................... else.................... {.................... *exp=0;.................... res=x;.................... }.................... }.................... if(sign).................... {.................... res=-res;.................... }.................... return res;.................... }.................... #endif........................................ //////////////////////////////////////////////////////////////////////////////.................... // float ldexp(float x, signed int *exp).................... //////////////////////////////////////////////////////////////////////////////.................... // Description : multiplies a floating point number by an integral power of 2..................... // Returns : returns the value of x times 2 raised to the power exp..................... // Date : N/A.................... //........................................ float32 ldexp(float32 value, signed int8 exp).................... {.................... return (value * pow(2,exp));.................... }.................... //Overloaded functions for ldexp() for PCD.................... // Overloaded function ldexp() for data type - Float48........................................ #if defined(__PCD__).................... float48 ldexp(float48 value, signed int8 exp).................... {.................... return (value * pow(2,exp));.................... }.................... // Overloaded function ldexp() for data type - Float64.................... float64 ldexp(float64 value, signed int8 exp).................... {.................... return (value * pow(2,exp));.................... }.................... #endif........................................ #endif................................................................................ void main().................... {*0AB7: CLRF 040AB8: BCF 03.70AB9: MOVLW 1F0ABA: ANDWF 03,F0ABB: MOVLW 710ABC: BSF 03.50ABD: MOVWF 0F0ABE: MOVF 0F,W0ABF: BSF 03.60AC0: BCF 07.30AC1: MOVLW 0C0AC2: BCF 03.60AC3: MOVWF 190AC4: MOVLW A20AC5: MOVWF 180AC6: MOVLW 900AC7: BCF 03.50AC8: MOVWF 180AC9: BSF 03.50ACA: BSF 03.60ACB: MOVF 09,W0ACC: ANDLW C00ACD: MOVWF 090ACE: BCF 03.60ACF: BCF 1F.40AD0: BCF 1F.50AD1: MOVLW 000AD2: BSF 03.60AD3: MOVWF 080AD4: BCF 03.50AD5: CLRF 070AD6: CLRF 080AD7: CLRF 09*0AE1: CLRF 340AE2: CLRF 33.................... float temp1, temp2, humidity;.................... int16 i=0;........................................ setup_adc_ports(NO_ANALOGS|VSS_VDD);0AE3: BSF 03.50AE4: BSF 03.60AE5: MOVF 09,W0AE6: ANDLW C00AE7: MOVWF 090AE8: BCF 03.60AE9: BCF 1F.40AEA: BCF 1F.50AEB: MOVLW 000AEC: BSF 03.60AED: MOVWF 08.................... setup_adc(ADC_CLOCK_DIV_2);0AEE: BCF 03.50AEF: BCF 03.60AF0: BCF 1F.60AF1: BCF 1F.70AF2: BSF 03.50AF3: BSF 1F.70AF4: BCF 03.50AF5: BSF 1F.0.................... setup_spi(SPI_SS_DISABLED);0AF6: BCF 14.50AF7: BCF 20.50AF8: MOVF 20,W0AF9: BSF 03.50AFA: MOVWF 070AFB: BCF 03.50AFC: BSF 20.40AFD: MOVF 20,W0AFE: BSF 03.50AFF: MOVWF 070B00: BCF 03.50B01: BCF 20.30B02: MOVF 20,W0B03: BSF 03.50B04: MOVWF 070B05: MOVLW 010B06: BCF 03.50B07: MOVWF 140B08: MOVLW 000B09: BSF 03.50B0A: MOVWF 14.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);0B0B: MOVF 01,W0B0C: ANDLW C70B0D: IORLW 080B0E: MOVWF 01.................... setup_timer_1(T1_DISABLED);0B0F: BCF 03.50B10: CLRF 10.................... setup_timer_2(T2_DISABLED,0,1);0B11: MOVLW 000B12: MOVWF 780B13: MOVWF 120B14: MOVLW 000B15: BSF 03.50B16: MOVWF 12.................... setup_ccp1(CCP_OFF);0B17: BCF 03.50B18: BSF 20.20B19: MOVF 20,W0B1A: BSF 03.50B1B: MOVWF 070B1C: BCF 03.50B1D: CLRF 170B1E: BSF 03.50B1F: CLRF 1B0B20: CLRF 1C0B21: MOVLW 010B22: MOVWF 1D.................... setup_comparator(NC_NC_NC_NC); // This device COMP currently not supported by the PICWizard0B23: BCF 03.50B24: BSF 03.60B25: CLRF 070B26: CLRF 080B27: CLRF 09.................... setup_oscillator(OSC_8MHZ);0B28: MOVLW 710B29: BSF 03.50B2A: BCF 03.60B2B: MOVWF 0F0B2C: MOVF 0F,W............................................................ printf("GeoMet01A\r\n");0B2D: MOVLW 0C0B2E: BCF 03.50B2F: BSF 03.60B30: MOVWF 0D0B31: MOVLW 000B32: MOVWF 0F0B33: BCF 0A.30B34: BCF 03.60B35: CALL 0300B36: BSF 0A.3.................... printf("(c) Kaklik 2013\r\n");0B37: MOVLW 120B38: BSF 03.60B39: MOVWF 0D0B3A: MOVLW 000B3B: MOVWF 0F0B3C: BCF 0A.30B3D: BCF 03.60B3E: CALL 0300B3F: BSF 0A.3.................... printf("www.mlab.cz\r\n");0B40: MOVLW 1B0B41: BSF 03.60B42: MOVWF 0D0B43: MOVLW 000B44: MOVWF 0F0B45: BCF 0A.30B46: BCF 03.60B47: CALL 0300B48: BSF 0A.3........................................ // Init the HMC5883L. Set Mode register for.................... // continuous measurements..................... hmc5883l_write_reg(HMC5883L_CFG_A_REG, 0x18); // no average, maximal update range0B49: CLRF 350B4A: MOVLW 180B4B: MOVWF 360B4C: BCF 0A.30B4D: CALL 0C20B4E: BSF 0A.3.................... hmc5883l_write_reg(HMC5883L_CFG_B_REG, 0x00); // minimal range0B4F: MOVLW 010B50: MOVWF 350B51: CLRF 360B52: BCF 0A.30B53: CALL 0C20B54: BSF 0A.3.................... hmc5883l_write_reg(HMC5883L_MODE_REG, 0x00);0B55: MOVLW 020B56: MOVWF 350B57: CLRF 360B58: BCF 0A.30B59: CALL 0C20B5A: BSF 0A.3........................................ lcd_init();0B5B: BCF 0A.30B5C: CALL 1C80B5D: BSF 0A.3.................... lcd_putc("(c) Kaklik 2013");0B5E: MOVLW 220B5F: BSF 03.60B60: MOVWF 0D0B61: MOVLW 000B62: MOVWF 0F0B63: BCF 0A.30B64: BCF 03.60B65: CALL 23F0B66: BSF 0A.3.................... lcd_gotoxy(3,2);0B67: MOVLW 030B68: MOVWF 430B69: MOVLW 020B6A: MOVWF 440B6B: BCF 0A.30B6C: CALL 2000B6D: BSF 0A.3.................... lcd_putc("www.mlab.cz");0B6E: MOVLW 2A0B6F: BSF 03.60B70: MOVWF 0D0B71: MOVLW 000B72: MOVWF 0F0B73: BCF 0A.30B74: BCF 03.60B75: CALL 23F0B76: BSF 0A.3.................... Delay_ms(2000);0B77: MOVLW 080B78: MOVWF 350B79: MOVLW FA0B7A: MOVWF 430B7B: BCF 0A.30B7C: CALL 0FB0B7D: BSF 0A.30B7E: DECFSZ 35,F0B7F: GOTO 379.................... lcd_init();0B80: BCF 0A.30B81: CALL 1C80B82: BSF 0A.3........................................ while (TRUE).................... {.................... lcd_gotoxy(1,1);0B83: MOVLW 010B84: MOVWF 430B85: MOVWF 440B86: BCF 0A.30B87: CALL 2000B88: BSF 0A.3.................... temp1 = SHT25_get_temp();0B89: BCF 0A.30B8A: GOTO 5670B8B: BSF 0A.30B8C: MOVF 7A,W0B8D: MOVWF 2A0B8E: MOVF 79,W0B8F: MOVWF 290B90: MOVF 78,W0B91: MOVWF 280B92: MOVF 77,W0B93: MOVWF 27.................... humidity = SHT25_get_hum();0B94: BCF 0A.30B95: GOTO 6360B96: BSF 0A.30B97: MOVF 7A,W0B98: MOVWF 320B99: MOVF 79,W0B9A: MOVWF 310B9B: MOVF 78,W0B9C: MOVWF 300B9D: MOVF 77,W0B9E: MOVWF 2F.................... temp2= LTS01_get_temp();0B9F: BCF 0A.30BA0: GOTO 6EC0BA1: BSF 0A.30BA2: MOVF 7A,W0BA3: MOVWF 2E0BA4: MOVF 79,W0BA5: MOVWF 2D0BA6: MOVF 78,W0BA7: MOVWF 2C0BA8: MOVF 77,W0BA9: MOVWF 2B.................... hmc5883l_read_data();0BAA: GOTO 000........................................ printf(lcd_putc,"%f C %f \%%",temp1, humidity);0BAB: MOVLW 890BAC: MOVWF 040BAD: MOVF 2A,W0BAE: MOVWF 380BAF: MOVF 29,W0BB0: MOVWF 370BB1: MOVF 28,W0BB2: MOVWF 360BB3: MOVF 27,W0BB4: MOVWF 350BB5: MOVLW 020BB6: MOVWF 390BB7: CALL 0910BB8: MOVLW 200BB9: MOVWF 420BBA: BCF 0A.30BBB: CALL 2120BBC: BSF 0A.30BBD: MOVLW 430BBE: MOVWF 420BBF: BCF 0A.30BC0: CALL 2120BC1: BSF 0A.30BC2: MOVLW 200BC3: MOVWF 420BC4: BCF 0A.30BC5: CALL 2120BC6: BSF 0A.30BC7: MOVLW 890BC8: MOVWF 040BC9: MOVF 32,W0BCA: MOVWF 380BCB: MOVF 31,W0BCC: MOVWF 370BCD: MOVF 30,W0BCE: MOVWF 360BCF: MOVF 2F,W0BD0: MOVWF 350BD1: MOVLW 020BD2: MOVWF 390BD3: CALL 0910BD4: MOVLW 200BD5: MOVWF 420BD6: BCF 0A.30BD7: CALL 2120BD8: BSF 0A.30BD9: MOVLW 250BDA: MOVWF 420BDB: BCF 0A.30BDC: CALL 2120BDD: BSF 0A.3.................... lcd_gotoxy(1,2);0BDE: MOVLW 010BDF: MOVWF 430BE0: MOVLW 020BE1: MOVWF 440BE2: BCF 0A.30BE3: CALL 2000BE4: BSF 0A.3.................... printf(lcd_putc," %f C",temp2);0BE5: MOVLW 200BE6: MOVWF 420BE7: BCF 0A.30BE8: CALL 2120BE9: BSF 0A.30BEA: MOVLW 890BEB: MOVWF 040BEC: MOVF 2E,W0BED: MOVWF 380BEE: MOVF 2D,W0BEF: MOVWF 370BF0: MOVF 2C,W0BF1: MOVWF 360BF2: MOVF 2B,W0BF3: MOVWF 350BF4: MOVLW 020BF5: MOVWF 390BF6: CALL 0910BF7: MOVLW 200BF8: MOVWF 420BF9: BCF 0A.30BFA: CALL 2120BFB: BSF 0A.30BFC: MOVLW 430BFD: MOVWF 420BFE: BCF 0A.30BFF: CALL 2120C00: BSF 0A.3.................... printf("%ld %f %f %f ",i, temp1, humidity, temp2);0C01: MOVLW 100C02: MOVWF 040C03: MOVF 34,W0C04: MOVWF 360C05: MOVF 33,W0C06: MOVWF 350C07: CALL 16B0C08: MOVLW 200C09: BTFSS 0C.40C0A: GOTO 4090C0B: MOVWF 190C0C: MOVLW 890C0D: MOVWF 040C0E: MOVF 2A,W0C0F: MOVWF 380C10: MOVF 29,W0C11: MOVWF 370C12: MOVF 28,W0C13: MOVWF 360C14: MOVF 27,W0C15: MOVWF 350C16: MOVLW 020C17: MOVWF 390C18: CALL 1E10C19: MOVLW 200C1A: BTFSS 0C.40C1B: GOTO 41A0C1C: MOVWF 190C1D: MOVLW 890C1E: MOVWF 040C1F: MOVF 32,W0C20: MOVWF 380C21: MOVF 31,W0C22: MOVWF 370C23: MOVF 30,W0C24: MOVWF 360C25: MOVF 2F,W0C26: MOVWF 350C27: MOVLW 020C28: MOVWF 390C29: CALL 1E10C2A: MOVLW 200C2B: BTFSS 0C.40C2C: GOTO 42B0C2D: MOVWF 190C2E: MOVLW 890C2F: MOVWF 040C30: MOVF 2E,W0C31: MOVWF 380C32: MOVF 2D,W0C33: MOVWF 370C34: MOVF 2C,W0C35: MOVWF 360C36: MOVF 2B,W0C37: MOVWF 350C38: MOVLW 020C39: MOVWF 390C3A: CALL 1E10C3B: MOVLW 200C3C: BTFSS 0C.40C3D: GOTO 43C0C3E: MOVWF 19.................... printf("%Ld %Ld %Ld \n\r", compass.x, compass.y, compass.z);0C3F: MOVLW 100C40: MOVWF 040C41: MOVF 22,W0C42: MOVWF 360C43: MOVF 21,W0C44: MOVWF 350C45: CALL 16B0C46: MOVLW 200C47: BTFSS 0C.40C48: GOTO 4470C49: MOVWF 190C4A: MOVLW 100C4B: MOVWF 040C4C: MOVF 24,W0C4D: MOVWF 360C4E: MOVF 23,W0C4F: MOVWF 350C50: CALL 16B0C51: MOVLW 200C52: BTFSS 0C.40C53: GOTO 4520C54: MOVWF 190C55: MOVLW 100C56: MOVWF 040C57: MOVF 26,W0C58: MOVWF 360C59: MOVF 25,W0C5A: MOVWF 350C5B: CALL 16B0C5C: MOVLW 200C5D: BTFSS 0C.40C5E: GOTO 45D0C5F: MOVWF 190C60: MOVLW 0A0C61: BTFSS 0C.40C62: GOTO 4610C63: MOVWF 190C64: MOVLW 0D0C65: BTFSS 0C.40C66: GOTO 4650C67: MOVWF 19.................... i++;0C68: INCF 33,F0C69: BTFSC 03.20C6A: INCF 34,F.................... Delay_ms(100);0C6B: MOVLW 640C6C: MOVWF 430C6D: BCF 0A.30C6E: CALL 0FB0C6F: BSF 0A.3.................... }0C70: GOTO 383........................................ }0C71: SLEEPConfiguration Fuses:Word 1: 2CF5 INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUGWord 2: 3FFF NOWRT BORV40