-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathmain.lst
4881 lines (4877 loc) · 156 KB
/
main.lst
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
CCS PCH C Compiler, Version 4.114, 93460303 13-Jan-12 01:25
Filename: C:\Users\Amila\Desktop\uc_evaluation\main.lst
ROM used: 8386 bytes (26%)
Largest free fragment is 24378
RAM used: 131 (9%) at main() level
219 (14%) worst case
Stack: 8 worst case (6 in main + 2 for interrupts)
*
0000: GOTO 1FDE
*
0008: MOVWF 04
000A: MOVFF FD8,05
000E: MOVFF FE0,06
0012: MOVLB 0
0014: MOVFF FE9,0C
0018: MOVFF FEA,07
001C: MOVFF FE1,08
0020: MOVFF FE2,09
0024: MOVFF FD9,0A
0028: MOVFF FDA,0B
002C: MOVFF FF3,12
0030: MOVFF FF4,13
0034: MOVFF FFA,14
0038: MOVFF FF5,15
003C: MOVFF FF6,16
0040: MOVFF FF7,17
0044: MOVFF 00,0E
0048: MOVFF 01,0F
004C: MOVFF 02,10
0050: MOVFF 03,11
0054: BTFSS FF2.5
0056: GOTO 0060
005A: BTFSC FF2.2
005C: GOTO 01C4
0060: BTFSS FF2.4
0062: GOTO 006C
0066: BTFSC FF2.1
0068: GOTO 02BC
006C: BTFSS F9D.2
006E: GOTO 0078
0072: BTFSC F9E.2
0074: GOTO 00C6
0078: MOVFF 0E,00
007C: MOVFF 0F,01
0080: MOVFF 10,02
0084: MOVFF 11,03
0088: MOVFF 0C,FE9
008C: MOVFF 07,FEA
0090: BSF 07.7
0092: MOVFF 08,FE1
0096: MOVFF 09,FE2
009A: MOVFF 0A,FD9
009E: MOVFF 0B,FDA
00A2: MOVFF 12,FF3
00A6: MOVFF 13,FF4
00AA: MOVFF 14,FFA
00AE: MOVFF 15,FF5
00B2: MOVFF 16,FF6
00B6: MOVFF 17,FF7
00BA: MOVF 04,W
00BC: MOVFF 06,FE0
00C0: MOVFF 05,FD8
00C4: RETFIE 0
.................... #include <main.h>
.................... #include <18F452.h>
.................... //////// Standard Header file for the PIC18F452 device ////////////////
*
1E58: MOVFF 00,8E
1E5C: MOVFF 01,8F
1E60: MOVFF 02,90
1E64: MOVFF 03,91
1E68: CLRF x95
1E6A: CLRF x94
1E6C: CLRF x93
1E6E: MOVLW 80
1E70: MOVWF x92
1E72: MOVFF 03,99
1E76: MOVFF 02,98
1E7A: MOVFF 01,97
1E7E: MOVFF 00,96
1E82: BRA 1996
1E84: MOVFF 03,C1
1E88: MOVFF 02,C0
1E8C: MOVFF 01,BF
1E90: MOVFF 00,BE
1E94: CALL 08A6
.................... #device PIC18F452
.................... #list
....................
.................... #device adc=16
....................
.................... #FUSES NOWDT //No Watch Dog Timer
.................... #FUSES WDT128 //Watch Dog Timer uses 1:128 Postscale
.................... #FUSES HS //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
.................... #FUSES NOOSCSEN //Oscillator switching is disabled, main oscillator is source
.................... #FUSES NOPUT //No Power Up Timer
.................... #FUSES NOBROWNOUT //No brownout reset
.................... #FUSES BORV20 //Brownout reset at 2.0V
.................... #FUSES STVREN //Stack full/underflow will cause reset
.................... #FUSES NOLVP //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
.................... #FUSES NODEBUG //No Debug mode for ICD
.................... #FUSES NOPROTECT //Code not protected from reading
.................... #FUSES NOCPB //No Boot Block code protection
.................... #FUSES NOCPD //No EE protection
.................... #FUSES NOWRT //Program memory not write protected
.................... #FUSES NOWRTC //configuration not registers write protected
.................... #FUSES NOWRTB //Boot block not write protected
.................... #FUSES NOWRTD //Data EEPROM not write protected
.................... #FUSES NOEBTR //Memory not protected from table reads
.................... #FUSES NOEBTRB //Boot block not protected from table reads
....................
.................... #use delay(clock=10000000)
*
032C: CLRF FEA
032E: MOVLW 98
0330: MOVWF FE9
0332: MOVF FEF,W
0334: BZ 0352
0336: MOVLW 03
0338: MOVWF 01
033A: CLRF 00
033C: DECFSZ 00,F
033E: BRA 033C
0340: DECFSZ 01,F
0342: BRA 033A
0344: MOVLW 3C
0346: MOVWF 00
0348: DECFSZ 00,F
034A: BRA 0348
034C: BRA 034E
034E: DECFSZ FEF,F
0350: BRA 0336
0352: RETLW 00
.................... #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PORT1)
....................
....................
.................... #include <math.h>
.................... ////////////////////////////////////////////////////////////////////////////
.................... //// (C) Copyright 1996,2010 Custom Computer Services ////
.................... //// This source code may only be used by licensed users of the CCS C ////
.................... //// compiler. This source code may only be distributed to other ////
.................... //// licensed users of the CCS C compiler. No other use, reproduction ////
.................... //// or distribution is permitted without written permission. ////
.................... //// Derivative programs created using this software in object code ////
.................... //// form are not restricted in any way. ////
.................... ////////////////////////////////////////////////////////////////////////////
.................... //// ////
.................... //// History: ////
.................... //// * 9/20/2001 : Improvments are made to sin/cos code. ////
.................... //// The code now is small, much faster, ////
.................... //// and more accurate. ////
.................... //// * 2/21/2007 : Compiler handles & operator differently and does ////
.................... //// not return generic (int8 *) so type cast is done ////
.................... //// * 6/19/2010 : Divisions by constants converted to multiplication ////
.................... //// by its inverse to improve computation speed ////
.................... //// ////
.................... ////////////////////////////////////////////////////////////////////////////
....................
.................... #ifndef MATH_H
.................... #define MATH_H
....................
.................... #ifdef PI
.................... #undef PI
.................... #endif
.................... #define PI 3.1415926535897932
....................
....................
.................... #define SQRT2 1.4142135623730950
....................
.................... //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279};
.................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718};
....................
.................... ///////////////////////////// Round Functions //////////////////////////////
....................
.................... float32 CEIL_FLOOR(float32 x, unsigned int8 n)
.................... {
.................... float32 y, res;
.................... unsigned int16 l;
.................... int1 s;
....................
.................... s = 0;
*
0C3A: BCF xBD.0
.................... y = x;
0C3C: MOVFF B1,B6
0C40: MOVFF B0,B5
0C44: MOVFF AF,B4
0C48: MOVFF AE,B3
....................
.................... if (x < 0)
0C4C: MOVFF B1,C1
0C50: MOVFF B0,C0
0C54: MOVFF AF,BF
0C58: MOVFF AE,BE
0C5C: CLRF xC5
0C5E: CLRF xC4
0C60: CLRF xC3
0C62: CLRF xC2
0C64: RCALL 06D6
0C66: BNC 0C70
.................... {
.................... s = 1;
0C68: BSF xBD.0
.................... y = -y;
0C6A: MOVF xB4,W
0C6C: XORLW 80
0C6E: MOVWF xB4
.................... }
....................
.................... if (y <= 32768.0)
0C70: MOVFF B6,C1
0C74: MOVFF B5,C0
0C78: MOVFF B4,BF
0C7C: MOVFF B3,BE
0C80: CLRF xC5
0C82: CLRF xC4
0C84: CLRF xC3
0C86: MOVLW 8E
0C88: MOVWF xC2
0C8A: RCALL 06D6
0C8C: BC 0C90
0C8E: BNZ 0CBE
.................... res = (float32)(unsigned int16)y;
0C90: MOVFF B6,C1
0C94: MOVFF B5,C0
0C98: MOVFF B4,BF
0C9C: MOVFF B3,BE
0CA0: RCALL 08A6
0CA2: MOVFF 02,C3
0CA6: MOVFF 01,C2
0CAA: RCALL 06A0
0CAC: MOVFF 03,BA
0CB0: MOVFF 02,B9
0CB4: MOVFF 01,B8
0CB8: MOVFF 00,B7
....................
.................... else if (y < 10000000.0)
0CBC: BRA 0E38
0CBE: MOVFF B6,C1
0CC2: MOVFF B5,C0
0CC6: MOVFF B4,BF
0CCA: MOVFF B3,BE
0CCE: MOVLW 80
0CD0: MOVWF xC5
0CD2: MOVLW 96
0CD4: MOVWF xC4
0CD6: MOVLW 18
0CD8: MOVWF xC3
0CDA: MOVLW 96
0CDC: MOVWF xC2
0CDE: RCALL 06D6
0CE0: BTFSS FD8.0
0CE2: BRA 0E28
.................... {
.................... l = (unsigned int16)(y*0.000030517578125);
0CE4: MOVFF B6,C1
0CE8: MOVFF B5,C0
0CEC: MOVFF B4,BF
0CF0: MOVFF B3,BE
0CF4: CLRF xC5
0CF6: CLRF xC4
0CF8: CLRF xC3
0CFA: MOVLW 70
0CFC: MOVWF xC2
0CFE: RCALL 08DE
0D00: MOVFF 03,C1
0D04: MOVFF 02,C0
0D08: MOVFF 01,BF
0D0C: MOVFF 00,BE
0D10: RCALL 08A6
0D12: MOVFF 02,BC
0D16: MOVFF 01,BB
.................... y = 32768.0*(y*0.000030517578125 - (float32)l);
0D1A: MOVFF B6,C1
0D1E: MOVFF B5,C0
0D22: MOVFF B4,BF
0D26: MOVFF B3,BE
0D2A: CLRF xC5
0D2C: CLRF xC4
0D2E: CLRF xC3
0D30: MOVLW 70
0D32: MOVWF xC2
0D34: RCALL 08DE
0D36: MOVFF 00,BE
0D3A: MOVFF 01,BF
0D3E: MOVFF 02,C0
0D42: MOVFF 03,C1
0D46: MOVFF BC,C3
0D4A: MOVFF BB,C2
0D4E: RCALL 06A0
0D50: BSF FD8.1
0D52: MOVFF C1,C5
0D56: MOVFF C0,C4
0D5A: MOVFF BF,C3
0D5E: MOVFF BE,C2
0D62: MOVFF 03,C9
0D66: MOVFF 02,C8
0D6A: MOVFF 01,C7
0D6E: MOVFF 00,C6
0D72: RCALL 09D0
0D74: CLRF xC1
0D76: CLRF xC0
0D78: CLRF xBF
0D7A: MOVLW 8E
0D7C: MOVWF xBE
0D7E: MOVFF 03,C5
0D82: MOVFF 02,C4
0D86: MOVFF 01,C3
0D8A: MOVFF 00,C2
0D8E: RCALL 08DE
0D90: MOVFF 03,B6
0D94: MOVFF 02,B5
0D98: MOVFF 01,B4
0D9C: MOVFF 00,B3
.................... res = 32768.0*(float32)l;
0DA0: MOVFF BC,C3
0DA4: MOVFF BB,C2
0DA8: RCALL 06A0
0DAA: CLRF xC1
0DAC: CLRF xC0
0DAE: CLRF xBF
0DB0: MOVLW 8E
0DB2: MOVWF xBE
0DB4: MOVFF 03,C5
0DB8: MOVFF 02,C4
0DBC: MOVFF 01,C3
0DC0: MOVFF 00,C2
0DC4: RCALL 08DE
0DC6: MOVFF 03,BA
0DCA: MOVFF 02,B9
0DCE: MOVFF 01,B8
0DD2: MOVFF 00,B7
.................... res += (float32)(unsigned int16)y;
0DD6: MOVFF B6,C1
0DDA: MOVFF B5,C0
0DDE: MOVFF B4,BF
0DE2: MOVFF B3,BE
0DE6: RCALL 08A6
0DE8: MOVFF 02,C3
0DEC: MOVFF 01,C2
0DF0: RCALL 06A0
0DF2: BCF FD8.1
0DF4: MOVFF BA,C5
0DF8: MOVFF B9,C4
0DFC: MOVFF B8,C3
0E00: MOVFF B7,C2
0E04: MOVFF 03,C9
0E08: MOVFF 02,C8
0E0C: MOVFF 01,C7
0E10: MOVFF 00,C6
0E14: RCALL 09D0
0E16: MOVFF 03,BA
0E1A: MOVFF 02,B9
0E1E: MOVFF 01,B8
0E22: MOVFF 00,B7
.................... }
....................
.................... else
0E26: BRA 0E38
.................... res = y;
0E28: MOVFF B6,BA
0E2C: MOVFF B5,B9
0E30: MOVFF B4,B8
0E34: MOVFF B3,B7
....................
.................... y = y - (float32)(unsigned int16)y;
0E38: MOVFF B6,C1
0E3C: MOVFF B5,C0
0E40: MOVFF B4,BF
0E44: MOVFF B3,BE
0E48: RCALL 08A6
0E4A: MOVFF 02,C3
0E4E: MOVFF 01,C2
0E52: RCALL 06A0
0E54: BSF FD8.1
0E56: MOVFF B6,C5
0E5A: MOVFF B5,C4
0E5E: MOVFF B4,C3
0E62: MOVFF B3,C2
0E66: MOVFF 03,C9
0E6A: MOVFF 02,C8
0E6E: MOVFF 01,C7
0E72: MOVFF 00,C6
0E76: RCALL 09D0
0E78: MOVFF 03,B6
0E7C: MOVFF 02,B5
0E80: MOVFF 01,B4
0E84: MOVFF 00,B3
....................
.................... if (s)
0E88: BTFSS xBD.0
0E8A: BRA 0E92
.................... res = -res;
0E8C: MOVF xB8,W
0E8E: XORLW 80
0E90: MOVWF xB8
....................
.................... if (y != 0)
0E92: MOVFF B6,C1
0E96: MOVFF B5,C0
0E9A: MOVFF B4,BF
0E9E: MOVFF B3,BE
0EA2: CLRF xC5
0EA4: CLRF xC4
0EA6: CLRF xC3
0EA8: CLRF xC2
0EAA: RCALL 06D6
0EAC: BZ 0F1A
.................... {
.................... if (s == 1 && n == 0)
0EAE: BTFSS xBD.0
0EB0: BRA 0EE4
0EB2: MOVF xB2,F
0EB4: BNZ 0EE4
.................... res -= 1.0;
0EB6: BSF FD8.1
0EB8: MOVFF BA,C5
0EBC: MOVFF B9,C4
0EC0: MOVFF B8,C3
0EC4: MOVFF B7,C2
0EC8: CLRF xC9
0ECA: CLRF xC8
0ECC: CLRF xC7
0ECE: MOVLW 7F
0ED0: MOVWF xC6
0ED2: RCALL 09D0
0ED4: MOVFF 03,BA
0ED8: MOVFF 02,B9
0EDC: MOVFF 01,B8
0EE0: MOVFF 00,B7
....................
.................... if (s == 0 && n == 1)
0EE4: BTFSC xBD.0
0EE6: BRA 0F1A
0EE8: DECFSZ xB2,W
0EEA: BRA 0F1A
.................... res += 1.0;
0EEC: BCF FD8.1
0EEE: MOVFF BA,C5
0EF2: MOVFF B9,C4
0EF6: MOVFF B8,C3
0EFA: MOVFF B7,C2
0EFE: CLRF xC9
0F00: CLRF xC8
0F02: CLRF xC7
0F04: MOVLW 7F
0F06: MOVWF xC6
0F08: RCALL 09D0
0F0A: MOVFF 03,BA
0F0E: MOVFF 02,B9
0F12: MOVFF 01,B8
0F16: MOVFF 00,B7
.................... }
.................... if (x == 0)
0F1A: MOVFF B1,C1
0F1E: MOVFF B0,C0
0F22: MOVFF AF,BF
0F26: MOVFF AE,BE
0F2A: CLRF xC5
0F2C: CLRF xC4
0F2E: CLRF xC3
0F30: CLRF xC2
0F32: CALL 06D6
0F36: BNZ 0F40
.................... res = 0;
0F38: CLRF xBA
0F3A: CLRF xB9
0F3C: CLRF xB8
0F3E: CLRF xB7
....................
.................... return (res);
0F40: MOVFF B7,00
0F44: MOVFF B8,01
0F48: MOVFF B9,02
0F4C: MOVFF BA,03
.................... }
0F50: RETLW 00
....................
.................... // Overloaded Functions to take care for new Data types in PCD
.................... // Overloaded function CEIL_FLOOR() for data type - Float48
.................... #if defined(__PCD__)
.................... float48 CEIL_FLOOR(float48 x, unsigned int8 n)
.................... {
.................... float48 y, res;
.................... unsigned int16 l;
.................... int1 s;
....................
.................... s = 0;
.................... y = x;
....................
.................... if (x < 0)
.................... {
.................... s = 1;
.................... y = -y;
.................... }
....................
.................... if (y <= 32768.0)
.................... res = (float48)(unsigned int16)y;
....................
.................... else if (y < 10000000.0)
.................... {
.................... l = (unsigned int16)(y*0.000030517578125);
.................... y = 32768.0*(y*0.000030517578125 - (float48)l);
.................... res = 32768.0*(float48)l;
.................... res += (float48)(unsigned int16)y;
.................... }
....................
.................... else
.................... res = y;
....................
.................... y = y - (float48)(unsigned int16)y;
....................
.................... if (s)
.................... res = -res;
....................
.................... if (y != 0)
.................... {
.................... if (s == 1 && n == 0)
.................... res -= 1.0;
....................
.................... if (s == 0 && n == 1)
.................... res += 1.0;
.................... }
.................... if (x == 0)
.................... res = 0;
....................
.................... return (res);
.................... }
....................
....................
.................... // Overloaded function CEIL_FLOOR() for data type - Float64
.................... float64 CEIL_FLOOR(float64 x, unsigned int8 n)
.................... {
.................... float64 y, res;
.................... unsigned int16 l;
.................... int1 s;
....................
.................... s = 0;
.................... y = x;
....................
.................... if (x < 0)
.................... {
.................... s = 1;
.................... y = -y;
.................... }
....................
.................... if (y <= 32768.0)
.................... res = (float64)(unsigned int16)y;
....................
.................... else if (y < 10000000.0)
.................... {
.................... l = (unsigned int16)(y*0.000030517578125);
.................... y = 32768.0*(y*0.000030517578125 - (float64)l);
.................... res = 32768.0*(float64)l;
.................... res += (float64)(unsigned int16)y;
.................... }
....................
.................... else
.................... res = y;
....................
.................... y = y - (float64)(unsigned int16)y;
....................
.................... if (s)
.................... res = -res;
....................
.................... if (y != 0)
.................... {
.................... if (s == 1 && n == 0)
.................... res -= 1.0;
....................
.................... if (s == 0 && n == 1)
.................... res += 1.0;
.................... }
.................... if (x == 0)
.................... res = 0;
....................
.................... return (res);
.................... }
.................... #endif
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float floor(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : rounds down the number x.
.................... // Date : N/A
.................... //
.................... float32 floor(float32 x)
.................... {
.................... return CEIL_FLOOR(x,0);
*
0F6C: MOVFF AD,B1
0F70: MOVFF AC,B0
0F74: MOVFF AB,AF
0F78: MOVFF AA,AE
0F7C: CLRF xB2
0F7E: RCALL 0C3A
.................... }
0F80: GOTO 1084 (RETURN)
.................... // Following 2 functions are overloaded functions of floor() for PCD
.................... // Overloaded function floor() for data type - Float48
.................... #if defined(__PCD__)
.................... float48 floor(float48 x)
.................... {
.................... return CEIL_FLOOR(x, 0);
.................... }
....................
.................... // Overloaded function floor() for data type - Float64
.................... float64 floor(float64 x)
.................... {
.................... return CEIL_FLOOR(x, 0);
.................... }
.................... #endif
....................
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float ceil(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : rounds up the number x.
.................... // Date : N/A
.................... //
.................... float32 ceil(float32 x)
.................... {
.................... return CEIL_FLOOR(x, 1);
*
0F52: MOVFF AD,B1
0F56: MOVFF AC,B0
0F5A: MOVFF AB,AF
0F5E: MOVFF AA,AE
0F62: MOVLW 01
0F64: MOVWF xB2
0F66: RCALL 0C3A
.................... }
0F68: GOTO 103C (RETURN)
.................... // Following 2 functions are overloaded functions of ceil() for PCD
.................... // Overloaded function ceil() for data type - Float48
.................... #if defined(__PCD__)
.................... float48 ceil(float48 x)
.................... {
.................... return CEIL_FLOOR(x, 1);
.................... }
....................
.................... // Overloaded function ceil() for data type - Float64
.................... float64 ceil(float64 x)
.................... {
.................... return CEIL_FLOOR(x, 1);
.................... }
.................... #endif
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float fabs(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : Computes the absolute value of floating point number x
.................... // Returns : returns the absolute value of x
.................... // Date : N/A
.................... //
.................... #define fabs abs
....................
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float fmod(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : Computes the floating point remainder of x/y
.................... // Returns : returns the value of x= i*y, for some integer i such that, if y
.................... // is non zero, the result has the same isgn of x na dmagnitude less than the
.................... // magnitude of y. If y is zero then a domain error occurs.
.................... // Date : N/A
.................... //
....................
.................... float fmod(float32 x,float32 y)
.................... {
.................... float32 i;
.................... if (y!=0.0)
*
0F84: MOVFF A1,C1
0F88: MOVFF A0,C0
0F8C: MOVFF 9F,BF
0F90: MOVFF 9E,BE
0F94: CLRF xC5
0F96: CLRF xC4
0F98: CLRF xC3
0F9A: CLRF xC2
0F9C: CALL 06D6
0FA0: BTFSC FD8.2
0FA2: BRA 10DE
.................... {
.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);
0FA4: MOVFF 9D,BA
0FA8: MOVFF 9C,B9
0FAC: MOVFF 9B,B8
0FB0: MOVFF 9A,B7
0FB4: MOVFF A1,BE
0FB8: MOVFF A0,BD
0FBC: MOVFF 9F,BC
0FC0: MOVFF 9E,BB
0FC4: CALL 074C
0FC8: MOVFF 00,A6
0FCC: MOVFF 01,A7
0FD0: MOVFF 02,A8
0FD4: MOVFF 03,A9
0FD8: MOVFF 03,C1
0FDC: MOVFF 02,C0
0FE0: MOVFF 01,BF
0FE4: MOVFF 00,BE
0FE8: CLRF xC5
0FEA: CLRF xC4
0FEC: CLRF xC3
0FEE: CLRF xC2
0FF0: CALL 06D6
0FF4: BNC 103E
0FF6: MOVFF 9D,BA
0FFA: MOVFF 9C,B9
0FFE: MOVFF 9B,B8
1002: MOVFF 9A,B7
1006: MOVFF A1,BE
100A: MOVFF A0,BD
100E: MOVFF 9F,BC
1012: MOVFF 9E,BB
1016: CALL 074C
101A: MOVFF 00,A6
101E: MOVFF 01,A7
1022: MOVFF 02,A8
1026: MOVFF 03,A9
102A: MOVFF 03,AD
102E: MOVFF 02,AC
1032: MOVFF 01,AB
1036: MOVFF 00,AA
103A: BRA 0F52
103C: BRA 1084
103E: MOVFF 9D,BA
1042: MOVFF 9C,B9
1046: MOVFF 9B,B8
104A: MOVFF 9A,B7
104E: MOVFF A1,BE
1052: MOVFF A0,BD
1056: MOVFF 9F,BC
105A: MOVFF 9E,BB
105E: CALL 074C
1062: MOVFF 00,A6
1066: MOVFF 01,A7
106A: MOVFF 02,A8
106E: MOVFF 03,A9
1072: MOVFF 03,AD
1076: MOVFF 02,AC
107A: MOVFF 01,AB
107E: MOVFF 00,AA
1082: BRA 0F6C
1084: MOVFF 03,A5
1088: MOVFF 02,A4
108C: MOVFF 01,A3
1090: MOVFF 00,A2
.................... return(x-(i*y));
1094: MOVFF A5,C1
1098: MOVFF A4,C0
109C: MOVFF A3,BF
10A0: MOVFF A2,BE
10A4: MOVFF A1,C5
10A8: MOVFF A0,C4
10AC: MOVFF 9F,C3
10B0: MOVFF 9E,C2
10B4: RCALL 08DE
10B6: BSF FD8.1
10B8: MOVFF 9D,C5
10BC: MOVFF 9C,C4
10C0: MOVFF 9B,C3
10C4: MOVFF 9A,C2
10C8: MOVFF 03,C9
10CC: MOVFF 02,C8
10D0: MOVFF 01,C7
10D4: MOVFF 00,C6
10D8: RCALL 09D0
10DA: BRA 10DE
.................... }
.................... else
10DC: BRA 10DE
.................... {
.................... #ifdef _ERRNO
.................... {
.................... errno=EDOM;
.................... }
.................... #endif
.................... }
.................... }
10DE: RETLW 00
.................... //Overloaded function for fmod() for PCD
.................... // Overloaded function fmod() for data type - Float48
.................... #if defined(__PCD__)
.................... float48 fmod(float48 x,float48 y)
.................... {
.................... float48 i;
.................... if (y!=0.0)
.................... {
.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);
.................... return(x-(i*y));
.................... }
.................... else
.................... {
.................... #ifdef _ERRNO
.................... {
.................... errno=EDOM;
.................... }
.................... #endif
.................... }
.................... }
.................... // Overloaded function fmod() for data type - Float64
.................... float64 fmod(float64 x,float64 y)
.................... {
.................... float64 i;
.................... if (y!=0.0)
.................... {
.................... i=(x/y < 0.0)? ceil(x/y): floor(x/y);
.................... return(x-(i*y));
.................... }
.................... else
.................... {
.................... #ifdef _ERRNO
.................... {
.................... errno=EDOM;
.................... }
.................... #endif
.................... }
.................... }
.................... #endif
.................... //////////////////// Exponential and logarithmic functions ////////////////////
.................... ////////////////////////////////////////////////////////////////////////////
.................... // float exp(float x)
.................... ////////////////////////////////////////////////////////////////////////////
.................... // Description : returns the value (e^x)
.................... // Date : N/A
.................... //
.................... #define LN2 0.6931471805599453
.................... #define LN2_INV 1.4426950408889634073
....................
.................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,
.................... 0.0554965651, 0.240227138, 0.693147172};
....................
....................
.................... float32 exp(float32 x)
.................... {
.................... float32 y, res, r;
.................... #if defined(__PCD__)
.................... int8 data1;
.................... #endif
.................... signed int8 n;
.................... int1 s;
.................... #ifdef _ERRNO
.................... if(x > 88.722838)
.................... {
.................... errno=ERANGE;
.................... return(0);
.................... }
.................... #endif
.................... n = (signed int16)(x*LN2_INV);
*
15C4: MOVFF A1,C1
15C8: MOVFF A0,C0
15CC: MOVFF 9F,BF
15D0: MOVFF 9E,BE
15D4: MOVLW 3B
15D6: MOVWF xC5
15D8: MOVLW AA
15DA: MOVWF xC4
15DC: MOVLW 38
15DE: MOVWF xC3
15E0: MOVLW 7F
15E2: MOVWF xC2
15E4: CALL 08DE
15E8: MOVFF 03,C1
15EC: MOVFF 02,C0
15F0: MOVFF 01,BF
15F4: MOVFF 00,BE
15F8: CALL 08A6
15FC: MOVFF 01,AE
.................... s = 0;
1600: BCF xAF.0
.................... y = x;
1602: MOVFF A1,A5
1606: MOVFF A0,A4
160A: MOVFF 9F,A3
160E: MOVFF 9E,A2
....................
.................... if (x < 0)
1612: MOVFF A1,C1
1616: MOVFF A0,C0
161A: MOVFF 9F,BF
161E: MOVFF 9E,BE
1622: CLRF xC5
1624: CLRF xC4
1626: CLRF xC3
1628: CLRF xC2
162A: CALL 06D6
162E: BNC 163A
.................... {
.................... s = 1;
1630: BSF xAF.0
.................... n = -n;
1632: NEGF xAE
.................... y = -y;
1634: MOVF xA3,W
1636: XORLW 80
1638: MOVWF xA3
.................... }
....................
.................... res = 0.0;
163A: CLRF xA9
163C: CLRF xA8
163E: CLRF xA7
1640: CLRF xA6
.................... #if !defined(__PCD__)
.................... *((unsigned int8 *)(&res)) = n + 0x7F;
1642: CLRF xB1
1644: MOVLW A6
1646: MOVWF FE9
1648: MOVFF B1,FEA
164C: MOVLW 7F
164E: ADDWF xAE,W
1650: MOVWF FEF
.................... #endif
....................
.................... #if defined(__PCD__) // Takes care of IEEE format for PCD
.................... data1 = n+0x7F;
.................... if(bit_test(data1,0))
.................... bit_set(*(((unsigned int8 *)(&res)+2)),7);
.................... rotate_right(&data1,1);
.................... bit_clear(data1,7);
.................... *(((unsigned int8 *)(&res)+3)) = data1;
.................... #endif
....................
.................... y = y*LN2_INV - (float32)n;
1652: MOVFF A5,C1
1656: MOVFF A4,C0
165A: MOVFF A3,BF
165E: MOVFF A2,BE
1662: MOVLW 3B
1664: MOVWF xC5
1666: MOVLW AA
1668: MOVWF xC4
166A: MOVLW 38
166C: MOVWF xC3
166E: MOVLW 7F
1670: MOVWF xC2
1672: CALL 08DE
1676: MOVFF 00,B0
167A: MOVFF 01,B1
167E: MOVFF 02,B2
1682: MOVFF 03,B3
1686: CLRF xB5
1688: MOVFF AE,B4
168C: BTFSC xB4.7
168E: DECF xB5,F
1690: RCALL 10E0
1692: BSF FD8.1
1694: MOVFF B3,C5
1698: MOVFF B2,C4
169C: MOVFF B1,C3
16A0: MOVFF B0,C2
16A4: MOVFF 03,C9
16A8: MOVFF 02,C8
16AC: MOVFF 01,C7
16B0: MOVFF 00,C6
16B4: CALL 09D0
16B8: MOVFF 03,A5
16BC: MOVFF 02,A4
16C0: MOVFF 01,A3
16C4: MOVFF 00,A2
....................
.................... r = pe[0]*y + pe[1];
16C8: MOVLW 7C
16CA: MOVWF xC1
16CC: MOVLW 88
16CE: MOVWF xC0
16D0: MOVLW 59
16D2: MOVWF xBF
16D4: MOVLW 72
16D6: MOVWF xBE
16D8: MOVFF A5,C5
16DC: MOVFF A4,C4
16E0: MOVFF A3,C3
16E4: MOVFF A2,C2
16E8: CALL 08DE
16EC: MOVFF 00,B0
16F0: MOVFF 01,B1
16F4: MOVFF 02,B2
16F8: MOVFF 03,B3
16FC: BCF FD8.1
16FE: MOVFF 03,C5
1702: MOVFF 02,C4
1706: MOVFF 01,C3
170A: MOVFF 00,C2
170E: MOVLW E0
1710: MOVWF xC9
1712: MOVLW 97
1714: MOVWF xC8
1716: MOVLW 26
1718: MOVWF xC7
171A: MOVLW 75
171C: MOVWF xC6
171E: CALL 09D0
1722: MOVFF 03,AD