Rev Author Line No. Line
1045 jacho 1 CCS PCM C Compiler, Version 4.106, 47914 28-4-13 13:38
2  
3 Filename: C:\Users\Honza\Documents\pic\poloha_slunce\main.lst
4  
5 ROM used: 4642 words (57%)
6 Largest free fragment is 2048
7 RAM used: 10 (3%) at main() level
8 154 (42%) worst case
9 Stack: 4 locations
10  
11 *
12 0000: MOVLW 07
13 0001: MOVWF 0A
14 0002: GOTO 733
15 0003: NOP
16 .................... #include "C:\Users\Honza\Documents\pic\poloha_slunce\main.h"
17 .................... #include <16F887.h>
18 .................... //////// Standard Header file for the PIC16F887 device ////////////////
19 *
20 029C: MOVF 77,W
21 029D: MOVWF 73
22 029E: MOVF 78,W
23 029F: MOVWF 74
24 02A0: MOVF 79,W
25 02A1: MOVWF 75
26 02A2: MOVF 7A,W
27 02A3: MOVWF 76
28 02A4: BSF 03.5
29 02A5: MOVWF 4D
30 02A6: MOVF 79,W
31 02A7: MOVWF 4C
32 02A8: MOVF 78,W
33 02A9: MOVWF 4B
34 02AA: MOVF 77,W
35 02AB: MOVWF 4A
36 02AC: MOVLW C3
37 02AD: MOVWF 51
38 02AE: MOVLW F5
39 02AF: MOVWF 50
40 02B0: MOVLW 48
41 02B1: MOVWF 4F
42 02B2: MOVLW 80
43 02B3: MOVWF 4E
44 02B4: BCF 03.5
45 02B5: CALL 20E
46 *
47 0688: MOVF 77,W
48 0689: MOVWF 5E
49 068A: MOVF 78,W
50 068B: MOVWF 5F
51 068C: MOVF 79,W
52 068D: MOVWF 60
53 068E: MOVF 7A,W
54 068F: MOVWF 61
55 0690: BSF 03.5
56 0691: MOVWF 4D
57 0692: BCF 03.5
58 0693: MOVF 60,W
59 0694: BSF 03.5
60 0695: MOVWF 4C
61 0696: BCF 03.5
62 0697: MOVF 5F,W
63 0698: BSF 03.5
64 0699: MOVWF 4B
65 069A: BCF 03.5
66 069B: MOVF 5E,W
67 069C: BSF 03.5
68 069D: MOVWF 4A
69 069E: CLRF 51
70 069F: CLRF 50
71 06A0: MOVLW 34
72 06A1: MOVWF 4F
73 06A2: MOVLW 86
74 06A3: MOVWF 4E
75 06A4: BCF 03.5
76 06A5: CALL 20E
77 06A6: MOVF 7A,W
78 06A7: BSF 03.5
79 06A8: MOVWF 49
80 06A9: MOVF 79,W
81 06AA: MOVWF 48
82 06AB: MOVF 78,W
83 06AC: MOVWF 47
84 06AD: MOVF 77,W
85 06AE: MOVWF 46
86 06AF: BCF 03.5
87 06B0: CALL 44E
88 .................... #device PIC16F887
89 .................... #list
90 ....................
91 .................... #device adc=8
92 ....................
93 .................... #FUSES NOWDT //No Watch Dog Timer
94 .................... #FUSES INTRC //Internal RC Osc
95 .................... #FUSES NOPUT //No Power Up Timer
96 .................... #FUSES MCLR //Master Clear pin enabled
97 .................... #FUSES NOPROTECT //Code not protected from reading
98 .................... #FUSES NOCPD //No EE protection
99 .................... #FUSES NOBROWNOUT //No brownout reset
100 .................... #FUSES IESO //Internal External Switch Over mode enabled
101 .................... #FUSES FCMEN //Fail-safe clock monitor enabled
102 .................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
103 .................... #FUSES NODEBUG //No Debug mode for ICD
104 .................... #FUSES NOWRT //Program memory not write protected
105 .................... #FUSES BORV40 //Brownout reset at 4.0V
106 ....................
107 .................... #use delay(clock=8000000)
108 *
109 071D: MOVLW 25
110 071E: MOVWF 04
111 071F: BCF 03.7
112 0720: MOVF 00,W
113 0721: BTFSC 03.2
114 0722: GOTO 730
115 0723: MOVLW 02
116 0724: MOVWF 78
117 0725: CLRF 77
118 0726: DECFSZ 77,F
119 0727: GOTO 726
120 0728: DECFSZ 78,F
121 0729: GOTO 725
122 072A: MOVLW 97
123 072B: MOVWF 77
124 072C: DECFSZ 77,F
125 072D: GOTO 72C
126 072E: DECFSZ 00,F
127 072F: GOTO 723
128 0730: BCF 0A.3
129 0731: BCF 0A.4
130 0732: GOTO 7E2 (RETURN)
131 ....................
132 ....................
133 ....................
134 .................... #include "math.h"
135 .................... ////////////////////////////////////////////////////////////////////////////
136 .................... //// (C) Copyright 1996,2008 Custom Computer Services ////
137 .................... //// This source code may only be used by licensed users of the CCS C ////
138 .................... //// compiler. This source code may only be distributed to other ////
139 .................... //// licensed users of the CCS C compiler. No other use, reproduction ////
140 .................... //// or distribution is permitted without written permission. ////
141 .................... //// Derivative programs created using this software in object code ////
142 .................... //// form are not restricted in any way. ////
143 .................... ////////////////////////////////////////////////////////////////////////////
144 .................... //// ////
145 .................... //// History: ////
146 .................... //// * 9/20/2001 : Improvments are made to sin/cos code. ////
147 .................... //// The code now is small, much faster, ////
148 .................... //// and more accurate. ////
149 .................... //// * 2/21/2007 : Compiler handles & operator differently and does
150 .................... //// not return generic (int8 *) so type cast is done ////
151 .................... //// ////
152 .................... ////////////////////////////////////////////////////////////////////////////
153 ....................
154 .................... #ifndef MATH_H
155 .................... #define MATH_H
156 ....................
157 .................... #ifdef PI
158 .................... #undef PI
159 .................... #endif
160 .................... #define PI 3.1415926535897932
161 ....................
162 ....................
163 .................... #define SQRT2 1.4142135623730950
164 ....................
165 .................... //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279};
166 .................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718};
167 ....................
168 .................... ///////////////////////////// Round Functions //////////////////////////////
169 ....................
170 .................... float32 CEIL_FLOOR(float32 x, unsigned int8 n)
171 .................... {
172 .................... float32 y, res;
173 .................... unsigned int16 l;
174 .................... int1 s;
175 ....................
176 .................... s = 0;
177 .................... y = x;
178 ....................
179 .................... if (x < 0)
180 .................... {
181 .................... s = 1;
182 .................... y = -y;
183 .................... }
184 ....................
185 .................... if (y <= 32768.0)
186 .................... res = (float32)(unsigned int16)y;
187 ....................
188 .................... else if (y < 10000000.0)
189 .................... {
190 .................... l = (unsigned int16)(y/32768.0);
191 .................... y = 32768.0*(y/32768.0 - (float32)l);
192 .................... res = 32768.0*(float32)l;
193 .................... res += (float32)(unsigned int16)y;
194 .................... }
195 ....................
196 .................... else
197 .................... res = y;
198 ....................
199 .................... y = y - (float32)(unsigned int16)y;
200 ....................
201 .................... if (s)
202 .................... res = -res;
203 ....................
204 .................... if (y != 0)
205 .................... {
206 .................... if (s == 1 && n == 0)
207 .................... res -= 1.0;
208 ....................
209 .................... if (s == 0 && n == 1)
210 .................... res += 1.0;
211 .................... }
212 .................... if (x == 0)
213 .................... res = 0;
214 ....................
215 .................... return (res);
216 .................... }
217 ....................
218 .................... // Overloaded Functions to take care for new Data types in PCD
219 .................... // Overloaded function CEIL_FLOOR() for data type - Float48
220 .................... #if defined(__PCD__)
221 .................... float48 CEIL_FLOOR(float48 x, unsigned int8 n)
222 .................... {
223 .................... float48 y, res;
224 .................... unsigned int16 l;
225 .................... int1 s;
226 ....................
227 .................... s = 0;
228 .................... y = x;
229 ....................
230 .................... if (x < 0)
231 .................... {
232 .................... s = 1;
233 .................... y = -y;
234 .................... }
235 ....................
236 .................... if (y <= 32768.0)
237 .................... res = (float48)(unsigned int16)y;
238 ....................
239 .................... else if (y < 10000000.0)
240 .................... {
241 .................... l = (unsigned int16)(y/32768.0);
242 .................... y = 32768.0*(y/32768.0 - (float48)l);
243 .................... res = 32768.0*(float32)l;
244 .................... res += (float48)(unsigned int16)y;
245 .................... }
246 ....................
247 .................... else
248 .................... res = y;
249 ....................
250 .................... y = y - (float48)(unsigned int16)y;
251 ....................
252 .................... if (s)
253 .................... res = -res;
254 ....................
255 .................... if (y != 0)
256 .................... {
257 .................... if (s == 1 && n == 0)
258 .................... res -= 1.0;
259 ....................
260 .................... if (s == 0 && n == 1)
261 .................... res += 1.0;
262 .................... }
263 .................... if (x == 0)
264 .................... res = 0;
265 ....................
266 .................... return (res);
267 .................... }
268 ....................
269 ....................
270 .................... // Overloaded function CEIL_FLOOR() for data type - Float64
271 .................... float64 CEIL_FLOOR(float64 x, unsigned int8 n)
272 .................... {
273 .................... float64 y, res;
274 .................... unsigned int16 l;
275 .................... int1 s;
276 ....................
277 .................... s = 0;
278 .................... y = x;
279 ....................
280 .................... if (x < 0)
281 .................... {
282 .................... s = 1;
283 .................... y = -y;
284 .................... }
285 ....................
286 .................... if (y <= 32768.0)
287 .................... res = (float64)(unsigned int16)y;
288 ....................
289 .................... else if (y < 10000000.0)
290 .................... {
291 .................... l = (unsigned int16)(y/32768.0);
292 .................... y = 32768.0*(y/32768.0 - (float64)l);
293 .................... res = 32768.0*(float64)l;
294 .................... res += (float64)(unsigned int16)y;
295 .................... }
296 ....................
297 .................... else
298 .................... res = y;
299 ....................
300 .................... y = y - (float64)(unsigned int16)y;
301 ....................
302 .................... if (s)
303 .................... res = -res;
304 ....................
305 .................... if (y != 0)
306 .................... {
307 .................... if (s == 1 && n == 0)
308 .................... res -= 1.0;
309 ....................
310 .................... if (s == 0 && n == 1)
311 .................... res += 1.0;
312 .................... }
313 .................... if (x == 0)
314 .................... res = 0;
315 ....................
316 .................... return (res);
317 .................... }
318 .................... #endif
319 ....................
320 .................... ////////////////////////////////////////////////////////////////////////////
321 .................... // float floor(float x)
322 .................... ////////////////////////////////////////////////////////////////////////////
323 .................... // Description : rounds down the number x.
324 .................... // Date : N/A
325 .................... //
326 .................... float32 floor(float32 x)
327 .................... {
328 .................... return CEIL_FLOOR(x, 0);
329 .................... }
330 .................... // Following 2 functions are overloaded functions of floor() for PCD
331 .................... // Overloaded function floor() for data type - Float48
332 .................... #if defined(__PCD__)
333 .................... float48 floor(float48 x)
334 .................... {
335 .................... return CEIL_FLOOR(x, 0);
336 .................... }
337 ....................
338 .................... // Overloaded function floor() for data type - Float64
339 .................... float64 floor(float64 x)
340 .................... {
341 .................... return CEIL_FLOOR(x, 0);
342 .................... }
343 .................... #endif
344 ....................
345 ....................
346 .................... ////////////////////////////////////////////////////////////////////////////
347 .................... // float ceil(float x)
348 .................... ////////////////////////////////////////////////////////////////////////////
349 .................... // Description : rounds up the number x.
350 .................... // Date : N/A
351 .................... //
352 .................... float32 ceil(float32 x)
353 .................... {
354 .................... return CEIL_FLOOR(x, 1);
355 .................... }
356 .................... // Following 2 functions are overloaded functions of ceil() for PCD
357 .................... // Overloaded function ceil() for data type - Float48
358 .................... #if defined(__PCD__)
359 .................... float48 ceil(float48 x)
360 .................... {
361 .................... return CEIL_FLOOR(x, 1);
362 .................... }
363 ....................
364 .................... // Overloaded function ceil() for data type - Float64
365 .................... float64 ceil(float64 x)
366 .................... {
367 .................... return CEIL_FLOOR(x, 1);
368 .................... }
369 .................... #endif
370 ....................
371 .................... ////////////////////////////////////////////////////////////////////////////
372 .................... // float fabs(float x)
373 .................... ////////////////////////////////////////////////////////////////////////////
374 .................... // Description : Computes the absolute value of floating point number x
375 .................... // Returns : returns the absolute value of x
376 .................... // Date : N/A
377 .................... //
378 .................... #define fabs abs
379 ....................
380 .................... ////////////////////////////////////////////////////////////////////////////
381 .................... // float fmod(float x)
382 .................... ////////////////////////////////////////////////////////////////////////////
383 .................... // Description : Computes the floating point remainder of x/y
384 .................... // Returns : returns the value of x= i*y, for some integer i such that, if y
385 .................... // is non zero, the result has the same isgn of x na dmagnitude less than the
386 .................... // magnitude of y. If y is zero then a domain error occurs.
387 .................... // Date : N/A
388 .................... //
389 ....................
390 .................... float fmod(float32 x,float32 y)
391 .................... {
392 .................... float32 i;
393 .................... if (y!=0.0)
394 .................... {
395 .................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);
396 .................... return(x-(i*y));
397 .................... }
398 .................... else
399 .................... {
400 .................... #ifdef _ERRNO
401 .................... {
402 .................... errno=EDOM;
403 .................... }
404 .................... #endif
405 .................... }
406 .................... }
407 .................... //Overloaded function for fmod() for PCD
408 .................... // Overloaded function fmod() for data type - Float48
409 .................... #if defined(__PCD__)
410 .................... float48 fmod(float48 x,float48 y)
411 .................... {
412 .................... float48 i;
413 .................... if (y!=0.0)
414 .................... {
415 .................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);
416 .................... return(x-(i*y));
417 .................... }
418 .................... else
419 .................... {
420 .................... #ifdef _ERRNO
421 .................... {
422 .................... errno=EDOM;
423 .................... }
424 .................... #endif
425 .................... }
426 .................... }
427 .................... // Overloaded function fmod() for data type - Float64
428 .................... float64 fmod(float64 x,float64 y)
429 .................... {
430 .................... float64 i;
431 .................... if (y!=0.0)
432 .................... {
433 .................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);
434 .................... return(x-(i*y));
435 .................... }
436 .................... else
437 .................... {
438 .................... #ifdef _ERRNO
439 .................... {
440 .................... errno=EDOM;
441 .................... }
442 .................... #endif
443 .................... }
444 .................... }
445 .................... #endif
446 .................... //////////////////// Exponential and logarithmic functions ////////////////////
447 .................... ////////////////////////////////////////////////////////////////////////////
448 .................... // float exp(float x)
449 .................... ////////////////////////////////////////////////////////////////////////////
450 .................... // Description : returns the value (e^x)
451 .................... // Date : N/A
452 .................... //
453 .................... #define LN2 0.6931471805599453
454 ....................
455 .................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,
456 .................... 0.0554965651, 0.240227138, 0.693147172};
457 ....................
458 ....................
459 .................... float32 exp(float32 x)
460 .................... {
461 .................... float32 y, res, r;
462 .................... #if defined(__PCD__)
463 .................... int8 data1;
464 .................... #endif
465 .................... signed int8 n;
466 .................... int1 s;
467 .................... #ifdef _ERRNO
468 .................... if(x > 88.722838)
469 .................... {
470 .................... errno=ERANGE;
471 .................... return(0);
472 .................... }
473 .................... #endif
474 .................... n = (signed int16)(x/LN2);
475 .................... s = 0;
476 .................... y = x;
477 ....................
478 .................... if (x < 0)
479 .................... {
480 .................... s = 1;
481 .................... n = -n;
482 .................... y = -y;
483 .................... }
484 ....................
485 .................... res = 0.0;
486 .................... #if !defined(__PCD__)
487 .................... *((unsigned int8 *)(&res)) = n + 0x7F;
488 .................... #endif
489 ....................
490 .................... #if defined(__PCD__) // Takes care of IEEE format for PCD
491 .................... data1 = n+0x7F;
492 .................... if(bit_test(data1,0))
493 .................... bit_set(*(((unsigned int8 *)(&res)+2)),7);
494 .................... rotate_right(&data1,1);
495 .................... bit_clear(data1,7);
496 .................... *(((unsigned int8 *)(&res)+3)) = data1;
497 .................... #endif
498 ....................
499 .................... y = y/LN2 - (float32)n;
500 ....................
501 .................... r = pe[0]*y + pe[1];
502 .................... r = r*y + pe[2];
503 .................... r = r*y + pe[3];
504 .................... r = r*y + pe[4];
505 .................... r = r*y + pe[5];
506 ....................
507 .................... res = res*(1.0 + y*r);
508 ....................
509 .................... if (s)
510 .................... res = 1.0/res;
511 .................... return(res);
512 .................... }
513 ....................
514 ....................
515 .................... //Overloaded function for exp() for PCD
516 .................... // Overloaded function exp() for data type - Float48
517 .................... #if defined(__PCD__)
518 .................... float48 exp(float48 x)
519 .................... {
520 .................... float48 y, res, r;
521 .................... int8 data1;
522 .................... signed int8 n;
523 .................... int1 s;
524 .................... #ifdef _ERRNO
525 .................... if(x > 88.722838)
526 .................... {
527 .................... errno=ERANGE;
528 .................... return(0);
529 .................... }
530 .................... #endif
531 .................... n = (signed int16)(x/LN2);
532 .................... s = 0;
533 .................... y = x;
534 ....................
535 .................... if (x < 0)
536 .................... {
537 .................... s = 1;
538 .................... n = -n;
539 .................... y = -y;
540 .................... }
541 ....................
542 .................... res = 0.0;
543 ....................
544 .................... data1 = n+0x7F;
545 .................... if(bit_test(data1,0))
546 .................... bit_set(*(((unsigned int8 *)(&res)+4)),7);
547 .................... rotate_right(&data1,1);
548 .................... bit_clear(data1,7);
549 .................... *(((unsigned int8 *)(&res)+5)) = data1;
550 ....................
551 .................... y = y/LN2 - (float48)n;
552 ....................
553 .................... r = pe[0]*y + pe[1];
554 .................... r = r*y + pe[2];
555 .................... r = r*y + pe[3];
556 .................... r = r*y + pe[4];
557 .................... r = r*y + pe[5];
558 ....................
559 .................... res = res*(1.0 + y*r);
560 ....................
561 .................... if (s)
562 .................... res = 1.0/res;
563 .................... return(res);
564 .................... }
565 ....................
566 .................... // Overloaded function exp() for data type - Float64
567 .................... float64 exp(float64 x)
568 .................... {
569 .................... float64 y, res, r;
570 .................... unsigned int16 data1, data2;
571 .................... unsigned int16 *p;
572 .................... signed int16 n;
573 .................... int1 s;
574 .................... #ifdef _ERRNO
575 .................... if(x > 709.7827128)
576 .................... {
577 .................... errno=ERANGE;
578 .................... return(0);
579 .................... }
580 .................... #endif
581 .................... n = (signed int16)(x/LN2);
582 .................... s = 0;
583 .................... y = x;
584 ....................
585 .................... if (x < 0)
586 .................... {
587 .................... s = 1;
588 .................... n = -n;
589 .................... y = -y;
590 .................... }
591 ....................
592 .................... res = 0.0;
593 ....................
594 .................... #if !defined(__PCD__)
595 .................... *((unsigned int16 *)(&res)) = n + 0x7F;
596 .................... #endif
597 .................... p= (((unsigned int16 *)(&res))+3);
598 .................... data1 = *p;
599 .................... data2 = *p;
600 .................... data1 = n + 0x3FF;
601 .................... data1 = data1 <<4;
602 .................... if(bit_test(data2,15))
603 .................... bit_set(data1,15);
604 .................... data2 = data2 & 0x000F;
605 .................... data1 ^= data2;
606 ....................
607 .................... *(((unsigned int16 *)(&res)+3)) = data1;
608 ....................
609 ....................
610 .................... y = y/LN2 - (float64)n;
611 ....................
612 .................... r = pe[0]*y + pe[1];
613 .................... r = r*y + pe[2];
614 .................... r = r*y + pe[3];
615 .................... r = r*y + pe[4];
616 .................... r = r*y + pe[5];
617 ....................
618 .................... res = res*(1.0 + y*r);
619 ....................
620 .................... if (s)
621 .................... res = 1.0/res;
622 .................... return(res);
623 .................... }
624 ....................
625 .................... #ENDIF
626 ....................
627 ....................
628 .................... /************************************************************/
629 ....................
630 .................... float32 const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
631 .................... float32 const ql[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943};
632 ....................
633 .................... ////////////////////////////////////////////////////////////////////////////
634 .................... // float log(float x)
635 .................... ////////////////////////////////////////////////////////////////////////////
636 .................... // Description : returns the the natural log of x
637 .................... // Date : N/A
638 .................... //
639 .................... float32 log(float32 x)
640 .................... {
641 .................... float32 y, res, r, y2;
642 .................... #if defined(__PCD__)
643 .................... unsigned int8 data1,data2;
644 .................... #endif
645 .................... signed int8 n;
646 .................... #ifdef _ERRNO
647 .................... if(x <0)
648 .................... {
649 .................... errno=EDOM;
650 .................... }
651 .................... if(x ==0)
652 .................... {
653 .................... errno=ERANGE;
654 .................... return(0);
655 .................... }
656 .................... #endif
657 .................... y = x;
658 ....................
659 .................... if (y != 1.0)
660 .................... {
661 .................... #if !defined(__PCD__)
662 .................... *((unsigned int8 *)(&y)) = 0x7E;
663 .................... #endif
664 ....................
665 .................... #if defined(__PCD__) // Takes care of IEEE format
666 .................... data2 = *(((unsigned int8 *)(&y))+3);
667 .................... *(((unsigned int8 *)(&y))+3) = 0x3F;
668 .................... data1 = *(((unsigned int8 *)(&y))+2);
669 .................... bit_clear(data1,7);
670 .................... *(((unsigned int8 *)(&y))+2) = data1;
671 .................... if(bit_test(data2,7))
672 .................... bit_set(*(((unsigned int8 *)(&y))+3),7);
673 .................... #endif
674 ....................
675 .................... y = (y - 1.0)/(y + 1.0);
676 ....................
677 .................... y2=y*y;
678 ....................
679 .................... res = pl[0]*y2 + pl[1];
680 .................... res = res*y2 + pl[2];
681 .................... res = res*y2 + pl[3];
682 ....................
683 .................... r = ql[0]*y2 + ql[1];
684 .................... r = r*y2 + ql[2];
685 .................... r = r*y2 + ql[3];
686 ....................
687 .................... res = y*res/r;
688 .................... #if !defined(__PCD__)
689 .................... n = *((unsigned int8 *)(&x)) - 0x7E;
690 .................... #endif
691 .................... #if defined(__PCD__)
692 .................... data1 = *(((unsigned int8 *)(&x)+3));
693 .................... rotate_left(&data1,1);
694 .................... data2 = *(((unsigned int8 *)(&x)+2));
695 .................... if(bit_test (data2,7))
696 .................... bit_set(data1,0);
697 .................... n = data1 - 0x7E;
698 .................... #endif
699 ....................
700 .................... if (n<0)
701 .................... r = -(float32)-n;
702 .................... else
703 .................... r = (float32)n;
704 ....................
705 .................... res += r*LN2;
706 .................... }
707 ....................
708 .................... else
709 .................... res = 0.0;
710 ....................
711 .................... return(res);
712 .................... }
713 ....................
714 .................... //Overloaded function for log() for PCD
715 .................... // Overloaded function log() for data type - Float48
716 .................... #if defined(__PCD__)
717 .................... float48 log(float48 x)
718 .................... {
719 .................... float48 y, res, r, y2;
720 .................... unsigned int8 data1,data2;
721 .................... signed int8 n;
722 .................... #ifdef _ERRNO
723 .................... if(x <0)
724 .................... {
725 .................... errno=EDOM;
726 .................... }
727 .................... if(x ==0)
728 .................... {
729 .................... errno=ERANGE;
730 .................... return(0);
731 .................... }
732 .................... #endif
733 .................... y = x;
734 ....................
735 .................... if (y != 1.0)
736 .................... {
737 ....................
738 .................... #if !defined(__PCD__)
739 .................... *((unsigned int8 *)(&y)) = 0x7E;
740 .................... #endif
741 .................... data2 = *(((unsigned int8 *)(&y))+5);
742 .................... *(((unsigned int8 *)(&y))+5) = 0x3F;
743 .................... data1 = *(((unsigned int8 *)(&y))+4);
744 .................... bit_clear(data1,7);
745 .................... *(((unsigned int8 *)(&y))+4) = data1;
746 ....................
747 .................... if(bit_test(data2,7))
748 .................... bit_set(*(((unsigned int8 *)(&y))+4),7);
749 .................... y = (y - 1.0)/(y + 1.0);
750 ....................
751 .................... y2=y*y;
752 ....................
753 .................... res = pl[0]*y2 + pl[1];
754 .................... res = res*y2 + pl[2];
755 .................... res = res*y2 + pl[3];
756 ....................
757 .................... r = ql[0]*y2 + ql[1];
758 .................... r = r*y2 + ql[2];
759 .................... r = r*y2 + ql[3];
760 ....................
761 .................... res = y*res/r;
762 ....................
763 .................... data1 = *(((unsigned int8 *)(&x)+5));
764 .................... rotate_left(&data1,1);
765 .................... data2 = *(((unsigned int8 *)(&x)+4));
766 .................... if(bit_test (data2,7))
767 .................... bit_set(data1,0);
768 ....................
769 .................... n = data1 - 0x7E;
770 ....................
771 .................... if (n<0)
772 .................... r = -(float48)-n;
773 .................... else
774 .................... r = (float48)n;
775 ....................
776 .................... res += r*LN2;
777 .................... }
778 ....................
779 .................... else
780 .................... res = 0.0;
781 ....................
782 .................... return(res);
783 .................... }
784 ....................
785 .................... // Overloaded function log() for data type - Float48
786 .................... #if defined(__PCD__)
787 .................... float32 const pl_64[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
788 .................... float32 const ql_64[4] = {1.0000000, -8.1354259, 16.780517, -9.9300943};
789 .................... #endif
790 .................... float64 log(float64 x)
791 .................... {
792 .................... float64 y, res, r, y2;
793 .................... unsigned int16 data1,data2;
794 .................... unsigned int16 *p;
795 .................... signed int16 n;
796 .................... #ifdef _ERRNO
797 .................... if(x <0)
798 .................... {
799 .................... errno=EDOM;
800 .................... }
801 .................... if(x ==0)
802 .................... {
803 .................... errno=ERANGE;
804 .................... return(0);
805 .................... }
806 .................... #endif
807 .................... y = x;
808 ....................
809 .................... if (y != 1.0)
810 .................... {
811 .................... #if !defined(__PCD__)
812 .................... *((unsigned int8 *)(&y)) = 0x7E;
813 .................... #endif
814 .................... p= (((unsigned int16 *)(&y))+3);
815 .................... data1 = *p;
816 .................... data2 = *p;
817 .................... data1 = 0x3FE;
818 .................... data1 = data1 <<4;
819 .................... if(bit_test (data2,15))
820 .................... bit_set(data1,15);
821 .................... data2 = data2 & 0x000F;
822 .................... data1 ^=data2;
823 ....................
824 .................... *p = data1;
825 ....................
826 .................... y = (y - 1.0)/(y + 1.0);
827 ....................
828 .................... y2=y*y;
829 ....................
830 .................... res = pl_64[0]*y2 + pl_64[1];
831 .................... res = res*y2 + pl_64[2];
832 .................... res = res*y2 + pl_64[3];
833 ....................
834 .................... r = ql_64[0]*y2 + ql_64[1];
835 .................... r = r*y2 + ql_64[2];
836 .................... r = r*y2 + ql_64[3];
837 ....................
838 .................... res = y*res/r;
839 ....................
840 .................... p= (((unsigned int16 *)(&x))+3);
841 .................... data1 = *p;
842 .................... bit_clear(data1,15);
843 .................... data1 = data1 >>4;
844 .................... n = data1 - 0x3FE;
845 ....................
846 ....................
847 .................... if (n<0)
848 .................... r = -(float64)-n;
849 .................... else
850 .................... r = (float64)n;
851 ....................
852 .................... res += r*LN2;
853 .................... }
854 ....................
855 .................... else
856 .................... res = 0.0;
857 ....................
858 .................... return(res);
859 .................... }
860 .................... #endif
861 ....................
862 ....................
863 .................... #define LN10 2.3025850929940456
864 ....................
865 .................... ////////////////////////////////////////////////////////////////////////////
866 .................... // float log10(float x)
867 .................... ////////////////////////////////////////////////////////////////////////////
868 .................... // Description : returns the the log base 10 of x
869 .................... // Date : N/A
870 .................... //
871 .................... float32 log10(float32 x)
872 .................... {
873 .................... float32 r;
874 ....................
875 .................... r = log(x);
876 .................... r = r/LN10;
877 .................... return(r);
878 .................... }
879 ....................
880 .................... //Overloaded functions for log10() for PCD
881 .................... // Overloaded function log10() for data type - Float48
882 .................... #if defined(__PCD__)
883 .................... float48 log10(float48 x)
884 .................... {
885 .................... float48 r;
886 ....................
887 .................... r = log(x);
888 .................... r = r/LN10;
889 .................... return(r);
890 .................... }
891 ....................
892 .................... // Overloaded function log10() for data type - Float64
893 .................... float64 log10(float64 x)
894 .................... {
895 .................... float64 r;
896 ....................
897 .................... r = log(x);
898 .................... r = r/LN10;
899 .................... return(r);
900 .................... }
901 .................... #endif
902 .................... ////////////////////////////////////////////////////////////////////////////
903 .................... // float modf(float x)
904 .................... ////////////////////////////////////////////////////////////////////////////
905 .................... // Description :breaks the argument value int integral and fractional parts,
906 .................... // ach of which have the same sign as the argument. It stores the integral part
907 .................... // as a float in the object pointed to by the iptr
908 .................... // Returns : returns the signed fractional part of value.
909 .................... // Date : N/A
910 .................... //
911 ....................
912 .................... float32 modf(float32 value,float32 *iptr)
913 .................... {
914 .................... *iptr=(value < 0.0)? ceil(value): floor(value);
915 .................... return(value - *iptr);
916 .................... }
917 .................... //Overloaded functions for modf() for PCD
918 .................... // Overloaded function modf() for data type - Float48
919 .................... #if defined(__PCD__)
920 .................... float48 modf(float48 value,float48 *iptr)
921 .................... {
922 .................... *iptr=(value < 0.0)? ceil(value): floor(value);
923 .................... return(value - *iptr);
924 .................... }
925 .................... // Overloaded function modf() for data type - Float64
926 .................... float64 modf(float64 value,float64 *iptr)
927 .................... {
928 .................... *iptr=(value < 0.0)? ceil(value): floor(value);
929 .................... return(value - *iptr);
930 .................... }
931 .................... #endif
932 ....................
933 .................... ////////////////////////////////////////////////////////////////////////////
934 .................... // float pwr(float x,float y)
935 .................... ////////////////////////////////////////////////////////////////////////////
936 .................... // Description : returns the value (x^y)
937 .................... // Date : N/A
938 .................... // Note : 0 is returned when the function will generate an imaginary number
939 .................... //
940 .................... float32 pwr(float32 x,float32 y)
941 .................... {
942 .................... if(0 > x && fmod(y, 1) == 0) {
943 .................... if(fmod(y, 2) == 0) {
944 .................... return (exp(log(-x) * y));
945 .................... } else {
946 .................... return (-exp(log(-x) * y));
947 .................... }
948 .................... } else if(0 > x && fmod(y, 1) != 0) {
949 .................... return 0;
950 .................... } else {
951 .................... if(x != 0 || 0 >= y) {
952 .................... return (exp(log(x) * y));
953 .................... }
954 .................... }
955 .................... }
956 .................... //Overloaded functions for pwr() for PCD
957 .................... // Overloaded function pwr() for data type - Float48
958 .................... #if defined(__PCD__)
959 .................... float48 pwr(float48 x,float48 y)
960 .................... {
961 .................... if(0 > x && fmod(y, 1) == 0) {
962 .................... if(fmod(y, 2) == 0) {
963 .................... return (exp(log(-x) * y));
964 .................... } else {
965 .................... return (-exp(log(-x) * y));
966 .................... }
967 .................... } else if(0 > x && fmod(y, 1) != 0) {
968 .................... return 0;
969 .................... } else {
970 .................... if(x != 0 || 0 >= y) {
971 .................... return (exp(log(x) * y));
972 .................... }
973 .................... }
974 .................... }
975 .................... // Overloaded function pwr() for data type - Float64
976 .................... float64 pwr(float64 x,float64 y)
977 .................... {
978 .................... if(0 > x && fmod(y, 1) == 0) {
979 .................... if(fmod(y, 2) == 0) {
980 .................... return (exp(log(-x) * y));
981 .................... } else {
982 .................... return (-exp(log(-x) * y));
983 .................... }
984 .................... } else if(0 > x && fmod(y, 1) != 0) {
985 .................... return 0;
986 .................... } else {
987 .................... if(x != 0 || 0 >= y) {
988 .................... return (exp(log(x) * y));
989 .................... }
990 .................... }
991 .................... }
992 .................... #endif
993 ....................
994 .................... //////////////////// Power functions ////////////////////
995 ....................
996 .................... ////////////////////////////////////////////////////////////////////////////
997 .................... // float pow(float x,float y)
998 .................... ////////////////////////////////////////////////////////////////////////////
999 .................... // Description : returns the value (x^y)
1000 .................... // Date : N/A
1001 .................... // Note : 0 is returned when the function will generate an imaginary number
1002 .................... //
1003 .................... float32 pow(float32 x,float32 y)
1004 .................... {
1005 .................... if(0 > x && fmod(y, 1) == 0) {
1006 .................... if(fmod(y, 2) == 0) {
1007 .................... return (exp(log(-x) * y));
1008 .................... } else {
1009 .................... return (-exp(log(-x) * y));
1010 .................... }
1011 .................... } else if(0 > x && fmod(y, 1) != 0) {
1012 .................... return 0;
1013 .................... } else {
1014 .................... if(x != 0 || 0 >= y) {
1015 .................... return (exp(log(x) * y));
1016 .................... }
1017 .................... }
1018 .................... }
1019 .................... //Overloaded functions for pow() for PCD
1020 .................... // Overloaded function for pow() data type - Float48
1021 .................... #if defined(__PCD__)
1022 .................... float48 pow(float48 x,float48 y)
1023 .................... {
1024 .................... if(0 > x && fmod(y, 1) == 0) {
1025 .................... if(fmod(y, 2) == 0) {
1026 .................... return (exp(log(-x) * y));
1027 .................... } else {
1028 .................... return (-exp(log(-x) * y));
1029 .................... }
1030 .................... } else if(0 > x && fmod(y, 1) != 0) {
1031 .................... return 0;
1032 .................... } else {
1033 .................... if(x != 0 || 0 >= y) {
1034 .................... return (exp(log(x) * y));
1035 .................... }
1036 .................... }
1037 .................... }
1038 ....................
1039 .................... // Overloaded function pow() for data type - Float64
1040 .................... float64 pow(float64 x,float64 y)
1041 .................... {
1042 .................... if(0 > x && fmod(y, 1) == 0) {
1043 .................... if(fmod(y, 2) == 0) {
1044 .................... return (exp(log(-x) * y));
1045 .................... } else {
1046 .................... return (-exp(log(-x) * y));
1047 .................... }
1048 .................... } else if(0 > x && fmod(y, 1) != 0) {
1049 .................... return 0;
1050 .................... } else {
1051 .................... if(x != 0 || 0 >= y) {
1052 .................... return (exp(log(x) * y));
1053 .................... }
1054 .................... }
1055 .................... }
1056 .................... #endif
1057 ....................
1058 .................... ////////////////////////////////////////////////////////////////////////////
1059 .................... // float sqrt(float x)
1060 .................... ////////////////////////////////////////////////////////////////////////////
1061 .................... // Description : returns the square root of x
1062 .................... // Date : N/A
1063 .................... //
1064 .................... float32 sqrt(float32 x)
1065 .................... {
1066 .................... float32 y, res;
1067 .................... #if defined(__PCD__)
1068 .................... unsigned int16 data1,data2;
1069 .................... #endif
1070 .................... BYTE *p;
1071 ....................
1072 .................... #ifdef _ERRNO
1073 .................... if(x < 0)
1074 .................... {
1075 .................... errno=EDOM;
1076 .................... }
1077 .................... #endif
1078 ....................
1079 .................... if( x<=0.0)
1080 *
1081 0888: MOVF 2C,W
1082 0889: MOVWF 49
1083 088A: MOVF 2B,W
1084 088B: MOVWF 48
1085 088C: MOVF 2A,W
1086 088D: MOVWF 47
1087 088E: MOVF 29,W
1088 088F: MOVWF 46
1089 0890: CLRF 4D
1090 0891: CLRF 4C
1091 0892: CLRF 4B
1092 0893: CLRF 4A
1093 0894: BCF 0A.3
1094 0895: BCF 03.5
1095 0896: CALL 40D
1096 0897: BSF 0A.3
1097 0898: BTFSC 03.0
1098 0899: GOTO 09C
1099 089A: BTFSS 03.2
1100 089B: GOTO 0A1
1101 .................... return(0.0);
1102 089C: CLRF 77
1103 089D: CLRF 78
1104 089E: CLRF 79
1105 089F: CLRF 7A
1106 08A0: GOTO 129
1107 ....................
1108 .................... y=x;
1109 08A1: BSF 03.5
1110 08A2: MOVF 2C,W
1111 08A3: MOVWF 30
1112 08A4: MOVF 2B,W
1113 08A5: MOVWF 2F
1114 08A6: MOVF 2A,W
1115 08A7: MOVWF 2E
1116 08A8: MOVF 29,W
1117 08A9: MOVWF 2D
1118 ....................
1119 .................... #if !defined(__PCD__)
1120 .................... p=&y;
1121 08AA: CLRF 36
1122 08AB: MOVLW AD
1123 08AC: MOVWF 35
1124 .................... (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1);
1125 08AD: MOVF 35,W
1126 08AE: MOVWF 04
1127 08AF: BCF 03.7
1128 08B0: BTFSC 36.0
1129 08B1: BSF 03.7
1130 08B2: MOVF 00,W
1131 08B3: CLRF 3A
1132 08B4: MOVWF 39
1133 08B5: MOVLW 7F
1134 08B6: ADDWF 39,F
1135 08B7: BTFSC 03.0
1136 08B8: INCF 3A,F
1137 08B9: BCF 03.0
1138 08BA: RRF 3A,W
1139 08BB: MOVWF 7A
1140 08BC: RRF 39,W
1141 08BD: MOVWF 79
1142 08BE: MOVWF 39
1143 08BF: MOVF 35,W
1144 08C0: MOVWF 04
1145 08C1: BCF 03.7
1146 08C2: BTFSC 36.0
1147 08C3: BSF 03.7
1148 08C4: MOVF 39,W
1149 08C5: MOVWF 00
1150 .................... #endif
1151 ....................
1152 .................... #if defined(__PCD__)
1153 .................... p = (((unsigned int8 *)(&y))+3);
1154 .................... data1 = *(((unsigned int8 *)(&y))+3);
1155 .................... data2 = *(((unsigned int8 *)(&y))+2);
1156 .................... rotate_left(&data1,1);
1157 .................... if(bit_test(data2,7))
1158 .................... bit_set(data1,0);
1159 .................... data1 = ((data1+127) >>1);
1160 .................... bit_clear(data2,7);
1161 .................... if(bit_test(data1,0))
1162 .................... bit_set(data2,7);
1163 .................... data1 = data1 >>1;
1164 .................... *(((unsigned int8 *)(&y))+3) = data1;
1165 .................... *(((unsigned int8 *)(&y))+2) = data2;
1166 ....................
1167 .................... #endif
1168 ....................
1169 .................... do {
1170 .................... res=y;
1171 08C6: MOVF 30,W
1172 08C7: MOVWF 34
1173 08C8: MOVF 2F,W
1174 08C9: MOVWF 33
1175 08CA: MOVF 2E,W
1176 08CB: MOVWF 32
1177 08CC: MOVF 2D,W
1178 08CD: MOVWF 31
1179 .................... y+=(x/y);
1180 08CE: MOVF 2C,W
1181 08CF: MOVWF 49
1182 08D0: MOVF 2B,W
1183 08D1: MOVWF 48
1184 08D2: MOVF 2A,W
1185 08D3: MOVWF 47
1186 08D4: MOVF 29,W
1187 08D5: MOVWF 46
1188 08D6: MOVF 30,W
1189 08D7: MOVWF 4D
1190 08D8: MOVF 2F,W
1191 08D9: MOVWF 4C
1192 08DA: MOVF 2E,W
1193 08DB: MOVWF 4B
1194 08DC: MOVF 2D,W
1195 08DD: MOVWF 4A
1196 08DE: BCF 0A.3
1197 08DF: BCF 03.5
1198 08E0: CALL 142
1199 08E1: BSF 0A.3
1200 08E2: BCF 03.1
1201 08E3: BSF 03.5
1202 08E4: MOVF 30,W
1203 08E5: MOVWF 4D
1204 08E6: MOVF 2F,W
1205 08E7: MOVWF 4C
1206 08E8: MOVF 2E,W
1207 08E9: MOVWF 4B
1208 08EA: MOVF 2D,W
1209 08EB: MOVWF 4A
1210 08EC: MOVF 7A,W
1211 08ED: MOVWF 51
1212 08EE: MOVF 79,W
1213 08EF: MOVWF 50
1214 08F0: MOVF 78,W
1215 08F1: MOVWF 4F
1216 08F2: MOVF 77,W
1217 08F3: MOVWF 4E
1218 08F4: BCF 0A.3
1219 08F5: BCF 03.5
1220 08F6: CALL 2C7
1221 08F7: BSF 0A.3
1222 08F8: MOVF 7A,W
1223 08F9: BSF 03.5
1224 08FA: MOVWF 30
1225 08FB: MOVF 79,W
1226 08FC: MOVWF 2F
1227 08FD: MOVF 78,W
1228 08FE: MOVWF 2E
1229 08FF: MOVF 77,W
1230 0900: MOVWF 2D
1231 ....................
1232 .................... #if !defined(__PCD__)
1233 .................... (*p)--;
1234 0901: MOVF 35,W
1235 0902: MOVWF 04
1236 0903: BCF 03.7
1237 0904: BTFSC 36.0
1238 0905: BSF 03.7
1239 0906: DECF 00,F
1240 .................... #endif
1241 ....................
1242 .................... #if defined(__PCD__)
1243 .................... data1 = *(((unsigned int8 *)(&y))+3);
1244 .................... data2 = *(((unsigned int8 *)(&y))+2);
1245 .................... rotate_left(&data1,1);
1246 .................... if(bit_test(data2,7))
1247 .................... bit_set(data1,0);
1248 .................... data1--;
1249 .................... bit_clear(data2,7);
1250 .................... if(bit_test(data1,0))
1251 .................... bit_set(data2,7);
1252 .................... data1 = data1 >>1;
1253 .................... *(((unsigned int8 *)(&y))+3) = data1;
1254 .................... *(((unsigned int8 *)(&y))+2) = data2;
1255 ....................
1256 .................... #endif
1257 .................... } while(res != y);
1258 0907: MOVF 34,W
1259 0908: MOVWF 49
1260 0909: MOVF 33,W
1261 090A: MOVWF 48
1262 090B: MOVF 32,W
1263 090C: MOVWF 47
1264 090D: MOVF 31,W
1265 090E: MOVWF 46
1266 090F: MOVF 30,W
1267 0910: MOVWF 4D
1268 0911: MOVF 2F,W
1269 0912: MOVWF 4C
1270 0913: MOVF 2E,W
1271 0914: MOVWF 4B
1272 0915: MOVF 2D,W
1273 0916: MOVWF 4A
1274 0917: BCF 0A.3
1275 0918: BCF 03.5
1276 0919: CALL 40D
1277 091A: BSF 0A.3
1278 091B: BTFSC 03.2
1279 091C: GOTO 11F
1280 091D: BSF 03.5
1281 091E: GOTO 0C6
1282 ....................
1283 .................... return(res);
1284 091F: BSF 03.5
1285 0920: MOVF 31,W
1286 0921: MOVWF 77
1287 0922: MOVF 32,W
1288 0923: MOVWF 78
1289 0924: MOVF 33,W
1290 0925: MOVWF 79
1291 0926: MOVF 34,W
1292 0927: MOVWF 7A
1293 0928: BCF 03.5
1294 .................... }
1295 .................... //Overloaded functions for sqrt() for PCD
1296 .................... // Overloaded function sqrt() for data type - Float48
1297 .................... #if defined(__PCD__)
1298 .................... float48 sqrt(float48 x)
1299 .................... {
1300 .................... float48 y, res;
1301 .................... unsigned int16 data1,data2;
1302 .................... BYTE *p;
1303 ....................
1304 .................... #ifdef _ERRNO
1305 .................... if(x < 0)
1306 .................... {
1307 .................... errno=EDOM;
1308 .................... }
1309 .................... #endif
1310 ....................
1311 .................... if( x<=0.0)
1312 .................... return(0.0);
1313 ....................
1314 .................... y=x;
1315 ....................
1316 .................... #if !defined(__PCD__)
1317 .................... p=&y;
1318 .................... (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1);
1319 .................... #endif
1320 ....................
1321 .................... #if defined(__PCD__)
1322 .................... p = (((unsigned int8 *)(&y))+5);
1323 .................... data1 = *(((unsigned int8 *)(&y))+5);
1324 .................... data2 = *(((unsigned int8 *)(&y))+4);
1325 .................... rotate_left(&data1,1);
1326 .................... if(bit_test(data2,7))
1327 .................... bit_set(data1,0);
1328 .................... data1 = ((data1+127) >>1);
1329 .................... bit_clear(data2,7);
1330 .................... if(bit_test(data1,0))
1331 .................... bit_set(data2,7);
1332 .................... data1 = data1 >>1;
1333 .................... *(((unsigned int8 *)(&y))+5) = data1;
1334 .................... *(((unsigned int8 *)(&y))+4) = data2;
1335 ....................
1336 .................... #endif
1337 ....................
1338 .................... do {
1339 .................... res=y;
1340 .................... y+=(x/y);
1341 ....................
1342 .................... #if !defined(__PCD__)
1343 .................... (*p)--;
1344 .................... #endif
1345 ....................
1346 .................... data1 = *(((unsigned int8 *)(&y))+5);
1347 .................... data2 = *(((unsigned int8 *)(&y))+4);
1348 .................... rotate_left(&data1,1);
1349 .................... if(bit_test(data2,7))
1350 .................... bit_set(data1,0);
1351 .................... data1--;
1352 .................... bit_clear(data2,7);
1353 .................... if(bit_test(data1,0))
1354 .................... bit_set(data2,7);
1355 .................... data1 = data1 >>1;
1356 .................... *(((unsigned int8 *)(&y))+5) = data1;
1357 .................... *(((unsigned int8 *)(&y))+4) = data2;
1358 ....................
1359 .................... } while(res != y);
1360 ....................
1361 .................... return(res);
1362 .................... }
1363 ....................
1364 .................... // Overloaded function sqrt() for data type - Float64
1365 .................... float64 sqrt(float64 x)
1366 .................... {
1367 .................... float64 y, res;
1368 .................... unsigned int16 *p;
1369 .................... unsigned int16 temp1,temp2;
1370 ....................
1371 .................... #ifdef _ERRNO
1372 .................... if(x < 0)
1373 .................... {
1374 .................... errno=EDOM;
1375 .................... }
1376 .................... #endif
1377 ....................
1378 .................... if( x<=0.0)
1379 .................... return(0.0);
1380 ....................
1381 .................... y=x;
1382 .................... p= (((unsigned int16 *)(&y))+3);
1383 .................... temp1 = *p;
1384 .................... temp2 = *p;
1385 .................... bit_clear(temp1,15);
1386 .................... temp1 = (temp1>>4)+1023;
1387 .................... temp1 = temp1 >> 1;
1388 .................... temp1 = (temp1<<4) & 0xFFF0;
1389 .................... if(bit_test(temp2,15))
1390 .................... bit_set(temp1,15);
1391 .................... temp2 = temp2 & 0x000F;
1392 .................... temp1 ^= temp2;
1393 ....................
1394 .................... (*p) = temp1;
1395 ....................
1396 .................... do {
1397 .................... res=y;
1398 .................... y+=(x/y);
1399 .................... temp1 = *p;
1400 .................... temp2 = *p;
1401 .................... bit_clear(temp1,15);
1402 .................... temp1 = (temp1>>4);
1403 .................... temp1--;
1404 .................... temp1 = (temp1<<4) & 0xFFF0;
1405 .................... if(bit_test(temp2,15))
1406 .................... bit_set(temp1,15);
1407 .................... temp2 = temp2 & 0x000F;
1408 .................... temp1 ^= temp2;
1409 .................... (*p) = temp1;
1410 ....................
1411 .................... } while(res != y);
1412 ....................
1413 .................... return(res);
1414 .................... }
1415 .................... #endif
1416 ....................
1417 .................... ////////////////////////////// Trig Functions //////////////////////////////
1418 .................... #ifdef PI_DIV_BY_TWO
1419 .................... #undef PI_DIV_BY_TWO
1420 .................... #endif
1421 .................... #define PI_DIV_BY_TWO 1.5707963267948966
1422 .................... #ifdef TWOBYPI
1423 .................... #undef TWOBYPI
1424 .................... #define TWOBYPI 0.6366197723675813
1425 .................... #endif
1426 .................... ////////////////////////////////////////////////////////////////////////////
1427 .................... // float cos(float x)
1428 .................... ////////////////////////////////////////////////////////////////////////////
1429 .................... // Description : returns the cosine value of the angle x, which is in radian
1430 .................... // Date : 9/20/2001
1431 .................... //
1432 .................... float32 cos(float32 x)
1433 .................... {
1434 *
1435 046F: BSF 03.5
1436 0470: CLRF 27
1437 0471: CLRF 26
1438 0472: CLRF 25
1439 0473: MOVLW 7F
1440 0474: MOVWF 24
1441 .................... float32 y, t, t2 = 1.0;
1442 .................... unsigned int8 quad, i;
1443 .................... float32 frac;
1444 .................... float32 p[6] = { //by the series definition for cosine
1445 .................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! )
1446 .................... 0.04166666666667,
1447 .................... -0.00138888888889,
1448 .................... 0.00002480158730,
1449 .................... -0.00000027557319,
1450 .................... 0.00000000208767,
1451 .................... //-0.00000000001147,
1452 .................... // 0.00000000000005
1453 .................... };
1454 0475: MOVLW 7E
1455 0476: MOVWF 2E
1456 0477: MOVLW 80
1457 0478: MOVWF 2F
1458 0479: CLRF 30
1459 047A: CLRF 31
1460 047B: MOVLW 7A
1461 047C: MOVWF 32
1462 047D: MOVLW 2A
1463 047E: MOVWF 33
1464 047F: MOVLW AA
1465 0480: MOVWF 34
1466 0481: MOVLW AB
1467 0482: MOVWF 35
1468 0483: MOVLW 75
1469 0484: MOVWF 36
1470 0485: MOVLW B6
1471 0486: MOVWF 37
1472 0487: MOVLW 0B
1473 0488: MOVWF 38
1474 0489: MOVLW 61
1475 048A: MOVWF 39
1476 048B: MOVLW 6F
1477 048C: MOVWF 3A
1478 048D: MOVLW 50
1479 048E: MOVWF 3B
1480 048F: MOVLW 0D
1481 0490: MOVWF 3C
1482 0491: MOVLW 01
1483 0492: MOVWF 3D
1484 0493: MOVLW 69
1485 0494: MOVWF 3E
1486 0495: MOVLW 93
1487 0496: MOVWF 3F
1488 0497: MOVLW F2
1489 0498: MOVWF 40
1490 0499: MOVLW 7E
1491 049A: MOVWF 41
1492 049B: MOVLW 62
1493 049C: MOVWF 42
1494 049D: MOVLW 0F
1495 049E: MOVWF 43
1496 049F: MOVLW 76
1497 04A0: MOVWF 44
1498 04A1: MOVLW AE
1499 04A2: MOVWF 45
1500 ....................
1501 .................... if (x < 0) x = -x; // absolute value of input
1502 04A3: MOVF 76,W
1503 04A4: MOVWF 49
1504 04A5: MOVF 75,W
1505 04A6: MOVWF 48
1506 04A7: MOVF 74,W
1507 04A8: MOVWF 47
1508 04A9: MOVF 73,W
1509 04AA: MOVWF 46
1510 04AB: CLRF 4D
1511 04AC: CLRF 4C
1512 04AD: CLRF 4B
1513 04AE: CLRF 4A
1514 04AF: BCF 03.5
1515 04B0: CALL 40D
1516 04B1: BTFSS 03.0
1517 04B2: GOTO 4B6
1518 04B3: MOVF 74,W
1519 04B4: XORLW 80
1520 04B5: MOVWF 74
1521 ....................
1522 .................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant
1523 04B6: MOVF 76,W
1524 04B7: BSF 03.5
1525 04B8: MOVWF 49
1526 04B9: MOVF 75,W
1527 04BA: MOVWF 48
1528 04BB: MOVF 74,W
1529 04BC: MOVWF 47
1530 04BD: MOVF 73,W
1531 04BE: MOVWF 46
1532 04BF: MOVLW DB
1533 04C0: MOVWF 4D
1534 04C1: MOVLW 0F
1535 04C2: MOVWF 4C
1536 04C3: MOVLW 49
1537 04C4: MOVWF 4B
1538 04C5: MOVLW 7F
1539 04C6: MOVWF 4A
1540 04C7: BCF 03.5
1541 04C8: CALL 142
1542 04C9: MOVF 7A,W
1543 04CA: BSF 03.5
1544 04CB: MOVWF 49
1545 04CC: MOVF 79,W
1546 04CD: MOVWF 48
1547 04CE: MOVF 78,W
1548 04CF: MOVWF 47
1549 04D0: MOVF 77,W
1550 04D1: MOVWF 46
1551 04D2: BCF 03.5
1552 04D3: CALL 44E
1553 04D4: MOVF 78,W
1554 04D5: BSF 03.5
1555 04D6: MOVWF 28
1556 .................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input
1557 04D7: MOVF 76,W
1558 04D8: MOVWF 49
1559 04D9: MOVF 75,W
1560 04DA: MOVWF 48
1561 04DB: MOVF 74,W
1562 04DC: MOVWF 47
1563 04DD: MOVF 73,W
1564 04DE: MOVWF 46
1565 04DF: MOVLW DB
1566 04E0: MOVWF 4D
1567 04E1: MOVLW 0F
1568 04E2: MOVWF 4C
1569 04E3: MOVLW 49
1570 04E4: MOVWF 4B
1571 04E5: MOVLW 7F
1572 04E6: MOVWF 4A
1573 04E7: BCF 03.5
1574 04E8: CALL 142
1575 04E9: MOVF 77,W
1576 04EA: BSF 03.5
1577 04EB: MOVWF 46
1578 04EC: MOVF 78,W
1579 04ED: MOVWF 47
1580 04EE: MOVF 79,W
1581 04EF: MOVWF 48
1582 04F0: MOVF 7A,W
1583 04F1: MOVWF 49
1584 04F2: CLRF 4B
1585 04F3: MOVF 28,W
1586 04F4: MOVWF 4A
1587 04F5: BCF 03.5
1588 04F6: CALL 030
1589 04F7: BSF 03.1
1590 04F8: BSF 03.5
1591 04F9: MOVF 49,W
1592 04FA: MOVWF 4D
1593 04FB: MOVF 48,W
1594 04FC: MOVWF 4C
1595 04FD: MOVF 47,W
1596 04FE: MOVWF 4B
1597 04FF: MOVF 46,W
1598 0500: MOVWF 4A
1599 0501: MOVF 7A,W
1600 0502: MOVWF 51
1601 0503: MOVF 79,W
1602 0504: MOVWF 50
1603 0505: MOVF 78,W
1604 0506: MOVWF 4F
1605 0507: MOVF 77,W
1606 0508: MOVWF 4E
1607 0509: BCF 03.5
1608 050A: CALL 2C7
1609 050B: MOVF 7A,W
1610 050C: BSF 03.5
1611 050D: MOVWF 2D
1612 050E: MOVF 79,W
1613 050F: MOVWF 2C
1614 0510: MOVF 78,W
1615 0511: MOVWF 2B
1616 0512: MOVF 77,W
1617 0513: MOVWF 2A
1618 .................... quad = quad % 4; // quadrant (0 to 3)
1619 0514: MOVLW 03
1620 0515: ANDWF 28,F
1621 ....................
1622 .................... if (quad == 0 || quad == 2)
1623 0516: MOVF 28,F
1624 0517: BTFSC 03.2
1625 0518: GOTO 51D
1626 0519: MOVF 28,W
1627 051A: SUBLW 02
1628 051B: BTFSS 03.2
1629 051C: GOTO 539
1630 .................... t = frac * PI_DIV_BY_TWO;
1631 051D: MOVF 2D,W
1632 051E: MOVWF 4D
1633 051F: MOVF 2C,W
1634 0520: MOVWF 4C
1635 0521: MOVF 2B,W
1636 0522: MOVWF 4B
1637 0523: MOVF 2A,W
1638 0524: MOVWF 4A
1639 0525: MOVLW DB
1640 0526: MOVWF 51
1641 0527: MOVLW 0F
1642 0528: MOVWF 50
1643 0529: MOVLW 49
1644 052A: MOVWF 4F
1645 052B: MOVLW 7F
1646 052C: MOVWF 4E
1647 052D: BCF 03.5
1648 052E: CALL 20E
1649 052F: MOVF 7A,W
1650 0530: BSF 03.5
1651 0531: MOVWF 23
1652 0532: MOVF 79,W
1653 0533: MOVWF 22
1654 0534: MOVF 78,W
1655 0535: MOVWF 21
1656 0536: MOVF 77,W
1657 0537: MOVWF 20
1658 .................... else if (quad == 1)
1659 0538: GOTO 5A2
1660 0539: DECFSZ 28,W
1661 053A: GOTO 56F
1662 .................... t = (1-frac) * PI_DIV_BY_TWO;
1663 053B: BSF 03.1
1664 053C: CLRF 4D
1665 053D: CLRF 4C
1666 053E: CLRF 4B
1667 053F: MOVLW 7F
1668 0540: MOVWF 4A
1669 0541: MOVF 2D,W
1670 0542: MOVWF 51
1671 0543: MOVF 2C,W
1672 0544: MOVWF 50
1673 0545: MOVF 2B,W
1674 0546: MOVWF 4F
1675 0547: MOVF 2A,W
1676 0548: MOVWF 4E
1677 0549: BCF 03.5
1678 054A: CALL 2C7
1679 054B: MOVF 77,W
1680 054C: BSF 03.5
1681 054D: MOVWF 46
1682 054E: MOVF 78,W
1683 054F: MOVWF 47
1684 0550: MOVF 79,W
1685 0551: MOVWF 48
1686 0552: MOVF 7A,W
1687 0553: MOVWF 49
1688 0554: MOVWF 4D
1689 0555: MOVF 48,W
1690 0556: MOVWF 4C
1691 0557: MOVF 47,W
1692 0558: MOVWF 4B
1693 0559: MOVF 46,W
1694 055A: MOVWF 4A
1695 055B: MOVLW DB
1696 055C: MOVWF 51
1697 055D: MOVLW 0F
1698 055E: MOVWF 50
1699 055F: MOVLW 49
1700 0560: MOVWF 4F
1701 0561: MOVLW 7F
1702 0562: MOVWF 4E
1703 0563: BCF 03.5
1704 0564: CALL 20E
1705 0565: MOVF 7A,W
1706 0566: BSF 03.5
1707 0567: MOVWF 23
1708 0568: MOVF 79,W
1709 0569: MOVWF 22
1710 056A: MOVF 78,W
1711 056B: MOVWF 21
1712 056C: MOVF 77,W
1713 056D: MOVWF 20
1714 .................... else // should be 3
1715 056E: GOTO 5A2
1716 .................... t = (frac-1) * PI_DIV_BY_TWO;
1717 056F: BSF 03.1
1718 0570: MOVF 2D,W
1719 0571: MOVWF 4D
1720 0572: MOVF 2C,W
1721 0573: MOVWF 4C
1722 0574: MOVF 2B,W
1723 0575: MOVWF 4B
1724 0576: MOVF 2A,W
1725 0577: MOVWF 4A
1726 0578: CLRF 51
1727 0579: CLRF 50
1728 057A: CLRF 4F
1729 057B: MOVLW 7F
1730 057C: MOVWF 4E
1731 057D: BCF 03.5
1732 057E: CALL 2C7
1733 057F: MOVF 77,W
1734 0580: BSF 03.5
1735 0581: MOVWF 46
1736 0582: MOVF 78,W
1737 0583: MOVWF 47
1738 0584: MOVF 79,W
1739 0585: MOVWF 48
1740 0586: MOVF 7A,W
1741 0587: MOVWF 49
1742 0588: MOVWF 4D
1743 0589: MOVF 48,W
1744 058A: MOVWF 4C
1745 058B: MOVF 47,W
1746 058C: MOVWF 4B
1747 058D: MOVF 46,W
1748 058E: MOVWF 4A
1749 058F: MOVLW DB
1750 0590: MOVWF 51
1751 0591: MOVLW 0F
1752 0592: MOVWF 50
1753 0593: MOVLW 49
1754 0594: MOVWF 4F
1755 0595: MOVLW 7F
1756 0596: MOVWF 4E
1757 0597: BCF 03.5
1758 0598: CALL 20E
1759 0599: MOVF 7A,W
1760 059A: BSF 03.5
1761 059B: MOVWF 23
1762 059C: MOVF 79,W
1763 059D: MOVWF 22
1764 059E: MOVF 78,W
1765 059F: MOVWF 21
1766 05A0: MOVF 77,W
1767 05A1: MOVWF 20
1768 ....................
1769 .................... y = 1.0;
1770 05A2: CLRF 7E
1771 05A3: CLRF 7D
1772 05A4: CLRF 7C
1773 05A5: MOVLW 7F
1774 05A6: MOVWF 7B
1775 .................... t = t * t;
1776 05A7: MOVF 23,W
1777 05A8: MOVWF 4D
1778 05A9: MOVF 22,W
1779 05AA: MOVWF 4C
1780 05AB: MOVF 21,W
1781 05AC: MOVWF 4B
1782 05AD: MOVF 20,W
1783 05AE: MOVWF 4A
1784 05AF: MOVF 23,W
1785 05B0: MOVWF 51
1786 05B1: MOVF 22,W
1787 05B2: MOVWF 50
1788 05B3: MOVF 21,W
1789 05B4: MOVWF 4F
1790 05B5: MOVF 20,W
1791 05B6: MOVWF 4E
1792 05B7: BCF 03.5
1793 05B8: CALL 20E
1794 05B9: MOVF 7A,W
1795 05BA: BSF 03.5
1796 05BB: MOVWF 23
1797 05BC: MOVF 79,W
1798 05BD: MOVWF 22
1799 05BE: MOVF 78,W
1800 05BF: MOVWF 21
1801 05C0: MOVF 77,W
1802 05C1: MOVWF 20
1803 .................... for (i = 0; i <= 5; i++)
1804 05C2: CLRF 29
1805 05C3: MOVF 29,W
1806 05C4: SUBLW 05
1807 05C5: BTFSS 03.0
1808 05C6: GOTO 631
1809 .................... {
1810 .................... t2 = t2 * t;
1811 05C7: MOVF 27,W
1812 05C8: MOVWF 4D
1813 05C9: MOVF 26,W
1814 05CA: MOVWF 4C
1815 05CB: MOVF 25,W
1816 05CC: MOVWF 4B
1817 05CD: MOVF 24,W
1818 05CE: MOVWF 4A
1819 05CF: MOVF 23,W
1820 05D0: MOVWF 51
1821 05D1: MOVF 22,W
1822 05D2: MOVWF 50
1823 05D3: MOVF 21,W
1824 05D4: MOVWF 4F
1825 05D5: MOVF 20,W
1826 05D6: MOVWF 4E
1827 05D7: BCF 03.5
1828 05D8: CALL 20E
1829 05D9: MOVF 7A,W
1830 05DA: BSF 03.5
1831 05DB: MOVWF 27
1832 05DC: MOVF 79,W
1833 05DD: MOVWF 26
1834 05DE: MOVF 78,W
1835 05DF: MOVWF 25
1836 05E0: MOVF 77,W
1837 05E1: MOVWF 24
1838 .................... y = y + p[i] * t2;
1839 05E2: RLF 29,W
1840 05E3: MOVWF 77
1841 05E4: RLF 77,F
1842 05E5: MOVLW FC
1843 05E6: ANDWF 77,F
1844 05E7: MOVF 77,W
1845 05E8: ADDLW AE
1846 05E9: MOVWF 04
1847 05EA: BCF 03.7
1848 05EB: MOVF 00,W
1849 05EC: MOVWF 46
1850 05ED: INCF 04,F
1851 05EE: MOVF 00,W
1852 05EF: MOVWF 47
1853 05F0: INCF 04,F
1854 05F1: MOVF 00,W
1855 05F2: MOVWF 48
1856 05F3: INCF 04,F
1857 05F4: MOVF 00,W
1858 05F5: MOVWF 49
1859 05F6: MOVWF 4D
1860 05F7: MOVF 48,W
1861 05F8: MOVWF 4C
1862 05F9: MOVF 47,W
1863 05FA: MOVWF 4B
1864 05FB: MOVF 46,W
1865 05FC: MOVWF 4A
1866 05FD: MOVF 27,W
1867 05FE: MOVWF 51
1868 05FF: MOVF 26,W
1869 0600: MOVWF 50
1870 0601: MOVF 25,W
1871 0602: MOVWF 4F
1872 0603: MOVF 24,W
1873 0604: MOVWF 4E
1874 0605: BCF 03.5
1875 0606: CALL 20E
1876 0607: BSF 03.5
1877 0608: CLRF 47
1878 0609: MOVF 04,W
1879 060A: MOVWF 46
1880 060B: BCF 47.0
1881 060C: BTFSC 03.7
1882 060D: BSF 47.0
1883 060E: BCF 03.1
1884 060F: MOVF 7E,W
1885 0610: MOVWF 4D
1886 0611: MOVF 7D,W
1887 0612: MOVWF 4C
1888 0613: MOVF 7C,W
1889 0614: MOVWF 4B
1890 0615: MOVF 7B,W
1891 0616: MOVWF 4A
1892 0617: MOVF 7A,W
1893 0618: MOVWF 51
1894 0619: MOVF 79,W
1895 061A: MOVWF 50
1896 061B: MOVF 78,W
1897 061C: MOVWF 4F
1898 061D: MOVF 77,W
1899 061E: MOVWF 4E
1900 061F: BCF 03.5
1901 0620: CALL 2C7
1902 0621: BSF 03.5
1903 0622: MOVF 46,W
1904 0623: MOVWF 04
1905 0624: BCF 03.7
1906 0625: BTFSC 47.0
1907 0626: BSF 03.7
1908 0627: MOVF 7A,W
1909 0628: MOVWF 7E
1910 0629: MOVF 79,W
1911 062A: MOVWF 7D
1912 062B: MOVF 78,W
1913 062C: MOVWF 7C
1914 062D: MOVF 77,W
1915 062E: MOVWF 7B
1916 .................... }
1917 062F: INCF 29,F
1918 0630: GOTO 5C3
1919 ....................
1920 .................... if (quad == 2 || quad == 1)
1921 0631: MOVF 28,W
1922 0632: SUBLW 02
1923 0633: BTFSC 03.2
1924 0634: GOTO 637
1925 0635: DECFSZ 28,W
1926 0636: GOTO 63A
1927 .................... y = -y; // correct sign
1928 0637: MOVF 7C,W
1929 0638: XORLW 80
1930 0639: MOVWF 7C
1931 ....................
1932 .................... return (y);
1933 063A: MOVF 7B,W
1934 063B: MOVWF 77
1935 063C: MOVF 7C,W
1936 063D: MOVWF 78
1937 063E: MOVF 7D,W
1938 063F: MOVWF 79
1939 0640: MOVF 7E,W
1940 0641: MOVWF 7A
1941 .................... }
1942 0642: BCF 03.5
1943 0643: RETURN
1944 ....................
1945 ....................
1946 .................... //Overloaded functions for cos() for PCD
1947 .................... // Overloaded function cos() for data type - Float48
1948 .................... #if defined(__PCD__)
1949 .................... float48 cos(float48 x)
1950 .................... {
1951 .................... float48 y, t, t2 = 1.0;
1952 .................... unsigned int8 quad, i;
1953 .................... float48 frac;
1954 .................... float48 p[6] = { //by the series definition for cosine
1955 .................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! )
1956 .................... 0.04166666666667,
1957 .................... -0.00138888888889,
1958 .................... 0.00002480158730,
1959 .................... -0.00000027557319,
1960 .................... 0.00000000208767,
1961 .................... //-0.00000000001147,
1962 .................... // 0.00000000000005
1963 .................... };
1964 ....................
1965 .................... if (x < 0) x = -x; // absolute value of input
1966 ....................
1967 .................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant
1968 .................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input
1969 .................... quad = quad % 4; // quadrant (0 to 3)
1970 ....................
1971 .................... if (quad == 0 || quad == 2)
1972 .................... t = frac * PI_DIV_BY_TWO;
1973 .................... else if (quad == 1)
1974 .................... t = (1-frac) * PI_DIV_BY_TWO;
1975 .................... else // should be 3
1976 .................... t = (frac-1) * PI_DIV_BY_TWO;
1977 ....................
1978 .................... y = 0.999999999781;
1979 .................... t = t * t;
1980 .................... for (i = 0; i <= 5; i++)
1981 .................... {
1982 .................... t2 = t2 * t;
1983 .................... y = y + p[i] * t2;
1984 .................... }
1985 ....................
1986 .................... if (quad == 2 || quad == 1)
1987 .................... y = -y; // correct sign
1988 ....................
1989 .................... return (y);
1990 .................... }
1991 ....................
1992 .................... // Overloaded function cos() for data type - Float48
1993 .................... float64 cos(float64 x)
1994 .................... {
1995 .................... float64 y, t, t2 = 1.0;
1996 .................... unsigned int8 quad, i;
1997 .................... float64 frac;
1998 .................... float64 p[6] = { //by the series definition for cosine
1999 .................... -0.5, // sum ( ( (-1)^n * x^2n )/(2n)! )
2000 .................... 0.04166666666667,
2001 .................... -0.00138888888889,
2002 .................... 0.00002480158730,
2003 .................... -0.00000027557319,
2004 .................... 0.00000000208767,
2005 .................... //-0.00000000001147,
2006 .................... // 0.00000000000005
2007 .................... };
2008 ....................
2009 .................... if (x < 0) x = -x; // absolute value of input
2010 ....................
2011 .................... quad = (unsigned int8)(x / PI_DIV_BY_TWO); // quadrant
2012 .................... frac = (x / PI_DIV_BY_TWO) - quad; // fractional part of input
2013 .................... quad = quad % 4; // quadrant (0 to 3)
2014 ....................
2015 .................... if (quad == 0 || quad == 2)
2016 .................... t = frac * PI_DIV_BY_TWO;
2017 .................... else if (quad == 1)
2018 .................... t = (1-frac) * PI_DIV_BY_TWO;
2019 .................... else // should be 3
2020 .................... t = (frac-1) * PI_DIV_BY_TWO;
2021 ....................
2022 .................... y = 0.999999999781;
2023 .................... t = t * t;
2024 .................... for (i = 0; i <= 5; i++)
2025 .................... {
2026 .................... t2 = t2 * t;
2027 .................... y = y + p[i] * t2;
2028 .................... }
2029 ....................
2030 .................... if (quad == 2 || quad == 1)
2031 .................... y = -y; // correct sign
2032 ....................
2033 .................... return (y);
2034 .................... }
2035 ....................
2036 .................... #endif
2037 ....................
2038 .................... ////////////////////////////////////////////////////////////////////////////
2039 .................... // float sin(float x)
2040 .................... ////////////////////////////////////////////////////////////////////////////
2041 .................... // Description : returns the sine value of the angle x, which is in radian
2042 .................... // Date : 9/20/2001
2043 .................... //
2044 .................... float32 sin(float32 x)
2045 .................... {
2046 .................... return cos(x - PI_DIV_BY_TWO);
2047 0644: BSF 03.1
2048 0645: MOVF 6E,W
2049 0646: BSF 03.5
2050 0647: MOVWF 4D
2051 0648: BCF 03.5
2052 0649: MOVF 6D,W
2053 064A: BSF 03.5
2054 064B: MOVWF 4C
2055 064C: BCF 03.5
2056 064D: MOVF 6C,W
2057 064E: BSF 03.5
2058 064F: MOVWF 4B
2059 0650: BCF 03.5
2060 0651: MOVF 6B,W
2061 0652: BSF 03.5
2062 0653: MOVWF 4A
2063 0654: MOVLW DB
2064 0655: MOVWF 51
2065 0656: MOVLW 0F
2066 0657: MOVWF 50
2067 0658: MOVLW 49
2068 0659: MOVWF 4F
2069 065A: MOVLW 7F
2070 065B: MOVWF 4E
2071 065C: BCF 03.5
2072 065D: CALL 2C7
2073 065E: MOVF 77,W
2074 065F: MOVWF 6F
2075 0660: MOVF 78,W
2076 0661: MOVWF 70
2077 0662: MOVF 79,W
2078 0663: MOVWF 71
2079 0664: MOVF 7A,W
2080 0665: MOVWF 72
2081 0666: MOVWF 76
2082 0667: MOVF 79,W
2083 0668: MOVWF 75
2084 0669: MOVF 78,W
2085 066A: MOVWF 74
2086 066B: MOVF 77,W
2087 066C: MOVWF 73
2088 066D: CALL 46F
2089 .................... }
2090 066E: RETURN
2091 ....................
2092 .................... //Overloaded functions for sin() for PCD
2093 .................... // Overloaded function sin() for data type - Float48
2094 .................... #if defined(__PCD__)
2095 .................... float48 sin(float48 x)
2096 .................... {
2097 .................... return cos(x - PI_DIV_BY_TWO);
2098 .................... }
2099 ....................
2100 .................... // Overloaded function sin() for data type - Float48
2101 .................... float64 sin(float64 x)
2102 .................... {
2103 .................... return cos(x - PI_DIV_BY_TWO);
2104 .................... }
2105 .................... #endif
2106 ....................
2107 .................... ////////////////////////////////////////////////////////////////////////////
2108 .................... // float tan(float x)
2109 .................... ////////////////////////////////////////////////////////////////////////////
2110 .................... // Description : returns the tangent value of the angle x, which is in radian
2111 .................... // Date : 9/20/2001
2112 .................... //
2113 .................... float32 tan(float32 x)
2114 .................... {
2115 .................... float32 c, s;
2116 ....................
2117 .................... c = cos(x);
2118 .................... if (c == 0.0)
2119 .................... return (1.0e+36);
2120 ....................
2121 .................... s = sin(x);
2122 .................... return(s/c);
2123 .................... }
2124 .................... //Overloaded functions for tan() for PCD
2125 .................... // Overloaded function tan() for data type - Float48
2126 .................... #if defined(__PCD__)
2127 .................... float48 tan(float48 x)
2128 .................... {
2129 .................... float48 c, s;
2130 ....................
2131 .................... c = cos(x);
2132 .................... if (c == 0.0)
2133 .................... return (1.0e+36);
2134 ....................
2135 .................... s = sin(x);
2136 .................... return(s/c);
2137 .................... }
2138 ....................
2139 .................... // Overloaded function tan() for data type - Float48
2140 .................... float64 tan(float64 x)
2141 .................... {
2142 .................... float64 c, s;
2143 ....................
2144 .................... c = cos(x);
2145 .................... if (c == 0.0)
2146 .................... return (1.0e+36);
2147 ....................
2148 .................... s = sin(x);
2149 .................... return(s/c);
2150 .................... }
2151 .................... #endif
2152 ....................
2153 .................... float32 const pas[3] = {0.49559947, -4.6145309, 5.6036290};
2154 .................... float32 const qas[3] = {1.0000000, -5.5484666, 5.6036290};
2155 ....................
2156 .................... float32 ASIN_COS(float32 x, unsigned int8 n)
2157 .................... {
2158 .................... float32 y, res, r, y2;
2159 .................... int1 s;
2160 .................... #ifdef _ERRNO
2161 .................... if(x <-1 || x > 1)
2162 .................... {
2163 .................... errno=EDOM;
2164 .................... }
2165 .................... #endif
2166 .................... s = 0;
2167 *
2168 0800: BCF 74.0
2169 .................... y = x;
2170 0801: MOVF 6A,W
2171 0802: MOVWF 6F
2172 0803: MOVF 69,W
2173 0804: MOVWF 6E
2174 0805: MOVF 68,W
2175 0806: MOVWF 6D
2176 0807: MOVF 67,W
2177 0808: MOVWF 6C
2178 ....................
2179 .................... if (x < 0)
2180 0809: MOVF 6A,W
2181 080A: BSF 03.5
2182 080B: MOVWF 49
2183 080C: BCF 03.5
2184 080D: MOVF 69,W
2185 080E: BSF 03.5
2186 080F: MOVWF 48
2187 0810: BCF 03.5
2188 0811: MOVF 68,W
2189 0812: BSF 03.5
2190 0813: MOVWF 47
2191 0814: BCF 03.5
2192 0815: MOVF 67,W
2193 0816: BSF 03.5
2194 0817: MOVWF 46
2195 0818: CLRF 4D
2196 0819: CLRF 4C
2197 081A: CLRF 4B
2198 081B: CLRF 4A
2199 081C: BCF 0A.3
2200 081D: BCF 03.5
2201 081E: CALL 40D
2202 081F: BSF 0A.3
2203 0820: BTFSS 03.0
2204 0821: GOTO 026
2205 .................... {
2206 .................... s = 1;
2207 0822: BSF 74.0
2208 .................... y = -y;
2209 0823: MOVF 6D,W
2210 0824: XORLW 80
2211 0825: MOVWF 6D
2212 .................... }
2213 ....................
2214 .................... if (y > 0.5)
2215 0826: BSF 03.5
2216 0827: CLRF 49
2217 0828: CLRF 48
2218 0829: CLRF 47
2219 082A: MOVLW 7E
2220 082B: MOVWF 46
2221 082C: BCF 03.5
2222 082D: MOVF 6F,W
2223 082E: BSF 03.5
2224 082F: MOVWF 4D
2225 0830: BCF 03.5
2226 0831: MOVF 6E,W
2227 0832: BSF 03.5
2228 0833: MOVWF 4C
2229 0834: BCF 03.5
2230 0835: MOVF 6D,W
2231 0836: BSF 03.5
2232 0837: MOVWF 4B
2233 0838: BCF 03.5
2234 0839: MOVF 6C,W
2235 083A: BSF 03.5
2236 083B: MOVWF 4A
2237 083C: BCF 0A.3
2238 083D: BCF 03.5
2239 083E: CALL 40D
2240 083F: BSF 0A.3
2241 0840: BTFSS 03.0
2242 0841: GOTO 133
2243 .................... {
2244 .................... y = sqrt((1.0 - y)/2.0);
2245 0842: BSF 03.1
2246 0843: BSF 03.5
2247 0844: CLRF 4D
2248 0845: CLRF 4C
2249 0846: CLRF 4B
2250 0847: MOVLW 7F
2251 0848: MOVWF 4A
2252 0849: BCF 03.5
2253 084A: MOVF 6F,W
2254 084B: BSF 03.5
2255 084C: MOVWF 51
2256 084D: BCF 03.5
2257 084E: MOVF 6E,W
2258 084F: BSF 03.5
2259 0850: MOVWF 50
2260 0851: BCF 03.5
2261 0852: MOVF 6D,W
2262 0853: BSF 03.5
2263 0854: MOVWF 4F
2264 0855: BCF 03.5
2265 0856: MOVF 6C,W
2266 0857: BSF 03.5
2267 0858: MOVWF 4E
2268 0859: BCF 0A.3
2269 085A: BCF 03.5
2270 085B: CALL 2C7
2271 085C: BSF 0A.3
2272 085D: MOVF 77,W
2273 085E: BSF 03.5
2274 085F: MOVWF 24
2275 0860: MOVF 78,W
2276 0861: MOVWF 25
2277 0862: MOVF 79,W
2278 0863: MOVWF 26
2279 0864: MOVF 7A,W
2280 0865: MOVWF 27
2281 0866: MOVF 27,W
2282 0867: MOVWF 49
2283 0868: MOVF 26,W
2284 0869: MOVWF 48
2285 086A: MOVF 25,W
2286 086B: MOVWF 47
2287 086C: MOVF 24,W
2288 086D: MOVWF 46
2289 086E: CLRF 4D
2290 086F: CLRF 4C
2291 0870: CLRF 4B
2292 0871: MOVLW 80
2293 0872: MOVWF 4A
2294 0873: BCF 0A.3
2295 0874: BCF 03.5
2296 0875: CALL 142
2297 0876: BSF 0A.3
2298 0877: MOVF 77,W
2299 0878: BSF 03.5
2300 0879: MOVWF 24
2301 087A: MOVF 78,W
2302 087B: MOVWF 25
2303 087C: MOVF 79,W
2304 087D: MOVWF 26
2305 087E: MOVF 7A,W
2306 087F: MOVWF 27
2307 0880: MOVF 27,W
2308 0881: MOVWF 2C
2309 0882: MOVF 26,W
2310 0883: MOVWF 2B
2311 0884: MOVF 25,W
2312 0885: MOVWF 2A
2313 0886: MOVF 24,W
2314 0887: MOVWF 29
2315 *
2316 0929: MOVF 7A,W
2317 092A: MOVWF 6F
2318 092B: MOVF 79,W
2319 092C: MOVWF 6E
2320 092D: MOVF 78,W
2321 092E: MOVWF 6D
2322 092F: MOVF 77,W
2323 0930: MOVWF 6C
2324 .................... n += 2;
2325 0931: MOVLW 02
2326 0932: ADDWF 6B,F
2327 .................... }
2328 ....................
2329 .................... y2=y*y;
2330 0933: MOVF 6F,W
2331 0934: BSF 03.5
2332 0935: MOVWF 4D
2333 0936: BCF 03.5
2334 0937: MOVF 6E,W
2335 0938: BSF 03.5
2336 0939: MOVWF 4C
2337 093A: BCF 03.5
2338 093B: MOVF 6D,W
2339 093C: BSF 03.5
2340 093D: MOVWF 4B
2341 093E: BCF 03.5
2342 093F: MOVF 6C,W
2343 0940: BSF 03.5
2344 0941: MOVWF 4A
2345 0942: BCF 03.5
2346 0943: MOVF 6F,W
2347 0944: BSF 03.5
2348 0945: MOVWF 51
2349 0946: BCF 03.5
2350 0947: MOVF 6E,W
2351 0948: BSF 03.5
2352 0949: MOVWF 50
2353 094A: BCF 03.5
2354 094B: MOVF 6D,W
2355 094C: BSF 03.5
2356 094D: MOVWF 4F
2357 094E: BCF 03.5
2358 094F: MOVF 6C,W
2359 0950: BSF 03.5
2360 0951: MOVWF 4E
2361 0952: BCF 0A.3
2362 0953: BCF 03.5
2363 0954: CALL 20E
2364 0955: BSF 0A.3
2365 0956: MOVF 7A,W
2366 0957: BSF 03.5
2367 0958: MOVWF 23
2368 0959: MOVF 79,W
2369 095A: MOVWF 22
2370 095B: MOVF 78,W
2371 095C: MOVWF 21
2372 095D: MOVF 77,W
2373 095E: MOVWF 20
2374 ....................
2375 .................... res = pas[0]*y2 + pas[1];
2376 095F: MOVLW 37
2377 0960: MOVWF 4D
2378 0961: MOVLW BF
2379 0962: MOVWF 4C
2380 0963: MOVLW 7D
2381 0964: MOVWF 4B
2382 0965: MOVWF 4A
2383 0966: MOVF 23,W
2384 0967: MOVWF 51
2385 0968: MOVF 22,W
2386 0969: MOVWF 50
2387 096A: MOVF 21,W
2388 096B: MOVWF 4F
2389 096C: MOVF 20,W
2390 096D: MOVWF 4E
2391 096E: BCF 0A.3
2392 096F: BCF 03.5
2393 0970: CALL 20E
2394 0971: BSF 0A.3
2395 0972: MOVF 77,W
2396 0973: BSF 03.5
2397 0974: MOVWF 24
2398 0975: MOVF 78,W
2399 0976: MOVWF 25
2400 0977: MOVF 79,W
2401 0978: MOVWF 26
2402 0979: MOVF 7A,W
2403 097A: MOVWF 27
2404 097B: BCF 03.1
2405 097C: MOVF 27,W
2406 097D: MOVWF 4D
2407 097E: MOVF 26,W
2408 097F: MOVWF 4C
2409 0980: MOVF 25,W
2410 0981: MOVWF 4B
2411 0982: MOVF 24,W
2412 0983: MOVWF 4A
2413 0984: MOVLW 3D
2414 0985: MOVWF 51
2415 0986: MOVLW AA
2416 0987: MOVWF 50
2417 0988: MOVLW 93
2418 0989: MOVWF 4F
2419 098A: MOVLW 81
2420 098B: MOVWF 4E
2421 098C: BCF 0A.3
2422 098D: BCF 03.5
2423 098E: CALL 2C7
2424 098F: BSF 0A.3
2425 0990: MOVF 7A,W
2426 0991: MOVWF 73
2427 0992: MOVF 79,W
2428 0993: MOVWF 72
2429 0994: MOVF 78,W
2430 0995: MOVWF 71
2431 0996: MOVF 77,W
2432 0997: MOVWF 70
2433 .................... res = res*y2 + pas[2];
2434 0998: MOVF 73,W
2435 0999: BSF 03.5
2436 099A: MOVWF 4D
2437 099B: MOVF 72,W
2438 099C: MOVWF 4C
2439 099D: MOVF 71,W
2440 099E: MOVWF 4B
2441 099F: MOVF 70,W
2442 09A0: MOVWF 4A
2443 09A1: MOVF 23,W
2444 09A2: MOVWF 51
2445 09A3: MOVF 22,W
2446 09A4: MOVWF 50
2447 09A5: MOVF 21,W
2448 09A6: MOVWF 4F
2449 09A7: MOVF 20,W
2450 09A8: MOVWF 4E
2451 09A9: BCF 0A.3
2452 09AA: BCF 03.5
2453 09AB: CALL 20E
2454 09AC: BSF 0A.3
2455 09AD: MOVF 77,W
2456 09AE: BSF 03.5
2457 09AF: MOVWF 24
2458 09B0: MOVF 78,W
2459 09B1: MOVWF 25
2460 09B2: MOVF 79,W
2461 09B3: MOVWF 26
2462 09B4: MOVF 7A,W
2463 09B5: MOVWF 27
2464 09B6: BCF 03.1
2465 09B7: MOVF 27,W
2466 09B8: MOVWF 4D
2467 09B9: MOVF 26,W
2468 09BA: MOVWF 4C
2469 09BB: MOVF 25,W
2470 09BC: MOVWF 4B
2471 09BD: MOVF 24,W
2472 09BE: MOVWF 4A
2473 09BF: MOVLW EE
2474 09C0: MOVWF 51
2475 09C1: MOVLW 50
2476 09C2: MOVWF 50
2477 09C3: MOVLW 33
2478 09C4: MOVWF 4F
2479 09C5: MOVLW 81
2480 09C6: MOVWF 4E
2481 09C7: BCF 0A.3
2482 09C8: BCF 03.5
2483 09C9: CALL 2C7
2484 09CA: BSF 0A.3
2485 09CB: MOVF 7A,W
2486 09CC: MOVWF 73
2487 09CD: MOVF 79,W
2488 09CE: MOVWF 72
2489 09CF: MOVF 78,W
2490 09D0: MOVWF 71
2491 09D1: MOVF 77,W
2492 09D2: MOVWF 70
2493 ....................
2494 .................... r = qas[0]*y2 + qas[1];
2495 09D3: BSF 03.5
2496 09D4: CLRF 4D
2497 09D5: CLRF 4C
2498 09D6: CLRF 4B
2499 09D7: MOVLW 7F
2500 09D8: MOVWF 4A
2501 09D9: MOVF 23,W
2502 09DA: MOVWF 51
2503 09DB: MOVF 22,W
2504 09DC: MOVWF 50
2505 09DD: MOVF 21,W
2506 09DE: MOVWF 4F
2507 09DF: MOVF 20,W
2508 09E0: MOVWF 4E
2509 09E1: BCF 0A.3
2510 09E2: BCF 03.5
2511 09E3: CALL 20E
2512 09E4: BSF 0A.3
2513 09E5: MOVF 77,W
2514 09E6: BSF 03.5
2515 09E7: MOVWF 24
2516 09E8: MOVF 78,W
2517 09E9: MOVWF 25
2518 09EA: MOVF 79,W
2519 09EB: MOVWF 26
2520 09EC: MOVF 7A,W
2521 09ED: MOVWF 27
2522 09EE: BCF 03.1
2523 09EF: MOVF 27,W
2524 09F0: MOVWF 4D
2525 09F1: MOVF 26,W
2526 09F2: MOVWF 4C
2527 09F3: MOVF 25,W
2528 09F4: MOVWF 4B
2529 09F5: MOVF 24,W
2530 09F6: MOVWF 4A
2531 09F7: MOVLW 0A
2532 09F8: MOVWF 51
2533 09F9: MOVLW 8D
2534 09FA: MOVWF 50
2535 09FB: MOVLW B1
2536 09FC: MOVWF 4F
2537 09FD: MOVLW 81
2538 09FE: MOVWF 4E
2539 09FF: BCF 0A.3
2540 0A00: BCF 03.5
2541 0A01: CALL 2C7
2542 0A02: BSF 0A.3
2543 0A03: MOVF 7A,W
2544 0A04: MOVWF 7E
2545 0A05: MOVF 79,W
2546 0A06: MOVWF 7D
2547 0A07: MOVF 78,W
2548 0A08: MOVWF 7C
2549 0A09: MOVF 77,W
2550 0A0A: MOVWF 7B
2551 .................... r = r*y2 + qas[2];
2552 0A0B: MOVF 7E,W
2553 0A0C: BSF 03.5
2554 0A0D: MOVWF 4D
2555 0A0E: MOVF 7D,W
2556 0A0F: MOVWF 4C
2557 0A10: MOVF 7C,W
2558 0A11: MOVWF 4B
2559 0A12: MOVF 7B,W
2560 0A13: MOVWF 4A
2561 0A14: MOVF 23,W
2562 0A15: MOVWF 51
2563 0A16: MOVF 22,W
2564 0A17: MOVWF 50
2565 0A18: MOVF 21,W
2566 0A19: MOVWF 4F
2567 0A1A: MOVF 20,W
2568 0A1B: MOVWF 4E
2569 0A1C: BCF 0A.3
2570 0A1D: BCF 03.5
2571 0A1E: CALL 20E
2572 0A1F: BSF 0A.3
2573 0A20: MOVF 77,W
2574 0A21: BSF 03.5
2575 0A22: MOVWF 24
2576 0A23: MOVF 78,W
2577 0A24: MOVWF 25
2578 0A25: MOVF 79,W
2579 0A26: MOVWF 26
2580 0A27: MOVF 7A,W
2581 0A28: MOVWF 27
2582 0A29: BCF 03.1
2583 0A2A: MOVF 27,W
2584 0A2B: MOVWF 4D
2585 0A2C: MOVF 26,W
2586 0A2D: MOVWF 4C
2587 0A2E: MOVF 25,W
2588 0A2F: MOVWF 4B
2589 0A30: MOVF 24,W
2590 0A31: MOVWF 4A
2591 0A32: MOVLW EE
2592 0A33: MOVWF 51
2593 0A34: MOVLW 50
2594 0A35: MOVWF 50
2595 0A36: MOVLW 33
2596 0A37: MOVWF 4F
2597 0A38: MOVLW 81
2598 0A39: MOVWF 4E
2599 0A3A: BCF 0A.3
2600 0A3B: BCF 03.5
2601 0A3C: CALL 2C7
2602 0A3D: BSF 0A.3
2603 0A3E: MOVF 7A,W
2604 0A3F: MOVWF 7E
2605 0A40: MOVF 79,W
2606 0A41: MOVWF 7D
2607 0A42: MOVF 78,W
2608 0A43: MOVWF 7C
2609 0A44: MOVF 77,W
2610 0A45: MOVWF 7B
2611 ....................
2612 .................... res = y*res/r;
2613 0A46: MOVF 6F,W
2614 0A47: BSF 03.5
2615 0A48: MOVWF 4D
2616 0A49: BCF 03.5
2617 0A4A: MOVF 6E,W
2618 0A4B: BSF 03.5
2619 0A4C: MOVWF 4C
2620 0A4D: BCF 03.5
2621 0A4E: MOVF 6D,W
2622 0A4F: BSF 03.5
2623 0A50: MOVWF 4B
2624 0A51: BCF 03.5
2625 0A52: MOVF 6C,W
2626 0A53: BSF 03.5
2627 0A54: MOVWF 4A
2628 0A55: MOVF 73,W
2629 0A56: MOVWF 51
2630 0A57: MOVF 72,W
2631 0A58: MOVWF 50
2632 0A59: MOVF 71,W
2633 0A5A: MOVWF 4F
2634 0A5B: MOVF 70,W
2635 0A5C: MOVWF 4E
2636 0A5D: BCF 0A.3
2637 0A5E: BCF 03.5
2638 0A5F: CALL 20E
2639 0A60: BSF 0A.3
2640 0A61: MOVF 77,W
2641 0A62: BSF 03.5
2642 0A63: MOVWF 24
2643 0A64: MOVF 78,W
2644 0A65: MOVWF 25
2645 0A66: MOVF 79,W
2646 0A67: MOVWF 26
2647 0A68: MOVF 7A,W
2648 0A69: MOVWF 27
2649 0A6A: MOVWF 49
2650 0A6B: MOVF 26,W
2651 0A6C: MOVWF 48
2652 0A6D: MOVF 25,W
2653 0A6E: MOVWF 47
2654 0A6F: MOVF 24,W
2655 0A70: MOVWF 46
2656 0A71: MOVF 7E,W
2657 0A72: MOVWF 4D
2658 0A73: MOVF 7D,W
2659 0A74: MOVWF 4C
2660 0A75: MOVF 7C,W
2661 0A76: MOVWF 4B
2662 0A77: MOVF 7B,W
2663 0A78: MOVWF 4A
2664 0A79: BCF 0A.3
2665 0A7A: BCF 03.5
2666 0A7B: CALL 142
2667 0A7C: BSF 0A.3
2668 0A7D: MOVF 7A,W
2669 0A7E: MOVWF 73
2670 0A7F: MOVF 79,W
2671 0A80: MOVWF 72
2672 0A81: MOVF 78,W
2673 0A82: MOVWF 71
2674 0A83: MOVF 77,W
2675 0A84: MOVWF 70
2676 ....................
2677 .................... if (n & 2) // |x| > 0.5
2678 0A85: BTFSS 6B.1
2679 0A86: GOTO 2B7
2680 .................... res = PI_DIV_BY_TWO - 2.0*res;
2681 0A87: BSF 03.5
2682 0A88: CLRF 4D
2683 0A89: CLRF 4C
2684 0A8A: CLRF 4B
2685 0A8B: MOVLW 80
2686 0A8C: MOVWF 4A
2687 0A8D: MOVF 73,W
2688 0A8E: MOVWF 51
2689 0A8F: MOVF 72,W
2690 0A90: MOVWF 50
2691 0A91: MOVF 71,W
2692 0A92: MOVWF 4F
2693 0A93: MOVF 70,W
2694 0A94: MOVWF 4E
2695 0A95: BCF 0A.3
2696 0A96: BCF 03.5
2697 0A97: CALL 20E
2698 0A98: BSF 0A.3
2699 0A99: BSF 03.1
2700 0A9A: MOVLW DB
2701 0A9B: BSF 03.5
2702 0A9C: MOVWF 4D
2703 0A9D: MOVLW 0F
2704 0A9E: MOVWF 4C
2705 0A9F: MOVLW 49
2706 0AA0: MOVWF 4B
2707 0AA1: MOVLW 7F
2708 0AA2: MOVWF 4A
2709 0AA3: MOVF 7A,W
2710 0AA4: MOVWF 51
2711 0AA5: MOVF 79,W
2712 0AA6: MOVWF 50
2713 0AA7: MOVF 78,W
2714 0AA8: MOVWF 4F
2715 0AA9: MOVF 77,W
2716 0AAA: MOVWF 4E
2717 0AAB: BCF 0A.3
2718 0AAC: BCF 03.5
2719 0AAD: CALL 2C7
2720 0AAE: BSF 0A.3
2721 0AAF: MOVF 7A,W
2722 0AB0: MOVWF 73
2723 0AB1: MOVF 79,W
2724 0AB2: MOVWF 72
2725 0AB3: MOVF 78,W
2726 0AB4: MOVWF 71
2727 0AB5: MOVF 77,W
2728 0AB6: MOVWF 70
2729 .................... if (s)
2730 0AB7: BTFSS 74.0
2731 0AB8: GOTO 2BC
2732 .................... res = -res;
2733 0AB9: MOVF 71,W
2734 0ABA: XORLW 80
2735 0ABB: MOVWF 71
2736 .................... if (n & 1) // take arccos
2737 0ABC: BTFSS 6B.0
2738 0ABD: GOTO 2DC
2739 .................... res = PI_DIV_BY_TWO - res;
2740 0ABE: BSF 03.1
2741 0ABF: MOVLW DB
2742 0AC0: BSF 03.5
2743 0AC1: MOVWF 4D
2744 0AC2: MOVLW 0F
2745 0AC3: MOVWF 4C
2746 0AC4: MOVLW 49
2747 0AC5: MOVWF 4B
2748 0AC6: MOVLW 7F
2749 0AC7: MOVWF 4A
2750 0AC8: MOVF 73,W
2751 0AC9: MOVWF 51
2752 0ACA: MOVF 72,W
2753 0ACB: MOVWF 50
2754 0ACC: MOVF 71,W
2755 0ACD: MOVWF 4F
2756 0ACE: MOVF 70,W
2757 0ACF: MOVWF 4E
2758 0AD0: BCF 0A.3
2759 0AD1: BCF 03.5
2760 0AD2: CALL 2C7
2761 0AD3: BSF 0A.3
2762 0AD4: MOVF 7A,W
2763 0AD5: MOVWF 73
2764 0AD6: MOVF 79,W
2765 0AD7: MOVWF 72
2766 0AD8: MOVF 78,W
2767 0AD9: MOVWF 71
2768 0ADA: MOVF 77,W
2769 0ADB: MOVWF 70
2770 ....................
2771 .................... return(res);
2772 0ADC: MOVF 70,W
2773 0ADD: MOVWF 77
2774 0ADE: MOVF 71,W
2775 0ADF: MOVWF 78
2776 0AE0: MOVF 72,W
2777 0AE1: MOVWF 79
2778 0AE2: MOVF 73,W
2779 0AE3: MOVWF 7A
2780 .................... }
2781 0AE4: RETURN
2782 ....................
2783 .................... //Overloaded functions for ASIN_COS() for PCD
2784 .................... // Overloaded function ASIN_COS() for data type - Float48
2785 .................... #if defined(__PCD__)
2786 .................... float48 ASIN_COS(float48 x, unsigned int8 n)
2787 .................... {
2788 .................... float48 y, res, r, y2;
2789 .................... int1 s;
2790 .................... #ifdef _ERRNO
2791 .................... if(x <-1 || x > 1)
2792 .................... {
2793 .................... errno=EDOM;
2794 .................... }
2795 .................... #endif
2796 .................... s = 0;
2797 .................... y = x;
2798 ....................
2799 .................... if (x < 0)
2800 .................... {
2801 .................... s = 1;
2802 .................... y = -y;
2803 .................... }
2804 ....................
2805 .................... if (y > 0.5)
2806 .................... {
2807 .................... y = sqrt((1.0 - y)/2.0);
2808 .................... n += 2;
2809 .................... }
2810 ....................
2811 .................... y2=y*y;
2812 ....................
2813 .................... res = pas[0]*y2 + pas[1];
2814 .................... res = res*y2 + pas[2];
2815 ....................
2816 .................... r = qas[0]*y2 + qas[1];
2817 .................... r = r*y2 + qas[2];
2818 ....................
2819 .................... res = y*res/r;
2820 ....................
2821 .................... if (n & 2) // |x| > 0.5
2822 .................... res = PI_DIV_BY_TWO - 2.0*res;
2823 .................... if (s)
2824 .................... res = -res;
2825 .................... if (n & 1) // take arccos
2826 .................... res = PI_DIV_BY_TWO - res;
2827 ....................
2828 .................... return(res);
2829 .................... }
2830 ....................
2831 .................... // Overloaded function ASIN_COS() for data type - Float64
2832 .................... float64 ASIN_COS(float64 x, unsigned int8 n)
2833 .................... {
2834 .................... float64 y, res, r, y2;
2835 .................... int1 s;
2836 .................... #ifdef _ERRNO
2837 .................... if(x <-1 || x > 1)
2838 .................... {
2839 .................... errno=EDOM;
2840 .................... }
2841 .................... #endif
2842 .................... s = 0;
2843 .................... y = x;
2844 ....................
2845 .................... if (x < 0)
2846 .................... {
2847 .................... s = 1;
2848 .................... y = -y;
2849 .................... }
2850 ....................
2851 .................... if (y > 0.5)
2852 .................... {
2853 .................... y = sqrt((1.0 - y)/2.0);
2854 .................... n += 2;
2855 .................... }
2856 ....................
2857 .................... y2=y*y;
2858 ....................
2859 .................... res = pas[0]*y2 + pas[1];
2860 .................... res = res*y2 + pas[2];
2861 ....................
2862 .................... r = qas[0]*y2 + qas[1];
2863 .................... r = r*y2 + qas[2];
2864 ....................
2865 .................... res = y*res/r;
2866 ....................
2867 .................... if (n & 2) // |x| > 0.5
2868 .................... res = PI_DIV_BY_TWO - 2.0*res;
2869 .................... if (s)
2870 .................... res = -res;
2871 .................... if (n & 1) // take arccos
2872 .................... res = PI_DIV_BY_TWO - res;
2873 ....................
2874 .................... return(res);
2875 .................... }
2876 .................... #endif
2877 ....................
2878 .................... ////////////////////////////////////////////////////////////////////////////
2879 .................... // float asin(float x)
2880 .................... ////////////////////////////////////////////////////////////////////////////
2881 .................... // Description : returns the arcsine value of the value x.
2882 .................... // Date : N/A
2883 .................... //
2884 .................... float32 asin(float32 x)
2885 .................... {
2886 .................... float32 r;
2887 ....................
2888 .................... r = ASIN_COS(x, 0);
2889 *
2890 15B6: MOVF 62,W
2891 15B7: MOVWF 6A
2892 15B8: MOVF 61,W
2893 15B9: MOVWF 69
2894 15BA: MOVF 60,W
2895 15BB: MOVWF 68
2896 15BC: MOVF 5F,W
2897 15BD: MOVWF 67
2898 15BE: CLRF 6B
2899 15BF: BCF 0A.4
2900 15C0: BSF 0A.3
2901 15C1: CALL 000
2902 15C2: BSF 0A.4
2903 15C3: BCF 0A.3
2904 15C4: MOVF 7A,W
2905 15C5: MOVWF 66
2906 15C6: MOVF 79,W
2907 15C7: MOVWF 65
2908 15C8: MOVF 78,W
2909 15C9: MOVWF 64
2910 15CA: MOVF 77,W
2911 15CB: MOVWF 63
2912 .................... return(r);
2913 15CC: MOVF 63,W
2914 15CD: MOVWF 77
2915 15CE: MOVF 64,W
2916 15CF: MOVWF 78
2917 15D0: MOVF 65,W
2918 15D1: MOVWF 79
2919 15D2: MOVF 66,W
2920 15D3: MOVWF 7A
2921 .................... }
2922 .................... //Overloaded functions for asin() for PCD
2923 .................... // Overloaded function asin() for data type - Float48
2924 .................... #if defined(__PCD__)
2925 .................... float48 asin(float48 x)
2926 .................... {
2927 .................... float48 r;
2928 ....................
2929 .................... r = ASIN_COS(x, 0);
2930 .................... return(r);
2931 .................... }
2932 ....................
2933 .................... // Overloaded function asin() for data type - Float64
2934 .................... float64 asin(float64 x)
2935 .................... {
2936 .................... float64 r;
2937 ....................
2938 .................... r = ASIN_COS(x, 0);
2939 .................... return(r);
2940 .................... }
2941 .................... #endif
2942 ....................
2943 .................... ////////////////////////////////////////////////////////////////////////////
2944 .................... // float acos(float x)
2945 .................... ////////////////////////////////////////////////////////////////////////////
2946 .................... // Description : returns the arccosine value of the value x.
2947 .................... // Date : N/A
2948 .................... //
2949 .................... float32 acos(float32 x)
2950 .................... {
2951 .................... float32 r;
2952 ....................
2953 .................... r = ASIN_COS(x, 1);
2954 *
2955 16E9: MOVF 62,W
2956 16EA: MOVWF 6A
2957 16EB: MOVF 61,W
2958 16EC: MOVWF 69
2959 16ED: MOVF 60,W
2960 16EE: MOVWF 68
2961 16EF: MOVF 5F,W
2962 16F0: MOVWF 67
2963 16F1: MOVLW 01
2964 16F2: MOVWF 6B
2965 16F3: BCF 0A.4
2966 16F4: BSF 0A.3
2967 16F5: CALL 000
2968 16F6: BSF 0A.4
2969 16F7: BCF 0A.3
2970 16F8: MOVF 7A,W
2971 16F9: MOVWF 66
2972 16FA: MOVF 79,W
2973 16FB: MOVWF 65
2974 16FC: MOVF 78,W
2975 16FD: MOVWF 64
2976 16FE: MOVF 77,W
2977 16FF: MOVWF 63
2978 .................... return(r);
2979 1700: MOVF 63,W
2980 1701: MOVWF 77
2981 1702: MOVF 64,W
2982 1703: MOVWF 78
2983 1704: MOVF 65,W
2984 1705: MOVWF 79
2985 1706: MOVF 66,W
2986 1707: MOVWF 7A
2987 .................... }
2988 .................... //Overloaded functions for acos() for PCD
2989 .................... // Overloaded function acos() for data type - Float48
2990 .................... #if defined(__PCD__)
2991 .................... float48 acos(float48 x)
2992 .................... {
2993 .................... float48 r;
2994 ....................
2995 .................... r = ASIN_COS(x, 1);
2996 .................... return(r);
2997 .................... }
2998 ....................
2999 .................... // Overloaded function acos() for data type - Float64
3000 .................... float64 acos(float64 x)
3001 .................... {
3002 .................... float64 r;
3003 ....................
3004 .................... r = ASIN_COS(x, 1);
3005 .................... return(r);
3006 .................... }
3007 .................... #endif
3008 ....................
3009 .................... float32 const pat[4] = {0.17630401, 5.6710795, 22.376096, 19.818457};
3010 .................... float32 const qat[4] = {1.0000000, 11.368190, 28.982246, 19.818457};
3011 ....................
3012 .................... ////////////////////////////////////////////////////////////////////////////
3013 .................... // float atan(float x)
3014 .................... ////////////////////////////////////////////////////////////////////////////
3015 .................... // Description : returns the arctangent value of the value x.
3016 .................... // Date : N/A
3017 .................... //
3018 .................... float32 atan(float32 x)
3019 .................... {
3020 .................... float32 y, res, r;
3021 .................... int1 s, flag;
3022 ....................
3023 .................... s = 0;
3024 .................... flag = 0;
3025 .................... y = x;
3026 ....................
3027 .................... if (x < 0)
3028 .................... {
3029 .................... s = 1;
3030 .................... y = -y;
3031 .................... }
3032 ....................
3033 .................... if (y > 1.0)
3034 .................... {
3035 .................... y = 1.0/y;
3036 .................... flag = 1;
3037 .................... }
3038 ....................
3039 .................... res = pat[0]*y*y + pat[1];
3040 .................... res = res*y*y + pat[2];
3041 .................... res = res*y*y + pat[3];
3042 ....................
3043 .................... r = qat[0]*y*y + qat[1];
3044 .................... r = r*y*y + qat[2];
3045 .................... r = r*y*y + qat[3];
3046 ....................
3047 .................... res = y*res/r;
3048 ....................
3049 ....................
3050 .................... if (flag) // for |x| > 1
3051 .................... res = PI_DIV_BY_TWO - res;
3052 .................... if (s)
3053 .................... res = -res;
3054 ....................
3055 .................... return(res);
3056 .................... }
3057 .................... //Overloaded functions for atan() for PCD
3058 .................... // Overloaded function atan() for data type - Float48
3059 .................... #if defined(__PCD__)
3060 .................... float48 atan(float48 x)
3061 .................... {
3062 .................... float48 y, res, r;
3063 .................... int1 s, flag;
3064 ....................
3065 .................... s = 0;
3066 .................... flag = 0;
3067 .................... y = x;
3068 ....................
3069 .................... if (x < 0)
3070 .................... {
3071 .................... s = 1;
3072 .................... y = -y;
3073 .................... }
3074 ....................
3075 .................... if (y > 1.0)
3076 .................... {
3077 .................... y = 1.0/y;
3078 .................... flag = 1;
3079 .................... }
3080 ....................
3081 .................... res = pat[0]*y*y + pat[1];
3082 .................... res = res*y*y + pat[2];
3083 .................... res = res*y*y + pat[3];
3084 ....................
3085 .................... r = qat[0]*y*y + qat[1];
3086 .................... r = r*y*y + qat[2];
3087 .................... r = r*y*y + qat[3];
3088 ....................
3089 .................... res = y*res/r;
3090 ....................
3091 ....................
3092 .................... if (flag) // for |x| > 1
3093 .................... res = PI_DIV_BY_TWO - res;
3094 .................... if (s)
3095 .................... res = -res;
3096 ....................
3097 .................... return(res);
3098 .................... }
3099 ....................
3100 .................... // Overloaded function atan() for data type - Float64
3101 .................... float64 atan(float64 x)
3102 .................... {
3103 .................... float64 y, res, r;
3104 .................... int1 s, flag;
3105 ....................
3106 .................... s = 0;
3107 .................... flag = 0;
3108 .................... y = x;
3109 ....................
3110 .................... if (x < 0)
3111 .................... {
3112 .................... s = 1;
3113 .................... y = -y;
3114 .................... }
3115 ....................
3116 .................... if (y > 1.0)
3117 .................... {
3118 .................... y = 1.0/y;
3119 .................... flag = 1;
3120 .................... }
3121 ....................
3122 .................... res = pat[0]*y*y + pat[1];
3123 .................... res = res*y*y + pat[2];
3124 .................... res = res*y*y + pat[3];
3125 ....................
3126 .................... r = qat[0]*y*y + qat[1];
3127 .................... r = r*y*y + qat[2];
3128 .................... r = r*y*y + qat[3];
3129 ....................
3130 .................... res = y*res/r;
3131 ....................
3132 ....................
3133 .................... if (flag) // for |x| > 1
3134 .................... res = PI_DIV_BY_TWO - res;
3135 .................... if (s)
3136 .................... res = -res;
3137 ....................
3138 .................... return(res);
3139 .................... }
3140 .................... #endif
3141 ....................
3142 .................... /////////////////////////////////////////////////////////////////////////////
3143 .................... // float atan2(float y, float x)
3144 .................... /////////////////////////////////////////////////////////////////////////////
3145 .................... // Description :computes the principal value of arc tangent of y/x, using the
3146 .................... // signs of both the arguments to determine the quadrant of the return value
3147 .................... // Returns : returns the arc tangent of y/x.
3148 .................... // Date : N/A
3149 .................... //
3150 ....................
3151 .................... float32 atan2(float32 y,float32 x)
3152 .................... {
3153 .................... float32 z;
3154 .................... int1 sign;
3155 .................... unsigned int8 quad;
3156 .................... sign=0;
3157 .................... quad=0; //quadrant
3158 .................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));
3159 .................... if(y<0.0)
3160 .................... {
3161 .................... sign=1;
3162 .................... y=-y;
3163 .................... }
3164 .................... if(x<0.0)
3165 .................... {
3166 .................... x=-x;
3167 .................... }
3168 .................... if (x==0.0)
3169 .................... {
3170 .................... if(y==0.0)
3171 .................... {
3172 .................... #ifdef _ERRNO
3173 .................... {
3174 .................... errno=EDOM;
3175 .................... }
3176 .................... #endif
3177 .................... }
3178 .................... else
3179 .................... {
3180 .................... if(sign)
3181 .................... {
3182 .................... return (-(PI_DIV_BY_TWO));
3183 .................... }
3184 .................... else
3185 .................... {
3186 .................... return (PI_DIV_BY_TWO);
3187 .................... }
3188 .................... }
3189 .................... }
3190 .................... else
3191 .................... {
3192 .................... z=y/x;
3193 .................... switch(quad)
3194 .................... {
3195 .................... case 1:
3196 .................... {
3197 .................... return atan(z);
3198 .................... break;
3199 .................... }
3200 .................... case 2:
3201 .................... {
3202 .................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122
3203 .................... return (PI-atan(z));
3204 .................... break;
3205 .................... }
3206 .................... case 3:
3207 .................... {
3208 .................... return (atan(z)-PI);
3209 .................... break;
3210 .................... }
3211 .................... case 4:
3212 .................... {
3213 .................... return (-atan(z));
3214 .................... break;
3215 .................... }
3216 .................... }
3217 .................... }
3218 .................... }
3219 ....................
3220 .................... //Overloaded functions for atan2() for PCD
3221 .................... // Overloaded function atan2() for data type - Float48
3222 .................... #if defined(__PCD__)
3223 .................... float48 atan2(float48 y,float48 x)
3224 .................... {
3225 .................... float48 z;
3226 .................... int1 sign;
3227 .................... unsigned int8 quad;
3228 .................... sign=0;
3229 .................... quad=0; //quadrant
3230 .................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));
3231 .................... if(y<0.0)
3232 .................... {
3233 .................... sign=1;
3234 .................... y=-y;
3235 .................... }
3236 .................... if(x<0.0)
3237 .................... {
3238 .................... x=-x;
3239 .................... }
3240 .................... if (x==0.0)
3241 .................... {
3242 .................... if(y==0.0)
3243 .................... {
3244 .................... #ifdef _ERRNO
3245 .................... {
3246 .................... errno=EDOM;
3247 .................... }
3248 .................... #endif
3249 .................... }
3250 .................... else
3251 .................... {
3252 .................... if(sign)
3253 .................... {
3254 .................... return (-(PI_DIV_BY_TWO));
3255 .................... }
3256 .................... else
3257 .................... {
3258 .................... return (PI_DIV_BY_TWO);
3259 .................... }
3260 .................... }
3261 .................... }
3262 .................... else
3263 .................... {
3264 .................... z=y/x;
3265 .................... switch(quad)
3266 .................... {
3267 .................... case 1:
3268 .................... {
3269 .................... return atan(z);
3270 .................... break;
3271 .................... }
3272 .................... case 2:
3273 .................... {
3274 .................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122
3275 .................... return (PI-atan(z));
3276 .................... break;
3277 .................... }
3278 .................... case 3:
3279 .................... {
3280 .................... return (atan(z)-PI);
3281 .................... break;
3282 .................... }
3283 .................... case 4:
3284 .................... {
3285 .................... return (-atan(z));
3286 .................... break;
3287 .................... }
3288 .................... }
3289 .................... }
3290 .................... }
3291 ....................
3292 .................... // Overloaded function atan2() for data type - Float64
3293 .................... float64 atan2(float64 y,float64 x)
3294 .................... {
3295 .................... float64 z;
3296 .................... int1 sign;
3297 .................... unsigned int8 quad;
3298 .................... sign=0;
3299 .................... quad=0; //quadrant
3300 .................... quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));
3301 .................... if(y<0.0)
3302 .................... {
3303 .................... sign=1;
3304 .................... y=-y;
3305 .................... }
3306 .................... if(x<0.0)
3307 .................... {
3308 .................... x=-x;
3309 .................... }
3310 .................... if (x==0.0)
3311 .................... {
3312 .................... if(y==0.0)
3313 .................... {
3314 .................... #ifdef _ERRNO
3315 .................... {
3316 .................... errno=EDOM;
3317 .................... }
3318 .................... #endif
3319 .................... }
3320 .................... else
3321 .................... {
3322 .................... if(sign)
3323 .................... {
3324 .................... return (-(PI_DIV_BY_TWO));
3325 .................... }
3326 .................... else
3327 .................... {
3328 .................... return (PI_DIV_BY_TWO);
3329 .................... }
3330 .................... }
3331 .................... }
3332 .................... else
3333 .................... {
3334 .................... z=y/x;
3335 .................... switch(quad)
3336 .................... {
3337 .................... case 1:
3338 .................... {
3339 .................... return atan(z);
3340 .................... break;
3341 .................... }
3342 .................... case 2:
3343 .................... {
3344 .................... // return (atan(z)+PI_DIV_BY_TWO); //2L3122
3345 .................... return (PI-atan(z));
3346 .................... break;
3347 .................... }
3348 .................... case 3:
3349 .................... {
3350 .................... return (atan(z)-PI);
3351 .................... break;
3352 .................... }
3353 .................... case 4:
3354 .................... {
3355 .................... return (-atan(z));
3356 .................... break;
3357 .................... }
3358 .................... }
3359 .................... }
3360 .................... }
3361 .................... #endif
3362 ....................
3363 .................... //////////////////// Hyperbolic functions ////////////////////
3364 ....................
3365 .................... ////////////////////////////////////////////////////////////////////////////
3366 .................... // float cosh(float x)
3367 .................... ////////////////////////////////////////////////////////////////////////////
3368 .................... // Description : Computes the hyperbolic cosine value of x
3369 .................... // Returns : returns the hyperbolic cosine value of x
3370 .................... // Date : N/A
3371 .................... //
3372 ....................
3373 .................... float32 cosh(float32 x)
3374 .................... {
3375 .................... return ((exp(x)+exp(-x))/2);
3376 .................... }
3377 .................... //Overloaded functions for cosh() for PCD
3378 .................... // Overloaded function cosh() for data type - Float48
3379 .................... #if defined(__PCD__)
3380 .................... float48 cosh(float48 x)
3381 .................... {
3382 .................... return ((exp(x)+exp(-x))/2);
3383 .................... }
3384 ....................
3385 .................... // Overloaded function cosh() for data type - Float64
3386 .................... float64 cosh(float64 x)
3387 .................... {
3388 .................... return ((exp(x)+exp(-x))/2);
3389 .................... }
3390 .................... #endif
3391 ....................
3392 .................... ////////////////////////////////////////////////////////////////////////////
3393 .................... // float sinh(float x)
3394 .................... ////////////////////////////////////////////////////////////////////////////
3395 .................... // Description : Computes the hyperbolic sine value of x
3396 .................... // Returns : returns the hyperbolic sine value of x
3397 .................... // Date : N/A
3398 .................... //
3399 ....................
3400 .................... float32 sinh(float32 x)
3401 .................... {
3402 ....................
3403 .................... return ((exp(x) - exp(-x))/2);
3404 .................... }
3405 .................... //Overloaded functions for sinh() for PCD
3406 .................... // Overloaded function sinh() for data type - Float48
3407 .................... #if defined(__PCD__)
3408 .................... float48 sinh(float48 x)
3409 .................... {
3410 ....................
3411 .................... return ((exp(x) - exp(-x))/2);
3412 .................... }
3413 ....................
3414 .................... // Overloaded function sinh() for data type - Float48
3415 .................... float64 sinh(float64 x)
3416 .................... {
3417 ....................
3418 .................... return ((exp(x) - exp(-x))/2);
3419 .................... }
3420 .................... #endif
3421 ....................
3422 .................... ////////////////////////////////////////////////////////////////////////////
3423 .................... // float tanh(float x)
3424 .................... ////////////////////////////////////////////////////////////////////////////
3425 .................... // Description : Computes the hyperbolic tangent value of x
3426 .................... // Returns : returns the hyperbolic tangent value of x
3427 .................... // Date : N/A
3428 .................... //
3429 ....................
3430 .................... float32 tanh(float32 x)
3431 .................... {
3432 .................... return(sinh(x)/cosh(x));
3433 .................... }
3434 .................... //Overloaded functions for tanh() for PCD
3435 .................... // Overloaded function tanh() for data type - Float48
3436 .................... #if defined(__PCD__)
3437 .................... float48 tanh(float48 x)
3438 .................... {
3439 .................... return(sinh(x)/cosh(x));
3440 .................... }
3441 ....................
3442 .................... // Overloaded function tanh() for data type - Float64
3443 .................... float64 tanh(float64 x)
3444 .................... {
3445 .................... return(sinh(x)/cosh(x));
3446 .................... }
3447 .................... #endif
3448 ....................
3449 .................... ////////////////////////////////////////////////////////////////////////////
3450 .................... // float frexp(float x, signed int *exp)
3451 .................... ////////////////////////////////////////////////////////////////////////////
3452 .................... // Description : breaks a floating point number into a normalized fraction and an integral
3453 .................... // power of 2. It stores the integer in the signed int object pointed to by exp.
3454 .................... // Returns : returns the value x, such that x is a double with magnitude in the interval
3455 .................... // [1/2,1) or zero, and value equals x times 2 raised to the power *exp.If value is zero,
3456 .................... // both parts of the result are zero.
3457 .................... // Date : N/A
3458 .................... //
3459 ....................
3460 .................... #define LOG2 .30102999566398119521
3461 .................... float32 frexp(float32 x, signed int8 *exp)
3462 .................... {
3463 .................... float32 res;
3464 .................... int1 sign = 0;
3465 .................... if(x == 0.0)
3466 .................... {
3467 .................... *exp=0;
3468 .................... return (0.0);
3469 .................... }
3470 .................... if(x < 0.0)
3471 .................... {
3472 .................... x=-x;
3473 .................... sign=1;
3474 .................... }
3475 .................... if (x > 1.0)
3476 .................... {
3477 .................... *exp=(ceil(log10(x)/LOG2));
3478 .................... res=x/(pow(2, *exp));
3479 .................... if (res == 1)
3480 .................... {
3481 .................... *exp=*exp+1;
3482 .................... res=.5;
3483 .................... }
3484 .................... }
3485 .................... else
3486 .................... {
3487 .................... if(x < 0.5)
3488 .................... {
3489 .................... *exp=-1;
3490 .................... res=x*2;
3491 .................... }
3492 .................... else
3493 .................... {
3494 .................... *exp=0;
3495 .................... res=x;
3496 .................... }
3497 .................... }
3498 .................... if(sign)
3499 .................... {
3500 .................... res=-res;
3501 .................... }
3502 .................... return res;
3503 .................... }
3504 ....................
3505 .................... //Overloaded functions for frexp() for PCD
3506 .................... // Overloaded function frexp() for data type - Float48
3507 .................... #if defined(__PCD__)
3508 .................... float48 frexp(float48 x, signed int8 *exp)
3509 .................... {
3510 .................... float48 res;
3511 .................... int1 sign = 0;
3512 .................... if(x == 0.0)
3513 .................... {
3514 .................... *exp=0;
3515 .................... return (0.0);
3516 .................... }
3517 .................... if(x < 0.0)
3518 .................... {
3519 .................... x=-x;
3520 .................... sign=1;
3521 .................... }
3522 .................... if (x > 1.0)
3523 .................... {
3524 .................... *exp=(ceil(log10(x)/LOG2));
3525 .................... res=x/(pow(2, *exp));
3526 .................... if (res == 1)
3527 .................... {
3528 .................... *exp=*exp+1;
3529 .................... res=.5;
3530 .................... }
3531 .................... }
3532 .................... else
3533 .................... {
3534 .................... if(x < 0.5)
3535 .................... {
3536 .................... *exp=-1;
3537 .................... res=x*2;
3538 .................... }
3539 .................... else
3540 .................... {
3541 .................... *exp=0;
3542 .................... res=x;
3543 .................... }
3544 .................... }
3545 .................... if(sign)
3546 .................... {
3547 .................... res=-res;
3548 .................... }
3549 .................... return res;
3550 .................... }
3551 ....................
3552 .................... // Overloaded function frexp() for data type - Float64
3553 .................... float64 frexp(float64 x, signed int8 *exp)
3554 .................... {
3555 .................... float64 res;
3556 .................... int1 sign = 0;
3557 .................... if(x == 0.0)
3558 .................... {
3559 .................... *exp=0;
3560 .................... return (0.0);
3561 .................... }
3562 .................... if(x < 0.0)
3563 .................... {
3564 .................... x=-x;
3565 .................... sign=1;
3566 .................... }
3567 .................... if (x > 1.0)
3568 .................... {
3569 .................... *exp=(ceil(log10(x)/LOG2));
3570 .................... res=x/(pow(2, *exp));
3571 .................... if (res == 1)
3572 .................... {
3573 .................... *exp=*exp+1;
3574 .................... res=.5;
3575 .................... }
3576 .................... }
3577 .................... else
3578 .................... {
3579 .................... if(x < 0.5)
3580 .................... {
3581 .................... *exp=-1;
3582 .................... res=x*2;
3583 .................... }
3584 .................... else
3585 .................... {
3586 .................... *exp=0;
3587 .................... res=x;
3588 .................... }
3589 .................... }
3590 .................... if(sign)
3591 .................... {
3592 .................... res=-res;
3593 .................... }
3594 .................... return res;
3595 .................... }
3596 .................... #endif
3597 ....................
3598 .................... //////////////////////////////////////////////////////////////////////////////
3599 .................... // float ldexp(float x, signed int *exp)
3600 .................... //////////////////////////////////////////////////////////////////////////////
3601 .................... // Description : multiplies a floating point number by an integral power of 2.
3602 .................... // Returns : returns the value of x times 2 raised to the power exp.
3603 .................... // Date : N/A
3604 .................... //
3605 ....................
3606 .................... float32 ldexp(float32 value, signed int8 exp)
3607 .................... {
3608 .................... return (value * pow(2,exp));
3609 .................... }
3610 .................... //Overloaded functions for ldexp() for PCD
3611 .................... // Overloaded function ldexp() for data type - Float48
3612 ....................
3613 .................... #if defined(__PCD__)
3614 .................... float48 ldexp(float48 value, signed int8 exp)
3615 .................... {
3616 .................... return (value * pow(2,exp));
3617 .................... }
3618 .................... // Overloaded function ldexp() for data type - Float64
3619 .................... float64 ldexp(float64 value, signed int8 exp)
3620 .................... {
3621 .................... return (value * pow(2,exp));
3622 .................... }
3623 .................... #endif
3624 ....................
3625 .................... #endif
3626 ....................
3627 ....................
3628 .................... #define PIN_SDA PIN_B0
3629 .................... #define PIN_SCL PIN_B1
3630 .................... #use i2c(master, sda=PIN_SDA, scl=PIN_SCL)
3631 .................... //set RS232
3632 .................... #use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD
3633 *
3634 004F: BCF 20.7
3635 0050: MOVF 20,W
3636 0051: BSF 03.5
3637 0052: MOVWF 07
3638 0053: BCF 03.5
3639 0054: BCF 07.7
3640 0055: MOVLW 08
3641 0056: MOVWF 78
3642 0057: GOTO 058
3643 0058: NOP
3644 0059: BSF 78.7
3645 005A: GOTO 069
3646 005B: BCF 78.7
3647 005C: RRF 65,F
3648 005D: BTFSC 03.0
3649 005E: BSF 07.7
3650 005F: BTFSS 03.0
3651 0060: BCF 07.7
3652 0061: BSF 78.6
3653 0062: GOTO 069
3654 0063: BCF 78.6
3655 0064: DECFSZ 78,F
3656 0065: GOTO 05C
3657 0066: GOTO 067
3658 0067: NOP
3659 0068: BSF 07.7
3660 0069: MOVLW 3F
3661 006A: MOVWF 04
3662 006B: DECFSZ 04,F
3663 006C: GOTO 06B
3664 006D: NOP
3665 006E: BTFSC 78.7
3666 006F: GOTO 05B
3667 0070: BTFSC 78.6
3668 0071: GOTO 063
3669 0072: RETURN
3670 ....................
3671 ....................
3672 .................... signed int16 AZIMUT;
3673 .................... signed int ELEVACE;
3674 ....................
3675 .................... int stupne (float rad)
3676 .................... {
3677 *
3678 066F: MOVF 5C,W
3679 0670: BSF 03.5
3680 0671: MOVWF 49
3681 0672: BCF 03.5
3682 0673: MOVF 5B,W
3683 0674: BSF 03.5
3684 0675: MOVWF 48
3685 0676: BCF 03.5
3686 0677: MOVF 5A,W
3687 0678: BSF 03.5
3688 0679: MOVWF 47
3689 067A: BCF 03.5
3690 067B: MOVF 59,W
3691 067C: BSF 03.5
3692 067D: MOVWF 46
3693 067E: MOVLW C3
3694 067F: MOVWF 4D
3695 0680: MOVLW F5
3696 0681: MOVWF 4C
3697 0682: MOVLW 48
3698 0683: MOVWF 4B
3699 0684: MOVLW 80
3700 0685: MOVWF 4A
3701 0686: BCF 03.5
3702 0687: CALL 142
3703 *
3704 06B1: MOVF 78,W
3705 06B2: MOVWF 5D
3706 .................... int a =(int) ((rad/3.14)*180);
3707 .................... return a;
3708 06B3: MOVF 5D,W
3709 06B4: MOVWF 78
3710 .................... }
3711 06B5: RETURN
3712 ....................
3713 .................... float rad (float stup)
3714 .................... {
3715 *
3716 0285: MOVF 6E,W
3717 0286: BSF 03.5
3718 0287: MOVWF 49
3719 0288: BCF 03.5
3720 0289: MOVF 6D,W
3721 028A: BSF 03.5
3722 028B: MOVWF 48
3723 028C: BCF 03.5
3724 028D: MOVF 6C,W
3725 028E: BSF 03.5
3726 028F: MOVWF 47
3727 0290: BCF 03.5
3728 0291: MOVF 6B,W
3729 0292: BSF 03.5
3730 0293: MOVWF 46
3731 0294: CLRF 4D
3732 0295: CLRF 4C
3733 0296: MOVLW 34
3734 0297: MOVWF 4B
3735 0298: MOVLW 86
3736 0299: MOVWF 4A
3737 029A: BCF 03.5
3738 029B: CALL 142
3739 *
3740 02B6: MOVF 7A,W
3741 02B7: MOVWF 72
3742 02B8: MOVF 79,W
3743 02B9: MOVWF 71
3744 02BA: MOVF 78,W
3745 02BB: MOVWF 70
3746 02BC: MOVF 77,W
3747 02BD: MOVWF 6F
3748 .................... float a = ((stup/180)*3.14);
3749 .................... return a;
3750 02BE: MOVF 6F,W
3751 02BF: MOVWF 77
3752 02C0: MOVF 70,W
3753 02C1: MOVWF 78
3754 02C2: MOVF 71,W
3755 02C3: MOVWF 79
3756 02C4: MOVF 72,W
3757 02C5: MOVWF 7A
3758 .................... }
3759 02C6: RETURN
3760 ....................
3761 .................... //provede vypocet dnu od zacatku roku
3762 .................... int16 den (int m, int16 d) //vstupem je mesic a den
3763 .................... {
3764 .................... switch (m) {
3765 *
3766 101D: MOVF 59,W
3767 101E: XORLW 01
3768 101F: BTFSC 03.2
3769 1020: GOTO 043
3770 1021: XORLW 03
3771 1022: BTFSC 03.2
3772 1023: GOTO 044
3773 1024: XORLW 01
3774 1025: BTFSC 03.2
3775 1026: GOTO 049
3776 1027: XORLW 07
3777 1028: BTFSC 03.2
3778 1029: GOTO 04E
3779 102A: XORLW 01
3780 102B: BTFSC 03.2
3781 102C: GOTO 053
3782 102D: XORLW 03
3783 102E: BTFSC 03.2
3784 102F: GOTO 058
3785 1030: XORLW 01
3786 1031: BTFSC 03.2
3787 1032: GOTO 05D
3788 1033: XORLW 0F
3789 1034: BTFSC 03.2
3790 1035: GOTO 062
3791 1036: XORLW 01
3792 1037: BTFSC 03.2
3793 1038: GOTO 067
3794 1039: XORLW 03
3795 103A: BTFSC 03.2
3796 103B: GOTO 06C
3797 103C: XORLW 01
3798 103D: BTFSC 03.2
3799 103E: GOTO 073
3800 103F: XORLW 07
3801 1040: BTFSC 03.2
3802 1041: GOTO 07A
3803 1042: GOTO 081
3804 ....................
3805 .................... case 1: d=d;
3806 ....................
3807 .................... break;
3808 1043: GOTO 0CD
3809 ....................
3810 .................... case 2: d=31+d;
3811 1044: MOVLW 1F
3812 1045: ADDWF 5A,F
3813 1046: BTFSC 03.0
3814 1047: INCF 5B,F
3815 ....................
3816 .................... break;
3817 1048: GOTO 0CD
3818 ....................
3819 .................... case 3: d=58+d;
3820 1049: MOVLW 3A
3821 104A: ADDWF 5A,F
3822 104B: BTFSC 03.0
3823 104C: INCF 5B,F
3824 ....................
3825 .................... break;
3826 104D: GOTO 0CD
3827 ....................
3828 .................... case 4: d=89+d;
3829 104E: MOVLW 59
3830 104F: ADDWF 5A,F
3831 1050: BTFSC 03.0
3832 1051: INCF 5B,F
3833 ....................
3834 .................... break;
3835 1052: GOTO 0CD
3836 .................... case 5: d=119+d;
3837 1053: MOVLW 77
3838 1054: ADDWF 5A,F
3839 1055: BTFSC 03.0
3840 1056: INCF 5B,F
3841 ....................
3842 .................... break;
3843 1057: GOTO 0CD
3844 ....................
3845 .................... case 6: d=150+d;
3846 1058: MOVLW 96
3847 1059: ADDWF 5A,F
3848 105A: BTFSC 03.0
3849 105B: INCF 5B,F
3850 ....................
3851 .................... break;
3852 105C: GOTO 0CD
3853 .................... case 7: d=180+d;
3854 105D: MOVLW B4
3855 105E: ADDWF 5A,F
3856 105F: BTFSC 03.0
3857 1060: INCF 5B,F
3858 ....................
3859 .................... break;
3860 1061: GOTO 0CD
3861 ....................
3862 .................... case 8: d=211+d;
3863 1062: MOVLW D3
3864 1063: ADDWF 5A,F
3865 1064: BTFSC 03.0
3866 1065: INCF 5B,F
3867 ....................
3868 .................... break;
3869 1066: GOTO 0CD
3870 .................... case 9: d=242+d;
3871 1067: MOVLW F2
3872 1068: ADDWF 5A,F
3873 1069: BTFSC 03.0
3874 106A: INCF 5B,F
3875 ....................
3876 .................... break;
3877 106B: GOTO 0CD
3878 ....................
3879 .................... case 10: d=262+d;
3880 106C: MOVLW 06
3881 106D: ADDWF 5A,F
3882 106E: MOVLW 01
3883 106F: BTFSC 03.0
3884 1070: MOVLW 02
3885 1071: ADDWF 5B,F
3886 ....................
3887 .................... break;
3888 1072: GOTO 0CD
3889 .................... case 11: d=303+d;
3890 1073: MOVLW 2F
3891 1074: ADDWF 5A,F
3892 1075: MOVLW 01
3893 1076: BTFSC 03.0
3894 1077: MOVLW 02
3895 1078: ADDWF 5B,F
3896 ....................
3897 .................... break;
3898 1079: GOTO 0CD
3899 ....................
3900 .................... case 12: d=333+d;
3901 107A: MOVLW 4D
3902 107B: ADDWF 5A,F
3903 107C: MOVLW 01
3904 107D: BTFSC 03.0
3905 107E: MOVLW 02
3906 107F: ADDWF 5B,F
3907 ....................
3908 .................... break;
3909 1080: GOTO 0CD
3910 ....................
3911 .................... default:printf("chyba");
3912 1081: MOVLW 04
3913 1082: BSF 03.6
3914 1083: MOVWF 0D
3915 1084: MOVLW 00
3916 1085: MOVWF 0F
3917 ....................
3918 .................... break; }
3919 *
3920 10CB: BCF 03.6
3921 10CC: GOTO 0CD
3922 ....................
3923 ....................
3924 .................... printf("Den: %ld\r\n", d);
3925 10CD: MOVLW 07
3926 10CE: BSF 03.6
3927 10CF: MOVWF 0D
3928 10D0: MOVLW 00
3929 10D1: MOVWF 0F
3930 10D2: BCF 03.0
3931 10D3: MOVLW 05
3932 10D4: BCF 03.6
3933 10D5: MOVWF 5C
3934 10D6: BCF 0A.4
3935 10D7: CALL 073
3936 10D8: BSF 0A.4
3937 10D9: MOVLW 10
3938 10DA: MOVWF 04
3939 10DB: MOVF 5B,W
3940 10DC: MOVWF 5D
3941 10DD: MOVF 5A,W
3942 10DE: MOVWF 5C
3943 10DF: BCF 0A.4
3944 10E0: CALL 0C2
3945 10E1: BSF 0A.4
3946 10E2: MOVLW 0D
3947 10E3: MOVWF 65
3948 10E4: BCF 0A.4
3949 10E5: CALL 04F
3950 10E6: BSF 0A.4
3951 10E7: MOVLW 0A
3952 10E8: MOVWF 65
3953 10E9: BCF 0A.4
3954 10EA: CALL 04F
3955 10EB: BSF 0A.4
3956 .................... return d;
3957 10EC: MOVF 5A,W
3958 10ED: MOVWF 78
3959 10EE: MOVF 5B,W
3960 10EF: MOVWF 79
3961 ....................
3962 .................... }
3963 ....................
3964 .................... float deklinace (float d) //vstupem je den v roce
3965 .................... {
3966 *
3967 1109: MOVLW 3F
3968 110A: MOVWF 60
3969 110B: MOVLW 7E
3970 110C: MOVWF 5F
3971 110D: MOVLW 7C
3972 110E: MOVWF 5E
3973 110F: MOVLW 7E
3974 1110: MOVWF 5D
3975 .................... float b = 0.98630137;
3976 .................... d=((rad(23.45))*sin(rad(b*(d-81))));
3977 1111: MOVLW 9A
3978 1112: MOVWF 6E
3979 1113: MOVLW 99
3980 1114: MOVWF 6D
3981 1115: MOVLW 3B
3982 1116: MOVWF 6C
3983 1117: MOVLW 83
3984 1118: MOVWF 6B
3985 1119: BCF 0A.4
3986 111A: CALL 285
3987 111B: BSF 0A.4
3988 111C: MOVF 77,W
3989 111D: MOVWF 61
3990 111E: MOVF 78,W
3991 111F: MOVWF 62
3992 1120: MOVF 79,W
3993 1121: MOVWF 63
3994 1122: MOVF 7A,W
3995 1123: MOVWF 64
3996 1124: CLRF 66
3997 1125: MOVF 04,W
3998 1126: MOVWF 65
3999 1127: BCF 66.0
4000 1128: BTFSC 03.7
4001 1129: BSF 66.0
4002 112A: BSF 03.1
4003 112B: MOVF 5C,W
4004 112C: BSF 03.5
4005 112D: MOVWF 4D
4006 112E: BCF 03.5
4007 112F: MOVF 5B,W
4008 1130: BSF 03.5
4009 1131: MOVWF 4C
4010 1132: BCF 03.5
4011 1133: MOVF 5A,W
4012 1134: BSF 03.5
4013 1135: MOVWF 4B
4014 1136: BCF 03.5
4015 1137: MOVF 59,W
4016 1138: BSF 03.5
4017 1139: MOVWF 4A
4018 113A: CLRF 51
4019 113B: CLRF 50
4020 113C: MOVLW 22
4021 113D: MOVWF 4F
4022 113E: MOVLW 85
4023 113F: MOVWF 4E
4024 1140: BCF 0A.4
4025 1141: BCF 03.5
4026 1142: CALL 2C7
4027 1143: BSF 0A.4
4028 1144: MOVF 65,W
4029 1145: MOVWF 04
4030 1146: BCF 03.7
4031 1147: BTFSC 66.0
4032 1148: BSF 03.7
4033 1149: MOVF 60,W
4034 114A: BSF 03.5
4035 114B: MOVWF 4D
4036 114C: BCF 03.5
4037 114D: MOVF 5F,W
4038 114E: BSF 03.5
4039 114F: MOVWF 4C
4040 1150: BCF 03.5
4041 1151: MOVF 5E,W
4042 1152: BSF 03.5
4043 1153: MOVWF 4B
4044 1154: BCF 03.5
4045 1155: MOVF 5D,W
4046 1156: BSF 03.5
4047 1157: MOVWF 4A
4048 1158: MOVF 7A,W
4049 1159: MOVWF 51
4050 115A: MOVF 79,W
4051 115B: MOVWF 50
4052 115C: MOVF 78,W
4053 115D: MOVWF 4F
4054 115E: MOVF 77,W
4055 115F: MOVWF 4E
4056 1160: BCF 0A.4
4057 1161: BCF 03.5
4058 1162: CALL 20E
4059 1163: BSF 0A.4
4060 1164: MOVF 77,W
4061 1165: MOVWF 67
4062 1166: MOVF 78,W
4063 1167: MOVWF 68
4064 1168: MOVF 79,W
4065 1169: MOVWF 69
4066 116A: MOVF 7A,W
4067 116B: MOVWF 6A
4068 116C: MOVWF 6E
4069 116D: MOVF 79,W
4070 116E: MOVWF 6D
4071 116F: MOVF 78,W
4072 1170: MOVWF 6C
4073 1171: MOVF 77,W
4074 1172: MOVWF 6B
4075 1173: BCF 0A.4
4076 1174: CALL 285
4077 1175: BSF 0A.4
4078 1176: MOVF 77,W
4079 1177: MOVWF 67
4080 1178: MOVF 78,W
4081 1179: MOVWF 68
4082 117A: MOVF 79,W
4083 117B: MOVWF 69
4084 117C: MOVF 7A,W
4085 117D: MOVWF 6A
4086 117E: MOVWF 6E
4087 117F: MOVF 79,W
4088 1180: MOVWF 6D
4089 1181: MOVF 78,W
4090 1182: MOVWF 6C
4091 1183: MOVF 77,W
4092 1184: MOVWF 6B
4093 1185: BCF 0A.4
4094 1186: CALL 644
4095 1187: BSF 0A.4
4096 1188: MOVF 64,W
4097 1189: BSF 03.5
4098 118A: MOVWF 4D
4099 118B: BCF 03.5
4100 118C: MOVF 63,W
4101 118D: BSF 03.5
4102 118E: MOVWF 4C
4103 118F: BCF 03.5
4104 1190: MOVF 62,W
4105 1191: BSF 03.5
4106 1192: MOVWF 4B
4107 1193: BCF 03.5
4108 1194: MOVF 61,W
4109 1195: BSF 03.5
4110 1196: MOVWF 4A
4111 1197: MOVF 7A,W
4112 1198: MOVWF 51
4113 1199: MOVF 79,W
4114 119A: MOVWF 50
4115 119B: MOVF 78,W
4116 119C: MOVWF 4F
4117 119D: MOVF 77,W
4118 119E: MOVWF 4E
4119 119F: BCF 0A.4
4120 11A0: BCF 03.5
4121 11A1: CALL 20E
4122 11A2: BSF 0A.4
4123 11A3: MOVF 7A,W
4124 11A4: MOVWF 5C
4125 11A5: MOVF 79,W
4126 11A6: MOVWF 5B
4127 11A7: MOVF 78,W
4128 11A8: MOVWF 5A
4129 11A9: MOVF 77,W
4130 11AA: MOVWF 59
4131 .................... return d;
4132 11AB: MOVF 59,W
4133 11AC: MOVWF 77
4134 11AD: MOVF 5A,W
4135 11AE: MOVWF 78
4136 11AF: MOVF 5B,W
4137 11B0: MOVWF 79
4138 11B1: MOVF 5C,W
4139 11B2: MOVWF 7A
4140 ....................
4141 .................... }
4142 ....................
4143 .................... float lstm (int gmt) //vstupem je GMT dane lokality
4144 .................... {
4145 .................... float a;
4146 .................... a=((rad(15))*gmt);
4147 *
4148 11BD: CLRF 6E
4149 11BE: CLRF 6D
4150 11BF: MOVLW 70
4151 11C0: MOVWF 6C
4152 11C1: MOVLW 82
4153 11C2: MOVWF 6B
4154 11C3: BCF 0A.4
4155 11C4: CALL 285
4156 11C5: BSF 0A.4
4157 11C6: MOVF 77,W
4158 11C7: MOVWF 5E
4159 11C8: MOVF 78,W
4160 11C9: MOVWF 5F
4161 11CA: MOVF 79,W
4162 11CB: MOVWF 60
4163 11CC: MOVF 7A,W
4164 11CD: MOVWF 61
4165 11CE: BSF 03.5
4166 11CF: CLRF 4B
4167 11D0: BCF 03.5
4168 11D1: MOVF 59,W
4169 11D2: BSF 03.5
4170 11D3: MOVWF 4A
4171 11D4: BCF 0A.4
4172 11D5: BCF 03.5
4173 11D6: CALL 030
4174 11D7: BSF 0A.4
4175 11D8: MOVF 61,W
4176 11D9: BSF 03.5
4177 11DA: MOVWF 4D
4178 11DB: BCF 03.5
4179 11DC: MOVF 60,W
4180 11DD: BSF 03.5
4181 11DE: MOVWF 4C
4182 11DF: BCF 03.5
4183 11E0: MOVF 5F,W
4184 11E1: BSF 03.5
4185 11E2: MOVWF 4B
4186 11E3: BCF 03.5
4187 11E4: MOVF 5E,W
4188 11E5: BSF 03.5
4189 11E6: MOVWF 4A
4190 11E7: MOVF 7A,W
4191 11E8: MOVWF 51
4192 11E9: MOVF 79,W
4193 11EA: MOVWF 50
4194 11EB: MOVF 78,W
4195 11EC: MOVWF 4F
4196 11ED: MOVF 77,W
4197 11EE: MOVWF 4E
4198 11EF: BCF 0A.4
4199 11F0: BCF 03.5
4200 11F1: CALL 20E
4201 11F2: BSF 0A.4
4202 11F3: MOVF 7A,W
4203 11F4: MOVWF 5D
4204 11F5: MOVF 79,W
4205 11F6: MOVWF 5C
4206 11F7: MOVF 78,W
4207 11F8: MOVWF 5B
4208 11F9: MOVF 77,W
4209 11FA: MOVWF 5A
4210 .................... return a;
4211 11FB: MOVF 5A,W
4212 11FC: MOVWF 77
4213 11FD: MOVF 5B,W
4214 11FE: MOVWF 78
4215 11FF: MOVF 5C,W
4216 1200: MOVWF 79
4217 1201: MOVF 5D,W
4218 1202: MOVWF 7A
4219 .................... }
4220 ....................
4221 ....................
4222 .................... float eot (float d) //vstupem je den v roce
4223 .................... {
4224 .................... float a;
4225 .................... a=rad(0.98630137*(d-81));
4226 *
4227 1213: BSF 03.1
4228 1214: MOVF 5C,W
4229 1215: BSF 03.5
4230 1216: MOVWF 4D
4231 1217: BCF 03.5
4232 1218: MOVF 5B,W
4233 1219: BSF 03.5
4234 121A: MOVWF 4C
4235 121B: BCF 03.5
4236 121C: MOVF 5A,W
4237 121D: BSF 03.5
4238 121E: MOVWF 4B
4239 121F: BCF 03.5
4240 1220: MOVF 59,W
4241 1221: BSF 03.5
4242 1222: MOVWF 4A
4243 1223: CLRF 51
4244 1224: CLRF 50
4245 1225: MOVLW 22
4246 1226: MOVWF 4F
4247 1227: MOVLW 85
4248 1228: MOVWF 4E
4249 1229: BCF 0A.4
4250 122A: BCF 03.5
4251 122B: CALL 2C7
4252 122C: BSF 0A.4
4253 122D: MOVLW 3F
4254 122E: BSF 03.5
4255 122F: MOVWF 4D
4256 1230: MOVLW 7E
4257 1231: MOVWF 4C
4258 1232: MOVLW 7C
4259 1233: MOVWF 4B
4260 1234: MOVLW 7E
4261 1235: MOVWF 4A
4262 1236: MOVF 7A,W
4263 1237: MOVWF 51
4264 1238: MOVF 79,W
4265 1239: MOVWF 50
4266 123A: MOVF 78,W
4267 123B: MOVWF 4F
4268 123C: MOVF 77,W
4269 123D: MOVWF 4E
4270 123E: BCF 0A.4
4271 123F: BCF 03.5
4272 1240: CALL 20E
4273 1241: BSF 0A.4
4274 1242: MOVF 77,W
4275 1243: MOVWF 61
4276 1244: MOVF 78,W
4277 1245: MOVWF 62
4278 1246: MOVF 79,W
4279 1247: MOVWF 63
4280 1248: MOVF 7A,W
4281 1249: MOVWF 64
4282 124A: MOVWF 6E
4283 124B: MOVF 79,W
4284 124C: MOVWF 6D
4285 124D: MOVF 78,W
4286 124E: MOVWF 6C
4287 124F: MOVF 77,W
4288 1250: MOVWF 6B
4289 1251: BCF 0A.4
4290 1252: CALL 285
4291 1253: BSF 0A.4
4292 1254: MOVF 7A,W
4293 1255: MOVWF 60
4294 1256: MOVF 79,W
4295 1257: MOVWF 5F
4296 1258: MOVF 78,W
4297 1259: MOVWF 5E
4298 125A: MOVF 77,W
4299 125B: MOVWF 5D
4300 .................... a=9.87*sin(2*a)-7.53*cos(a)-1.5*sin(a);
4301 125C: BSF 03.5
4302 125D: CLRF 4D
4303 125E: CLRF 4C
4304 125F: CLRF 4B
4305 1260: MOVLW 80
4306 1261: MOVWF 4A
4307 1262: BCF 03.5
4308 1263: MOVF 60,W
4309 1264: BSF 03.5
4310 1265: MOVWF 51
4311 1266: BCF 03.5
4312 1267: MOVF 5F,W
4313 1268: BSF 03.5
4314 1269: MOVWF 50
4315 126A: BCF 03.5
4316 126B: MOVF 5E,W
4317 126C: BSF 03.5
4318 126D: MOVWF 4F
4319 126E: BCF 03.5
4320 126F: MOVF 5D,W
4321 1270: BSF 03.5
4322 1271: MOVWF 4E
4323 1272: BCF 0A.4
4324 1273: BCF 03.5
4325 1274: CALL 20E
4326 1275: BSF 0A.4
4327 1276: MOVF 77,W
4328 1277: MOVWF 61
4329 1278: MOVF 78,W
4330 1279: MOVWF 62
4331 127A: MOVF 79,W
4332 127B: MOVWF 63
4333 127C: MOVF 7A,W
4334 127D: MOVWF 64
4335 127E: MOVWF 6E
4336 127F: MOVF 79,W
4337 1280: MOVWF 6D
4338 1281: MOVF 78,W
4339 1282: MOVWF 6C
4340 1283: MOVF 77,W
4341 1284: MOVWF 6B
4342 1285: BCF 0A.4
4343 1286: CALL 644
4344 1287: BSF 0A.4
4345 1288: MOVLW 85
4346 1289: BSF 03.5
4347 128A: MOVWF 4D
4348 128B: MOVLW EB
4349 128C: MOVWF 4C
4350 128D: MOVLW 1D
4351 128E: MOVWF 4B
4352 128F: MOVLW 82
4353 1290: MOVWF 4A
4354 1291: MOVF 7A,W
4355 1292: MOVWF 51
4356 1293: MOVF 79,W
4357 1294: MOVWF 50
4358 1295: MOVF 78,W
4359 1296: MOVWF 4F
4360 1297: MOVF 77,W
4361 1298: MOVWF 4E
4362 1299: BCF 0A.4
4363 129A: BCF 03.5
4364 129B: CALL 20E
4365 129C: BSF 0A.4
4366 129D: MOVF 77,W
4367 129E: MOVWF 61
4368 129F: MOVF 78,W
4369 12A0: MOVWF 62
4370 12A1: MOVF 79,W
4371 12A2: MOVWF 63
4372 12A3: MOVF 7A,W
4373 12A4: MOVWF 64
4374 12A5: MOVF 60,W
4375 12A6: MOVWF 76
4376 12A7: MOVF 5F,W
4377 12A8: MOVWF 75
4378 12A9: MOVF 5E,W
4379 12AA: MOVWF 74
4380 12AB: MOVF 5D,W
4381 12AC: MOVWF 73
4382 12AD: BCF 0A.4
4383 12AE: CALL 46F
4384 12AF: BSF 0A.4
4385 12B0: MOVLW C3
4386 12B1: BSF 03.5
4387 12B2: MOVWF 4D
4388 12B3: MOVLW F5
4389 12B4: MOVWF 4C
4390 12B5: MOVLW 70
4391 12B6: MOVWF 4B
4392 12B7: MOVLW 81
4393 12B8: MOVWF 4A
4394 12B9: MOVF 7A,W
4395 12BA: MOVWF 51
4396 12BB: MOVF 79,W
4397 12BC: MOVWF 50
4398 12BD: MOVF 78,W
4399 12BE: MOVWF 4F
4400 12BF: MOVF 77,W
4401 12C0: MOVWF 4E
4402 12C1: BCF 0A.4
4403 12C2: BCF 03.5
4404 12C3: CALL 20E
4405 12C4: BSF 0A.4
4406 12C5: CLRF 66
4407 12C6: MOVF 04,W
4408 12C7: MOVWF 65
4409 12C8: BCF 66.0
4410 12C9: BTFSC 03.7
4411 12CA: BSF 66.0
4412 12CB: BSF 03.1
4413 12CC: MOVF 64,W
4414 12CD: BSF 03.5
4415 12CE: MOVWF 4D
4416 12CF: BCF 03.5
4417 12D0: MOVF 63,W
4418 12D1: BSF 03.5
4419 12D2: MOVWF 4C
4420 12D3: BCF 03.5
4421 12D4: MOVF 62,W
4422 12D5: BSF 03.5
4423 12D6: MOVWF 4B
4424 12D7: BCF 03.5
4425 12D8: MOVF 61,W
4426 12D9: BSF 03.5
4427 12DA: MOVWF 4A
4428 12DB: MOVF 7A,W
4429 12DC: MOVWF 51
4430 12DD: MOVF 79,W
4431 12DE: MOVWF 50
4432 12DF: MOVF 78,W
4433 12E0: MOVWF 4F
4434 12E1: MOVF 77,W
4435 12E2: MOVWF 4E
4436 12E3: BCF 0A.4
4437 12E4: BCF 03.5
4438 12E5: CALL 2C7
4439 12E6: BSF 0A.4
4440 12E7: MOVF 65,W
4441 12E8: MOVWF 04
4442 12E9: BCF 03.7
4443 12EA: BTFSC 66.0
4444 12EB: BSF 03.7
4445 12EC: MOVF 77,W
4446 12ED: MOVWF 61
4447 12EE: MOVF 78,W
4448 12EF: MOVWF 62
4449 12F0: MOVF 79,W
4450 12F1: MOVWF 63
4451 12F2: MOVF 7A,W
4452 12F3: MOVWF 64
4453 12F4: MOVF 60,W
4454 12F5: MOVWF 6E
4455 12F6: MOVF 5F,W
4456 12F7: MOVWF 6D
4457 12F8: MOVF 5E,W
4458 12F9: MOVWF 6C
4459 12FA: MOVF 5D,W
4460 12FB: MOVWF 6B
4461 12FC: BCF 0A.4
4462 12FD: CALL 644
4463 12FE: BSF 0A.4
4464 12FF: BSF 03.5
4465 1300: CLRF 4D
4466 1301: CLRF 4C
4467 1302: MOVLW 40
4468 1303: MOVWF 4B
4469 1304: MOVLW 7F
4470 1305: MOVWF 4A
4471 1306: MOVF 7A,W
4472 1307: MOVWF 51
4473 1308: MOVF 79,W
4474 1309: MOVWF 50
4475 130A: MOVF 78,W
4476 130B: MOVWF 4F
4477 130C: MOVF 77,W
4478 130D: MOVWF 4E
4479 130E: BCF 0A.4
4480 130F: BCF 03.5
4481 1310: CALL 20E
4482 1311: BSF 0A.4
4483 1312: CLRF 68
4484 1313: MOVF 04,W
4485 1314: MOVWF 67
4486 1315: BCF 68.0
4487 1316: BTFSC 03.7
4488 1317: BSF 68.0
4489 1318: BSF 03.1
4490 1319: MOVF 64,W
4491 131A: BSF 03.5
4492 131B: MOVWF 4D
4493 131C: BCF 03.5
4494 131D: MOVF 63,W
4495 131E: BSF 03.5
4496 131F: MOVWF 4C
4497 1320: BCF 03.5
4498 1321: MOVF 62,W
4499 1322: BSF 03.5
4500 1323: MOVWF 4B
4501 1324: BCF 03.5
4502 1325: MOVF 61,W
4503 1326: BSF 03.5
4504 1327: MOVWF 4A
4505 1328: MOVF 7A,W
4506 1329: MOVWF 51
4507 132A: MOVF 79,W
4508 132B: MOVWF 50
4509 132C: MOVF 78,W
4510 132D: MOVWF 4F
4511 132E: MOVF 77,W
4512 132F: MOVWF 4E
4513 1330: BCF 0A.4
4514 1331: BCF 03.5
4515 1332: CALL 2C7
4516 1333: BSF 0A.4
4517 1334: MOVF 67,W
4518 1335: MOVWF 04
4519 1336: BCF 03.7
4520 1337: BTFSC 68.0
4521 1338: BSF 03.7
4522 1339: MOVF 7A,W
4523 133A: MOVWF 60
4524 133B: MOVF 79,W
4525 133C: MOVWF 5F
4526 133D: MOVF 78,W
4527 133E: MOVWF 5E
4528 133F: MOVF 77,W
4529 1340: MOVWF 5D
4530 .................... return a;
4531 1341: MOVF 5D,W
4532 1342: MOVWF 77
4533 1343: MOVF 5E,W
4534 1344: MOVWF 78
4535 1345: MOVF 5F,W
4536 1346: MOVWF 79
4537 1347: MOVF 60,W
4538 1348: MOVWF 7A
4539 ....................
4540 .................... }
4541 ....................
4542 ....................
4543 .................... float tc (int delka, float lstm, float eot) //vstupem je zemepisná delka, LSTM, EoT
4544 .................... {
4545 .................... float a;
4546 .................... a=4*(float)(delka-lstm)+eot;
4547 *
4548 1378: BSF 03.5
4549 1379: CLRF 4B
4550 137A: BCF 03.5
4551 137B: MOVF 5A,W
4552 137C: BSF 03.5
4553 137D: MOVWF 4A
4554 137E: BCF 0A.4
4555 137F: BCF 03.5
4556 1380: CALL 030
4557 1381: BSF 0A.4
4558 1382: BSF 03.1
4559 1383: MOVF 7A,W
4560 1384: BSF 03.5
4561 1385: MOVWF 4D
4562 1386: MOVF 79,W
4563 1387: MOVWF 4C
4564 1388: MOVF 78,W
4565 1389: MOVWF 4B
4566 138A: MOVF 77,W
4567 138B: MOVWF 4A
4568 138C: BCF 03.5
4569 138D: MOVF 5E,W
4570 138E: BSF 03.5
4571 138F: MOVWF 51
4572 1390: BCF 03.5
4573 1391: MOVF 5D,W
4574 1392: BSF 03.5
4575 1393: MOVWF 50
4576 1394: BCF 03.5
4577 1395: MOVF 5C,W
4578 1396: BSF 03.5
4579 1397: MOVWF 4F
4580 1398: BCF 03.5
4581 1399: MOVF 5B,W
4582 139A: BSF 03.5
4583 139B: MOVWF 4E
4584 139C: BCF 0A.4
4585 139D: BCF 03.5
4586 139E: CALL 2C7
4587 139F: BSF 0A.4
4588 13A0: BSF 03.5
4589 13A1: CLRF 4D
4590 13A2: CLRF 4C
4591 13A3: CLRF 4B
4592 13A4: MOVLW 81
4593 13A5: MOVWF 4A
4594 13A6: MOVF 7A,W
4595 13A7: MOVWF 51
4596 13A8: MOVF 79,W
4597 13A9: MOVWF 50
4598 13AA: MOVF 78,W
4599 13AB: MOVWF 4F
4600 13AC: MOVF 77,W
4601 13AD: MOVWF 4E
4602 13AE: BCF 0A.4
4603 13AF: BCF 03.5
4604 13B0: CALL 20E
4605 13B1: BSF 0A.4
4606 13B2: MOVF 77,W
4607 13B3: MOVWF 67
4608 13B4: MOVF 78,W
4609 13B5: MOVWF 68
4610 13B6: MOVF 79,W
4611 13B7: MOVWF 69
4612 13B8: MOVF 7A,W
4613 13B9: MOVWF 6A
4614 13BA: BCF 03.1
4615 13BB: MOVF 7A,W
4616 13BC: BSF 03.5
4617 13BD: MOVWF 4D
4618 13BE: BCF 03.5
4619 13BF: MOVF 79,W
4620 13C0: BSF 03.5
4621 13C1: MOVWF 4C
4622 13C2: BCF 03.5
4623 13C3: MOVF 78,W
4624 13C4: BSF 03.5
4625 13C5: MOVWF 4B
4626 13C6: BCF 03.5
4627 13C7: MOVF 77,W
4628 13C8: BSF 03.5
4629 13C9: MOVWF 4A
4630 13CA: BCF 03.5
4631 13CB: MOVF 62,W
4632 13CC: BSF 03.5
4633 13CD: MOVWF 51
4634 13CE: BCF 03.5
4635 13CF: MOVF 61,W
4636 13D0: BSF 03.5
4637 13D1: MOVWF 50
4638 13D2: BCF 03.5
4639 13D3: MOVF 60,W
4640 13D4: BSF 03.5
4641 13D5: MOVWF 4F
4642 13D6: BCF 03.5
4643 13D7: MOVF 5F,W
4644 13D8: BSF 03.5
4645 13D9: MOVWF 4E
4646 13DA: BCF 0A.4
4647 13DB: BCF 03.5
4648 13DC: CALL 2C7
4649 13DD: BSF 0A.4
4650 13DE: MOVF 7A,W
4651 13DF: MOVWF 66
4652 13E0: MOVF 79,W
4653 13E1: MOVWF 65
4654 13E2: MOVF 78,W
4655 13E3: MOVWF 64
4656 13E4: MOVF 77,W
4657 13E5: MOVWF 63
4658 .................... return a;
4659 13E6: MOVF 63,W
4660 13E7: MOVWF 77
4661 13E8: MOVF 64,W
4662 13E9: MOVWF 78
4663 13EA: MOVF 65,W
4664 13EB: MOVWF 79
4665 13EC: MOVF 66,W
4666 13ED: MOVWF 7A
4667 .................... }
4668 ....................
4669 ....................
4670 .................... float lst (float lt, float tc) //vstupem je den GMT dane lokality
4671 .................... {
4672 .................... float a;
4673 .................... a=lt+(tc/60);
4674 *
4675 1406: MOVF 60,W
4676 1407: BSF 03.5
4677 1408: MOVWF 49
4678 1409: BCF 03.5
4679 140A: MOVF 5F,W
4680 140B: BSF 03.5
4681 140C: MOVWF 48
4682 140D: BCF 03.5
4683 140E: MOVF 5E,W
4684 140F: BSF 03.5
4685 1410: MOVWF 47
4686 1411: BCF 03.5
4687 1412: MOVF 5D,W
4688 1413: BSF 03.5
4689 1414: MOVWF 46
4690 1415: CLRF 4D
4691 1416: CLRF 4C
4692 1417: MOVLW 70
4693 1418: MOVWF 4B
4694 1419: MOVLW 84
4695 141A: MOVWF 4A
4696 141B: BCF 0A.4
4697 141C: BCF 03.5
4698 141D: CALL 142
4699 141E: BSF 0A.4
4700 141F: BCF 03.1
4701 1420: MOVF 5C,W
4702 1421: BSF 03.5
4703 1422: MOVWF 4D
4704 1423: BCF 03.5
4705 1424: MOVF 5B,W
4706 1425: BSF 03.5
4707 1426: MOVWF 4C
4708 1427: BCF 03.5
4709 1428: MOVF 5A,W
4710 1429: BSF 03.5
4711 142A: MOVWF 4B
4712 142B: BCF 03.5
4713 142C: MOVF 59,W
4714 142D: BSF 03.5
4715 142E: MOVWF 4A
4716 142F: MOVF 7A,W
4717 1430: MOVWF 51
4718 1431: MOVF 79,W
4719 1432: MOVWF 50
4720 1433: MOVF 78,W
4721 1434: MOVWF 4F
4722 1435: MOVF 77,W
4723 1436: MOVWF 4E
4724 1437: BCF 0A.4
4725 1438: BCF 03.5
4726 1439: CALL 2C7
4727 143A: BSF 0A.4
4728 143B: MOVF 7A,W
4729 143C: MOVWF 64
4730 143D: MOVF 79,W
4731 143E: MOVWF 63
4732 143F: MOVF 78,W
4733 1440: MOVWF 62
4734 1441: MOVF 77,W
4735 1442: MOVWF 61
4736 .................... return a;
4737 1443: MOVF 61,W
4738 1444: MOVWF 77
4739 1445: MOVF 62,W
4740 1446: MOVWF 78
4741 1447: MOVF 63,W
4742 1448: MOVWF 79
4743 1449: MOVF 64,W
4744 144A: MOVWF 7A
4745 .................... }
4746 ....................
4747 .................... float hra (float lst) //vstupem je den v roce
4748 .................... {
4749 .................... lst=(rad(15))*(lst-12);
4750 *
4751 145B: CLRF 6E
4752 145C: CLRF 6D
4753 145D: MOVLW 70
4754 145E: MOVWF 6C
4755 145F: MOVLW 82
4756 1460: MOVWF 6B
4757 1461: BCF 0A.4
4758 1462: CALL 285
4759 1463: BSF 0A.4
4760 1464: MOVF 77,W
4761 1465: MOVWF 5D
4762 1466: MOVF 78,W
4763 1467: MOVWF 5E
4764 1468: MOVF 79,W
4765 1469: MOVWF 5F
4766 146A: MOVF 7A,W
4767 146B: MOVWF 60
4768 146C: CLRF 62
4769 146D: MOVF 04,W
4770 146E: MOVWF 61
4771 146F: BCF 62.0
4772 1470: BTFSC 03.7
4773 1471: BSF 62.0
4774 1472: BSF 03.1
4775 1473: MOVF 5C,W
4776 1474: BSF 03.5
4777 1475: MOVWF 4D
4778 1476: BCF 03.5
4779 1477: MOVF 5B,W
4780 1478: BSF 03.5
4781 1479: MOVWF 4C
4782 147A: BCF 03.5
4783 147B: MOVF 5A,W
4784 147C: BSF 03.5
4785 147D: MOVWF 4B
4786 147E: BCF 03.5
4787 147F: MOVF 59,W
4788 1480: BSF 03.5
4789 1481: MOVWF 4A
4790 1482: CLRF 51
4791 1483: CLRF 50
4792 1484: MOVLW 40
4793 1485: MOVWF 4F
4794 1486: MOVLW 82
4795 1487: MOVWF 4E
4796 1488: BCF 0A.4
4797 1489: BCF 03.5
4798 148A: CALL 2C7
4799 148B: BSF 0A.4
4800 148C: MOVF 61,W
4801 148D: MOVWF 04
4802 148E: BCF 03.7
4803 148F: BTFSC 62.0
4804 1490: BSF 03.7
4805 1491: MOVF 60,W
4806 1492: BSF 03.5
4807 1493: MOVWF 4D
4808 1494: BCF 03.5
4809 1495: MOVF 5F,W
4810 1496: BSF 03.5
4811 1497: MOVWF 4C
4812 1498: BCF 03.5
4813 1499: MOVF 5E,W
4814 149A: BSF 03.5
4815 149B: MOVWF 4B
4816 149C: BCF 03.5
4817 149D: MOVF 5D,W
4818 149E: BSF 03.5
4819 149F: MOVWF 4A
4820 14A0: MOVF 7A,W
4821 14A1: MOVWF 51
4822 14A2: MOVF 79,W
4823 14A3: MOVWF 50
4824 14A4: MOVF 78,W
4825 14A5: MOVWF 4F
4826 14A6: MOVF 77,W
4827 14A7: MOVWF 4E
4828 14A8: BCF 0A.4
4829 14A9: BCF 03.5
4830 14AA: CALL 20E
4831 14AB: BSF 0A.4
4832 14AC: MOVF 7A,W
4833 14AD: MOVWF 5C
4834 14AE: MOVF 79,W
4835 14AF: MOVWF 5B
4836 14B0: MOVF 78,W
4837 14B1: MOVWF 5A
4838 14B2: MOVF 77,W
4839 14B3: MOVWF 59
4840 .................... return lst;
4841 14B4: MOVF 59,W
4842 14B5: MOVWF 77
4843 14B6: MOVF 5A,W
4844 14B7: MOVWF 78
4845 14B8: MOVF 5B,W
4846 14B9: MOVWF 79
4847 14BA: MOVF 5C,W
4848 14BB: MOVWF 7A
4849 ....................
4850 .................... }
4851 ....................
4852 .................... void poziceSL(int m, int d, int h, int min, int gmt, float sirka, float delka) //vstupem je mesic, den, hodina, minuty, GMT, zemepisna sirka ve stupnich
4853 .................... {
4854 *
4855 1000: MOVF 27,W
4856 1001: MOVWF 59
4857 1002: MOVLW 3C
4858 1003: MOVWF 5A
4859 1004: BCF 0A.4
4860 1005: CALL 01B
4861 1006: BSF 0A.4
4862 1007: MOVF 78,W
4863 1008: ADDWF 26,W
4864 1009: BSF 03.5
4865 100A: CLRF 4B
4866 100B: MOVWF 4A
4867 100C: BCF 0A.4
4868 100D: BCF 03.5
4869 100E: CALL 030
4870 100F: BSF 0A.4
4871 1010: MOVF 7A,W
4872 1011: MOVWF 58
4873 1012: MOVF 79,W
4874 1013: MOVWF 57
4875 1014: MOVF 78,W
4876 1015: MOVWF 56
4877 1016: MOVF 77,W
4878 1017: MOVWF 55
4879 .................... float den1;
4880 .................... float ele,azi,deklin, lstm1, eot1, tc1, lst1, hra1;
4881 .................... float lt = h+(min/60);
4882 ....................
4883 .................... den1=(float) den(m,d);
4884 1018: MOVF 24,W
4885 1019: MOVWF 59
4886 101A: CLRF 5B
4887 101B: MOVF 25,W
4888 101C: MOVWF 5A
4889 *
4890 10F0: MOVF 79,W
4891 10F1: BSF 03.5
4892 10F2: MOVWF 4B
4893 10F3: MOVF 78,W
4894 10F4: MOVWF 4A
4895 10F5: BCF 0A.4
4896 10F6: BCF 03.5
4897 10F7: CALL 030
4898 10F8: BSF 0A.4
4899 10F9: MOVF 7A,W
4900 10FA: MOVWF 34
4901 10FB: MOVF 79,W
4902 10FC: MOVWF 33
4903 10FD: MOVF 78,W
4904 10FE: MOVWF 32
4905 10FF: MOVF 77,W
4906 1100: MOVWF 31
4907 .................... deklin=deklinace(den1);
4908 1101: MOVF 34,W
4909 1102: MOVWF 5C
4910 1103: MOVF 33,W
4911 1104: MOVWF 5B
4912 1105: MOVF 32,W
4913 1106: MOVWF 5A
4914 1107: MOVF 31,W
4915 1108: MOVWF 59
4916 *
4917 11B3: MOVF 7A,W
4918 11B4: MOVWF 40
4919 11B5: MOVF 79,W
4920 11B6: MOVWF 3F
4921 11B7: MOVF 78,W
4922 11B8: MOVWF 3E
4923 11B9: MOVF 77,W
4924 11BA: MOVWF 3D
4925 .................... lstm1=lstm(gmt);
4926 11BB: MOVF 28,W
4927 11BC: MOVWF 59
4928 *
4929 1203: MOVF 7A,W
4930 1204: MOVWF 44
4931 1205: MOVF 79,W
4932 1206: MOVWF 43
4933 1207: MOVF 78,W
4934 1208: MOVWF 42
4935 1209: MOVF 77,W
4936 120A: MOVWF 41
4937 .................... eot1=eot(den1);
4938 120B: MOVF 34,W
4939 120C: MOVWF 5C
4940 120D: MOVF 33,W
4941 120E: MOVWF 5B
4942 120F: MOVF 32,W
4943 1210: MOVWF 5A
4944 1211: MOVF 31,W
4945 1212: MOVWF 59
4946 *
4947 1349: MOVF 7A,W
4948 134A: MOVWF 48
4949 134B: MOVF 79,W
4950 134C: MOVWF 47
4951 134D: MOVF 78,W
4952 134E: MOVWF 46
4953 134F: MOVF 77,W
4954 1350: MOVWF 45
4955 .................... tc1=tc(delka, lstm1, eot1);
4956 1351: MOVF 30,W
4957 1352: BSF 03.5
4958 1353: MOVWF 49
4959 1354: BCF 03.5
4960 1355: MOVF 2F,W
4961 1356: BSF 03.5
4962 1357: MOVWF 48
4963 1358: BCF 03.5
4964 1359: MOVF 2E,W
4965 135A: BSF 03.5
4966 135B: MOVWF 47
4967 135C: BCF 03.5
4968 135D: MOVF 2D,W
4969 135E: BSF 03.5
4970 135F: MOVWF 46
4971 1360: BCF 0A.4
4972 1361: BCF 03.5
4973 1362: CALL 44E
4974 1363: BSF 0A.4
4975 1364: MOVF 78,W
4976 1365: MOVWF 59
4977 1366: MOVF 59,W
4978 1367: MOVWF 5A
4979 1368: MOVF 44,W
4980 1369: MOVWF 5E
4981 136A: MOVF 43,W
4982 136B: MOVWF 5D
4983 136C: MOVF 42,W
4984 136D: MOVWF 5C
4985 136E: MOVF 41,W
4986 136F: MOVWF 5B
4987 1370: MOVF 48,W
4988 1371: MOVWF 62
4989 1372: MOVF 47,W
4990 1373: MOVWF 61
4991 1374: MOVF 46,W
4992 1375: MOVWF 60
4993 1376: MOVF 45,W
4994 1377: MOVWF 5F
4995 *
4996 13EE: MOVF 7A,W
4997 13EF: MOVWF 4C
4998 13F0: MOVF 79,W
4999 13F1: MOVWF 4B
5000 13F2: MOVF 78,W
5001 13F3: MOVWF 4A
5002 13F4: MOVF 77,W
5003 13F5: MOVWF 49
5004 .................... lst1=lst(lt,tc1);
5005 13F6: MOVF 58,W
5006 13F7: MOVWF 5C
5007 13F8: MOVF 57,W
5008 13F9: MOVWF 5B
5009 13FA: MOVF 56,W
5010 13FB: MOVWF 5A
5011 13FC: MOVF 55,W
5012 13FD: MOVWF 59
5013 13FE: MOVF 4C,W
5014 13FF: MOVWF 60
5015 1400: MOVF 4B,W
5016 1401: MOVWF 5F
5017 1402: MOVF 4A,W
5018 1403: MOVWF 5E
5019 1404: MOVF 49,W
5020 1405: MOVWF 5D
5021 *
5022 144B: MOVF 7A,W
5023 144C: MOVWF 50
5024 144D: MOVF 79,W
5025 144E: MOVWF 4F
5026 144F: MOVF 78,W
5027 1450: MOVWF 4E
5028 1451: MOVF 77,W
5029 1452: MOVWF 4D
5030 .................... hra1=hra(lst1);
5031 1453: MOVF 50,W
5032 1454: MOVWF 5C
5033 1455: MOVF 4F,W
5034 1456: MOVWF 5B
5035 1457: MOVF 4E,W
5036 1458: MOVWF 5A
5037 1459: MOVF 4D,W
5038 145A: MOVWF 59
5039 *
5040 14BC: MOVF 7A,W
5041 14BD: MOVWF 54
5042 14BE: MOVF 79,W
5043 14BF: MOVWF 53
5044 14C0: MOVF 78,W
5045 14C1: MOVWF 52
5046 14C2: MOVF 77,W
5047 14C3: MOVWF 51
5048 ....................
5049 .................... sirka=rad(sirka);
5050 14C4: MOVF 2C,W
5051 14C5: MOVWF 6E
5052 14C6: MOVF 2B,W
5053 14C7: MOVWF 6D
5054 14C8: MOVF 2A,W
5055 14C9: MOVWF 6C
5056 14CA: MOVF 29,W
5057 14CB: MOVWF 6B
5058 14CC: BCF 0A.4
5059 14CD: CALL 285
5060 14CE: BSF 0A.4
5061 14CF: MOVF 7A,W
5062 14D0: MOVWF 2C
5063 14D1: MOVF 79,W
5064 14D2: MOVWF 2B
5065 14D3: MOVF 78,W
5066 14D4: MOVWF 2A
5067 14D5: MOVF 77,W
5068 14D6: MOVWF 29
5069 .................... ele=asin((sin(deklin)*sin(sirka))+(cos(deklin)*cos(sirka)*cos(hra1)));
5070 14D7: MOVF 40,W
5071 14D8: MOVWF 6E
5072 14D9: MOVF 3F,W
5073 14DA: MOVWF 6D
5074 14DB: MOVF 3E,W
5075 14DC: MOVWF 6C
5076 14DD: MOVF 3D,W
5077 14DE: MOVWF 6B
5078 14DF: BCF 0A.4
5079 14E0: CALL 644
5080 14E1: BSF 0A.4
5081 14E2: MOVF 77,W
5082 14E3: MOVWF 59
5083 14E4: MOVF 78,W
5084 14E5: MOVWF 5A
5085 14E6: MOVF 79,W
5086 14E7: MOVWF 5B
5087 14E8: MOVF 7A,W
5088 14E9: MOVWF 5C
5089 14EA: MOVF 2C,W
5090 14EB: MOVWF 6E
5091 14EC: MOVF 2B,W
5092 14ED: MOVWF 6D
5093 14EE: MOVF 2A,W
5094 14EF: MOVWF 6C
5095 14F0: MOVF 29,W
5096 14F1: MOVWF 6B
5097 14F2: BCF 0A.4
5098 14F3: CALL 644
5099 14F4: BSF 0A.4
5100 14F5: MOVF 5C,W
5101 14F6: BSF 03.5
5102 14F7: MOVWF 4D
5103 14F8: BCF 03.5
5104 14F9: MOVF 5B,W
5105 14FA: BSF 03.5
5106 14FB: MOVWF 4C
5107 14FC: BCF 03.5
5108 14FD: MOVF 5A,W
5109 14FE: BSF 03.5
5110 14FF: MOVWF 4B
5111 1500: BCF 03.5
5112 1501: MOVF 59,W
5113 1502: BSF 03.5
5114 1503: MOVWF 4A
5115 1504: MOVF 7A,W
5116 1505: MOVWF 51
5117 1506: MOVF 79,W
5118 1507: MOVWF 50
5119 1508: MOVF 78,W
5120 1509: MOVWF 4F
5121 150A: MOVF 77,W
5122 150B: MOVWF 4E
5123 150C: BCF 0A.4
5124 150D: BCF 03.5
5125 150E: CALL 20E
5126 150F: BSF 0A.4
5127 1510: MOVF 77,W
5128 1511: MOVWF 59
5129 1512: MOVF 78,W
5130 1513: MOVWF 5A
5131 1514: MOVF 79,W
5132 1515: MOVWF 5B
5133 1516: MOVF 7A,W
5134 1517: MOVWF 5C
5135 1518: MOVF 40,W
5136 1519: MOVWF 76
5137 151A: MOVF 3F,W
5138 151B: MOVWF 75
5139 151C: MOVF 3E,W
5140 151D: MOVWF 74
5141 151E: MOVF 3D,W
5142 151F: MOVWF 73
5143 1520: BCF 0A.4
5144 1521: CALL 46F
5145 1522: BSF 0A.4
5146 1523: MOVF 77,W
5147 1524: MOVWF 5D
5148 1525: MOVF 78,W
5149 1526: MOVWF 5E
5150 1527: MOVF 79,W
5151 1528: MOVWF 5F
5152 1529: MOVF 7A,W
5153 152A: MOVWF 60
5154 152B: MOVF 2C,W
5155 152C: MOVWF 76
5156 152D: MOVF 2B,W
5157 152E: MOVWF 75
5158 152F: MOVF 2A,W
5159 1530: MOVWF 74
5160 1531: MOVF 29,W
5161 1532: MOVWF 73
5162 1533: BCF 0A.4
5163 1534: CALL 46F
5164 1535: BSF 0A.4
5165 1536: MOVF 60,W
5166 1537: BSF 03.5
5167 1538: MOVWF 4D
5168 1539: BCF 03.5
5169 153A: MOVF 5F,W
5170 153B: BSF 03.5
5171 153C: MOVWF 4C
5172 153D: BCF 03.5
5173 153E: MOVF 5E,W
5174 153F: BSF 03.5
5175 1540: MOVWF 4B
5176 1541: BCF 03.5
5177 1542: MOVF 5D,W
5178 1543: BSF 03.5
5179 1544: MOVWF 4A
5180 1545: MOVF 7A,W
5181 1546: MOVWF 51
5182 1547: MOVF 79,W
5183 1548: MOVWF 50
5184 1549: MOVF 78,W
5185 154A: MOVWF 4F
5186 154B: MOVF 77,W
5187 154C: MOVWF 4E
5188 154D: BCF 0A.4
5189 154E: BCF 03.5
5190 154F: CALL 20E
5191 1550: BSF 0A.4
5192 1551: MOVF 77,W
5193 1552: MOVWF 5D
5194 1553: MOVF 78,W
5195 1554: MOVWF 5E
5196 1555: MOVF 79,W
5197 1556: MOVWF 5F
5198 1557: MOVF 7A,W
5199 1558: MOVWF 60
5200 1559: MOVF 54,W
5201 155A: MOVWF 76
5202 155B: MOVF 53,W
5203 155C: MOVWF 75
5204 155D: MOVF 52,W
5205 155E: MOVWF 74
5206 155F: MOVF 51,W
5207 1560: MOVWF 73
5208 1561: BCF 0A.4
5209 1562: CALL 46F
5210 1563: BSF 0A.4
5211 1564: MOVF 60,W
5212 1565: BSF 03.5
5213 1566: MOVWF 4D
5214 1567: BCF 03.5
5215 1568: MOVF 5F,W
5216 1569: BSF 03.5
5217 156A: MOVWF 4C
5218 156B: BCF 03.5
5219 156C: MOVF 5E,W
5220 156D: BSF 03.5
5221 156E: MOVWF 4B
5222 156F: BCF 03.5
5223 1570: MOVF 5D,W
5224 1571: BSF 03.5
5225 1572: MOVWF 4A
5226 1573: MOVF 7A,W
5227 1574: MOVWF 51
5228 1575: MOVF 79,W
5229 1576: MOVWF 50
5230 1577: MOVF 78,W
5231 1578: MOVWF 4F
5232 1579: MOVF 77,W
5233 157A: MOVWF 4E
5234 157B: BCF 0A.4
5235 157C: BCF 03.5
5236 157D: CALL 20E
5237 157E: BSF 0A.4
5238 157F: CLRF 5E
5239 1580: MOVF 04,W
5240 1581: MOVWF 5D
5241 1582: BCF 5E.0
5242 1583: BTFSC 03.7
5243 1584: BSF 5E.0
5244 1585: BCF 03.1
5245 1586: MOVF 5C,W
5246 1587: BSF 03.5
5247 1588: MOVWF 4D
5248 1589: BCF 03.5
5249 158A: MOVF 5B,W
5250 158B: BSF 03.5
5251 158C: MOVWF 4C
5252 158D: BCF 03.5
5253 158E: MOVF 5A,W
5254 158F: BSF 03.5
5255 1590: MOVWF 4B
5256 1591: BCF 03.5
5257 1592: MOVF 59,W
5258 1593: BSF 03.5
5259 1594: MOVWF 4A
5260 1595: MOVF 7A,W
5261 1596: MOVWF 51
5262 1597: MOVF 79,W
5263 1598: MOVWF 50
5264 1599: MOVF 78,W
5265 159A: MOVWF 4F
5266 159B: MOVF 77,W
5267 159C: MOVWF 4E
5268 159D: BCF 0A.4
5269 159E: BCF 03.5
5270 159F: CALL 2C7
5271 15A0: BSF 0A.4
5272 15A1: MOVF 5D,W
5273 15A2: MOVWF 04
5274 15A3: BCF 03.7
5275 15A4: BTFSC 5E.0
5276 15A5: BSF 03.7
5277 15A6: MOVF 77,W
5278 15A7: MOVWF 59
5279 15A8: MOVF 78,W
5280 15A9: MOVWF 5A
5281 15AA: MOVF 79,W
5282 15AB: MOVWF 5B
5283 15AC: MOVF 7A,W
5284 15AD: MOVWF 5C
5285 15AE: MOVF 5C,W
5286 15AF: MOVWF 62
5287 15B0: MOVF 5B,W
5288 15B1: MOVWF 61
5289 15B2: MOVF 5A,W
5290 15B3: MOVWF 60
5291 15B4: MOVF 59,W
5292 15B5: MOVWF 5F
5293 *
5294 15D4: MOVF 7A,W
5295 15D5: MOVWF 38
5296 15D6: MOVF 79,W
5297 15D7: MOVWF 37
5298 15D8: MOVF 78,W
5299 15D9: MOVWF 36
5300 15DA: MOVF 77,W
5301 15DB: MOVWF 35
5302 .................... azi = acos(((sin(deklin)*cos(sirka))-(cos(deklin)*sin(sirka)*cos(hra1)))/(cos(ele)));
5303 15DC: MOVF 40,W
5304 15DD: MOVWF 6E
5305 15DE: MOVF 3F,W
5306 15DF: MOVWF 6D
5307 15E0: MOVF 3E,W
5308 15E1: MOVWF 6C
5309 15E2: MOVF 3D,W
5310 15E3: MOVWF 6B
5311 15E4: BCF 0A.4
5312 15E5: CALL 644
5313 15E6: BSF 0A.4
5314 15E7: MOVF 77,W
5315 15E8: MOVWF 59
5316 15E9: MOVF 78,W
5317 15EA: MOVWF 5A
5318 15EB: MOVF 79,W
5319 15EC: MOVWF 5B
5320 15ED: MOVF 7A,W
5321 15EE: MOVWF 5C
5322 15EF: MOVF 2C,W
5323 15F0: MOVWF 76
5324 15F1: MOVF 2B,W
5325 15F2: MOVWF 75
5326 15F3: MOVF 2A,W
5327 15F4: MOVWF 74
5328 15F5: MOVF 29,W
5329 15F6: MOVWF 73
5330 15F7: BCF 0A.4
5331 15F8: CALL 46F
5332 15F9: BSF 0A.4
5333 15FA: MOVF 5C,W
5334 15FB: BSF 03.5
5335 15FC: MOVWF 4D
5336 15FD: BCF 03.5
5337 15FE: MOVF 5B,W
5338 15FF: BSF 03.5
5339 1600: MOVWF 4C
5340 1601: BCF 03.5
5341 1602: MOVF 5A,W
5342 1603: BSF 03.5
5343 1604: MOVWF 4B
5344 1605: BCF 03.5
5345 1606: MOVF 59,W
5346 1607: BSF 03.5
5347 1608: MOVWF 4A
5348 1609: MOVF 7A,W
5349 160A: MOVWF 51
5350 160B: MOVF 79,W
5351 160C: MOVWF 50
5352 160D: MOVF 78,W
5353 160E: MOVWF 4F
5354 160F: MOVF 77,W
5355 1610: MOVWF 4E
5356 1611: BCF 0A.4
5357 1612: BCF 03.5
5358 1613: CALL 20E
5359 1614: BSF 0A.4
5360 1615: MOVF 77,W
5361 1616: MOVWF 59
5362 1617: MOVF 78,W
5363 1618: MOVWF 5A
5364 1619: MOVF 79,W
5365 161A: MOVWF 5B
5366 161B: MOVF 7A,W
5367 161C: MOVWF 5C
5368 161D: MOVF 40,W
5369 161E: MOVWF 76
5370 161F: MOVF 3F,W
5371 1620: MOVWF 75
5372 1621: MOVF 3E,W
5373 1622: MOVWF 74
5374 1623: MOVF 3D,W
5375 1624: MOVWF 73
5376 1625: BCF 0A.4
5377 1626: CALL 46F
5378 1627: BSF 0A.4
5379 1628: MOVF 77,W
5380 1629: MOVWF 5D
5381 162A: MOVF 78,W
5382 162B: MOVWF 5E
5383 162C: MOVF 79,W
5384 162D: MOVWF 5F
5385 162E: MOVF 7A,W
5386 162F: MOVWF 60
5387 1630: MOVF 2C,W
5388 1631: MOVWF 6E
5389 1632: MOVF 2B,W
5390 1633: MOVWF 6D
5391 1634: MOVF 2A,W
5392 1635: MOVWF 6C
5393 1636: MOVF 29,W
5394 1637: MOVWF 6B
5395 1638: BCF 0A.4
5396 1639: CALL 644
5397 163A: BSF 0A.4
5398 163B: MOVF 60,W
5399 163C: BSF 03.5
5400 163D: MOVWF 4D
5401 163E: BCF 03.5
5402 163F: MOVF 5F,W
5403 1640: BSF 03.5
5404 1641: MOVWF 4C
5405 1642: BCF 03.5
5406 1643: MOVF 5E,W
5407 1644: BSF 03.5
5408 1645: MOVWF 4B
5409 1646: BCF 03.5
5410 1647: MOVF 5D,W
5411 1648: BSF 03.5
5412 1649: MOVWF 4A
5413 164A: MOVF 7A,W
5414 164B: MOVWF 51
5415 164C: MOVF 79,W
5416 164D: MOVWF 50
5417 164E: MOVF 78,W
5418 164F: MOVWF 4F
5419 1650: MOVF 77,W
5420 1651: MOVWF 4E
5421 1652: BCF 0A.4
5422 1653: BCF 03.5
5423 1654: CALL 20E
5424 1655: BSF 0A.4
5425 1656: MOVF 77,W
5426 1657: MOVWF 5D
5427 1658: MOVF 78,W
5428 1659: MOVWF 5E
5429 165A: MOVF 79,W
5430 165B: MOVWF 5F
5431 165C: MOVF 7A,W
5432 165D: MOVWF 60
5433 165E: MOVF 54,W
5434 165F: MOVWF 76
5435 1660: MOVF 53,W
5436 1661: MOVWF 75
5437 1662: MOVF 52,W
5438 1663: MOVWF 74
5439 1664: MOVF 51,W
5440 1665: MOVWF 73
5441 1666: BCF 0A.4
5442 1667: CALL 46F
5443 1668: BSF 0A.4
5444 1669: MOVF 60,W
5445 166A: BSF 03.5
5446 166B: MOVWF 4D
5447 166C: BCF 03.5
5448 166D: MOVF 5F,W
5449 166E: BSF 03.5
5450 166F: MOVWF 4C
5451 1670: BCF 03.5
5452 1671: MOVF 5E,W
5453 1672: BSF 03.5
5454 1673: MOVWF 4B
5455 1674: BCF 03.5
5456 1675: MOVF 5D,W
5457 1676: BSF 03.5
5458 1677: MOVWF 4A
5459 1678: MOVF 7A,W
5460 1679: MOVWF 51
5461 167A: MOVF 79,W
5462 167B: MOVWF 50
5463 167C: MOVF 78,W
5464 167D: MOVWF 4F
5465 167E: MOVF 77,W
5466 167F: MOVWF 4E
5467 1680: BCF 0A.4
5468 1681: BCF 03.5
5469 1682: CALL 20E
5470 1683: BSF 0A.4
5471 1684: CLRF 5E
5472 1685: MOVF 04,W
5473 1686: MOVWF 5D
5474 1687: BCF 5E.0
5475 1688: BTFSC 03.7
5476 1689: BSF 5E.0
5477 168A: BSF 03.1
5478 168B: MOVF 5C,W
5479 168C: BSF 03.5
5480 168D: MOVWF 4D
5481 168E: BCF 03.5
5482 168F: MOVF 5B,W
5483 1690: BSF 03.5
5484 1691: MOVWF 4C
5485 1692: BCF 03.5
5486 1693: MOVF 5A,W
5487 1694: BSF 03.5
5488 1695: MOVWF 4B
5489 1696: BCF 03.5
5490 1697: MOVF 59,W
5491 1698: BSF 03.5
5492 1699: MOVWF 4A
5493 169A: MOVF 7A,W
5494 169B: MOVWF 51
5495 169C: MOVF 79,W
5496 169D: MOVWF 50
5497 169E: MOVF 78,W
5498 169F: MOVWF 4F
5499 16A0: MOVF 77,W
5500 16A1: MOVWF 4E
5501 16A2: BCF 0A.4
5502 16A3: BCF 03.5
5503 16A4: CALL 2C7
5504 16A5: BSF 0A.4
5505 16A6: MOVF 5D,W
5506 16A7: MOVWF 04
5507 16A8: BCF 03.7
5508 16A9: BTFSC 5E.0
5509 16AA: BSF 03.7
5510 16AB: MOVF 77,W
5511 16AC: MOVWF 59
5512 16AD: MOVF 78,W
5513 16AE: MOVWF 5A
5514 16AF: MOVF 79,W
5515 16B0: MOVWF 5B
5516 16B1: MOVF 7A,W
5517 16B2: MOVWF 5C
5518 16B3: MOVF 38,W
5519 16B4: MOVWF 76
5520 16B5: MOVF 37,W
5521 16B6: MOVWF 75
5522 16B7: MOVF 36,W
5523 16B8: MOVWF 74
5524 16B9: MOVF 35,W
5525 16BA: MOVWF 73
5526 16BB: BCF 0A.4
5527 16BC: CALL 46F
5528 16BD: BSF 0A.4
5529 16BE: MOVF 5C,W
5530 16BF: BSF 03.5
5531 16C0: MOVWF 49
5532 16C1: BCF 03.5
5533 16C2: MOVF 5B,W
5534 16C3: BSF 03.5
5535 16C4: MOVWF 48
5536 16C5: BCF 03.5
5537 16C6: MOVF 5A,W
5538 16C7: BSF 03.5
5539 16C8: MOVWF 47
5540 16C9: BCF 03.5
5541 16CA: MOVF 59,W
5542 16CB: BSF 03.5
5543 16CC: MOVWF 46
5544 16CD: MOVF 7A,W
5545 16CE: MOVWF 4D
5546 16CF: MOVF 79,W
5547 16D0: MOVWF 4C
5548 16D1: MOVF 78,W
5549 16D2: MOVWF 4B
5550 16D3: MOVF 77,W
5551 16D4: MOVWF 4A
5552 16D5: BCF 0A.4
5553 16D6: BCF 03.5
5554 16D7: CALL 142
5555 16D8: BSF 0A.4
5556 16D9: MOVF 77,W
5557 16DA: MOVWF 59
5558 16DB: MOVF 78,W
5559 16DC: MOVWF 5A
5560 16DD: MOVF 79,W
5561 16DE: MOVWF 5B
5562 16DF: MOVF 7A,W
5563 16E0: MOVWF 5C
5564 16E1: MOVF 5C,W
5565 16E2: MOVWF 62
5566 16E3: MOVF 5B,W
5567 16E4: MOVWF 61
5568 16E5: MOVF 5A,W
5569 16E6: MOVWF 60
5570 16E7: MOVF 59,W
5571 16E8: MOVWF 5F
5572 *
5573 1708: MOVF 7A,W
5574 1709: MOVWF 3C
5575 170A: MOVF 79,W
5576 170B: MOVWF 3B
5577 170C: MOVF 78,W
5578 170D: MOVWF 3A
5579 170E: MOVF 77,W
5580 170F: MOVWF 39
5581 ....................
5582 .................... //printf("Azimut: %6.3f\r\n", azi);
5583 .................... //printf("Elevce: %6.3f\r\n", ele);
5584 .................... ELEVACE=stupne(ele);
5585 1710: MOVF 38,W
5586 1711: MOVWF 5C
5587 1712: MOVF 37,W
5588 1713: MOVWF 5B
5589 1714: MOVF 36,W
5590 1715: MOVWF 5A
5591 1716: MOVF 35,W
5592 1717: MOVWF 59
5593 1718: BCF 0A.4
5594 1719: CALL 66F
5595 171A: BSF 0A.4
5596 171B: MOVF 78,W
5597 171C: MOVWF 23
5598 .................... AZIMUT= stupne(azi);
5599 171D: MOVF 3C,W
5600 171E: MOVWF 5C
5601 171F: MOVF 3B,W
5602 1720: MOVWF 5B
5603 1721: MOVF 3A,W
5604 1722: MOVWF 5A
5605 1723: MOVF 39,W
5606 1724: MOVWF 59
5607 1725: BCF 0A.4
5608 1726: CALL 66F
5609 1727: BSF 0A.4
5610 1728: CLRF 7A
5611 1729: MOVF 78,W
5612 172A: MOVWF 21
5613 172B: MOVF 7A,W
5614 172C: MOVWF 22
5615 .................... if(hra1>0)
5616 172D: BSF 03.5
5617 172E: CLRF 49
5618 172F: CLRF 48
5619 1730: CLRF 47
5620 1731: CLRF 46
5621 1732: BCF 03.5
5622 1733: MOVF 54,W
5623 1734: BSF 03.5
5624 1735: MOVWF 4D
5625 1736: BCF 03.5
5626 1737: MOVF 53,W
5627 1738: BSF 03.5
5628 1739: MOVWF 4C
5629 173A: BCF 03.5
5630 173B: MOVF 52,W
5631 173C: BSF 03.5
5632 173D: MOVWF 4B
5633 173E: BCF 03.5
5634 173F: MOVF 51,W
5635 1740: BSF 03.5
5636 1741: MOVWF 4A
5637 1742: BCF 0A.4
5638 1743: BCF 03.5
5639 1744: CALL 40D
5640 1745: BSF 0A.4
5641 1746: BTFSS 03.0
5642 1747: GOTO 753
5643 .................... {
5644 .................... AZIMUT= 360-AZIMUT;
5645 1748: MOVF 21,W
5646 1749: SUBLW 68
5647 174A: MOVWF 21
5648 174B: MOVF 22,W
5649 174C: BTFSS 03.0
5650 174D: INCFSZ 22,W
5651 174E: GOTO 751
5652 174F: MOVLW 01
5653 1750: GOTO 752
5654 1751: SUBLW 01
5655 1752: MOVWF 22
5656 .................... }
5657 .................... }
5658 1753: BCF 0A.3
5659 1754: BCF 0A.4
5660 1755: GOTO 7B0 (RETURN)
5661 ....................
5662 .................... void main()
5663 .................... {
5664 *
5665 0733: CLRF 04
5666 0734: BCF 03.7
5667 0735: MOVLW 1F
5668 0736: ANDWF 03,F
5669 0737: MOVLW 71
5670 0738: BSF 03.5
5671 0739: MOVWF 0F
5672 073A: MOVF 0F,W
5673 073B: BCF 03.5
5674 073C: BCF 20.7
5675 073D: MOVF 20,W
5676 073E: BSF 03.5
5677 073F: MOVWF 07
5678 0740: BCF 03.5
5679 0741: BSF 07.7
5680 0742: BSF 03.5
5681 0743: BSF 03.6
5682 0744: MOVF 09,W
5683 0745: ANDLW C0
5684 0746: MOVWF 09
5685 0747: BCF 03.6
5686 0748: BCF 1F.4
5687 0749: BCF 1F.5
5688 074A: MOVLW 00
5689 074B: BSF 03.6
5690 074C: MOVWF 08
5691 074D: BCF 03.5
5692 074E: CLRF 07
5693 074F: CLRF 08
5694 0750: CLRF 09
5695 ....................
5696 .................... setup_adc_ports(NO_ANALOGS|VSS_VDD);
5697 *
5698 0754: BSF 03.5
5699 0755: BSF 03.6
5700 0756: MOVF 09,W
5701 0757: ANDLW C0
5702 0758: MOVWF 09
5703 0759: BCF 03.6
5704 075A: BCF 1F.4
5705 075B: BCF 1F.5
5706 075C: MOVLW 00
5707 075D: BSF 03.6
5708 075E: MOVWF 08
5709 .................... setup_adc(ADC_CLOCK_DIV_2);
5710 075F: BCF 03.5
5711 0760: BCF 03.6
5712 0761: BCF 1F.6
5713 0762: BCF 1F.7
5714 0763: BSF 03.5
5715 0764: BCF 1F.7
5716 0765: BCF 03.5
5717 0766: BSF 1F.0
5718 .................... setup_spi(SPI_SS_DISABLED);
5719 0767: BCF 14.5
5720 0768: BCF 20.5
5721 0769: MOVF 20,W
5722 076A: BSF 03.5
5723 076B: MOVWF 07
5724 076C: BCF 03.5
5725 076D: BSF 20.4
5726 076E: MOVF 20,W
5727 076F: BSF 03.5
5728 0770: MOVWF 07
5729 0771: BCF 03.5
5730 0772: BCF 20.3
5731 0773: MOVF 20,W
5732 0774: BSF 03.5
5733 0775: MOVWF 07
5734 0776: MOVLW 01
5735 0777: BCF 03.5
5736 0778: MOVWF 14
5737 0779: MOVLW 00
5738 077A: BSF 03.5
5739 077B: MOVWF 14
5740 .................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
5741 077C: MOVF 01,W
5742 077D: ANDLW C7
5743 077E: IORLW 08
5744 077F: MOVWF 01
5745 .................... setup_timer_1(T1_DISABLED);
5746 0780: BCF 03.5
5747 0781: CLRF 10
5748 .................... setup_timer_2(T2_DISABLED,0,1);
5749 0782: MOVLW 00
5750 0783: MOVWF 78
5751 0784: MOVWF 12
5752 0785: MOVLW 00
5753 0786: BSF 03.5
5754 0787: MOVWF 12
5755 .................... setup_ccp1(CCP_OFF);
5756 0788: BCF 03.5
5757 0789: BSF 20.2
5758 078A: MOVF 20,W
5759 078B: BSF 03.5
5760 078C: MOVWF 07
5761 078D: BCF 03.5
5762 078E: CLRF 17
5763 078F: BSF 03.5
5764 0790: CLRF 1B
5765 0791: CLRF 1C
5766 0792: MOVLW 01
5767 0793: MOVWF 1D
5768 .................... setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
5769 0794: BCF 03.5
5770 0795: BSF 03.6
5771 0796: CLRF 07
5772 0797: CLRF 08
5773 0798: CLRF 09
5774 ....................
5775 .................... //TODO: User Code
5776 ....................
5777 .................... while(TRUE)
5778 .................... {
5779 .................... //do promenne AZIMUT vlosti azimut a do ELEVACE elevaci slunce
5780 .................... poziceSL(11, 18, 14, 0, 0, 49, 14); //int mesic, den, hodina, minuta, odchylka èasu od GMT, sirka, delka
5781 0799: MOVLW 0B
5782 079A: BCF 03.6
5783 079B: MOVWF 24
5784 079C: MOVLW 12
5785 079D: MOVWF 25
5786 079E: MOVLW 0E
5787 079F: MOVWF 26
5788 07A0: CLRF 27
5789 07A1: CLRF 28
5790 07A2: CLRF 2C
5791 07A3: CLRF 2B
5792 07A4: MOVLW 44
5793 07A5: MOVWF 2A
5794 07A6: MOVLW 84
5795 07A7: MOVWF 29
5796 07A8: CLRF 30
5797 07A9: CLRF 2F
5798 07AA: MOVLW 60
5799 07AB: MOVWF 2E
5800 07AC: MOVLW 82
5801 07AD: MOVWF 2D
5802 07AE: BSF 0A.4
5803 07AF: GOTO 000
5804 07B0: BCF 0A.4
5805 ....................
5806 ....................
5807 .................... printf("Azimut: %ld\r\n", AZIMUT);
5808 07B1: MOVLW 0D
5809 07B2: BSF 03.6
5810 07B3: MOVWF 0D
5811 07B4: MOVLW 00
5812 07B5: MOVWF 0F
5813 07B6: BCF 03.0
5814 07B7: MOVLW 08
5815 07B8: BCF 03.6
5816 07B9: MOVWF 5C
5817 07BA: CALL 073
5818 07BB: MOVLW 10
5819 07BC: MOVWF 04
5820 07BD: MOVF 22,W
5821 07BE: MOVWF 5D
5822 07BF: MOVF 21,W
5823 07C0: MOVWF 5C
5824 07C1: CALL 0C2
5825 07C2: MOVLW 0D
5826 07C3: MOVWF 65
5827 07C4: CALL 04F
5828 07C5: MOVLW 0A
5829 07C6: MOVWF 65
5830 07C7: CALL 04F
5831 .................... printf("Elevce: %d\r\n", ELEVACE);
5832 07C8: MOVLW 14
5833 07C9: BSF 03.6
5834 07CA: MOVWF 0D
5835 07CB: MOVLW 00
5836 07CC: MOVWF 0F
5837 07CD: BCF 03.0
5838 07CE: MOVLW 08
5839 07CF: BCF 03.6
5840 07D0: MOVWF 5C
5841 07D1: CALL 073
5842 07D2: MOVF 23,W
5843 07D3: MOVWF 24
5844 07D4: MOVLW 1F
5845 07D5: MOVWF 25
5846 07D6: GOTO 6B6
5847 07D7: MOVLW 0D
5848 07D8: MOVWF 65
5849 07D9: CALL 04F
5850 07DA: MOVLW 0A
5851 07DB: MOVWF 65
5852 07DC: CALL 04F
5853 .................... delay_ms(2000);
5854 07DD: MOVLW 08
5855 07DE: MOVWF 24
5856 07DF: MOVLW FA
5857 07E0: MOVWF 25
5858 07E1: GOTO 71D
5859 07E2: DECFSZ 24,F
5860 07E3: GOTO 7DF
5861 ....................
5862 .................... }
5863 07E4: BSF 03.6
5864 07E5: GOTO 799
5865 ....................
5866 ....................
5867 ....................
5868 ....................
5869 .................... }
5870 07E6: SLEEP
5871  
5872 Configuration Fuses:
5873 Word 1: 2CF5 INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG
5874 Word 2: 3FFF NOWRT BORV40