@mchp-mcc/scf-pic8-pwm-v2 4.2.9 → 4.2.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (25) hide show
  1. package/Changelog.md +6 -8
  2. package/Readme.md +6 -8
  3. package/output/autoCreator.js +12 -5
  4. package/output/autoCreator.js.map +1 -1
  5. package/output/autoProcessor.js +12 -5
  6. package/output/autoProcessor.js.map +1 -1
  7. package/output/creator.js +33 -5
  8. package/output/creator.js.map +1 -1
  9. package/output/processor.js +33 -5
  10. package/output/processor.js.map +1 -1
  11. package/package.json +9 -8
  12. package/src/CreatorFunctions.ts +0 -17
  13. package/src/DerivedData.test.ts +0 -654
  14. package/src/DerivedData.ts +0 -346
  15. package/src/GeneratorModel.test.tsx +0 -39
  16. package/src/GeneratorModel.tsx +0 -65
  17. package/src/PinsLogic.test.ts +0 -2838
  18. package/src/PinsLogic.ts +0 -213
  19. package/src/PwmCalculator.test.tsx +0 -113
  20. package/src/PwmCalculator.tsx +0 -67
  21. package/src/catalog.json +0 -23
  22. package/src/interfaces/pwm_general_parameters.test.tsx +0 -40
  23. package/src/interfaces/pwm_general_parameters.tsx +0 -121
  24. package/src/moduleConfig.json +0 -433
  25. package/src/pinsdata.json +0 -54
