📄 psp_wrt_transmitter.lst
字号:
....................
.................... #define SQRT2 1.41421356
....................
.................... //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 //////////////////////////////
....................
.................... float CEIL_FLOOR(float x, int n)
.................... {
.................... float y, res;
.................... long l;
.................... int1 s;
....................
.................... s = 0;
.................... y = x;
....................
.................... if (x < 0)
.................... {
.................... s = 1;
.................... y = -y;
.................... }
....................
.................... if (y <= 32768.0)
.................... res = (float)(long)y;
....................
.................... else if (y < 10000000.0)
.................... {
.................... l = (long)(y/32768.0);
.................... y = 32768.0*(y/32768.0 - (float)l);
.................... res = 32768.0*(float)l;
.................... res += (float)(long)y;
.................... }
....................
.................... else
.................... res = y;
....................
.................... y = y - (float)(long)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);
.................... }
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float floor(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : rounds down the number x.
.................... // Date : N/A
.................... //
.................... float floor(float x)
.................... {
.................... return CEIL_FLOOR(x, 0);
.................... }
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float ceil(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : rounds up the number x.
.................... // Date : N/A
.................... //
.................... float ceil(float x)
.................... {
.................... return CEIL_FLOOR(x, 1);
.................... }
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // 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(float x,float y)
.................... {
.................... float 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
.................... }
.................... }
....................
.................... //////////////////// Exponential and logarithmic functions ////////////////////
....................
.................... #define LN2 0.6931471806
....................
.................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,
.................... 0.0554965651, 0.240227138, 0.693147172};
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float exp(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the value (e^x)
.................... // Date : N/A
.................... //
.................... float exp(float x)
.................... {
.................... float y, res, r;
.................... signed int n;
.................... int1 s;
.................... #ifdef _ERRNO
.................... if(x > 88.722838)
.................... {
.................... errno=ERANGE;
.................... return(0);
.................... }
.................... #endif
.................... n = (signed long)(x/LN2);
.................... s = 0;
.................... y = x;
....................
.................... if (x < 0)
.................... {
.................... s = 1;
.................... n = -n;
.................... y = -y;
.................... }
....................
.................... res = 0.0;
.................... *(&res) = n + 0x7F;
....................
.................... y = y/LN2 - (float)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);
.................... }
....................
.................... /************************************************************/
....................
.................... float const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
.................... float 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
.................... //
.................... float log(float x)
.................... {
.................... float y, res, r, y2;
.................... signed n;
.................... #ifdef _ERRNO
.................... if(x <0)
.................... {
.................... errno=EDOM;
.................... }
.................... if(x ==0)
.................... {
.................... errno=ERANGE;
.................... return(0);
.................... }
.................... #endif
.................... y = x;
....................
.................... if (y != 1.0)
.................... {
.................... *(&y) = 0x7E;
....................
.................... 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;
....................
.................... n = *(&x) - 0x7E;
....................
.................... if (n<0)
.................... r = -(float)-n;
.................... else
.................... r = (float)n;
....................
.................... res += r*LN2;
.................... }
....................
.................... else
.................... res = 0.0;
....................
.................... return(res);
.................... }
....................
.................... #define LN10 2.30258509
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float log10(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the the log base 10 of x
.................... // Date : N/A
.................... //
.................... float log10(float x)
.................... {
.................... float r;
....................
.................... r = log(x);
.................... r = r/LN10;
.................... return(r);
.................... }
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // 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
.................... //
....................
.................... float modf(float value,float *iptr)
.................... {
.................... *iptr=(value < 0.0)?ceil(value): floor(value);
.................... return(value - *iptr);
.................... }
....................
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float pwr(float x,float y)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the value (x^y)
.................... // Date : N/A
.................... //
.................... float pwr(float x,float y)
.................... {
.................... if(x>=0)
.................... return( exp(y*log(x)) );
.................... else
.................... return( -exp(y*log(-x)) );
.................... }
....................
....................
.................... //////////////////// Power functions ////////////////////
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float pow(float x,float y)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the value (x^y)
.................... // Date : N/A
.................... //
.................... float pow(float x,float y)
.................... {
.................... if(x>=0)
.................... return( exp(y*log(x)) );
.................... else
.................... return( -exp(y*log(-x)) );
.................... }
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float sqrt(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the square root of x
.................... // Date : N/A
.................... //
.................... float sqrt(float x)
.................... {
.................... float y, res;
.................... BYTE *p;
....................
.................... #ifdef _ERRNO
.................... if(x < 0)
.................... {
.................... errno=EDOM;
.................... }
.................... #endif
....................
.................... if( x<=0.0)
.................... return(0.0);
....................
.................... y=x;
.................... p=&y;
.................... (*p)=(BYTE)((((int16)(*p)) + 127) >> 1);
....................
.................... do {
.................... res=y;
.................... y+=(x/y);
.................... (*p)--;
.................... } while(res != y);
....................
.................... return(res);
.................... }
....................
....................
....................
.................... ////////////////////////////// Trig Functions //////////////////////////////
.................... #undef PI_DIV_BY_TWO
.................... #define PI_DIV_BY_TWO 1.570796326794896
.................... #undef TWOBYPI
.................... #define TWOBYPI 0.6366197724
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float cos(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the cosine value of the angle x, which is in radian
.................... // Date : 9/20/2001
.................... //
.................... float cos(float x)
.................... {
.................... float y, t, t2 = 1.0;
*
0BFE: MOVLW 7F
0BFF: BSF 03.5
0C00: MOVWF 24
0C01: CLRF 25
0C02: CLRF 26
0C03: CLRF 27
.................... int quad, i;
.................... float frac;
.................... float p[4] = {
.................... -0.499999993585,
.................... 0.041666636258,
.................... -0.0013888361399,
.................... 0.00002476016134
.................... };
0C04: MOVLW 7E
0C05: MOVWF 2C
0C06: MOVLW 80
0C07: MOVWF 2D
0C08: CLRF 2E
0C09: CLRF 2F
0C0A: MOVLW 7A
0C0B: MOVWF 30
0C0C: MOVLW 2A
0C0D: MOVWF 31
0C0E: MOVLW AA
0C0F: MOVWF 32
0C10: MOVLW A3
0C11: MOVWF 33
0C12: MOVLW 75
0C13: MOVWF 34
0C14: MOVLW B6
0C15: MOVWF 35
0C16: MOVLW 09
0C17: MOVWF 36
0C18: MOVLW 9C
0C19: MOVWF 37
0C1A: MOVLW 6F
0C1B: MOVWF 38
0C1C: MOVLW 4F
0C1D: MOVWF 39
0C1E: MOVLW B4
0C1F: MOVWF 3A
0C20: MOVLW 0B
0C21: MOVWF 3B
....................
.................... if (x < 0) x = -x; // absolute value of input
0C22: MOVF 70,W
0C23: MOVWF 41
0C24: BCF 03.5
0C25: MOVF 6F,W
0C26: BSF 03.5
0C27: MOVWF 40
0C28: BCF 03.5
0C29: MOVF 6E,W
0C2A: BSF 03.5
0C2B: MOVWF 3F
0C2C: BCF 03.5
0C2D: MOVF 6D,W
0C2E: BSF 03.5
0C2F: MOVWF 3E
0C30: CLRF 45
0C31: CLRF 44
0C32: CLRF 43
0C33: CLRF 42
0C34: BCF 0A.3
0C35: BCF 03.5
0C36: CALL 599
0C37: BSF 0A.3
0C38: BTFSS 03.0
0C39: GOTO 43C
0C3A: MOVLW 80
0C3B: XORWF 6E,F
....................
.................... quad = (int)(x / PI_DIV_BY_TWO); // quadrant
0C3C: MOVF 70,W
0C3D: BSF 03.5
0C3E: MOVWF 41
0C3F: BCF 03.5
0C40: MOVF 6F,W
0C41: BSF 03.5
0C42: MOVWF 40
0C43: BCF 03.5
0C44: MOVF 6E,W
0C45: BSF 03.5
0C46: MOVWF 3F
0C47: BCF 03.5
0C48: MOVF 6D,W
0C49: BSF 03.5
0C4A: MOVWF 3E
0C4B: MOVLW DB
0C4C: MOVWF 45
0C4D: MOVLW 0F
0C4E: MOVWF 44
0C4F: MOVLW 49
0C50: MOVWF 43
0C51: MOVLW 7F
0C52: MOVWF 42
0C53: BCF 0A.3
0C54: BCF 03.5
0C55: CALL 4CC
0C56: BSF 0A.3
0C57: MOVF 7A,W
0C58: BSF 03.5
0C59: MOVWF 41
0C5A: MOVF 79,W
0C5B: MOVWF 40
0C5C: MOVF 78,W
0C5D: MOVWF 3F
0C5E: MOVF 77,W
0C5F: MOVWF 3E
0C60: BCF 0A.3
0C61: BCF 03.5
0C62: CALL 363
0C63: BSF 0A.3
0C64: MOVF 78,W
0C65: MOVWF 75
.................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input
0C66: MOVF 70,W
0C67: BSF 03.5
0C68: MOVWF 41
0C69: BCF 03.5
0C6A: MOVF 6F,W
0C6B: BSF 03.5
0C6C: MOVWF 40
0C6D: BCF 03.5
0C6E: MOVF 6E,W
0C6F: BSF 03.5
0C70: MOVWF 3F
0C71: BCF 03.5
0C72: MOVF 6D,W
0C73: BSF 03.5
0C74: MOVWF 3E
0C75: MOVLW DB
0C76: MOVWF 45
0C77: MOVLW 0F
0C78: MOVWF 44
0C79: MOVLW 49
0C7A: MOVWF 43
0C7B: MOVLW 7F
0C7C: MOVWF 42
0C7D: BCF 0A.3
0C7E: BCF 03.5
0C7F: CALL 4CC
0C80: BSF 0A.3
0C81: MOVF 77,W
0C82: BSF 03.5
0C83: MOVWF 3C
0C84: MOVF 78,W
0C85: MOVWF 3D
0C86: MOVF 79,W
0C87: MOVWF 3E
0C88: MOVF 7A,W
0C89: MOVWF 3F
0C8A: CLRF 43
0C8B: MOVF 75,W
0C8C: MOVWF 42
0C8D: BCF 0A.3
0C8E: BCF 03.5
0C8F: CALL 2CB
0C90: BSF 0A.3
0C91: BSF 03.1
0C92: BSF 03.5
0C93: MOVF 3F,W
0C94: MOVWF 47
0C95: MOVF 3E,W
0C96: MOVWF 46
0C97: MOVF 3D,W
0C98: MOVWF 45
0C99: MOVF 3C,W
0C9A: MOVWF 44
0C9B: MOVF 7A,W
0C9C: MOVWF 4B
0C9D: MOVF 79,W
0C9E: MOVWF 4A
0C9F: MOVF 78,W
0CA0: MOVWF 49
0CA1: MOVF 77,W
0CA2: MOVWF 48
0CA3: BCF 0A.3
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -