export from camera.lst

Embedded camera control program.

060E:  MOVWF  62
060F:  MOVF   5E,W
0610:  MOVWF  63
0611:  MOVF   5A,W
0612:  SUBWF  63,F
0613:  BTFSC  03.2
0614:  GOTO   61B
0615:  BTFSS  62.7
0616:  GOTO   640
0617:  MOVF   03,W
0618:  XORLW  01
0619:  MOVWF  03
061A:  GOTO   640
061B:  MOVF   5F,W
061C:  MOVWF  63
061D:  MOVF   5B,W
061E:  SUBWF  63,F
061F:  BTFSC  03.2
0620:  GOTO   627
0621:  BTFSS  62.7
0622:  GOTO   640
0623:  MOVF   03,W
0624:  XORLW  01
0625:  MOVWF  03
0626:  GOTO   640
0627:  MOVF   60,W
0628:  MOVWF  63
0629:  MOVF   5C,W
062A:  SUBWF  63,F
062B:  BTFSC  03.2
062C:  GOTO   633
062D:  BTFSS  62.7
062E:  GOTO   640
062F:  MOVF   03,W
0630:  XORLW  01
0631:  MOVWF  03
0632:  GOTO   640
0633:  MOVF   61,W
0634:  MOVWF  63
0635:  MOVF   5D,W
0636:  SUBWF  63,F
0637:  BTFSC  03.2
0638:  GOTO   63F
0639:  BTFSS  62.7
063A:  GOTO   640
063B:  MOVF   03,W
063C:  XORLW  01
063D:  MOVWF  03
063E:  GOTO   640
063F:  BCF    03.0
0640:  RETLW  00
0641:  MOVLW  8E
0642:  MOVWF  77
0643:  MOVF   46,W
0644:  SUBWF  77,F
0645:  MOVF   47,W
0646:  MOVWF  79
0647:  MOVF   48,W
0648:  MOVWF  78
0649:  BSF    79.7
064A:  MOVF   77,F
064B:  BTFSC  03.2
064C:  GOTO   658
064D:  BCF    03.0
064E:  MOVF   79,F
064F:  BTFSS  03.2
0650:  GOTO   654
0651:  MOVF   78,F
0652:  BTFSC  03.2
0653:  GOTO   658
0654:  RRF    79,F
0655:  RRF    78,F
0656:  DECFSZ 77,F
0657:  GOTO   64D
0658:  BTFSS  47.7
0659:  GOTO   65F
065A:  COMF   78,F
065B:  COMF   79,F
065C:  INCF   78,F
065D:  BTFSC  03.2
065E:  INCF   79,F
065F:  NOP
0660:  BSF    0A.3
0661:  BCF    0A.4
0662:  GOTO   30B (RETURN)
.................... #include <16f877.h> 
....................  //////// Standard Header file for the PIC16F877 device ////////////////  
.................... //#device PIC16F877  
.................... #list  
....................  
.................... #include <math.h> 
....................  ////////////////////////////////////////////////////////////////////////////  
.................... ////        (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.                                ////  
.................... ////////////////////////////////////////////////////////////////////////////  
.................... ////                                                                    ////  
.................... //// History:                                                           ////  
.................... ////  * 9/20/2001 :  Improvments are made to sin/cos code.              ////  
.................... ////                 The code now is small, much faster,                ////  
.................... ////                 and more accurate.                                 ////  
.................... ////                                                                    ////  
.................... ////////////////////////////////////////////////////////////////////////////  
....................   
.................... #ifndef MATH_H  
.................... #define MATH_H  
....................   
....................   
.................... #undef  PI  
.................... #define PI     3.141592654  
....................   
....................   
.................... #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;  
.................... 	int quad, i;  
.................... 	float frac;  
.................... 	float p[4] = {  
.................... 		-0.499999993585,  
.................... 		 0.041666636258,  
.................... 		-0.0013888361399,  
.................... 		 0.00002476016134  
.................... 	};  
....................   
.................... 	if (x < 0) x = -x;                  // absolute value of input  
....................   
.................... 	quad = (int)(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;