package/src/PinsLogic.test.ts DELETED
@@ -1,2838 +0,0 @@
1
- import { behaviour, direction, pin_row } from "@microchip/pin-standard";
2
- //import { getModel } from "../generated_module/src/App/AppModel";
3
- import { MyState } from "../generated_module/src/types/AutoModuleTypes";
4
- import { getModel, mockState } from "../generated_module/tests/AppModel.test";
5
- import { mockAssignedModule } from "../generated_module/tests/processor.test";
6
- import { getDerivedData } from "./DerivedData";
7
- import { getRowData } from "./PinsLogic";
8
-
9
- export const getMockState = (): MyState => {
10
- return {
11
- main: {
12
- software: {
13
- componentName: "PWM4",
14
- tmr2Dependency: "TMR2",
15
- },
16
- hardware: {
17
- timerSelection: "TMR2",
18
- dutyCycle: 50,
19
- pwmdcValue: 511,
20
- pwmPeriod: 0.001024,
21
- pwmFrequency: 976.56,
22
- pwmResolution: 10,
23
- pwmpolPwmcon: "active_hi",
24
- pwmenPwmcon: true,
25
- },
26
- },
27
- };
28
- };
29
-
30
- describe("PinsLogic --> Test Cases ", () => {
31
- describe("getRowData() test case ", () => {
32
- const mockModule = mockAssignedModule(getMockState());
33
- const model = getModel(mockModule, getDerivedData as any);
34
-
35
- const pwmPpsData: pin_row = {
36
- name: "pwmPps",
37
- module: "PWM6",
38
- function: "PWM6OUT",
39
- direction: direction.output,
40
- filter: {
41
- module: "PWM6",
42
- aliasReEx: "PWM[0-9]",
43
- },
44
- behaviour: behaviour.PPS,
45
- };
46
- it("Test for pwmPpsData pin data: PWM mode", () => {
47
- if (model) {
48
- expect(getRowData(model as any, pwmPpsData)?.actions).toBeUndefined();
49
- } else {
50
- throw "Model not configured for testcase";
51
- }
52
- });
53
- });
54
-
55
- describe("getRowData() test case for out pin ", () => {
56
- const mockModule = mockAssignedModule(getMockState());
57
- const model = getModel(mockModule, getDerivedData as any);
58
-
59
- if (model) {
60
- model.getName = (): string => {
61
- return "PWM1";
62
- };
63
- model.getComponentValue = (cmp: string): any => {
64
- const data = {
65
- pwmoutPwmcon: "PWM1OUT",
66
- };
67
- return data[cmp];
68
- };
69
- model.getImportValue = (imp: string): any => {
70
- return {
71
- allpins: {
72
- RA0: {
73
- PWM1: {
74
- PWM10: {
75
- alias: "PWM10",
76
- pps: {
77
- direction: "output",
78
- },
79
- },
80
- },
81
- },
82
- RA1: {
83
- PWM1: {
84
- PWM11: {
85
- alias: "PWM11",
86
- pps: {
87
- direction: "output",
88
- },
89
- },
90
- },
91
- },
92
- RA2: {
93
- PWM1: {
94
- PWM12: {
95
- alias: "PWM12",
96
- pps: {
97
- direction: "output",
98
- },
99
- },
100
- },
101
- },
102
- RA3: {
103
- PWM1: {
104
- PWM13: {
105
- alias: "PWM13",
106
- pps: {
107
- direction: "output",
108
- },
109
- },
110
- },
111
- },
112
- RB0: {
113
- PWM2: {
114
- PWM20: {
115
- alias: "PWM20",
116
- pps: {
117
- direction: "output",
118
- },
119
- },
120
- },
121
- },
122
- RB1: {
123
- PWM2: {
124
- PWM21: {
125
- alias: "PWM21",
126
- pps: {
127
- direction: "output",
128
- },
129
- },
130
- },
131
- },
132
- RB2: {
133
- PWM2: {
134
- PWM22: {
135
- alias: "PWM22",
136
- pps: {
137
- direction: "output",
138
- },
139
- },
140
- },
141
- },
142
- RB3: {
143
- PWM2: {
144
- PWM23: {
145
- alias: "PWM23",
146
- pps: {
147
- direction: "output",
148
- },
149
- },
150
- },
151
- },
152
- RC2: {
153
- PWM1: {
154
- PWM1: {
155
- alias: "PWM1",
156
- pps: {
157
- direction: "output",
158
- },
159
- },
160
- },
161
- },
162
- RC3: {
163
- PWM2: {
164
- PWM2: {
165
- alias: "PWM2",
166
- pps: {
167
- direction: "output",
168
- },
169
- },
170
- },
171
- },
172
- },
173
- };
174
- };
175
- }
176
-
177
- const pwmData: pin_row = {
178
- name: "out",
179
- module: "PWM1",
180
- function: "PWM1OUT",
181
- direction: direction.output,
182
- filter: {
183
- module: "PWM1",
184
- aliasReEx: "^PWM[0-9]$",
185
- },
186
- behaviour: behaviour.PPS,
187
- };
188
- const expectedData: pin_row = {
189
- name: "out",
190
- module: "PWM1",
191
- function: "PWM1OUT",
192
- direction: direction.output,
193
- filter: {
194
- module: "PWM1",
195
- aliasReEx: "^PWM7$",
196
- },
197
- behaviour: behaviour.PPS,
198
- };
199
- it("Test for pwmPpsData pin data: PWM out pin", () => {
200
- if (model) {
201
- expect(getRowData(model as any, pwmData)).toMatchObject(expectedData);
202
- } else {
203
- throw "Model not configured for testcase";
204
- }
205
- });
206
- });
207
-
208
- describe("getRowData() test case for PWM Additional pin 0 ", () => {
209
- const mockModule = mockAssignedModule(getMockState());
210
- const model = getModel(mockModule, getDerivedData as any);
211
-
212
- if (model) {
213
- model.getName = (): string => {
214
- return "PWM1";
215
- };
216
- model.getComponentValue = (cmp: string): any => {
217
- const data = {
218
- pwmoe0Pwmaoe: "PWM10OUT",
219
- };
220
- return data[cmp];
221
- };
222
- model.getImportValue = (imp: string): any => {
223
- return {
224
- allpins: {
225
- RA0: {
226
- PWM1: {
227
- PWM10: {
228
- alias: "PWM10",
229
- pps: {
230
- direction: "output",
231
- },
232
- },
233
- },
234
- },
235
- RA1: {
236
- PWM1: {
237
- PWM11: {
238
- alias: "PWM11",
239
- pps: {
240
- direction: "output",
241
- },
242
- },
243
- },
244
- },
245
- RA2: {
246
- PWM1: {
247
- PWM12: {
248
- alias: "PWM12",
249
- pps: {
250
- direction: "output",
251
- },
252
- },
253
- },
254
- },
255
- RA3: {
256
- PWM1: {
257
- PWM13: {
258
- alias: "PWM13",
259
- pps: {
260
- direction: "output",
261
- },
262
- },
263
- },
264
- },
265
- RB0: {
266
- PWM2: {
267
- PWM20: {
268
- alias: "PWM20",
269
- pps: {
270
- direction: "output",
271
- },
272
- },
273
- },
274
- },
275
- RB1: {
276
- PWM2: {
277
- PWM21: {
278
- alias: "PWM21",
279
- pps: {
280
- direction: "output",
281
- },
282
- },
283
- },
284
- },
285
- RB2: {
286
- PWM2: {
287
- PWM22: {
288
- alias: "PWM22",
289
- pps: {
290
- direction: "output",
291
- },
292
- },
293
- },
294
- },
295
- RB3: {
296
- PWM2: {
297
- PWM23: {
298
- alias: "PWM23",
299
- pps: {
300
- direction: "output",
301
- },
302
- },
303
- },
304
- },
305
- RC2: {
306
- PWM1: {
307
- PWM1: {
308
- alias: "PWM1",
309
- pps: {
310
- direction: "output",
311
- },
312
- },
313
- },
314
- },
315
- RC3: {
316
- PWM2: {
317
- PWM2: {
318
- alias: "PWM2",
319
- pps: {
320
- direction: "output",
321
- },
322
- },
323
- },
324
- },
325
- },
326
- };
327
- };
328
- }
329
-
330
- const pwmData: pin_row = {
331
- name: "pwmx0",
332
- module: "PWM1",
333
- function: "PWM10OUT",
334
- direction: direction.output,
335
- filter: {
336
- module: "PWM10",
337
- aliasReEx: "^PWM[0-9]0$",
338
- },
339
- behaviour: behaviour.LOCK_UNLOCK,
340
- };
341
- const expectedData: pin_row = {
342
- name: "pwmx0",
343
- module: "PWM1",
344
- function: "PWM10OUT",
345
- direction: direction.output,
346
- filter: {
347
- module: "PWM1",
348
- aliasReEx: "^PWM[0-9]0$",
349
- },
350
- behaviour: behaviour.PPS,
351
- };
352
- it("Test for pwmPpsData pin data: PWM Additional pin 0", () => {
353
- if (model) {
354
- expect(getRowData(model as any, pwmData)).toMatchObject(expectedData);
355
- expect(getRowData(model as any, pwmData)?.actions).toBeDefined();
356
- } else {
357
- throw "Model not configured for testcase";
358
- }
359
- });
360
- });
361
-
362
- describe("getRowData() test case for PWM Additional pin 1 ", () => {
363
- const mockModule = mockAssignedModule(getMockState());
364
- const model = getModel(mockModule, getDerivedData as any);
365
-
366
- if (model) {
367
- model.getName = (): string => {
368
- return "PWM1";
369
- };
370
- model.getComponentValue = (cmp: string): any => {
371
- const data = {
372
- pwmoe1Pwmaoe: "PWM11OUT",
373
- };
374
- return data[cmp];
375
- };
376
- model.getImportValue = (imp: string): any => {
377
- return {
378
- allpins: {
379
- RA0: {
380
- PWM1: {
381
- PWM10: {
382
- alias: "PWM10",
383
- pps: {
384
- direction: "output",
385
- },
386
- },
387
- },
388
- },
389
- RA1: {
390
- PWM1: {
391
- PWM11: {
392
- alias: "PWM11",
393
- pps: {
394
- direction: "output",
395
- },
396
- },
397
- },
398
- },
399
- RA2: {
400
- PWM1: {
401
- PWM12: {
402
- alias: "PWM12",
403
- pps: {
404
- direction: "output",
405
- },
406
- },
407
- },
408
- },
409
- RA3: {
410
- PWM1: {
411
- PWM13: {
412
- alias: "PWM13",
413
- pps: {
414
- direction: "output",
415
- },
416
- },
417
- },
418
- },
419
- RB0: {
420
- PWM2: {
421
- PWM20: {
422
- alias: "PWM20",
423
- pps: {
424
- direction: "output",
425
- },
426
- },
427
- },
428
- },
429
- RB1: {
430
- PWM2: {
431
- PWM21: {
432
- alias: "PWM21",
433
- pps: {
434
- direction: "output",
435
- },
436
- },
437
- },
438
- },
439
- RB2: {
440
- PWM2: {
441
- PWM22: {
442
- alias: "PWM22",
443
- pps: {
444
- direction: "output",
445
- },
446
- },
447
- },
448
- },
449
- RB3: {
450
- PWM2: {
451
- PWM23: {
452
- alias: "PWM23",
453
- pps: {
454
- direction: "output",
455
- },
456
- },
457
- },
458
- },
459
- RC2: {
460
- PWM1: {
461
- PWM1: {
462
- alias: "PWM1",
463
- pps: {
464
- direction: "output",
465
- },
466
- },
467
- },
468
- },
469
- RC3: {
470
- PWM2: {
471
- PWM2: {
472
- alias: "PWM2",
473
- pps: {
474
- direction: "output",
475
- },
476
- },
477
- },
478
- },
479
- },
480
- };
481
- };
482
- }
483
-
484
- const pwmData: pin_row = {
485
- name: "pwmx1",
486
- module: "PWM1",
487
- function: "PWM10OUT",
488
- direction: direction.output,
489
- filter: {
490
- module: "PWM11",
491
- aliasReEx: "^PWM[0-9]1$",
492
- },
493
- behaviour: behaviour.LOCK_UNLOCK,
494
- };
495
- const expectedData: pin_row = {
496
- name: "pwmx1",
497
- module: "PWM1",
498
- function: "PWM11OUT",
499
- direction: direction.output,
500
- filter: {
501
- module: "PWM1",
502
- aliasReEx: "^PWM[0-9]1$",
503
- },
504
- behaviour: behaviour.PPS,
505
- };
506
- it("Test for pwmPpsData pin data: PWM Additional pin 1", () => {
507
- if (model) {
508
- expect(getRowData(model as any, pwmData)).toMatchObject(expectedData);
509
- expect(getRowData(model as any, pwmData)?.actions).toBeDefined();
510
- } else {
511
- throw "Model not configured for testcase";
512
- }
513
- });
514
- });
515
-
516
- describe("getRowData() test case for PWM Additional pin 2 ", () => {
517
- const mockModule = mockAssignedModule(getMockState());
518
- const model = getModel(mockModule, getDerivedData as any);
519
-
520
- if (model) {
521
- model.getName = (): string => {
522
- return "PWM2";
523
- };
524
- model.getComponentValue = (cmp: string): any => {
525
- const data = {
526
- pwmoe2Pwmaoe: "PWM22OUT",
527
- };
528
- return data[cmp];
529
- };
530
- model.getImportValue = (imp: string): any => {
531
- return {
532
- allpins: {
533
- RA0: {
534
- PWM1: {
535
- PWM10: {
536
- alias: "PWM10",
537
- pps: {
538
- direction: "output",
539
- },
540
- },
541
- },
542
- },
543
- RA1: {
544
- PWM1: {
545
- PWM11: {
546
- alias: "PWM11",
547
- pps: {
548
- direction: "output",
549
- },
550
- },
551
- },
552
- },
553
- RA2: {
554
- PWM1: {
555
- PWM12: {
556
- alias: "PWM12",
557
- pps: {
558
- direction: "output",
559
- },
560
- },
561
- },
562
- },
563
- RA3: {
564
- PWM1: {
565
- PWM13: {
566
- alias: "PWM13",
567
- pps: {
568
- direction: "output",
569
- },
570
- },
571
- },
572
- },
573
- RB0: {
574
- PWM2: {
575
- PWM20: {
576
- alias: "PWM20",
577
- pps: {
578
- direction: "output",
579
- },
580
- },
581
- },
582
- },
583
- RB1: {
584
- PWM2: {
585
- PWM21: {
586
- alias: "PWM21",
587
- pps: {
588
- direction: "output",
589
- },
590
- },
591
- },
592
- },
593
- RB2: {
594
- PWM2: {
595
- PWM22: {
596
- alias: "PWM22",
597
- pps: {
598
- direction: "output",
599
- },
600
- },
601
- },
602
- },
603
- RB3: {
604
- PWM2: {
605
- PWM23: {
606
- alias: "PWM23",
607
- pps: {
608
- direction: "output",
609
- },
610
- },
611
- },
612
- },
613
- RC2: {
614
- PWM1: {
615
- PWM1: {
616
- alias: "PWM1",
617
- pps: {
618
- direction: "output",
619
- },
620
- },
621
- },
622
- },
623
- RC3: {
624
- PWM2: {
625
- PWM2: {
626
- alias: "PWM2",
627
- pps: {
628
- direction: "output",
629
- },
630
- },
631
- },
632
- },
633
- },
634
- };
635
- };
636
- }
637
-
638
- const pwmData: pin_row = {
639
- name: "pwmx2",
640
- module: "PWM2",
641
- function: "PWM22OUT",
642
- direction: direction.output,
643
- filter: {
644
- module: "PWM21",
645
- aliasReEx: "^PWM[0-9]2$",
646
- },
647
- behaviour: behaviour.LOCK_UNLOCK,
648
- };
649
- const expectedData: pin_row = {
650
- name: "pwmx2",
651
- module: "PWM2",
652
- function: "PWM22OUT",
653
- direction: direction.output,
654
- filter: {
655
- module: "PWM2",
656
- aliasReEx: "^PWM[0-9]2$",
657
- },
658
- behaviour: behaviour.PPS,
659
- };
660
- it("Test for pwmPpsData pin data: PWM Additional pin 2", () => {
661
- if (model) {
662
- expect(getRowData(model as any, pwmData)).toMatchObject(expectedData);
663
- expect(getRowData(model as any, pwmData)?.actions).toBeDefined();
664
- } else {
665
- throw "Model not configured for testcase";
666
- }
667
- });
668
- });
669
-
670
- describe("getRowData() test case for PWM Additional pin 3 ", () => {
671
- const mockModule = mockAssignedModule(getMockState());
672
- const model = getModel(mockModule, getDerivedData as any);
673
-
674
- if (model) {
675
- model.getName = (): string => {
676
- return "PWM2";
677
- };
678
- model.getComponentValue = (cmp: string): any => {
679
- const data = {
680
- pwmoe3Pwmaoe: "PWM23OUT",
681
- };
682
- return data[cmp];
683
- };
684
- model.getImportValue = (imp: string): any => {
685
- return {
686
- allpins: {
687
- RA0: {
688
- PWM1: {
689
- PWM10: {
690
- alias: "PWM10",
691
- pps: {
692
- direction: "output",
693
- },
694
- },
695
- },
696
- },
697
- RA1: {
698
- PWM1: {
699
- PWM11: {
700
- alias: "PWM11",
701
- pps: {
702
- direction: "output",
703
- },
704
- },
705
- },
706
- },
707
- RA2: {
708
- PWM1: {
709
- PWM12: {
710
- alias: "PWM12",
711
- pps: {
712
- direction: "output",
713
- },
714
- },
715
- },
716
- },
717
- RA3: {
718
- PWM1: {
719
- PWM13: {
720
- alias: "PWM13",
721
- pps: {
722
- direction: "output",
723
- },
724
- },
725
- },
726
- },
727
- RB0: {
728
- PWM2: {
729
- PWM20: {
730
- alias: "PWM20",
731
- pps: {
732
- direction: "output",
733
- },
734
- },
735
- },
736
- },
737
- RB1: {
738
- PWM2: {
739
- PWM21: {
740
- alias: "PWM21",
741
- pps: {
742
- direction: "output",
743
- },
744
- },
745
- },
746
- },
747
- RB2: {
748
- PWM2: {
749
- PWM22: {
750
- alias: "PWM22",
751
- pps: {
752
- direction: "output",
753
- },
754
- },
755
- },
756
- },
757
- RB3: {
758
- PWM2: {
759
- PWM23: {
760
- alias: "PWM23",
761
- pps: {
762
- direction: "output",
763
- },
764
- },
765
- },
766
- },
767
- RC2: {
768
- PWM1: {
769
- PWM1: {
770
- alias: "PWM1",
771
- pps: {
772
- direction: "output",
773
- },
774
- },
775
- },
776
- },
777
- RC3: {
778
- PWM2: {
779
- PWM2: {
780
- alias: "PWM2",
781
- pps: {
782
- direction: "output",
783
- },
784
- },
785
- },
786
- },
787
- },
788
- };
789
- };
790
- }
791
-
792
- const pwmData: pin_row = {
793
- name: "pwmx3",
794
- module: "PWM2",
795
- function: "PWM23OUT",
796
- direction: direction.output,
797
- filter: {
798
- module: "PWM23",
799
- aliasReEx: "^PWM[0-9]3$",
800
- },
801
- behaviour: behaviour.LOCK_UNLOCK,
802
- };
803
- const expectedData: pin_row = {
804
- name: "pwmx3",
805
- module: "PWM2",
806
- function: "PWM23OUT",
807
- direction: direction.output,
808
- filter: {
809
- module: "PWM2",
810
- aliasReEx: "^PWM[0-9]3$",
811
- },
812
- behaviour: behaviour.PPS,
813
- };
814
- it("Test for pwmPpsData pin data: PWM Additional pin 3", () => {
815
- if (model) {
816
- expect(getRowData(model as any, pwmData)).toMatchObject(expectedData);
817
- expect(getRowData(model as any, pwmData)?.actions).toBeDefined();
818
- } else {
819
- throw "Model not configured for testcase";
820
- }
821
- });
822
- });
823
-
824
- describe("getRowData() test case : invalid", () => {
825
- const mockModule = mockAssignedModule(mockState());
826
- const model = getModel(mockModule, getDerivedData as any);
827
-
828
- if (model) {
829
- model.getName = (): string => {
830
- return "PWM1";
831
- };
832
- model.getComponentValue = (cmp: string): any => {
833
- const data = {
834
- pwmoutPwmcon: "PWM1OUT",
835
- };
836
- return data[cmp];
837
- };
838
- model.getImportValue = (imp: string): any => {
839
- return {
840
- allpins: {
841
- RA0: {
842
- PWM1: {
843
- PWM10: {
844
- alias: "PWM10",
845
- pps: {
846
- direction: "output",
847
- },
848
- },
849
- },
850
- },
851
- RA1: {
852
- PWM1: {
853
- PWM11: {
854
- alias: "PWM11",
855
- pps: {
856
- direction: "output",
857
- },
858
- },
859
- },
860
- },
861
- RA2: {
862
- PWM1: {
863
- PWM12: {
864
- alias: "PWM12",
865
- pps: {
866
- direction: "output",
867
- },
868
- },
869
- },
870
- },
871
- RA3: {
872
- PWM1: {
873
- PWM13: {
874
- alias: "PWM13",
875
- pps: {
876
- direction: "output",
877
- },
878
- },
879
- },
880
- },
881
- RB0: {
882
- PWM2: {
883
- PWM20: {
884
- alias: "PWM20",
885
- pps: {
886
- direction: "output",
887
- },
888
- },
889
- },
890
- },
891
- RB1: {
892
- PWM2: {
893
- PWM21: {
894
- alias: "PWM21",
895
- pps: {
896
- direction: "output",
897
- },
898
- },
899
- },
900
- },
901
- RB2: {
902
- PWM2: {
903
- PWM22: {
904
- alias: "PWM22",
905
- pps: {
906
- direction: "output",
907
- },
908
- },
909
- },
910
- },
911
- RB3: {
912
- PWM2: {
913
- PWM23: {
914
- alias: "PWM23",
915
- pps: {
916
- direction: "output",
917
- },
918
- },
919
- },
920
- },
921
- RC2: {
922
- PWM1: {
923
- PWM1: {
924
- alias: "PWM1",
925
- pps: {
926
- direction: "output",
927
- },
928
- },
929
- },
930
- },
931
- RC3: {
932
- PWM2: {
933
- PWM2: {
934
- alias: "PWM2",
935
- pps: {
936
- direction: "output",
937
- },
938
- },
939
- },
940
- },
941
- },
942
- };
943
- };
944
- }
945
-
946
- const pwmPpsData: pin_row = {
947
- name: "dummy",
948
- module: "PWM1",
949
- function: "PWM1OUT",
950
- direction: direction.output,
951
- filter: {
952
- module: "PWM1",
953
- aliasReEx: "PWM[0-9]",
954
- },
955
- behaviour: behaviour.PPS,
956
- };
957
- it("Test for pwmPpsData pin data: invalid", () => {
958
- if (model) {
959
- expect(getRowData(model as any, pwmPpsData)).toMatchObject(pwmPpsData);
960
- } else {
961
- throw "Model not configured for testcase";
962
- }
963
- });
964
- });
965
-
966
- describe("Test case for behaviour actions for pwmoe0Pwmaoe", () => {
967
- const mockMod = mockAssignedModule(mockState());
968
- const model = getModel(mockMod, getDerivedData);
969
-
970
- if (model) {
971
- model.getName = (): string => {
972
- return "PWM2";
973
- };
974
- model.getComponentValue = (cmp: string): any => {
975
- const data = {
976
- pwmoe0Pwmaoe: "PWM20OUT",
977
- };
978
- return data[cmp];
979
- };
980
- model.isComponentValue = (cmp: string): any => {
981
- const data = {
982
- pwmoe0Pwmaoe: true,
983
- };
984
- return data[cmp];
985
- };
986
- model.getImportValue = (imp: string): any => {
987
- return {
988
- allpins: {
989
- RA0: {
990
- PWM1: {
991
- PWM10: {
992
- alias: "PWM10",
993
- pps: {
994
- direction: "output",
995
- },
996
- },
997
- },
998
- },
999
- RA1: {
1000
- PWM1: {
1001
- PWM11: {
1002
- alias: "PWM11",
1003
- pps: {
1004
- direction: "output",
1005
- },
1006
- },
1007
- },
1008
- },
1009
- RA2: {
1010
- PWM1: {
1011
- PWM12: {
1012
- alias: "PWM12",
1013
- pps: {
1014
- direction: "output",
1015
- },
1016
- },
1017
- },
1018
- },
1019
- RA3: {
1020
- PWM1: {
1021
- PWM13: {
1022
- alias: "PWM13",
1023
- pps: {
1024
- direction: "output",
1025
- },
1026
- },
1027
- },
1028
- },
1029
- RB0: {
1030
- PWM2: {
1031
- PWM20: {
1032
- alias: "PWM20",
1033
- pps: {
1034
- direction: "output",
1035
- },
1036
- },
1037
- },
1038
- },
1039
- RB1: {
1040
- PWM2: {
1041
- PWM21: {
1042
- alias: "PWM21",
1043
- pps: {
1044
- direction: "output",
1045
- },
1046
- },
1047
- },
1048
- },
1049
- RB2: {
1050
- PWM2: {
1051
- PWM22: {
1052
- alias: "PWM22",
1053
- pps: {
1054
- direction: "output",
1055
- },
1056
- },
1057
- },
1058
- },
1059
- RB3: {
1060
- PWM2: {
1061
- PWM23: {
1062
- alias: "PWM23",
1063
- pps: {
1064
- direction: "output",
1065
- },
1066
- },
1067
- },
1068
- },
1069
- RC2: {
1070
- PWM1: {
1071
- PWM1: {
1072
- alias: "PWM1",
1073
- pps: {
1074
- direction: "output",
1075
- },
1076
- },
1077
- },
1078
- },
1079
- RC3: {
1080
- PWM2: {
1081
- PWM2: {
1082
- alias: "PWM2",
1083
- pps: {
1084
- direction: "output",
1085
- },
1086
- },
1087
- },
1088
- },
1089
- },
1090
- };
1091
- };
1092
- }
1093
-
1094
- const rowData: pin_row = {
1095
- name: "pwmx0",
1096
- module: "PWM2",
1097
- function: "PWM20OUT",
1098
- direction: direction.input,
1099
- filter: {
1100
- module: "PWM2",
1101
- aliasReEx: "^PWM[0-9]0$",
1102
- },
1103
- behaviour: behaviour.LOCK_UNLOCK,
1104
- };
1105
- it("Test for behaviormeta", () => {
1106
- if (model) {
1107
- const expectedData = { lockPinRegEx: "PWM20" };
1108
- expect(getRowData(model as any, rowData)?.behaviourMeta).toMatchObject(
1109
- expectedData,
1110
- );
1111
- } else {
1112
- throw "Model not configured for testcase";
1113
- }
1114
- });
1115
- });
1116
-
1117
- describe("Test case for behaviour actions for pwmoe1Pwmaoe", () => {
1118
- const mockMod = mockAssignedModule(mockState());
1119
- const model = getModel(mockMod, getDerivedData);
1120
-
1121
- if (model) {
1122
- model.getName = (): string => {
1123
- return "PWM2";
1124
- };
1125
- model.getComponentValue = (cmp: string): any => {
1126
- const data = {
1127
- pwmoe1Pwmaoe: "PWM21OUT",
1128
- };
1129
- return data[cmp];
1130
- };
1131
- model.isComponentValue = (cmp: string): any => {
1132
- const data = {
1133
- pwmoe1Pwmaoe: true,
1134
- };
1135
- return data[cmp];
1136
- };
1137
- model.getImportValue = (imp: string): any => {
1138
- return {
1139
- allpins: {
1140
- RA0: {
1141
- PWM1: {
1142
- PWM10: {
1143
- alias: "PWM10",
1144
- pps: {
1145
- direction: "output",
1146
- },
1147
- },
1148
- },
1149
- },
1150
- RA1: {
1151
- PWM1: {
1152
- PWM11: {
1153
- alias: "PWM11",
1154
- pps: {
1155
- direction: "output",
1156
- },
1157
- },
1158
- },
1159
- },
1160
- RA2: {
1161
- PWM1: {
1162
- PWM12: {
1163
- alias: "PWM12",
1164
- pps: {
1165
- direction: "output",
1166
- },
1167
- },
1168
- },
1169
- },
1170
- RA3: {
1171
- PWM1: {
1172
- PWM13: {
1173
- alias: "PWM13",
1174
- pps: {
1175
- direction: "output",
1176
- },
1177
- },
1178
- },
1179
- },
1180
- RB0: {
1181
- PWM2: {
1182
- PWM20: {
1183
- alias: "PWM20",
1184
- pps: {
1185
- direction: "output",
1186
- },
1187
- },
1188
- },
1189
- },
1190
- RB1: {
1191
- PWM2: {
1192
- PWM21: {
1193
- alias: "PWM21",
1194
- pps: {
1195
- direction: "output",
1196
- },
1197
- },
1198
- },
1199
- },
1200
- RB2: {
1201
- PWM2: {
1202
- PWM22: {
1203
- alias: "PWM22",
1204
- pps: {
1205
- direction: "output",
1206
- },
1207
- },
1208
- },
1209
- },
1210
- RB3: {
1211
- PWM2: {
1212
- PWM23: {
1213
- alias: "PWM23",
1214
- pps: {
1215
- direction: "output",
1216
- },
1217
- },
1218
- },
1219
- },
1220
- RC2: {
1221
- PWM1: {
1222
- PWM1: {
1223
- alias: "PWM1",
1224
- pps: {
1225
- direction: "output",
1226
- },
1227
- },
1228
- },
1229
- },
1230
- RC3: {
1231
- PWM2: {
1232
- PWM2: {
1233
- alias: "PWM2",
1234
- pps: {
1235
- direction: "output",
1236
- },
1237
- },
1238
- },
1239
- },
1240
- },
1241
- };
1242
- };
1243
- }
1244
-
1245
- const rowData: pin_row = {
1246
- name: "pwmx1",
1247
- module: "PWM2",
1248
- function: "PWM21OUT",
1249
- direction: direction.input,
1250
- filter: {
1251
- module: "PWM2",
1252
- aliasReEx: "^PWM[0-9]1$",
1253
- },
1254
- behaviour: behaviour.LOCK_UNLOCK,
1255
- };
1256
- it("Test for behaviormeta", () => {
1257
- if (model) {
1258
- const expectedData = { lockPinRegEx: "PWM21" };
1259
- expect(getRowData(model as any, rowData)?.behaviourMeta).toMatchObject(
1260
- expectedData,
1261
- );
1262
- } else {
1263
- throw "Model not configured for testcase";
1264
- }
1265
- });
1266
- });
1267
-
1268
- describe("Test case for behaviour actions for pwmoe2Pwmaoe", () => {
1269
- const mockMod = mockAssignedModule(mockState());
1270
- const model = getModel(mockMod, getDerivedData);
1271
-
1272
- if (model) {
1273
- model.getName = (): string => {
1274
- return "PWM2";
1275
- };
1276
- model.getComponentValue = (cmp: string): any => {
1277
- const data = {
1278
- pwmoe2Pwmaoe: "PWM22OUT",
1279
- };
1280
- return data[cmp];
1281
- };
1282
- model.isComponentValue = (cmp: string): any => {
1283
- const data = {
1284
- pwmoe2Pwmaoe: true,
1285
- };
1286
- return data[cmp];
1287
- };
1288
- model.getImportValue = (imp: string): any => {
1289
- return {
1290
- allpins: {
1291
- RA0: {
1292
- PWM1: {
1293
- PWM10: {
1294
- alias: "PWM10",
1295
- pps: {
1296
- direction: "output",
1297
- },
1298
- },
1299
- },
1300
- },
1301
- RA1: {
1302
- PWM1: {
1303
- PWM11: {
1304
- alias: "PWM11",
1305
- pps: {
1306
- direction: "output",
1307
- },
1308
- },
1309
- },
1310
- },
1311
- RA2: {
1312
- PWM1: {
1313
- PWM12: {
1314
- alias: "PWM12",
1315
- pps: {
1316
- direction: "output",
1317
- },
1318
- },
1319
- },
1320
- },
1321
- RA3: {
1322
- PWM1: {
1323
- PWM13: {
1324
- alias: "PWM13",
1325
- pps: {
1326
- direction: "output",
1327
- },
1328
- },
1329
- },
1330
- },
1331
- RB0: {
1332
- PWM2: {
1333
- PWM20: {
1334
- alias: "PWM20",
1335
- pps: {
1336
- direction: "output",
1337
- },
1338
- },
1339
- },
1340
- },
1341
- RB1: {
1342
- PWM2: {
1343
- PWM21: {
1344
- alias: "PWM21",
1345
- pps: {
1346
- direction: "output",
1347
- },
1348
- },
1349
- },
1350
- },
1351
- RB2: {
1352
- PWM2: {
1353
- PWM22: {
1354
- alias: "PWM22",
1355
- pps: {
1356
- direction: "output",
1357
- },
1358
- },
1359
- },
1360
- },
1361
- RB3: {
1362
- PWM2: {
1363
- PWM23: {
1364
- alias: "PWM23",
1365
- pps: {
1366
- direction: "output",
1367
- },
1368
- },
1369
- },
1370
- },
1371
- RC2: {
1372
- PWM1: {
1373
- PWM1: {
1374
- alias: "PWM1",
1375
- pps: {
1376
- direction: "output",
1377
- },
1378
- },
1379
- },
1380
- },
1381
- RC3: {
1382
- PWM2: {
1383
- PWM2: {
1384
- alias: "PWM2",
1385
- pps: {
1386
- direction: "output",
1387
- },
1388
- },
1389
- },
1390
- },
1391
- },
1392
- };
1393
- };
1394
- }
1395
-
1396
- const rowData: pin_row = {
1397
- name: "pwmx2",
1398
- module: "PWM2",
1399
- function: "PWM22OUT",
1400
- direction: direction.input,
1401
- filter: {
1402
- module: "PWM2",
1403
- aliasReEx: "^PWM[0-9]2$",
1404
- },
1405
- behaviour: behaviour.LOCK_UNLOCK,
1406
- };
1407
- it("Test for behaviormeta", () => {
1408
- if (model) {
1409
- const expectedData = { lockPinRegEx: "PWM22" };
1410
- expect(getRowData(model as any, rowData)?.behaviourMeta).toMatchObject(
1411
- expectedData,
1412
- );
1413
- } else {
1414
- throw "Model not configured for testcase";
1415
- }
1416
- });
1417
- });
1418
-
1419
- describe("Test case for behaviour actions for pwmoe3Pwmaoe", () => {
1420
- const mockMod = mockAssignedModule(mockState());
1421
- const model = getModel(mockMod, getDerivedData);
1422
-
1423
- if (model) {
1424
- model.getName = (): string => {
1425
- return "PWM2";
1426
- };
1427
- model.getComponentValue = (cmp: string): any => {
1428
- const data = {
1429
- pwmoe3Pwmaoe: "PWM23OUT",
1430
- };
1431
- return data[cmp];
1432
- };
1433
- model.isComponentValue = (cmp: string): any => {
1434
- const data = {
1435
- pwmoe3Pwmaoe: true,
1436
- };
1437
- return data[cmp];
1438
- };
1439
- model.getImportValue = (imp: string): any => {
1440
- return {
1441
- allpins: {
1442
- RA0: {
1443
- PWM1: {
1444
- PWM10: {
1445
- alias: "PWM10",
1446
- pps: {
1447
- direction: "output",
1448
- },
1449
- },
1450
- },
1451
- },
1452
- RA1: {
1453
- PWM1: {
1454
- PWM11: {
1455
- alias: "PWM11",
1456
- pps: {
1457
- direction: "output",
1458
- },
1459
- },
1460
- },
1461
- },
1462
- RA2: {
1463
- PWM1: {
1464
- PWM12: {
1465
- alias: "PWM12",
1466
- pps: {
1467
- direction: "output",
1468
- },
1469
- },
1470
- },
1471
- },
1472
- RA3: {
1473
- PWM1: {
1474
- PWM13: {
1475
- alias: "PWM13",
1476
- pps: {
1477
- direction: "output",
1478
- },
1479
- },
1480
- },
1481
- },
1482
- RB0: {
1483
- PWM2: {
1484
- PWM20: {
1485
- alias: "PWM20",
1486
- pps: {
1487
- direction: "output",
1488
- },
1489
- },
1490
- },
1491
- },
1492
- RB1: {
1493
- PWM2: {
1494
- PWM21: {
1495
- alias: "PWM21",
1496
- pps: {
1497
- direction: "output",
1498
- },
1499
- },
1500
- },
1501
- },
1502
- RB2: {
1503
- PWM2: {
1504
- PWM22: {
1505
- alias: "PWM22",
1506
- pps: {
1507
- direction: "output",
1508
- },
1509
- },
1510
- },
1511
- },
1512
- RB3: {
1513
- PWM2: {
1514
- PWM23: {
1515
- alias: "PWM23",
1516
- pps: {
1517
- direction: "output",
1518
- },
1519
- },
1520
- },
1521
- },
1522
- RC2: {
1523
- PWM1: {
1524
- PWM1: {
1525
- alias: "PWM1",
1526
- pps: {
1527
- direction: "output",
1528
- },
1529
- },
1530
- },
1531
- },
1532
- RC3: {
1533
- PWM2: {
1534
- PWM2: {
1535
- alias: "PWM2",
1536
- pps: {
1537
- direction: "output",
1538
- },
1539
- },
1540
- },
1541
- },
1542
- },
1543
- };
1544
- };
1545
- }
1546
-
1547
- const rowData: pin_row = {
1548
- name: "pwmx3",
1549
- module: "PWM2",
1550
- function: "PWM23OUT",
1551
- direction: direction.input,
1552
- filter: {
1553
- module: "PWM2",
1554
- aliasReEx: "^PWM[0-9]3$",
1555
- },
1556
- behaviour: behaviour.LOCK_UNLOCK,
1557
- };
1558
- it("Test for behaviormeta", () => {
1559
- if (model) {
1560
- const expectedData = { lockPinRegEx: "PWM23" };
1561
- expect(getRowData(model as any, rowData)?.behaviourMeta).toMatchObject(
1562
- expectedData,
1563
- );
1564
- } else {
1565
- throw "Model not configured for testcase";
1566
- }
1567
- });
1568
- });
1569
-
1570
- it("Module have apfcon pins on out pin", () => {
1571
- const mockMod = mockAssignedModule(mockState());
1572
- const model = getModel(mockMod, getDerivedData);
1573
-
1574
- if (model) {
1575
- model.getName = (): string => {
1576
- return "PWM2";
1577
- };
1578
- model.getComponentValue = (cmp: string): any => {
1579
- const data = {
1580
- pwmoutPwmcon: "PWM2",
1581
- };
1582
- return data[cmp];
1583
- };
1584
- model.getImportValue = (imp: string): any => {
1585
- return {
1586
- allpins: {
1587
- RA0: {
1588
- PWM1: {
1589
- PWM10: {
1590
- alias: "PWM10",
1591
- apfcon: {
1592
- direction: "output",
1593
- },
1594
- },
1595
- },
1596
- },
1597
- RA1: {
1598
- PWM1: {
1599
- PWM11: {
1600
- alias: "PWM11",
1601
- apfcon: {
1602
- direction: "output",
1603
- },
1604
- },
1605
- },
1606
- },
1607
- RA2: {
1608
- PWM1: {
1609
- PWM12: {
1610
- alias: "PWM12",
1611
- apfcon: {
1612
- direction: "output",
1613
- },
1614
- },
1615
- },
1616
- },
1617
- RA3: {
1618
- PWM1: {
1619
- PWM13: {
1620
- alias: "PWM13",
1621
- apfcon: {
1622
- direction: "output",
1623
- },
1624
- },
1625
- },
1626
- },
1627
- RB0: {
1628
- PWM2: {
1629
- PWM20: {
1630
- alias: "PWM20",
1631
- apfcon: {
1632
- direction: "output",
1633
- },
1634
- },
1635
- },
1636
- },
1637
- RB1: {
1638
- PWM2: {
1639
- PWM21: {
1640
- alias: "PWM21",
1641
- apfcon: {
1642
- direction: "output",
1643
- },
1644
- },
1645
- },
1646
- },
1647
- RB2: {
1648
- PWM2: {
1649
- PWM22: {
1650
- alias: "PWM22",
1651
- apfcon: {
1652
- direction: "output",
1653
- },
1654
- },
1655
- },
1656
- },
1657
- RB3: {
1658
- PWM2: {
1659
- PWM23: {
1660
- alias: "PWM23",
1661
- apfcon: {
1662
- direction: "output",
1663
- },
1664
- },
1665
- },
1666
- },
1667
- RC2: {
1668
- PWM1: {
1669
- PWM1: {
1670
- alias: "PWM1",
1671
- apfcon: {
1672
- direction: "output",
1673
- },
1674
- },
1675
- },
1676
- },
1677
- RC3: {
1678
- PWM2: {
1679
- PWM2: {
1680
- alias: "PWM2",
1681
- apfcon: {
1682
- direction: "output",
1683
- },
1684
- },
1685
- },
1686
- },
1687
- },
1688
- };
1689
- };
1690
-
1691
- const rowData: pin_row = {
1692
- name: "out",
1693
- module: "PWM2",
1694
- function: "PWM2OUT",
1695
- direction: direction.output,
1696
- filter: {
1697
- module: "PWM2",
1698
- aliasReEx: "^PWM[0-9]$",
1699
- },
1700
- behaviour: behaviour.APFCON,
1701
- };
1702
- const expectedRowData = {
1703
- name: "out",
1704
- module: "PWM2",
1705
- function: "PWM2OUT",
1706
- direction: "output",
1707
- filter: {
1708
- module: "PWM2",
1709
- aliasReEx: "^PWM7$",
1710
- },
1711
- behaviour: behaviour.APFCON,
1712
- };
1713
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
1714
- } else {
1715
- throw "Model not configured for testcase.";
1716
- }
1717
- });
1718
-
1719
- it("Module have apfcon pins on pwmoe0Pwmaoe", () => {
1720
- const mockMod = mockAssignedModule(mockState());
1721
- const model = getModel(mockMod, getDerivedData);
1722
-
1723
- if (model) {
1724
- model.getName = (): string => {
1725
- return "PWM2";
1726
- };
1727
- model.getComponentValue = (cmp: string): any => {
1728
- const data = {
1729
- pwmoe0Pwmaoe: "PWM20OUT",
1730
- };
1731
- return data[cmp];
1732
- };
1733
- model.isComponentValue = (cmp: string): any => {
1734
- const data = {
1735
- pwmoePwmaoe: true,
1736
- };
1737
- return data[cmp];
1738
- };
1739
- model.getImportValue = (imp: string): any => {
1740
- return {
1741
- allpins: {
1742
- RA0: {
1743
- PWM1: {
1744
- PWM10: {
1745
- alias: "PWM10",
1746
- apfcon: {
1747
- direction: "output",
1748
- },
1749
- },
1750
- },
1751
- },
1752
- RA1: {
1753
- PWM1: {
1754
- PWM11: {
1755
- alias: "PWM11",
1756
- apfcon: {
1757
- direction: "output",
1758
- },
1759
- },
1760
- },
1761
- },
1762
- RA2: {
1763
- PWM1: {
1764
- PWM12: {
1765
- alias: "PWM12",
1766
- apfcon: {
1767
- direction: "output",
1768
- },
1769
- },
1770
- },
1771
- },
1772
- RA3: {
1773
- PWM1: {
1774
- PWM13: {
1775
- alias: "PWM13",
1776
- apfcon: {
1777
- direction: "output",
1778
- },
1779
- },
1780
- },
1781
- },
1782
- RB0: {
1783
- PWM2: {
1784
- PWM20: {
1785
- alias: "PWM20",
1786
- apfcon: {
1787
- direction: "output",
1788
- },
1789
- },
1790
- },
1791
- },
1792
- RB1: {
1793
- PWM2: {
1794
- PWM21: {
1795
- alias: "PWM21",
1796
- apfcon: {
1797
- direction: "output",
1798
- },
1799
- },
1800
- },
1801
- },
1802
- RB2: {
1803
- PWM2: {
1804
- PWM22: {
1805
- alias: "PWM22",
1806
- apfcon: {
1807
- direction: "output",
1808
- },
1809
- },
1810
- },
1811
- },
1812
- RB3: {
1813
- PWM2: {
1814
- PWM23: {
1815
- alias: "PWM23",
1816
- apfcon: {
1817
- direction: "output",
1818
- },
1819
- },
1820
- },
1821
- },
1822
- RC2: {
1823
- PWM1: {
1824
- PWM1: {
1825
- alias: "PWM1",
1826
- apfcon: {
1827
- direction: "output",
1828
- },
1829
- },
1830
- },
1831
- },
1832
- RC3: {
1833
- PWM2: {
1834
- PWM2: {
1835
- alias: "PWM2",
1836
- apfcon: {
1837
- direction: "output",
1838
- },
1839
- },
1840
- },
1841
- },
1842
- },
1843
- };
1844
- };
1845
-
1846
- const rowData: pin_row = {
1847
- name: "pwmx0",
1848
- module: "PWM2",
1849
- function: "PWM20OUT",
1850
- direction: direction.output,
1851
- filter: {
1852
- module: "PWM2",
1853
- aliasReEx: "^PWM[0-9]0$",
1854
- },
1855
- behaviour: behaviour.APFCON,
1856
- };
1857
- const expectedRowData = {
1858
- name: "pwmx0",
1859
- module: "PWM2",
1860
- function: "PWM20OUT",
1861
- direction: "output",
1862
- filter: {
1863
- module: "PWM2",
1864
- aliasReEx: "^PWM[0-9]0$",
1865
- },
1866
- behaviour: behaviour.APFCON,
1867
- };
1868
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
1869
- } else {
1870
- throw "Model not configured for testcase.";
1871
- }
1872
- });
1873
-
1874
- it("Module have apfcon pins on pwmoe1Pwmaoe", () => {
1875
- const mockMod = mockAssignedModule(mockState());
1876
- const model = getModel(mockMod, getDerivedData);
1877
-
1878
- if (model) {
1879
- model.getName = (): string => {
1880
- return "PWM2";
1881
- };
1882
- model.getComponentValue = (cmp: string): any => {
1883
- const data = {
1884
- pwmoe1Pwmaoe: "PWM21OUT",
1885
- };
1886
- return data[cmp];
1887
- };
1888
- model.isComponentValue = (cmp: string): any => {
1889
- const data = {
1890
- pwmoe1Pwmaoe: true,
1891
- };
1892
- return data[cmp];
1893
- };
1894
- model.getImportValue = (imp: string): any => {
1895
- return {
1896
- allpins: {
1897
- RA0: {
1898
- PWM1: {
1899
- PWM10: {
1900
- alias: "PWM10",
1901
- apfcon: {
1902
- direction: "output",
1903
- },
1904
- },
1905
- },
1906
- },
1907
- RA1: {
1908
- PWM1: {
1909
- PWM11: {
1910
- alias: "PWM11",
1911
- apfcon: {
1912
- direction: "output",
1913
- },
1914
- },
1915
- },
1916
- },
1917
- RA2: {
1918
- PWM1: {
1919
- PWM12: {
1920
- alias: "PWM12",
1921
- apfcon: {
1922
- direction: "output",
1923
- },
1924
- },
1925
- },
1926
- },
1927
- RA3: {
1928
- PWM1: {
1929
- PWM13: {
1930
- alias: "PWM13",
1931
- apfcon: {
1932
- direction: "output",
1933
- },
1934
- },
1935
- },
1936
- },
1937
- RB0: {
1938
- PWM2: {
1939
- PWM20: {
1940
- alias: "PWM20",
1941
- apfcon: {
1942
- direction: "output",
1943
- },
1944
- },
1945
- },
1946
- },
1947
- RB1: {
1948
- PWM2: {
1949
- PWM21: {
1950
- alias: "PWM21",
1951
- apfcon: {
1952
- direction: "output",
1953
- },
1954
- },
1955
- },
1956
- },
1957
- RB2: {
1958
- PWM2: {
1959
- PWM22: {
1960
- alias: "PWM22",
1961
- apfcon: {
1962
- direction: "output",
1963
- },
1964
- },
1965
- },
1966
- },
1967
- RB3: {
1968
- PWM2: {
1969
- PWM23: {
1970
- alias: "PWM23",
1971
- apfcon: {
1972
- direction: "output",
1973
- },
1974
- },
1975
- },
1976
- },
1977
- RC2: {
1978
- PWM1: {
1979
- PWM1: {
1980
- alias: "PWM1",
1981
- apfcon: {
1982
- direction: "output",
1983
- },
1984
- },
1985
- },
1986
- },
1987
- RC3: {
1988
- PWM2: {
1989
- PWM2: {
1990
- alias: "PWM2",
1991
- apfcon: {
1992
- direction: "output",
1993
- },
1994
- },
1995
- },
1996
- },
1997
- },
1998
- };
1999
- };
2000
-
2001
- const rowData: pin_row = {
2002
- name: "pwmx1",
2003
- module: "PWM2",
2004
- function: "PWM21OUT",
2005
- direction: direction.output,
2006
- filter: {
2007
- module: "PWM2",
2008
- aliasReEx: "^PWM[0-9]1$",
2009
- },
2010
- behaviour: behaviour.APFCON,
2011
- };
2012
- const expectedRowData = {
2013
- name: "pwmx1",
2014
- module: "PWM2",
2015
- function: "PWM21OUT",
2016
- direction: "output",
2017
- filter: {
2018
- module: "PWM2",
2019
- aliasReEx: "^PWM[0-9]1$",
2020
- },
2021
- behaviour: behaviour.APFCON,
2022
- };
2023
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2024
- } else {
2025
- throw "Model not configured for testcase.";
2026
- }
2027
- });
2028
-
2029
- it("Module have apfcon pins on pwmoe2Pwmaoe", () => {
2030
- const mockMod = mockAssignedModule(mockState());
2031
- const model = getModel(mockMod, getDerivedData);
2032
-
2033
- if (model) {
2034
- model.getName = (): string => {
2035
- return "PWM2";
2036
- };
2037
- model.getComponentValue = (cmp: string): any => {
2038
- const data = {
2039
- pwmoe2Pwmaoe: "PWM22OUT",
2040
- };
2041
- return data[cmp];
2042
- };
2043
- model.isComponentValue = (cmp: string): any => {
2044
- const data = {
2045
- pwmoe2Pwmaoe: true,
2046
- };
2047
- return data[cmp];
2048
- };
2049
- model.getImportValue = (imp: string): any => {
2050
- return {
2051
- allpins: {
2052
- RA0: {
2053
- PWM1: {
2054
- PWM10: {
2055
- alias: "PWM10",
2056
- apfcon: {
2057
- direction: "output",
2058
- },
2059
- },
2060
- },
2061
- },
2062
- RA1: {
2063
- PWM1: {
2064
- PWM11: {
2065
- alias: "PWM11",
2066
- apfcon: {
2067
- direction: "output",
2068
- },
2069
- },
2070
- },
2071
- },
2072
- RA2: {
2073
- PWM1: {
2074
- PWM12: {
2075
- alias: "PWM12",
2076
- apfcon: {
2077
- direction: "output",
2078
- },
2079
- },
2080
- },
2081
- },
2082
- RA3: {
2083
- PWM1: {
2084
- PWM13: {
2085
- alias: "PWM13",
2086
- apfcon: {
2087
- direction: "output",
2088
- },
2089
- },
2090
- },
2091
- },
2092
- RB0: {
2093
- PWM2: {
2094
- PWM20: {
2095
- alias: "PWM20",
2096
- apfcon: {
2097
- direction: "output",
2098
- },
2099
- },
2100
- },
2101
- },
2102
- RB1: {
2103
- PWM2: {
2104
- PWM21: {
2105
- alias: "PWM21",
2106
- apfcon: {
2107
- direction: "output",
2108
- },
2109
- },
2110
- },
2111
- },
2112
- RB2: {
2113
- PWM2: {
2114
- PWM22: {
2115
- alias: "PWM22",
2116
- apfcon: {
2117
- direction: "output",
2118
- },
2119
- },
2120
- },
2121
- },
2122
- RB3: {
2123
- PWM2: {
2124
- PWM23: {
2125
- alias: "PWM23",
2126
- apfcon: {
2127
- direction: "output",
2128
- },
2129
- },
2130
- },
2131
- },
2132
- RC2: {
2133
- PWM1: {
2134
- PWM1: {
2135
- alias: "PWM1",
2136
- apfcon: {
2137
- direction: "output",
2138
- },
2139
- },
2140
- },
2141
- },
2142
- RC3: {
2143
- PWM2: {
2144
- PWM2: {
2145
- alias: "PWM2",
2146
- apfcon: {
2147
- direction: "output",
2148
- },
2149
- },
2150
- },
2151
- },
2152
- },
2153
- };
2154
- };
2155
-
2156
- const rowData: pin_row = {
2157
- name: "pwmx2",
2158
- module: "PWM2",
2159
- function: "PWM22OUT",
2160
- direction: direction.output,
2161
- filter: {
2162
- module: "PWM2",
2163
- aliasReEx: "^PWM[0-9]2$",
2164
- },
2165
- behaviour: behaviour.APFCON,
2166
- };
2167
- const expectedRowData = {
2168
- name: "pwmx2",
2169
- module: "PWM2",
2170
- function: "PWM22OUT",
2171
- direction: "output",
2172
- filter: {
2173
- module: "PWM2",
2174
- aliasReEx: "^PWM[0-9]2$",
2175
- },
2176
- behaviour: behaviour.APFCON,
2177
- };
2178
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2179
- } else {
2180
- throw "Model not configured for testcase.";
2181
- }
2182
- });
2183
-
2184
- it("Module have apfcon pins on pwmoe3Pwmaoe", () => {
2185
- const mockMod = mockAssignedModule(mockState());
2186
- const model = getModel(mockMod, getDerivedData);
2187
-
2188
- if (model) {
2189
- model.getName = (): string => {
2190
- return "PWM2";
2191
- };
2192
- model.getComponentValue = (cmp: string): any => {
2193
- const data = {
2194
- pwmoe3Pwmaoe: "PWM23OUT",
2195
- };
2196
- return data[cmp];
2197
- };
2198
- model.isComponentValue = (cmp: string): any => {
2199
- const data = {
2200
- pwmoe3Pwmaoe: true,
2201
- };
2202
- return data[cmp];
2203
- };
2204
- model.getImportValue = (imp: string): any => {
2205
- return {
2206
- allpins: {
2207
- RA0: {
2208
- PWM1: {
2209
- PWM10: {
2210
- alias: "PWM10",
2211
- apfcon: {
2212
- direction: "output",
2213
- },
2214
- },
2215
- },
2216
- },
2217
- RA1: {
2218
- PWM1: {
2219
- PWM11: {
2220
- alias: "PWM11",
2221
- apfcon: {
2222
- direction: "output",
2223
- },
2224
- },
2225
- },
2226
- },
2227
- RA2: {
2228
- PWM1: {
2229
- PWM12: {
2230
- alias: "PWM12",
2231
- apfcon: {
2232
- direction: "output",
2233
- },
2234
- },
2235
- },
2236
- },
2237
- RA3: {
2238
- PWM1: {
2239
- PWM13: {
2240
- alias: "PWM13",
2241
- apfcon: {
2242
- direction: "output",
2243
- },
2244
- },
2245
- },
2246
- },
2247
- RB0: {
2248
- PWM2: {
2249
- PWM20: {
2250
- alias: "PWM20",
2251
- apfcon: {
2252
- direction: "output",
2253
- },
2254
- },
2255
- },
2256
- },
2257
- RB1: {
2258
- PWM2: {
2259
- PWM21: {
2260
- alias: "PWM21",
2261
- apfcon: {
2262
- direction: "output",
2263
- },
2264
- },
2265
- },
2266
- },
2267
- RB2: {
2268
- PWM2: {
2269
- PWM22: {
2270
- alias: "PWM22",
2271
- apfcon: {
2272
- direction: "output",
2273
- },
2274
- },
2275
- },
2276
- },
2277
- RB3: {
2278
- PWM2: {
2279
- PWM23: {
2280
- alias: "PWM23",
2281
- apfcon: {
2282
- direction: "output",
2283
- },
2284
- },
2285
- },
2286
- },
2287
- RC2: {
2288
- PWM1: {
2289
- PWM1: {
2290
- alias: "PWM1",
2291
- apfcon: {
2292
- direction: "output",
2293
- },
2294
- },
2295
- },
2296
- },
2297
- RC3: {
2298
- PWM2: {
2299
- PWM2: {
2300
- alias: "PWM2",
2301
- apfcon: {
2302
- direction: "output",
2303
- },
2304
- },
2305
- },
2306
- },
2307
- },
2308
- };
2309
- };
2310
-
2311
- const rowData: pin_row = {
2312
- name: "pwmx3",
2313
- module: "PWM2",
2314
- function: "PWM23OUT",
2315
- direction: direction.output,
2316
- filter: {
2317
- module: "PWM2",
2318
- aliasReEx: "^PWM[0-9]3$",
2319
- },
2320
- behaviour: behaviour.APFCON,
2321
- };
2322
- const expectedRowData = {
2323
- name: "pwmx3",
2324
- module: "PWM2",
2325
- function: "PWM23OUT",
2326
- direction: "output",
2327
- filter: {
2328
- module: "PWM2",
2329
- aliasReEx: "^PWM[0-9]3$",
2330
- },
2331
- behaviour: behaviour.APFCON,
2332
- };
2333
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2334
- } else {
2335
- throw "Model not configured for testcase.";
2336
- }
2337
- });
2338
-
2339
- it("Module have LOCK_UNLOCK pins pwmoe0Pwmaoe", () => {
2340
- const mockMod = mockAssignedModule(mockState());
2341
- const model = getModel(mockMod, getDerivedData);
2342
-
2343
- if (model) {
2344
- model.getName = (): string => {
2345
- return "PWM2";
2346
- };
2347
- model.getComponentValue = (cmp: string): any => {
2348
- const data = {
2349
- pwmoe0Pwmaoe: "PWM20OUT",
2350
- };
2351
- return data[cmp];
2352
- };
2353
- model.isComponentValue = (cmp: string): any => {
2354
- const data = {
2355
- pwmoe0Pwmaoe: true,
2356
- };
2357
- return data[cmp];
2358
- };
2359
- model.getImportValue = (imp: string): any => {
2360
- return {
2361
- allpins: {
2362
- RA0: {
2363
- PWM1: {
2364
- PWM10: {
2365
- alias: "PWM10",
2366
- },
2367
- },
2368
- },
2369
- RA1: {
2370
- PWM1: {
2371
- PWM11: {
2372
- alias: "PWM11",
2373
- },
2374
- },
2375
- },
2376
- RA2: {
2377
- PWM1: {
2378
- PWM12: {
2379
- alias: "PWM12",
2380
- },
2381
- },
2382
- },
2383
- RA3: {
2384
- PWM1: {
2385
- PWM13: {
2386
- alias: "PWM13",
2387
- },
2388
- },
2389
- },
2390
- RB0: {
2391
- PWM2: {
2392
- PWM20: {
2393
- alias: "PWM20",
2394
- },
2395
- },
2396
- },
2397
- RB1: {
2398
- PWM2: {
2399
- PWM21: {
2400
- alias: "PWM21",
2401
- },
2402
- },
2403
- },
2404
- RB2: {
2405
- PWM2: {
2406
- PWM22: {
2407
- alias: "PWM22",
2408
- },
2409
- },
2410
- },
2411
- RB3: {
2412
- PWM2: {
2413
- PWM23: {
2414
- alias: "PWM23",
2415
- },
2416
- },
2417
- },
2418
- RC2: {
2419
- PWM1: {
2420
- PWM1: {
2421
- alias: "PWM1",
2422
- },
2423
- },
2424
- },
2425
- RC3: {
2426
- PWM2: {
2427
- PWM2: {
2428
- alias: "PWM2",
2429
- },
2430
- },
2431
- },
2432
- },
2433
- };
2434
- };
2435
-
2436
- const rowData: pin_row = {
2437
- name: "pwmx0",
2438
- module: "PWM2",
2439
- function: "PWM20OUT",
2440
- direction: direction.output,
2441
- filter: {
2442
- module: "PWM2",
2443
- aliasReEx: "^PWM[0-9]0$",
2444
- },
2445
- behaviour: behaviour.LOCK_UNLOCK,
2446
- };
2447
- const expectedRowData = {
2448
- name: "pwmx0",
2449
- module: "PWM2",
2450
- function: "PWM20OUT",
2451
- direction: "output",
2452
- filter: {
2453
- module: "PWM2",
2454
- aliasReEx: "^PWM[0-9]0$",
2455
- },
2456
- behaviour: behaviour.LOCK_UNLOCK,
2457
- };
2458
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2459
- } else {
2460
- throw "Model not configured for testcase.";
2461
- }
2462
- });
2463
-
2464
- it("Module have LOCK_UNLOCK pins pwmoe1Pwmaoe", () => {
2465
- const mockMod = mockAssignedModule(mockState());
2466
- const model = getModel(mockMod, getDerivedData);
2467
-
2468
- if (model) {
2469
- model.getName = (): string => {
2470
- return "PWM2";
2471
- };
2472
- model.getComponentValue = (cmp: string): any => {
2473
- const data = {
2474
- pwmoe1Pwmaoe: "PWM21OUT",
2475
- };
2476
- return data[cmp];
2477
- };
2478
- model.isComponentValue = (cmp: string): any => {
2479
- const data = {
2480
- pwmoe1Pwmaoe: true,
2481
- };
2482
- return data[cmp];
2483
- };
2484
- model.getImportValue = (imp: string): any => {
2485
- return {
2486
- allpins: {
2487
- RA0: {
2488
- PWM1: {
2489
- PWM10: {
2490
- alias: "PWM10",
2491
- },
2492
- },
2493
- },
2494
- RA1: {
2495
- PWM1: {
2496
- PWM11: {
2497
- alias: "PWM11",
2498
- },
2499
- },
2500
- },
2501
- RA2: {
2502
- PWM1: {
2503
- PWM12: {
2504
- alias: "PWM12",
2505
- },
2506
- },
2507
- },
2508
- RA3: {
2509
- PWM1: {
2510
- PWM13: {
2511
- alias: "PWM13",
2512
- },
2513
- },
2514
- },
2515
- RB0: {
2516
- PWM2: {
2517
- PWM20: {
2518
- alias: "PWM20",
2519
- },
2520
- },
2521
- },
2522
- RB1: {
2523
- PWM2: {
2524
- PWM21: {
2525
- alias: "PWM21",
2526
- },
2527
- },
2528
- },
2529
- RB2: {
2530
- PWM2: {
2531
- PWM22: {
2532
- alias: "PWM22",
2533
- },
2534
- },
2535
- },
2536
- RB3: {
2537
- PWM2: {
2538
- PWM23: {
2539
- alias: "PWM23",
2540
- },
2541
- },
2542
- },
2543
- RC2: {
2544
- PWM1: {
2545
- PWM1: {
2546
- alias: "PWM1",
2547
- },
2548
- },
2549
- },
2550
- RC3: {
2551
- PWM2: {
2552
- PWM2: {
2553
- alias: "PWM2",
2554
- },
2555
- },
2556
- },
2557
- },
2558
- };
2559
- };
2560
-
2561
- const rowData: pin_row = {
2562
- name: "pwmx1",
2563
- module: "PWM2",
2564
- function: "PWM21OUT",
2565
- direction: direction.output,
2566
- filter: {
2567
- module: "PWM2",
2568
- aliasReEx: "^PWM[0-9]1$",
2569
- },
2570
- behaviour: behaviour.LOCK_UNLOCK,
2571
- };
2572
- const expectedRowData = {
2573
- name: "pwmx1",
2574
- module: "PWM2",
2575
- function: "PWM21OUT",
2576
- direction: "output",
2577
- filter: {
2578
- module: "PWM2",
2579
- aliasReEx: "^PWM[0-9]1$",
2580
- },
2581
- behaviour: behaviour.LOCK_UNLOCK,
2582
- };
2583
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2584
- } else {
2585
- throw "Model not configured for testcase.";
2586
- }
2587
- });
2588
-
2589
- it("Module have LOCK_UNLOCK pins pwmoe2Pwmaoe", () => {
2590
- const mockMod = mockAssignedModule(mockState());
2591
- const model = getModel(mockMod, getDerivedData);
2592
-
2593
- if (model) {
2594
- model.getName = (): string => {
2595
- return "PWM2";
2596
- };
2597
- model.getComponentValue = (cmp: string): any => {
2598
- const data = {
2599
- pwmoe2Pwmaoe: "PWM22OUT",
2600
- };
2601
- return data[cmp];
2602
- };
2603
- model.isComponentValue = (cmp: string): any => {
2604
- const data = {
2605
- pwmoe2Pwmaoe: true,
2606
- };
2607
- return data[cmp];
2608
- };
2609
- model.getImportValue = (imp: string): any => {
2610
- return {
2611
- allpins: {
2612
- RA0: {
2613
- PWM1: {
2614
- PWM10: {
2615
- alias: "PWM10",
2616
- },
2617
- },
2618
- },
2619
- RA1: {
2620
- PWM1: {
2621
- PWM11: {
2622
- alias: "PWM11",
2623
- },
2624
- },
2625
- },
2626
- RA2: {
2627
- PWM1: {
2628
- PWM12: {
2629
- alias: "PWM12",
2630
- },
2631
- },
2632
- },
2633
- RA3: {
2634
- PWM1: {
2635
- PWM13: {
2636
- alias: "PWM13",
2637
- },
2638
- },
2639
- },
2640
- RB0: {
2641
- PWM2: {
2642
- PWM20: {
2643
- alias: "PWM20",
2644
- },
2645
- },
2646
- },
2647
- RB1: {
2648
- PWM2: {
2649
- PWM21: {
2650
- alias: "PWM21",
2651
- },
2652
- },
2653
- },
2654
- RB2: {
2655
- PWM2: {
2656
- PWM22: {
2657
- alias: "PWM22",
2658
- },
2659
- },
2660
- },
2661
- RB3: {
2662
- PWM2: {
2663
- PWM23: {
2664
- alias: "PWM23",
2665
- },
2666
- },
2667
- },
2668
- RC2: {
2669
- PWM1: {
2670
- PWM1: {
2671
- alias: "PWM1",
2672
- },
2673
- },
2674
- },
2675
- RC3: {
2676
- PWM2: {
2677
- PWM2: {
2678
- alias: "PWM2",
2679
- },
2680
- },
2681
- },
2682
- },
2683
- };
2684
- };
2685
-
2686
- const rowData: pin_row = {
2687
- name: "pwmx2",
2688
- module: "PWM2",
2689
- function: "PWM22OUT",
2690
- direction: direction.output,
2691
- filter: {
2692
- module: "PWM2",
2693
- aliasReEx: "^PWM[0-9]2$",
2694
- },
2695
- behaviour: behaviour.LOCK_UNLOCK,
2696
- };
2697
- const expectedRowData = {
2698
- name: "pwmx2",
2699
- module: "PWM2",
2700
- function: "PWM22OUT",
2701
- direction: "output",
2702
- filter: {
2703
- module: "PWM2",
2704
- aliasReEx: "^PWM[0-9]2$",
2705
- },
2706
- behaviour: behaviour.LOCK_UNLOCK,
2707
- };
2708
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2709
- } else {
2710
- throw "Model not configured for testcase.";
2711
- }
2712
- });
2713
-
2714
- it("Module have LOCK_UNLOCK pins pwmoe3Pwmaoe", () => {
2715
- const mockMod = mockAssignedModule(mockState());
2716
- const model = getModel(mockMod, getDerivedData);
2717
-
2718
- if (model) {
2719
- model.getName = (): string => {
2720
- return "PWM2";
2721
- };
2722
- model.getComponentValue = (cmp: string): any => {
2723
- const data = {
2724
- pwmoe3Pwmaoe: "PWM23OUT",
2725
- };
2726
- return data[cmp];
2727
- };
2728
- model.isComponentValue = (cmp: string): any => {
2729
- const data = {
2730
- pwmoe3Pwmaoe: true,
2731
- };
2732
- return data[cmp];
2733
- };
2734
- model.getImportValue = (imp: string): any => {
2735
- return {
2736
- allpins: {
2737
- RA0: {
2738
- PWM1: {
2739
- PWM10: {
2740
- alias: "PWM10",
2741
- },
2742
- },
2743
- },
2744
- RA1: {
2745
- PWM1: {
2746
- PWM11: {
2747
- alias: "PWM11",
2748
- },
2749
- },
2750
- },
2751
- RA2: {
2752
- PWM1: {
2753
- PWM12: {
2754
- alias: "PWM12",
2755
- },
2756
- },
2757
- },
2758
- RA3: {
2759
- PWM1: {
2760
- PWM13: {
2761
- alias: "PWM13",
2762
- },
2763
- },
2764
- },
2765
- RB0: {
2766
- PWM2: {
2767
- PWM20: {
2768
- alias: "PWM20",
2769
- },
2770
- },
2771
- },
2772
- RB1: {
2773
- PWM2: {
2774
- PWM21: {
2775
- alias: "PWM21",
2776
- },
2777
- },
2778
- },
2779
- RB2: {
2780
- PWM2: {
2781
- PWM22: {
2782
- alias: "PWM22",
2783
- },
2784
- },
2785
- },
2786
- RB3: {
2787
- PWM2: {
2788
- PWM23: {
2789
- alias: "PWM23",
2790
- },
2791
- },
2792
- },
2793
- RC2: {
2794
- PWM1: {
2795
- PWM1: {
2796
- alias: "PWM1",
2797
- },
2798
- },
2799
- },
2800
- RC3: {
2801
- PWM2: {
2802
- PWM2: {
2803
- alias: "PWM2",
2804
- },
2805
- },
2806
- },
2807
- },
2808
- };
2809
- };
2810
-
2811
- const rowData: pin_row = {
2812
- name: "pwmx3",
2813
- module: "PWM2",
2814
- function: "PWM23OUT",
2815
- direction: direction.output,
2816
- filter: {
2817
- module: "PWM2",
2818
- aliasReEx: "^PWM[0-9]3$",
2819
- },
2820
- behaviour: behaviour.LOCK_UNLOCK,
2821
- };
2822
- const expectedRowData = {
2823
- name: "pwmx3",
2824
- module: "PWM2",
2825
- function: "PWM23OUT",
2826
- direction: "output",
2827
- filter: {
2828
- module: "PWM2",
2829
- aliasReEx: "^PWM[0-9]3$",
2830
- },
2831
- behaviour: behaviour.LOCK_UNLOCK,
2832
- };
2833
- expect(getRowData(model as any, rowData)).toMatchObject(expectedRowData);
2834
- } else {
2835
- throw "Model not configured for testcase.";
2836
- }
2837
- });
2838
- });