CCS PCH C Compiler, Version 4.088, 36728 26-aug.-09 18:53 Filename: E:\Raktar\Elektronika\AGC-Ferro\main.lst ROM used: 728 bytes (4%) Largest free fragment is 15656 RAM used: 14 (2%) at main() level 19 (2%) worst case Stack: 2 locations * 0000: GOTO 019E .................... #include "E:\Raktar\Elektronika\AGC-Ferro\main.h" .................... #include <18F14K50.h> .................... //////// Standard Header file for the PIC18F14K50 device //////////////// .................... #device PIC18F14K50 .................... #list .................... .................... #device adc=8 .................... .................... #FUSES NOWDT //No Watch Dog Timer .................... #FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale .................... #FUSES INTRC_IO //Internal RC Osc, no CLKOUT .................... #FUSES FCMEN //Fail-safe clock monitor enabled .................... #FUSES NOBROWNOUT //No brownout reset .................... #FUSES BORV22 //Brownout reset at 2.2V .................... #FUSES PUT // Power Up Timer .................... #FUSES NOCPD //No EE protection .................... #FUSES STVREN //Stack full/underflow will cause reset .................... #FUSES NODEBUG //No Debug mode for ICD .................... #FUSES NOXINST //Extended set extension and Indexed Addressing mode disabled (Legacy mode) .................... #FUSES NOWRT //Program memory not write protected .................... #FUSES NOWRTD //Data EEPROM not write protected .................... #FUSES NOWRTC //configuration not registers write protected .................... #FUSES IESO //Internal External Switch Over mode enabled .................... #FUSES NOEBTR //Memory not protected from table reads .................... #FUSES NOEBTRB //Boot block not protected from table reads .................... #FUSES MCLR //Master Clear pin enabled .................... #FUSES NOPROTECT //Code not protected from reading .................... #FUSES NOCPB //No Boot Block code protection .................... #FUSES NOWRTB //Boot block not write protected .................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O .................... #FUSES NOHFOFST .................... #FUSES WRT0 .................... #FUSES WRT1 .................... #FUSES USBDIV2 .................... #FUSES PCLKEN .................... #FUSES BBSIZ2K //2K words Boot Block size .................... #FUSES PLLEN .................... #FUSES CPUDIV4 //System Clock by 4 .................... .................... #use delay(clock=8000000) 0004: MOVLW 09 0006: SUBWF 12,F 0008: BNC 0020 000A: CLRF FEA 000C: MOVLW 12 000E: MOVWF FE9 0010: BCF FD8.0 0012: RRCF FEF,F 0014: MOVF FEF,W 0016: BZ 0020 0018: BRA 001C 001A: NOP 001C: DECFSZ FEF,F 001E: BRA 001A 0020: RETLW 00 * 006C: CLRF FEA 006E: MOVLW 0E 0070: MOVWF FE9 0072: MOVF FEF,W 0074: BZ 0090 0076: MOVLW 02 0078: MOVWF 01 007A: CLRF 00 007C: DECFSZ 00,F 007E: BRA 007C 0080: DECFSZ 01,F 0082: BRA 007A 0084: MOVLW 97 0086: MOVWF 00 0088: DECFSZ 00,F 008A: BRA 0088 008C: DECFSZ FEF,F 008E: BRA 0076 0090: RETLW 00 .................... .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... /* float.h */ .................... .................... .................... #ifndef _FLOAT .................... #define _FLOAT .................... /* Float properties */ .................... .................... #define FLT_RADIX 2 .................... #define FLT_MANT_DIG 24 // # of bits in mantissa .................... .................... #define FLT_DIG 6 // # of decimal digits of precision .................... .................... #define FLT_MIN_EXP (-125) // min binary exponent .................... #define FLT_MIN_10_EXP (-37) // min decimal exponent .................... #define FLT_MAX_EXP 128 // max binary exponent .................... #define FLT_MAX_10_EXP 38 // max decimal exponent .................... #define FLT_MAX 3.402823466e+38F // max value .................... #define FLT_EPSILON 1.192092896e-07F // smallest such that 1.0+FLT_EPSILON != 1.0 .................... #define FLT_MIN 1.175494351e-38F // min positive value .................... .................... .................... /* Double properties */ .................... #define DBL_MANT_DIG 53 // # of bits in mantissa .................... .................... #define DBL_DIG 15 // # of decimal digits of precision .................... .................... #define DBL_MIN_EXP (-1021) // min binary exponent .................... #define DBL_MIN_10_EXP (-307) // min decimal exponent .................... #define DBL_MAX_EXP 1024 // max binary exponent .................... #define DBL_MAX_10_EXP 308 // max decimal exponent .................... #define DBL_MAX 1.79769313486231e+308F // max value .................... #define DBL_EPSILON 2.2204460492503131e-16F // smallest such that 1.0+FLT_EPSILON != 1.0 .................... #define DBL_MIN 2.22507385850721e-308F // min positive value .................... .................... /*Long double properties */ .................... .................... #define LDBL_MANT_DIG 64 // # of bits in mantissa .................... .................... #define LDBL_DIG 18 // # of decimal digits of precision .................... .................... #define LDBL_MIN_EXP (-16381) // min binary exponent .................... #define LDBL_MIN_10_EXP (-4931) // min decimal exponent .................... #define LDBL_MAX_EXP 16384 // max binary exponent .................... #define LDBL_MAX_10_EXP 4932 // max decimal exponent .................... #define LDBL_MAX 1.18973149535723176502e+4932F // max value .................... #define LDBL_EPSILON 1.084202172485504434e-019F // smallest such that 1.0+FLT_EPSILON != 1.0 .................... #define LDBL_MIN 3.36210314311209350626e-4932F // min positive value .................... #endif .................... .................... .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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 .................... // .................... float32 pwr(float32 x,float32 y) .................... { .................... if(x>=0) .................... return( exp(y*log(x)) ); .................... else .................... return( -exp(y*log(-x)) ); .................... } .................... //Overloaded functions for pwr() for PCD .................... // Overloaded function pwr() for data type - Float48 .................... #if defined(__PCD__) .................... float48 pwr(float48 x,float48 y) .................... { .................... if(x>=0) .................... return( exp(y*log(x)) ); .................... else .................... return( -exp(y*log(-x)) ); .................... } .................... // Overloaded function pwr() for data type - Float64 .................... float64 pwr(float64 x,float64 y) .................... { .................... if(x>=0) .................... return( exp(y*log(x)) ); .................... else .................... return( -exp(y*log(-x)) ); .................... } .................... #endif .................... .................... //////////////////// Power functions //////////////////// .................... .................... //////////////////////////////////////////////////////////////////////////// .................... // float pow(float x,float y) .................... //////////////////////////////////////////////////////////////////////////// .................... // Description : returns the value (x^y) .................... // Date : N/A .................... // .................... float32 pow(float32 x,float32 y) .................... { .................... if(x>=0) .................... return( exp(y*log(x)) ); .................... else .................... return( -exp(y*log(-x)) ); .................... } .................... //Overloaded functions for pow() for PCD .................... // Overloaded function for pow() data type - Float48 .................... #if defined(__PCD__) .................... float48 pow(float48 x,float48 y) .................... { .................... if(x>=0) .................... return( exp(y*log(x)) ); .................... else .................... return( -exp(y*log(-x)) ); .................... } .................... .................... // Overloaded function pow() for data type - Float64 .................... float64 pow(float64 x,float64 y) .................... { .................... if(x>=0) .................... return( exp(y*log(x)) ); .................... else .................... return( -exp(y*log(-x)) ); .................... } .................... #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[4] = { .................... -0.499999993585, .................... 0.041666636258, .................... -0.0013888361399, .................... 0.00002476016134 .................... }; .................... .................... 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 <= 3; 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[4] = { .................... -0.499999993585, .................... 0.041666636258, .................... -0.0013888361399, .................... 0.00002476016134 .................... }; .................... .................... 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 <= 3; 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[4] = { .................... -0.499999993585, .................... 0.041666636258, .................... -0.0013888361399, .................... 0.00002476016134 .................... }; .................... .................... 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 <= 3; 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 .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STDIO .................... #define _STDIO .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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. //// .................... //////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STRING .................... #define _STRING .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STDDEF .................... .................... #define _STDDEF .................... .................... #if sizeof(unsigned int8 *)==1 .................... #define ptrdiff_t unsigned int8 .................... #else .................... #define ptrdiff_t unsigned int16 .................... #endif .................... .................... #define size_t unsigned int8 .................... #define wchar_t char .................... #define NULL 0 .................... .................... #define offsetof(s,f) (offsetofbit(s,f)/8) .................... .................... #endif .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 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. //// .................... //////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _CTYPE .................... #define _CTYPE .................... .................... #define islower(x) isamong(x,"abcdefghijklmnopqrstuvwxyz") .................... #define isupper(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ") .................... #define isalnum(x) isamong(x,"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") .................... #define isalpha(x) isamong(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") .................... #define isdigit(x) isamong(x,"0123456789") .................... #define isspace(x) ((x)==' ') .................... #define isxdigit(x) isamong(x,"0123456789ABCDEFabcdef") .................... #define iscntrl(x) ((x)<' ') .................... #define isprint(x) ((x)>=' ') .................... #define isgraph(x) ((x)>' ') .................... #define ispunct(x) (((x)>' ')&&!isalnum(x)) .................... .................... #endif .................... .................... .................... .................... .................... .................... ////////////////////////////////////////////// .................... //// Uncomment the following define to //// .................... //// allow some functions to use a //// .................... //// quicker algorithm, but use more ROM //// .................... //// //// .................... //// #define FASTER_BUT_MORE_ROM //// .................... ////////////////////////////////////////////// .................... .................... .................... .................... /*Copying functions*/ .................... /* standard template: .................... void *memmove(void *s1, void *s2, size_t n). .................... Copies max of n characters safely (not following ending '\0') .................... from s2 in s1; if s2 has less than n characters, appends 0 */ .................... .................... char *memmove(void *s1,char *s2,size_t n) .................... { .................... char *sc1; .................... char *sc2; .................... sc1=s1; .................... sc2=s2; .................... if(sc2 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(s1); .................... } .................... /***********************************************************/ .................... .................... /*concatenation functions*/ .................... /* standard template: char *strcat(char *s1, const char *s2) .................... appends s2 to s1*/ .................... .................... char *strcat(char *s1, char *s2) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0') .................... { .................... *s = *s2; .................... ++s; .................... ++s2; .................... } .................... .................... *s = '\0'; .................... return(s1); .................... } .................... /* standard template: char *strncat(char *s1, char *s2,size_t n) .................... appends not more than n characters from s2 to s1*/ .................... .................... char *strncat(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0' && 0s2 */ .................... .................... signed int8 memcmp(void * s1,char *s2,size_t n) .................... { .................... char *su1, *su2; .................... for(su1=s1, su2=s2; 0s2 */ .................... .................... signed int8 strcmp(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... /* standard template: int strcoll(const char *s1, const char *s2). .................... Compares s1 & s2; returns -1 if s1s2 */ .................... .................... signed int8 strcoll(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... .................... /* standard template: .................... int strncmp(const char *s1, const char *s2, size_t n). .................... Compares max of n characters (not following 0) from s1 to s2; .................... returns same as strcmp */ .................... .................... signed int8 strncmp(char *s1, char *s2, size_t n) .................... { .................... for (; n > 0; s1++, s2++, n--) .................... if (*s1 != *s2) .................... return((*s1 <*s2) ? -1: 1); .................... else if (*s1 == '\0') .................... return(0); .................... return(0); .................... } .................... /* standard template: .................... int strxfrm(const char *s1, const char *s2, size_t n). .................... transforms maximum of n characters from s2 and places them into s1*/ .................... size_t strxfrm(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... unsigned int8 n1; .................... n1=n; .................... for (s = s1; n > 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(n1); .................... } .................... .................... .................... .................... .................... .................... /***********************************************************/ .................... /*Search functions*/ .................... /* standard template: void *memchr(const char *s, int c). .................... Finds first occurrence of c in n characters of s */ .................... .................... char *memchr(void *s,unsigned int8 c,size_t n) .................... { .................... char uc; .................... char *su; .................... uc=c; .................... for(su=s;0= 'A' && *p <='Z') .................... *p += 'a' - 'A'; .................... return(s); .................... } .................... .................... .................... /************************************************************/ .................... .................... .................... #endif .................... .................... #ifndef getc .................... #define getc getch .................... #define getchar getch .................... #define puts(s) {printf(s); putchar(13); putchar(10);} .................... #define putc putchar .................... #endif .................... /* maps error number to an error message. Writes a sequence of characters to .................... stderr stream thus: if s is not null then string pointed to by s follwed by .................... a colon (:) and a space and the appropriate error message returned by strerror .................... function with argument errno .................... .................... Returns: no value .................... */ .................... .................... #ifdef _ERRNO .................... void perror(char *s) .................... { .................... if(s) .................... fprintf(STDERR,"%s: ",s); .................... fprintf(STDERR,"%s\r\n",strerror(errno)); .................... } .................... #endif .................... #endif .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2007 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STDLIB .................... #define _STDLIB .................... .................... //--------------------------------------------------------------------------- .................... // Definitions and types .................... //--------------------------------------------------------------------------- .................... .................... #ifndef RAND_MAX .................... #define RAND_MAX 32767 // The value of which is the maximum value .................... // ... returned by the rand function .................... #endif .................... .................... .................... #IF (sizeof(int16*)>1) .................... #DEFINE LONG_POINTERS 1 .................... #ELSE .................... #DEFINE LONG_POINTERS 0 .................... #ENDIF .................... .................... typedef struct { .................... signed int quot; .................... signed int rem; .................... } div_t; .................... .................... typedef struct { .................... signed long quot; .................... signed long rem; .................... } ldiv_t; .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STDDEF .................... .................... #define _STDDEF .................... .................... #if sizeof(unsigned int8 *)==1 .................... #define ptrdiff_t unsigned int8 .................... #else .................... #define ptrdiff_t unsigned int16 .................... #endif .................... .................... #define size_t unsigned int8 .................... #define wchar_t char .................... #define NULL 0 .................... .................... #define offsetof(s,f) (offsetofbit(s,f)/8) .................... .................... #endif .................... .................... .................... //--------------------------------------------------------------------------- .................... // String conversion functions .................... //--------------------------------------------------------------------------- .................... .................... /* Standard template: signed int atoi(char * s) .................... * converts the initial portion of the string s to a signed int .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed int atoi(char *s); .................... .................... /* Syntax: signed int32 atoi32(char * s) .................... converts the initial portion of the string s to a signed int32 .................... returns the converted value if any, 0 otherwise*/ .................... #if (sizeof(long)==4) .................... #define atoi32(s) atol(s) .................... #else .................... signed int32 atoi32(char *s); .................... #endif .................... .................... #if defined(__PCD__) .................... // The following functions only work on the 24 bit compiler .................... // for the 30F, 33F, 24F and 24H parts .................... /* Syntax: signed int48 atoi48(char * s) .................... converts the initial portion of the string s to a signed int48 .................... returns the converted value if any, 0 otherwise*/ .................... .................... signed int48 atoi48(char *s); .................... .................... /* Syntax: signed int64 atoi64(char * s) .................... converts the initial portion of the string s to a signed int64 .................... returns the converted value if any, 0 otherwise*/ .................... signed int64 atoi64(char *s); .................... #endif .................... .................... /* Syntax: char * itoa(signed int32 num, int8 base, char * s) .................... converts the signed int32 to a string and .................... returns the converted value if any, 0 otherwise*/ .................... char * itoa(signed int32 num, unsigned int base, char * s); .................... .................... /* Standard template: signed int16 atol(char * s) .................... * converts the initial portion of the string s to a signed int16 .................... * returns the converted value if any, 0 otherwise .................... */ .................... signed long atol(char *s); .................... .................... /* Standard template: int16 strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a signed long. .................... * Returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... signed long strtol(char *s,char *endptr, signed int base); .................... .................... /* Standard template: int16 strtoul(char * s,char *endptr,signed int base) .................... * converts the initial portion of the string s, represented as an .................... * integral value of radix base to a unsigned long. .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... unsigned long strtoul(char *s,char *endptr, signed int base); .................... .................... /* Standart template: float strtof(char * s,char *endptr) .................... float48 strtof48(char *s,char *endptr); .................... float64 strtod(char *s,char *endptr); .................... * converts the initial portion of the string s to a float32, float48 or float64, .................... * returns the converted value if any, 0 otherwise .................... * the final string is returned in the endptr, if endptr is not null .................... */ .................... float strtof(char *s,char *endptr); .................... #if defined(__PCD__) .................... float48 strtof48(char *s,char *endptr); .................... float64 strtod(char *s,char *endptr); .................... #else .................... //provided for compatibility .................... #define strtof48(s, e) strtof(s, e) .................... #define strtod(s, e) strtof(s, e) .................... #endif .................... .................... /* Standard template: float32 atof(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... */ .................... #define atof(s) strtof(s, 0) .................... .................... #if defined(__PCD__) .................... // The following functions only work on the 24 bit compiler .................... // for the 30F, 33F, 24F and 24H parts .................... .................... /* Standard template: float48 atof48(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... */ .................... #define atof48(s) strtof48(s, 0) .................... .................... /* Standard template: float64 atof64(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... */ .................... #define atof64(s) strtod(s, 0) .................... #endif .................... .................... /* Standard template: float32 atoe(char * s) .................... * converts the initial portion of the string s to a float. .................... * returns the converted value if any, 0 otherwise .................... * also handles E format numbers .................... */ .................... #if !defined(__PCD__) .................... float atoe(char * s); .................... #endif .................... .................... #if defined(__PCD__) .................... float32 atoe(char * s); .................... #endif .................... .................... //--------------------------------------------------------------------------- .................... // Pseudo-random sequence generation functions .................... //--------------------------------------------------------------------------- .................... .................... /* The rand function computes a sequence of pseudo-random integers in .................... * the range 0 to RAND_MAX .................... * .................... * Parameters: .................... * (none) .................... * .................... * Returns: .................... * The pseudo-random integer .................... */ .................... unsigned int16 rand(void); .................... .................... /* The srand function uses the argument as a seed for a new sequence of .................... * pseudo-random numbers to be returned by subsequent calls to rand. .................... * .................... * Parameters: .................... * [in] seed: The seed value to start from. You might need to pass .................... * .................... * Returns: .................... * (none) .................... * .................... * Remarks .................... * The srand function sets the starting point for generating .................... * a series of pseudorandom integers. To reinitialize the .................... * generator, use 1 as the seed argument. Any other value for .................... * seed sets the generator to a random starting point. rand .................... * retrieves the pseudorandom numbers that are generated. .................... * Calling rand before any call to srand generates the same .................... * sequence as calling srand with seed passed as 1. .................... * Usually, you need to pass a time here from outer source .................... * so that the numbers will be different every time you run. .................... */ .................... void srand(unsigned int32 seed); .................... .................... //--------------------------------------------------------------------------- .................... // Memory management functions .................... //--------------------------------------------------------------------------- .................... .................... // Comming soon .................... .................... //--------------------------------------------------------------------------- .................... // Communication with the environment .................... //--------------------------------------------------------------------------- .................... .................... /* The function returns 0 always .................... */ .................... signed int8 system(char *string); .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities .................... //--------------------------------------------------------------------------- .................... .................... /* Performs a binary search of a sorted array.. .................... * .................... * Parameters: .................... * [in] key: Object to search for .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * bsearch returns a pointer to an occurrence of key in the array pointed .................... * to by base. If key is not found, the function returns NULL. If the .................... * array is not in order or contains duplicate records with identical keys, .................... * the result is unpredictable. .................... */ .................... //void *bsearch(const void *key, const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... /* Performs the shell-metzner sort (not the quick sort algorithm). The contents .................... * of the array are sorted into ascending order according to a comparison .................... * function pointed to by compar. .................... * .................... * Parameters: .................... * [in] base: Pointer to base of search data .................... * [in] num: Number of elements .................... * [in] width: Width of elements .................... * [in] compare: Function that compares two elements .................... * .................... * Returns: .................... * (none) .................... */ .................... //void *qsort(const void *base, size_t num, size_t width, .................... // int (*compare)(const void *, const void *)); .................... .................... //--------------------------------------------------------------------------- .................... // Integer arithmetic functions .................... //--------------------------------------------------------------------------- .................... .................... #define labs abs .................... .................... div_t div(signed int numer, signed int denom); .................... ldiv_t ldiv(signed long numer, signed long denom); .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte character functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... //--------------------------------------------------------------------------- .................... // Multibyte string functions .................... //--------------------------------------------------------------------------- .................... .................... // Not supported .................... .................... .................... //--------------------------------------------------------------------------- .................... // Internal implementation .................... //--------------------------------------------------------------------------- .................... .................... #include .................... /////////////////////////////////////////////////////////////////////////// .................... //// (C) Copyright 1996,2003 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. //// .................... /////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STDDEF .................... .................... #define _STDDEF .................... .................... #if sizeof(unsigned int8 *)==1 .................... #define ptrdiff_t unsigned int8 .................... #else .................... #define ptrdiff_t unsigned int16 .................... #endif .................... .................... #define size_t unsigned int8 .................... #define wchar_t char .................... #define NULL 0 .................... .................... #define offsetof(s,f) (offsetofbit(s,f)/8) .................... .................... #endif .................... .................... #include .................... //////////////////////////////////////////////////////////////////////////// .................... //// (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. //// .................... //////////////////////////////////////////////////////////////////////////// .................... .................... #ifndef _STRING .................... #define _STRING .................... #include .................... #include .................... .................... .................... .................... ////////////////////////////////////////////// .................... //// Uncomment the following define to //// .................... //// allow some functions to use a //// .................... //// quicker algorithm, but use more ROM //// .................... //// //// .................... //// #define FASTER_BUT_MORE_ROM //// .................... ////////////////////////////////////////////// .................... .................... .................... .................... /*Copying functions*/ .................... /* standard template: .................... void *memmove(void *s1, void *s2, size_t n). .................... Copies max of n characters safely (not following ending '\0') .................... from s2 in s1; if s2 has less than n characters, appends 0 */ .................... .................... char *memmove(void *s1,char *s2,size_t n) .................... { .................... char *sc1; .................... char *sc2; .................... sc1=s1; .................... sc2=s2; .................... if(sc2 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(s1); .................... } .................... /***********************************************************/ .................... .................... /*concatenation functions*/ .................... /* standard template: char *strcat(char *s1, const char *s2) .................... appends s2 to s1*/ .................... .................... char *strcat(char *s1, char *s2) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0') .................... { .................... *s = *s2; .................... ++s; .................... ++s2; .................... } .................... .................... *s = '\0'; .................... return(s1); .................... } .................... /* standard template: char *strncat(char *s1, char *s2,size_t n) .................... appends not more than n characters from s2 to s1*/ .................... .................... char *strncat(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... .................... for (s = s1; *s != '\0'; ++s); .................... while(*s2 != '\0' && 0s2 */ .................... .................... signed int8 memcmp(void * s1,char *s2,size_t n) .................... { .................... char *su1, *su2; .................... for(su1=s1, su2=s2; 0s2 */ .................... .................... signed int8 strcmp(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... /* standard template: int strcoll(const char *s1, const char *s2). .................... Compares s1 & s2; returns -1 if s1s2 */ .................... .................... signed int8 strcoll(char *s1, char *s2) .................... { .................... for (; *s1 == *s2; s1++, s2++) .................... if (*s1 == '\0') .................... return(0); .................... return((*s1 < *s2) ? -1: 1); .................... } .................... .................... /* standard template: .................... int strncmp(const char *s1, const char *s2, size_t n). .................... Compares max of n characters (not following 0) from s1 to s2; .................... returns same as strcmp */ .................... .................... signed int8 strncmp(char *s1, char *s2, size_t n) .................... { .................... for (; n > 0; s1++, s2++, n--) .................... if (*s1 != *s2) .................... return((*s1 <*s2) ? -1: 1); .................... else if (*s1 == '\0') .................... return(0); .................... return(0); .................... } .................... /* standard template: .................... int strxfrm(const char *s1, const char *s2, size_t n). .................... transforms maximum of n characters from s2 and places them into s1*/ .................... size_t strxfrm(char *s1, char *s2, size_t n) .................... { .................... char *s; .................... unsigned int8 n1; .................... n1=n; .................... for (s = s1; n > 0 && *s2 != '\0'; n--) .................... *s++ = *s2++; .................... for (; n > 0; n--) .................... *s++ = '\0'; .................... .................... return(n1); .................... } .................... .................... .................... .................... .................... .................... /***********************************************************/ .................... /*Search functions*/ .................... /* standard template: void *memchr(const char *s, int c). .................... Finds first occurrence of c in n characters of s */ .................... .................... char *memchr(void *s,unsigned int8 c,size_t n) .................... { .................... char uc; .................... char *su; .................... uc=c; .................... for(su=s;0= 'A' && *p <='Z') .................... *p += 'a' - 'A'; .................... return(s); .................... } .................... .................... .................... /************************************************************/ .................... .................... .................... #endif .................... .................... .................... div_t div(signed int numer, signed int denom) .................... { .................... div_t val; .................... val.quot = numer / denom; .................... val.rem = numer - (denom * val.quot); .................... return (val); .................... } .................... .................... ldiv_t ldiv(signed long numer, signed long denom) .................... { .................... ldiv_t val; .................... .................... val.quot = numer / denom; .................... val.rem = numer - (denom * val.quot); .................... return (val); .................... } .................... .................... #if defined(__PCD__) .................... float32 atoe(char * s) .................... { .................... float32 pow10 = 1.0; .................... float32 result = 0.0; .................... unsigned int8 sign = 0; .................... unsigned int8 expsign = 0; .................... char c; .................... unsigned int8 ptr = 0; .................... unsigned int8 i; .................... float32 exp = 1.0; .................... unsigned int8 expcnt = 0; .................... .................... c = s[ptr++]; .................... .................... if ((c>='0' && c<='9') || c=='+' || c=='-' || c=='.' || c=='E' || c=='e') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... // Handling the exponent .................... if (c=='e' || c=='E') { .................... c = s[ptr++]; .................... .................... if(c == '-') { .................... expsign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... expcnt = 10*expcnt + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... for(i=0;i='0' && c<='9') || c=='+' || c=='-' || c=='.' || c=='E' || c=='e') { .................... if(c == '-') { .................... sign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... result = 10*result + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... if (c == '.') { .................... c = s[ptr++]; .................... while((c >= '0' && c <= '9')) { .................... pow10 = pow10*10; .................... result += (c - '0')/pow10; .................... c = s[ptr++]; .................... } .................... } .................... .................... // Handling the exponent .................... if (c=='e' || c=='E') { .................... c = s[ptr++]; .................... .................... if(c == '-') { .................... expsign = 1; .................... c = s[ptr++]; .................... } .................... if(c == '+') .................... c = s[ptr++]; .................... .................... while((c >= '0' && c <= '9')) { .................... expcnt = 10*expcnt + c - '0'; .................... c = s[ptr++]; .................... } .................... .................... for(i=0;i= '0' && c <= '9') .................... { .................... .................... // Check for hexa number .................... if (c == '0' && (s[index] == 'x' || s[index] == 'X')) .................... { .................... base = 16; .................... index++; .................... c = s[index++]; .................... } .................... .................... // The number is a decimal number .................... if (base == 10) .................... { .................... while (c >= '0' && c <= '9') .................... { .................... result = 10*result + (c - '0'); .................... c = s[index++]; .................... } .................... } .................... else if (base == 16) // The number is a hexa number .................... { .................... c = toupper(c); .................... while ( (c >= '0' && c <= '9') || (c >= 'A' && c<='F')) .................... { .................... if (c >= '0' && c <= '9') .................... result = (result << 4) + (c - '0'); .................... else .................... result = (result << 4) + (c - 'A' + 10); .................... .................... c = s[index++]; .................... c = toupper(c); .................... } .................... } .................... } .................... .................... if (sign == 1 && base == 10) .................... result = -result; .................... .................... return(result); .................... } .................... .................... signed long atol(char *s) .................... { .................... signed long result; .................... unsigned int sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... c = s[index++]; .................... .................... // increase index if either positive or negative sign is detected .................... if (c == '-') .................... { .................... sign = 1; // Set the sign to negative .................... c = s[index++]; .................... } .................... else if (c == '+') .................... { .................... c = s[index++]; .................... } .................... .................... if (c >= '0' && c <= '9') .................... { .................... if (c == '0' && (s[index] == 'x' || s[index] == 'X')) .................... { .................... base = 16; .................... index++; .................... c = s[index++]; .................... } .................... .................... // The number is a decimal number .................... if (base == 10) .................... { .................... while (c >= '0' && c <= '9') .................... { .................... result = 10*result + (c - '0'); .................... c = s[index++]; .................... } .................... } .................... else if (base == 16) // The number is a hexa number .................... { .................... c = toupper(c); .................... while ( (c >= '0' && c <= '9') || (c >= 'A' && c <='F')) .................... { .................... if (c >= '0' && c <= '9') .................... result = (result << 4) + (c - '0'); .................... else .................... result = (result << 4) + (c - 'A' + 10); .................... .................... c = s[index++];c = toupper(c); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... /* A fast routine to multiply by 10 .................... */ .................... signed int32 mult_with10(int32 num) .................... { .................... return ( (num << 1) + (num << 3) ); .................... } .................... .................... #if sizeof(long)==2 .................... signed int32 atoi32(char *s) .................... { .................... signed int32 result; .................... int8 sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... c = s[index++]; .................... .................... // increase index if either positive or negative sign is detected .................... if (c == '-') .................... { .................... sign = 1; // Set the sign to negative .................... c = s[index++]; .................... } .................... else if (c == '+') .................... { .................... c = s[index++]; .................... } .................... .................... if (c >= '0' && c <= '9') .................... { .................... if (c == '0' && (s[index] == 'x' || s[index] == 'X')) .................... { .................... base = 16; .................... index++; .................... c = s[index++]; .................... } .................... .................... // The number is a decimal number .................... if (base == 10) .................... { .................... while (c >= '0' && c <= '9') { .................... result = (result << 1) + (result << 3); // result *= 10; .................... result += (c - '0'); .................... c = s[index++]; .................... } .................... } .................... else if (base == 16) // The number is a hexa number .................... { .................... c = toupper(c); .................... while ((c >= '0' && c <= '9') || (c >= 'A' && c <='F')) .................... { .................... if (c >= '0' && c <= '9') .................... result = (result << 4) + (c - '0'); .................... else .................... result = (result << 4) + (c - 'A' + 10); .................... .................... c = s[index++];c = toupper(c); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... #endif .................... .................... #if defined(__PCD__) .................... .................... signed int48 atoi48(char *s) .................... { .................... signed int48 result; .................... int8 sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... c = s[index++]; .................... .................... // increase index if either positive or negative sign is detected .................... if (c == '-') .................... { .................... sign = 1; // Set the sign to negative .................... c = s[index++]; .................... } .................... else if (c == '+') .................... { .................... c = s[index++]; .................... } .................... .................... if (c >= '0' && c <= '9') .................... { .................... if (c == '0' && (s[index] == 'x' || s[index] == 'X')) .................... { .................... base = 16; .................... index++; .................... c = s[index++]; .................... } .................... .................... // The number is a decimal number .................... if (base == 10) .................... { .................... while (c >= '0' && c <= '9') { .................... result = (result << 1) + (result << 3); // result *= 10; .................... result += (c - '0'); .................... c = s[index++]; .................... } .................... } .................... else if (base == 16) // The number is a hexa number .................... { .................... c = toupper(c); .................... while ((c >= '0' && c <= '9') || (c >= 'A' && c <='F')) .................... { .................... if (c >= '0' && c <= '9') .................... result = (result << 4) + (c - '0'); .................... else .................... result = (result << 4) + (c - 'A' + 10); .................... .................... c = s[index++];c = toupper(c); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... .................... signed int64 atoi64(char *s) .................... { .................... signed int64 result; .................... int8 sign, base, index; .................... char c; .................... .................... index = 0; .................... sign = 0; .................... base = 10; .................... result = 0; .................... .................... if (!s) .................... return 0; .................... c = s[index++]; .................... .................... // increase index if either positive or negative sign is detected .................... if (c == '-') .................... { .................... sign = 1; // Set the sign to negative .................... c = s[index++]; .................... } .................... else if (c == '+') .................... { .................... c = s[index++]; .................... } .................... .................... if (c >= '0' && c <= '9') .................... { .................... if (c == '0' && (s[index] == 'x' || s[index] == 'X')) .................... { .................... base = 16; .................... index++; .................... c = s[index++]; .................... } .................... .................... // The number is a decimal number .................... if (base == 10) .................... { .................... while (c >= '0' && c <= '9') { .................... result = (result << 1) + (result << 3); // result *= 10; .................... result += (c - '0'); .................... c = s[index++]; .................... } .................... } .................... else if (base == 16) // The number is a hexa number .................... { .................... c = toupper(c); .................... while ((c >= '0' && c <= '9') || (c >= 'A' && c <='F')) .................... { .................... if (c >= '0' && c <= '9') .................... result = (result << 4) + (c - '0'); .................... else .................... result = (result << 4) + (c - 'A' + 10); .................... .................... c = s[index++];c = toupper(c); .................... } .................... } .................... } .................... .................... if (base == 10 && sign == 1) .................... result = -result; .................... .................... return(result); .................... } .................... #endif .................... .................... char * itoa(signed int32 num, unsigned int base, char * s) .................... { .................... unsigned int32 temp=1; .................... unsigned int8 i,sign=0,cnt=0; .................... char c; .................... .................... if(num<0) { .................... sign=1; // Check for negative number .................... num*=-1; .................... } .................... .................... while(temp>0) { .................... temp=(num/base); .................... s[cnt]=(num%base)+'0'; // Conversion .................... .................... if(s[cnt]>0x39) .................... s[cnt]+=0x7; .................... .................... cnt++; .................... num=temp; .................... } .................... .................... if(sign==1) { .................... s[cnt]=0x2D; // Negative sign .................... cnt++; .................... } .................... .................... for(i = 0;i<(int8)(cnt/2);i++) { .................... .................... c=s[i]; .................... s[i]=s[cnt-i-1]; // Reverse the number .................... s[cnt-i-1]=c; .................... } .................... s[cnt]='\0'; // End the string .................... return s; .................... } .................... .................... float strtof(char *s, char *endptr) .................... { .................... float pow10 = 1.0; .................... float result = 0.0; .................... int1 skip = TRUE, sign = FALSE, point = FALSE; .................... char c; .................... unsigned int8 ptr = 0; .................... .................... if (!s) .................... return 0; .................... .................... for(c=s[ptr++]; c!=0; c=s[ptr++]) .................... { .................... if (skip && !isspace(c)) .................... { .................... skip = FALSE; .................... if (c == '+') .................... { .................... sign = FALSE; .................... continue; .................... } .................... else if (c == '-') .................... { .................... sign = TRUE; .................... continue; .................... } .................... } .................... if (!skip && (c == '.') && !point) .................... point = TRUE; .................... else if (!skip && isdigit(c)) .................... { .................... c -= '0'; .................... if (point) .................... { .................... pow10 = pow10 * 10.0; .................... result += (float)c / pow10; .................... } .................... else .................... { .................... result = 10.0 * result + (float)c; .................... } .................... } .................... else if (!skip) .................... break; .................... } .................... .................... if (sign) .................... result = -1*result; .................... .................... if(endptr) .................... { .................... if (ptr) { .................... ptr--; .................... #IF LONG_POINTERS .................... *((long *)endptr)= s+ptr; .................... #ELSE .................... *((char *)endptr)=s+ptr; .................... #ENDIF .................... } .................... else .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= s; .................... #ELSE .................... *((char *)endptr)=s; .................... #ENDIF .................... } .................... } .................... .................... return(result); .................... } .................... .................... #if defined(__PCD__) .................... float48 strtof48(char *s, char *endptr) .................... { .................... float48 pow10 = 1.0; .................... float48 result = 0.0; .................... int1 skip = TRUE, sign = FALSE, point = FALSE; .................... char c; .................... unsigned int8 ptr = 0; .................... .................... if (!s) .................... return 0; .................... .................... for(c=s[ptr++]; c!=0; c=s[ptr++]) .................... { .................... if (skip && !isspace(c)) .................... { .................... skip = FALSE; .................... if (c == '+') .................... { .................... sign = FALSE; .................... continue; .................... } .................... else if (c == '-') .................... { .................... sign = TRUE; .................... continue; .................... } .................... } .................... if (!skip && (c == '.') && !point) .................... point = TRUE; .................... else if (!skip && isdigit(c)) .................... { .................... c -= '0'; .................... if (point) .................... { .................... pow10 = pow10 * 10.0; .................... result += (float48)c / pow10; .................... } .................... else .................... { .................... result = 10.0 * result + (float48)c; .................... } .................... } .................... else if (!skip) .................... break; .................... } .................... .................... if (sign) .................... result = -1*result; .................... .................... if(endptr) .................... { .................... if (ptr) { .................... ptr--; .................... #IF LONG_POINTERS .................... *((long *)endptr)= s+ptr; .................... #ELSE .................... *((char *)endptr)=s+ptr; .................... #ENDIF .................... } .................... else .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= s; .................... #ELSE .................... *((char *)endptr)=s; .................... #ENDIF .................... } .................... } .................... .................... return(result); .................... } .................... .................... float64 strtod(char *s, char *endptr) .................... { .................... float64 pow10 = 1.0; .................... float64 result = 0.0; .................... int1 skip = TRUE, sign = FALSE, point = FALSE; .................... char c; .................... unsigned int8 ptr = 0; .................... .................... if (!s) .................... return 0; .................... .................... for(c=s[ptr++]; c!=0; c=s[ptr++]) .................... { .................... if (skip && !isspace(c)) .................... { .................... skip = FALSE; .................... if (c == '+') .................... { .................... sign = FALSE; .................... continue; .................... } .................... else if (c == '-') .................... { .................... sign = TRUE; .................... continue; .................... } .................... } .................... if (!skip && (c == '.') && !point) .................... point = TRUE; .................... else if (!skip && isdigit(c)) .................... { .................... c -= '0'; .................... if (point) .................... { .................... pow10 = pow10 * 10.0; .................... result += (float64)c / pow10; .................... } .................... else .................... { .................... result = 10.0 * result + (float64)c; .................... } .................... } .................... else if (!skip) .................... break; .................... } .................... .................... if (sign) .................... result = -1*result; .................... .................... if(endptr) .................... { .................... if (ptr) { .................... ptr--; .................... #IF LONG_POINTERS .................... *((long *)endptr)= s+ptr; .................... #ELSE .................... *((char *)endptr)=s+ptr; .................... #ENDIF .................... } .................... else .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= s; .................... #ELSE .................... *((char *)endptr)=s; .................... #ENDIF .................... } .................... } .................... .................... return(result); .................... } .................... #endif .................... .................... unsigned long strtoul(char *s, char *endptr, signed int base) .................... { .................... char *sc,*s1,*sd; .................... unsigned long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if(sign=='-' || base <0 || base ==1|| base >36) // invalid base .................... goto StrtoulGO; .................... .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... sd=memchr(digits,tolower(*sc),base); .................... for(; sd!=0; ) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... StrtoulGO: .................... if (endptr) .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= s; .................... #ELSE .................... *((char *)endptr)=s; .................... #ENDIF .................... } .................... return 0; .................... } .................... if (endptr) .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= sc; .................... #ELSE .................... *((char *)endptr)=sc; .................... #ENDIF .................... } .................... return x; .................... } .................... .................... .................... signed long strtol(char *s,char *endptr, signed int base) .................... { .................... char *sc,*s1,*sd; .................... signed long x=0; .................... char sign; .................... char digits[]="0123456789abcdefghijklmnopqstuvwxyz"; .................... for(sc=s;isspace(*sc);++sc); .................... sign=*sc=='-'||*sc=='+'?*sc++:'+'; .................... if (base <0 || base ==1|| base >36) // invalid base .................... goto StrtolGO; .................... else if (base) .................... { .................... if(base==16 && *sc =='0'&&(sc[1]=='x' || sc[1]=='X')) .................... sc+=2; .................... if(base==8 && *sc =='0') .................... sc+=1; .................... if(base==2 && *sc =='0'&&sc[1]=='b') .................... sc+=2; .................... .................... } .................... else if(*sc!='0') // base is 0, find base .................... base=10; .................... else if (sc[1]=='x' || sc[1]=='X') .................... base =16,sc+=2; .................... else if(sc[1]=='b') .................... base=2,sc+=2; .................... else .................... base=8; .................... for (s1=sc;*sc=='0';++sc);// skip leading zeroes .................... .................... sd=memchr(digits,tolower(*sc),base); .................... for(;sd!=0;) .................... { .................... x=x*base+(int16)(sd-digits); .................... ++sc; .................... sd=memchr(digits,tolower(*sc),base); .................... } .................... if(s1==sc) .................... { .................... StrtolGO: .................... if (endptr) .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= s; .................... #ELSE .................... *((char *)endptr)=s; .................... #ENDIF .................... } .................... return 0; .................... } .................... if(sign=='-') .................... x =-x; .................... if (endptr) .................... { .................... #IF LONG_POINTERS .................... *((long *)endptr)= sc; .................... #ELSE .................... *((char *)endptr)=sc; .................... #ENDIF .................... } .................... return x; .................... } .................... .................... signed int8 system(char *string) .................... { .................... return 0; .................... } .................... .................... int8 mblen(char *s,size_t n) .................... { .................... return strlen(s); .................... } .................... .................... int8 mbtowc(wchar_t *pwc,char *s,size_t n) .................... { .................... *pwc=*s; .................... return 1; .................... } .................... .................... int8 wctomb(char *s,wchar_t wchar) .................... { .................... *s=wchar; .................... return 1; .................... } .................... .................... size_t mbstowcs(wchar_t *pwcs,char *s,size_t n) .................... { .................... strncpy(pwcs,s,n); .................... return strlen(pwcs); .................... } .................... .................... size_t wcstombs(char *s,wchar_t *pwcs,size_t n) .................... { .................... strncpy(s,pwcs,n); .................... return strlen(s); .................... } .................... .................... //--------------------------------------------------------------------------- .................... // The random number implementation .................... //--------------------------------------------------------------------------- .................... .................... unsigned int32 _Randseed; .................... .................... unsigned int16 rand(void) .................... { .................... _Randseed = _Randseed * 1103515245 + 12345; .................... return ((unsigned int16)(_Randseed >> 16) % RAND_MAX); .................... } .................... .................... void srand(unsigned int32 seed) .................... { .................... _Randseed = seed; .................... } .................... .................... //--------------------------------------------------------------------------- .................... // Searching and sorting utilities implementation .................... //--------------------------------------------------------------------------- .................... .................... #if !defined(__PCD__) .................... typedef signed int8 (*_Cmpfun)(char * p1,char * p2); .................... #else .................... typedef signed int16 (*_Cmpfun)(char * p1,char * p2); .................... #endif .................... .................... .................... .................... void qsort(char * qdata, unsigned int qitems, unsigned int qsize, _Cmpfun cmp) { .................... unsigned int m,j,i,l; .................... int1 done; .................... BYTE t[16]; .................... .................... m = qitems/2; .................... while( m > 0 ) { .................... for(j=0; j<(qitems-m); ++j) { .................... i = j; .................... do .................... { .................... done=TRUE; .................... l = i+m; .................... if( (*cmp)(qdata+i*qsize, qdata+l*qsize) > 0 ) { .................... memcpy(t, qdata+i*qsize, qsize); .................... memcpy(qdata+i*qsize, qdata+l*qsize, qsize); .................... memcpy(qdata+l*qsize, t, qsize); .................... if(m <= i) .................... i -= m; .................... done = FALSE; .................... } .................... } while(!done); .................... } .................... m = m/2; .................... } .................... } .................... .................... .................... char *bsearch(char *key, char *base, size_t num, size_t width,_Cmpfun cmp) .................... { .................... char *p, *q; .................... size_t n; .................... size_t pivot; .................... signed int val; .................... .................... p = base; .................... n = num; .................... .................... while (n > 0) .................... { .................... pivot = n >> 1; .................... q = p + width * pivot; .................... .................... val = (*cmp)(key, q); .................... .................... if (val < 0) .................... n = pivot; .................... else if (val == 0) .................... return ((char *)q); .................... else { .................... p = q + width; .................... n -= pivot + 1; .................... } .................... } .................... .................... return NULL; // There's no match .................... } .................... .................... .................... #endif .................... .................... #ZERO_RAM .................... #use standard_io(ALL) .................... #int_AD .................... #define LED1 PIN_A5 //ez nalam nem mukodik .................... #define LED2 PIN_A4 .................... #define LED3 PIN_C5 .................... #define LED4 PIN_C4 .................... #define BUTTON1 PIN_C6 .................... #define BUTTON2 PIN_C1 .................... #define BUTTON3 PIN_B4 .................... #define SPEAKER PIN_C2 .................... #define SPI1 PIN_B5 .................... #define SPI2 PIN_B7 .................... #define SPI_OUT PIN_C7 .................... #define SPI_CLK PIN_B6 .................... int8 run; .................... .................... //void AD_isr(void) .................... //{ .................... .................... //} .................... .................... void sound(int8 pitty, int16 sound) //pitty: a hossza, sound: a hangmagassága .................... { .................... //div_t delay; .................... int8 c; .................... //delay=div(1000000,sound); .................... for (c=pitty;c>0;--c) * 0022: MOVFF 0D,10 0026: MOVF 10,F 0028: BZ 006A .................... { .................... output_high(SPEAKER); 002A: BCF F94.2 002C: BSF F8B.2 .................... delay_us(sound); 002E: MOVFF 0F,11 0032: INCF 11,F 0034: DECF 11,F 0036: BTFSC FD8.2 0038: BRA 0042 003A: MOVLW FF 003C: MOVWF 12 003E: RCALL 0004 0040: BRA 0034 0042: MOVFF 0E,12 0046: RCALL 0004 .................... output_low(SPEAKER); 0048: BCF F94.2 004A: BCF F8B.2 .................... delay_us(sound); 004C: MOVFF 0F,11 0050: INCF 11,F 0052: DECF 11,F 0054: BTFSC FD8.2 0056: BRA 0060 0058: MOVLW FF 005A: MOVWF 12 005C: RCALL 0004 005E: BRA 0052 0060: MOVFF 0E,12 0064: RCALL 0004 .................... } 0066: DECF 10,F 0068: BRA 0026 .................... } 006A: RETLW 00 .................... void spi(spi_data) .................... { .................... int8 a=0; * 0092: CLRF 0E .................... int1 bit; .................... int8 data; .................... data=0xDB; //command byte 0094: MOVLW DB 0096: MOVWF 10 .................... output_low(SPI_CLK); 0098: BCF F93.6 009A: BCF F8A.6 .................... output_low(SPI1); //SPI1 indit 009C: BCF F93.5 009E: BCF F8A.5 .................... while (a<2) //ketszer fut le .................... { 00A0: MOVF 0E,W 00A2: SUBLW 01 00A4: BTFSS FD8.0 00A6: BRA 0192 .................... bit=bit_test(data,7); 00A8: BCF 0F.0 00AA: BTFSC 10.7 00AC: BSF 0F.0 .................... if (bit) output_high(SPI_OUT); 00AE: BTFSS 0F.0 00B0: BRA 00B8 00B2: BCF F94.7 00B4: BSF F8B.7 .................... else output_low(SPI_OUT); 00B6: BRA 00BC 00B8: BCF F94.7 00BA: BCF F8B.7 .................... output_high(SPI_CLK); 00BC: BCF F93.6 00BE: BSF F8A.6 .................... bit=bit_test(data,6); 00C0: BCF 0F.0 00C2: BTFSC 10.6 00C4: BSF 0F.0 .................... output_low(SPI_CLK); 00C6: BCF F93.6 00C8: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 00CA: BTFSS 0F.0 00CC: BRA 00D4 00CE: BCF F94.7 00D0: BSF F8B.7 .................... else output_low(SPI_OUT); 00D2: BRA 00D8 00D4: BCF F94.7 00D6: BCF F8B.7 .................... output_high(SPI_CLK); 00D8: BCF F93.6 00DA: BSF F8A.6 .................... bit=bit_test(data,5); 00DC: BCF 0F.0 00DE: BTFSC 10.5 00E0: BSF 0F.0 .................... output_low(SPI_CLK); 00E2: BCF F93.6 00E4: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 00E6: BTFSS 0F.0 00E8: BRA 00F0 00EA: BCF F94.7 00EC: BSF F8B.7 .................... else output_low(SPI_OUT); 00EE: BRA 00F4 00F0: BCF F94.7 00F2: BCF F8B.7 .................... output_high(SPI_CLK); 00F4: BCF F93.6 00F6: BSF F8A.6 .................... bit=bit_test(data,4); 00F8: BCF 0F.0 00FA: BTFSC 10.4 00FC: BSF 0F.0 .................... output_low(SPI_CLK); 00FE: BCF F93.6 0100: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 0102: BTFSS 0F.0 0104: BRA 010C 0106: BCF F94.7 0108: BSF F8B.7 .................... else output_low(SPI_OUT); 010A: BRA 0110 010C: BCF F94.7 010E: BCF F8B.7 .................... output_high(SPI_CLK); 0110: BCF F93.6 0112: BSF F8A.6 .................... bit=bit_test(data,3); 0114: BCF 0F.0 0116: BTFSC 10.3 0118: BSF 0F.0 .................... output_low(SPI_CLK); 011A: BCF F93.6 011C: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 011E: BTFSS 0F.0 0120: BRA 0128 0122: BCF F94.7 0124: BSF F8B.7 .................... else output_low(SPI_OUT); 0126: BRA 012C 0128: BCF F94.7 012A: BCF F8B.7 .................... output_high(SPI_CLK); 012C: BCF F93.6 012E: BSF F8A.6 .................... bit=bit_test(data,2); 0130: BCF 0F.0 0132: BTFSC 10.2 0134: BSF 0F.0 .................... output_low(SPI_CLK); 0136: BCF F93.6 0138: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 013A: BTFSS 0F.0 013C: BRA 0144 013E: BCF F94.7 0140: BSF F8B.7 .................... else output_low(SPI_OUT); 0142: BRA 0148 0144: BCF F94.7 0146: BCF F8B.7 .................... output_high(SPI_CLK); 0148: BCF F93.6 014A: BSF F8A.6 .................... bit=bit_test(data,1); 014C: BCF 0F.0 014E: BTFSC 10.1 0150: BSF 0F.0 .................... output_low(SPI_CLK); 0152: BCF F93.6 0154: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 0156: BTFSS 0F.0 0158: BRA 0160 015A: BCF F94.7 015C: BSF F8B.7 .................... else output_low(SPI_OUT); 015E: BRA 0164 0160: BCF F94.7 0162: BCF F8B.7 .................... output_high(SPI_CLK); 0164: BCF F93.6 0166: BSF F8A.6 .................... bit=bit_test(data,0); 0168: BCF 0F.0 016A: BTFSC 10.0 016C: BSF 0F.0 .................... output_low(SPI_CLK); 016E: BCF F93.6 0170: BCF F8A.6 .................... if (bit) output_high(SPI_OUT); 0172: BTFSS 0F.0 0174: BRA 017C 0176: BCF F94.7 0178: BSF F8B.7 .................... else output_low(SPI_OUT); 017A: BRA 0180 017C: BCF F94.7 017E: BCF F8B.7 .................... output_high(SPI_CLK); 0180: BCF F93.6 0182: BSF F8A.6 .................... a=a+1; 0184: MOVLW 01 0186: ADDWF 0E,F .................... output_low(SPI_CLK); 0188: BCF F93.6 018A: BCF F8A.6 .................... data=spi_data; 018C: MOVFF 0D,10 .................... } 0190: BRA 00A0 .................... output_high(SPI1); //SPI1 leallit 0192: BCF F93.5 0194: BSF F8A.5 .................... output_low(SPI_OUT); 0196: BCF F94.7 0198: BCF F8B.7 .................... } 019A: GOTO 028E (RETURN) .................... .................... void main() .................... { 019E: CLRF FF8 01A0: BCF FD0.7 01A2: MOVLW FE 01A4: MOVWF 00 01A6: MOVLW 03 01A8: MOVWF 01 01AA: MOVLW 02 01AC: MOVWF FE9 01AE: MOVLW 00 01B0: MOVWF FEA 01B2: CLRF FEE 01B4: CLRWDT 01B6: DECFSZ 00,F 01B8: BRA 01B2 01BA: DECFSZ 01,F 01BC: BRA 01B2 01BE: CLRF FEA 01C0: CLRF FE9 01C2: MOVF FC1,W 01C4: ANDLW E0 01C6: MOVWF FC1 01C8: CLRF FB4 01CA: CLRF 05 01CC: CLRF 06 .................... static int1 button; .................... .................... //SET_TRIS_A(0x0F); // CF: xxoo ixii (A5 out,A4 out,A3 in,A1 in,A0 in) .................... //SET_TRIS_B(0x1F); // 1F: oooi iiii .................... //SET_TRIS_C(0x4B); // CB: oioo ioii .................... .................... setup_adc_ports(NO_ANALOGS); //AN3|VSS_VDD); 01CE: MOVF FC1,W 01D0: ANDLW E0 01D2: IORLW 0F 01D4: MOVWF FC1 .................... //setup_adc(ADC_OFF|ADC_TAD_MUL_12); .................... setup_spi(FALSE); //SPI_MASTER|SPI_L_TO_H|SPI_CLK_DIV_4); 01D6: CLRF FC6 .................... setup_wdt(WDT_OFF); 01D8: BCF FD1.0 .................... // setup_timer_0(RTCC_INTERNAL); .................... setup_timer_0(RTCC_OFF); 01DA: CLRF FD5 .................... setup_timer_1(T1_DISABLED); 01DC: CLRF FCD .................... setup_timer_2(T2_DISABLED,0,1); 01DE: MOVLW 00 01E0: MOVWF FCA 01E2: MOVLW 00 01E4: MOVWF FCB .................... setup_timer_3(T3_DISABLED); //|T3_DIV_BY_1); 01E6: CLRF FB1 .................... //setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard .................... disable_interrupts(INT_AD); 01E8: BCF F9D.6 .................... disable_interrupts(GLOBAL); 01EA: BCF FF2.6 01EC: BCF FF2.7 01EE: BTFSC FF2.7 01F0: BRA 01EC .................... setup_oscillator(OSC_8MHZ|OSC_INTRC); 01F2: MOVLW 72 01F4: MOVWF FD3 01F6: MOVF FD3,W .................... .................... .................... output_high(SPI1); 01F8: BCF F93.5 01FA: BSF F8A.5 .................... output_high(SPI2); //SPI alaphelyzetbe 01FC: BCF F93.7 01FE: BSF F8A.7 .................... output_low(SPI_OUT); 0200: BCF F94.7 0202: BCF F8B.7 .................... output_low(SPI_CLK); 0204: BCF F93.6 0206: BCF F8A.6 .................... .................... // TODO: USER CODE!! .................... input(BUTTON1); 0208: BSF F94.6 .................... input(BUTTON2); 020A: BSF F94.1 .................... input(BUTTON3); 020C: BSF F93.4 .................... output_high(LED1); //LEDek bekapcsolva 020E: BCF F92.5 0210: BSF F89.5 .................... output_high(LED2); 0212: BCF F92.4 0214: BSF F89.4 .................... output_high(LED3); 0216: BCF F94.5 0218: BSF F8B.5 .................... output_high(LED4); 021A: BCF F94.4 021C: BSF F8B.4 .................... .................... sound(20,800); 021E: MOVLW 14 0220: MOVWF 0D 0222: MOVLW 03 0224: MOVWF 0F 0226: MOVLW 20 0228: MOVWF 0E 022A: RCALL 0022 .................... delay_ms(200); 022C: MOVLW C8 022E: MOVWF 0E 0230: RCALL 006C .................... sound(20,800); 0232: MOVLW 14 0234: MOVWF 0D 0236: MOVLW 03 0238: MOVWF 0F 023A: MOVLW 20 023C: MOVWF 0E 023E: RCALL 0022 .................... delay_ms(200); 0240: MOVLW C8 0242: MOVWF 0E 0244: RCALL 006C .................... sound(10,1800); 0246: MOVLW 0A 0248: MOVWF 0D 024A: MOVLW 07 024C: MOVWF 0F 024E: MOVLW 08 0250: MOVWF 0E 0252: RCALL 0022 .................... delay_ms(200); 0254: MOVLW C8 0256: MOVWF 0E 0258: RCALL 006C .................... sound(10,1800); 025A: MOVLW 0A 025C: MOVWF 0D 025E: MOVLW 07 0260: MOVWF 0F 0262: MOVLW 08 0264: MOVWF 0E 0266: RCALL 0022 .................... delay_ms(1200); 0268: MOVLW 05 026A: MOVWF 0D 026C: MOVLW F0 026E: MOVWF 0E 0270: RCALL 006C 0272: DECFSZ 0D,F 0274: BRA 026C .................... .................... output_low(LED1); //LEDek kikapcsolva 0276: BCF F92.5 0278: BCF F89.5 .................... output_low(LED2); 027A: BCF F92.4 027C: BCF F89.4 .................... output_low(LED3); 027E: BCF F94.5 0280: BCF F8B.5 .................... output_low(LED4); 0282: BCF F94.4 0284: BCF F8B.4 .................... .................... run=0; 0286: CLRF 0B .................... while(TRUE) .................... { .................... spi(run); 0288: MOVFF 0B,0D 028C: BRA 0092 .................... output_low(LED4); 028E: BCF F94.4 0290: BCF F8B.4 .................... .................... button=input(BUTTON2); 0292: BSF F94.1 0294: BCF 0C.0 0296: BTFSC F82.1 0298: BSF 0C.0 .................... if (button==0) output_low(LED2); 029A: BTFSC 0C.0 029C: BRA 02A2 029E: BCF F92.4 02A0: BCF F89.4 .................... if (button==1) output_high(LED2); 02A2: BTFSS 0C.0 02A4: BRA 02AA 02A6: BCF F92.4 02A8: BSF F89.4 .................... button=input(BUTTON1); 02AA: BSF F94.6 02AC: BCF 0C.0 02AE: BTFSC F82.6 02B0: BSF 0C.0 .................... if (button==1) output_low(LED3); 02B2: BTFSS 0C.0 02B4: BRA 02BA 02B6: BCF F94.5 02B8: BCF F8B.5 .................... if (button==0) output_high(LED3); 02BA: BTFSC 0C.0 02BC: BRA 02C2 02BE: BCF F94.5 02C0: BSF F8B.5 .................... run++; 02C2: INCF 0B,F .................... delay_ms(100); 02C4: MOVLW 64 02C6: MOVWF 0E 02C8: RCALL 006C .................... output_high(LED4); 02CA: BCF F94.4 02CC: BSF F8B.4 .................... delay_ms(100); 02CE: MOVLW 64 02D0: MOVWF 0E 02D2: RCALL 006C .................... } 02D4: BRA 0288 .................... .................... .................... .................... .................... .................... } 02D6: SLEEP Configuration Fuses: Word 1: CB38 FCMEN IESO USBDIV2 PCLKEN PLLEN CPUDIV4 ECMED Word 2: 0E10 NOBROWNOUT WDT128 NOWDT BORV22 PUT Word 3: 8000 MCLR NOHFOFST Word 4: 0089 STVREN NODEBUG NOXINST NOLVP BBSIZ2K Word 5: C003 NOCPD NOPROTECT NOCPB Word 6: E003 NOWRT NOWRTD NOWRTC NOWRTB WRT0 WRT1 Word 7: 4003 NOEBTR NOEBTRB