@mchp-mcc/scf-pic8-pwm-v2 4.2.4 → 4.2.5

package/src/DerivedData.ts

@@ -11,6 +11,8 @@ import { Interface, Arguments } from "@microchip/scf-interface";
 import { getGeneratorModel, getHeaderFiles } from "./GeneratorModel";
 import { MyComponentNames, MyExportNames } from "../generated_module/src/types";
 import { getAutoSdlHelp } from "@microchip/scf-automodule-impl/lib/autoModule/ContextualHelp";
+import { getPinsLogic } from "../generated_module/src/pins/PCPHelper";
+import { MyImports } from "../generated_module/src/types";
 
 export const getDerivedData = (dataModel: AppModel): DerivedData => {
     if (dataModel) {
@@ -69,7 +71,8 @@ class MyDerivedData implements DerivedData {
             pwmFrequency: (): number => this.getPwmCalculator().getPwmFrequency(),
             pwmResolution: (): number => this.getPwmCalculator().getPwmResolution(),
 
-            ctselCcptmrs1: this.ctselCcptmrs1,
+            ctselCcptmrs1: this.ctselTimerSetting,
+            ctselPwmtmrs: this.ctselTimerSetting,
             pwmdchPwmdch: (): number =>
                 Number(this.dataModel.getComponentValue("pwmdcValue")) >> 2,
             pwmdclPwmdcl: (): number =>
@@ -77,9 +80,20 @@ class MyDerivedData implements DerivedData {
 
             templateData: (): any => getGeneratorModel(this.dataModel),
             getHelpUrl: this.getSdlHelpOverride,
+            filterImports: this.filterImports,
+            getPinsLogic: getPinsLogic,
+            importName: this.friendlyImportName,
         };
     };
 
+    private friendlyImportName = (importKey: string): string => {
+        if (importKey === "scf_pic8_pwm_v2") return "PWM Hardware";
+        if (importKey === "osc_clocks") return "Oscillator Clock";
+        if (importKey === "initializer_system") return "system.c Initialize()";
+        if (importKey === "pin_standard") return "Pins";
+        return importKey;
+    };
+
     private overrideDefaultValues = (componentName: string): any => {
         switch (componentName) {
             case "componentName":
@@ -95,6 +109,8 @@ class MyDerivedData implements DerivedData {
                 const result: any[] = [];
                 const CCPTMRSREG = this.dataModel.getPeripheralDescription()?.registers
                     ?.CCPTMRS1;
+                const PWMTMRSREG = this.dataModel.getPeripheralDescription()?.registers
+                    ?.PWMTMRS;
                 if (CCPTMRSREG) {
                     const CTSELSETT = CCPTMRSREG.settings?.CTSEL;
                     for (const eachoptn of CTSELSETT?.options ?? []) {
@@ -104,7 +120,18 @@ class MyDerivedData implements DerivedData {
                             (optnmatch?.length ?? 0) > 1 ? "TMR" + optnmatch?.[1] : "";
                         result.push(correctOptnName);
                     }
-                } else {
+                }
+                if (PWMTMRSREG) {
+                    const CTSELSETT = PWMTMRSREG.settings?.CTSEL;
+                    for (const eachoptn of CTSELSETT?.options ?? []) {
+                        const timeroptnregex = /^pwm[0-9]timer([0-9])$/i;
+                        const optnmatch = eachoptn.alias.match(timeroptnregex);
+                        const correctOptnName =
+                            (optnmatch?.length ?? 0) > 1 ? "TMR" + optnmatch?.[1] : "";
+                        result.push(correctOptnName);
+                    }
+                }
+                if (!CCPTMRSREG && !PWMTMRSREG) {
                     result.push("TMR2");
                 }
                 return result;
@@ -122,6 +149,31 @@ class MyDerivedData implements DerivedData {
         return {};
     };
 
+    private filterImports = (imports: MyImports): MyImports => {
+        let filteredImports: MyImports = imports;
+        const ImportKeys = ["Timer"];
+
+        ImportKeys.forEach((importKey) => {
+            filteredImports = this.getModel().filterImportBySetting(
+                filteredImports,
+                importKey,
+                (option: Processor.Option<any>): any => {
+                    if (option.payload !== undefined) {
+                        const rstSource =
+                            this.dataModel.getComponentValue("timerSelection") ??
+                            "disabled";
+                        const regexpNumber = /\d/;
+                        const inst = rstSource.match(regexpNumber);
+                        if (rstSource.indexOf("TMR") !== -1) {
+                            return option.payload.moduleName === "TMR" + inst;
+                        }
+                    }
+                },
+            ) as MyImports;
+        });
+        return filteredImports;
+    };
+
     private getMyAlerts = (): Processor.Alert[] => {
         const alerts: Processor.Alert[] = [];
 
@@ -170,6 +222,8 @@ class MyDerivedData implements DerivedData {
                 componentName = "ctselCcptmrs1";
             } else if (this.getModel().getPeripheralDescription()?.registers?.CCPTMRS) {
                 componentName = "ctselCcptmrs";
+            } else if (this.getModel().getPeripheralDescription()?.registers?.PWMTMRS) {
+                componentName = "ctselPwmtmrs";
             }
         } else if (componentName === "dutyCycle" || componentName === "pwmdcValue") {
             helpUrl = helpUrl?.replace(
@@ -221,14 +275,14 @@ class MyDerivedData implements DerivedData {
         return undefined;
     };
 
-    private ctselCcptmrs1 = (): string | undefined => {
+    private ctselTimerSetting = (): string | undefined => {
         switch (this.dataModel.getComponentValue("timerSelection")) {
             case "TMR2":
-                return this.dataModel.getHardware()?.getName() + "TMR2";
+                return this.dataModel.getHardware()?.getName() + "timer2";
             case "TMR4":
-                return this.dataModel.getHardware()?.getName() + "TMR4";
+                return this.dataModel.getHardware()?.getName() + "timer4";
             case "TMR6":
-                return this.dataModel.getHardware()?.getName() + "TMR6";
+                return this.dataModel.getHardware()?.getName() + "timer6";
             default:
                 return undefined;
         }

package/src/GeneratorModel.test.tsx

@@ -0,0 +1,69 @@
+//import { getModel } from "../generated_module/src/App/AppModel";
+import { AppModel } from "../generated_module/src/types/AutoModuleTypes";
+import { getModel, mockState } from "../generated_module/tests/AppModel.test";
+import { mockAssignedModule } from "../generated_module/tests/processor.test";
+import * as MyDerivedData from "./DerivedData";
+import * as GenertorModel from "./GeneratorModel";
+
+describe("GeneratorModel", () => {
+    describe("getGeneratorModel", () => {
+        test("componentName is undefined", () => {
+            const mockModule = mockAssignedModule(mockState());
+            const model = getModel(mockModule, MyDerivedData.getDerivedData);
+            if (model) {
+                model.getComponentValue = (comp_name: string): any => {
+                    const compData = {
+                        componentName: undefined,
+                    };
+                    return compData[comp_name];
+                };
+                expect(
+                    GenertorModel.getGeneratorModel(model as any).customName,
+                ).toBeUndefined();
+            }
+        });
+
+        test("PeripheralDescription is undefined", () => {
+            const mockModule = mockAssignedModule(mockState());
+            const model = getModel(mockModule, MyDerivedData.getDerivedData);
+            if (model) {
+                model.getPeripheralDescription = (): any => {
+                    return undefined;
+                };
+                expect(
+                    GenertorModel.getGeneratorModel(model as AppModel).hardwareSettings,
+                ).toBeDefined;
+            }
+        });
+    });
+    // describe("convertToTemplate", () => {
+    //     test("Hardware is undefined", () => {
+    //         const mockModule = mockAssignedModule(mockState());
+    //         const model = getModel(mockModule, MyDerivedData.getDerivedData);
+
+    //         if (model) {
+    //             model.getHardware = (): any => {
+    //                 return undefined;
+    //             };
+    //             const result1 = GenertorModel.convertToTemplate(
+    //                 model as AppModel,
+    //                 "positive",
+    //                 [],
+    //             );
+    //             expect(result1.length).toBe(0);
+    //             const result2 = GenertorModel.convertToTemplate(
+    //                 model as AppModel,
+    //                 "negative",
+    //                 [],
+    //             );
+    //             expect(result2.length).toBe(0);
+    //             const result3 = GenertorModel.convertToTemplate(
+    //                 model as AppModel,
+    //                 "none",
+    //                 [],
+    //             );
+    //             expect(result3.length).toBe(0);
+    //         }
+    //     });
+    // });
+});

package/src/PinsLogic.test.ts

@@ -0,0 +1,155 @@
+import { behaviour, direction, pin_row } from "@microchip/pin-standard";
+//import { getModel } from "../generated_module/src/App/AppModel";
+import { MyState } from "../generated_module/src/types/AutoModuleTypes";
+import { getModel, mockState } from "../generated_module/tests/AppModel.test";
+import { mockAssignedModule } from "../generated_module/tests/processor.test";
+import { getDerivedData } from "./DerivedData";
+import { getRowData } from "./PinsLogic";
+
+// export const getMockState = (ccpMode: string | undefined): MyState => {
+//     return {
+//         main: {
+//             software: {
+//                 componentName: "CCP1",
+//                 scf_pic8_ccp_v1: "CCP1",
+//             },
+//             interrupt: {
+//                 interruptEnable: false,
+//             },
+//             hardware: {
+//                 ccpMode: ccpMode,
+//                 captureMode: "Every edge",
+//                 compareMode: "Toggle_cleartmr",
+//                 dutyCycle: 0,
+//                 ccprValue: "0",
+//                 pwmPeriod: "0",
+//                 pwmFrequency: "0",
+//                 pwmResolution: "0",
+//                 ccpTimer: "Timer 1",
+//                 pwmTimer: "Timer 2",
+//                 enCcpcon: true,
+//                 fmtCcpcon: "right_aligned",
+//                 ctsCcpcap: "CCP1 pin",
+//             },
+//         },
+//     };
+// };
+
+export const getMockState = (): MyState => {
+    return {
+        main: {
+            software: {
+                componentName: "PWM4",
+                tmr2Dependency: "TMR2",
+            },
+            hardware: {
+                timerSelection: "TMR2",
+                dutyCycle: 50,
+                pwmdcValue: 511,
+                pwmPeriod: 0.001024,
+                pwmFrequency: 976.56,
+                pwmResolution: 10,
+                pwmpolPwmcon: "active_hi",
+                pwmenPwmcon: true,
+            },
+        },
+    };
+};
+
+describe("PinsLogic --> Test Cases ", () => {
+    describe("getRowData() test case ", () => {
+        const mockModule = mockAssignedModule(getMockState());
+        const model = getModel(mockModule, getDerivedData);
+
+        const pwmPpsData: pin_row = {
+            name: "pwmPps",
+            module: "PWM6",
+            function: "PWM6OUT",
+            direction: direction.output,
+            filter: {
+                module: "PWM6",
+                aliasReEx: "PWM[0-9]",
+            },
+            behaviour: behaviour.PPS,
+        };
+        it("Test for pwmPpsData pin data: PWM mode", () => {
+            if (model) {
+                expect(getRowData(model as any, pwmPpsData)).toMatchObject(pwmPpsData);
+                expect(getRowData(model as any, pwmPpsData)?.actions).toBeUndefined();
+            } else {
+                throw "Model not configured for testcase";
+            }
+        });
+    });
+    // describe("getRowData() test case : CCP in no mode", () => {
+    //     const mockModule = mockAssignedModule(getMockState(""));
+    //     const model = getModel(mockModule, getDerivedData);
+
+    //     const ccpPpsData: pin_row = {
+    //         name: "ccpPps",
+    //         module: "CCP3",
+    //         function: "CCP3",
+    //         direction: direction.output,
+    //         filter: {
+    //             module: "CCP3",
+    //             aliasReEx: "CCP[0-9]",
+    //         },
+    //         behaviour: behaviour.PPS,
+    //     };
+    //     it("Test for ccpPpsData pin data: no mode", () => {
+    //         if (model) {
+    //             expect(getRowData(model, ccpPpsData)).toMatchObject(ccpPpsData);
+    //             expect(getRowData(model, ccpPpsData)?.actions).toBeUndefined();
+    //         } else {
+    //             throw "Model not configured for testcase";
+    //         }
+    //     });
+    // });
+    describe("getRowData() test case : invalid", () => {
+        const mockModule = mockAssignedModule(mockState());
+        const model = getModel(mockModule, getDerivedData);
+
+        const pwmPpsData: pin_row = {
+            name: "dummy",
+            module: "PWM6",
+            function: "PWM6OUT",
+            direction: direction.output,
+            filter: {
+                module: "PWM6",
+                aliasReEx: "PWM[0-9]",
+            },
+            behaviour: behaviour.PPS,
+        };
+        it("Test for pwmPpsData pin data: invalid", () => {
+            if (model) {
+                expect(getRowData(model as any, pwmPpsData)).toMatchObject(pwmPpsData);
+                expect(getRowData(model as any, pwmPpsData)?.actions).toBeUndefined();
+            } else {
+                throw "Model not configured for testcase";
+            }
+        });
+        it("Test for ccpPpsData pin data, undefined registers", () => {
+            let mockAssignedMod = mockAssignedModule(mockState());
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        handle: undefined,
+                        payload: undefined,
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, getDerivedData);
+            if (mockModel) {
+                expect(getRowData(mockModel as any, pwmPpsData)).toMatchObject(
+                    pwmPpsData,
+                ); // check if the same data is returned
+                expect(getRowData(mockModel as any, pwmPpsData)?.actions).toBeUndefined();
+            } else {
+                throw "Model not configured for testcase";
+            }
+        });
+    });
+});

package/src/PwmCalculator.test.tsx

@@ -55,3 +55,59 @@ describe("Pwm Calculations: PR = 0x4d, Prescaler = 0x5, fosc = 1M, DC = 60", ()
         expect(pwmCalculator2.getActualPulseWidth()).toBe(0.005952);
     });
 });
+
+describe("Pwm Calculations: PR = 0x0, Prescaler = 0x0, fosc = 1M, DC = 0", () => {
+    const pwmCalculator2 = new PwmCalculator(0x0, 0, 1000000, 0);
+
+    test("getPwmPeriod", () => {
+        expect(pwmCalculator2.getPwmPeriod()).toBe(0);
+    });
+
+    test("getPwmFrequency", () => {
+        expect(pwmCalculator2.getPwmFrequency()).toBe(0);
+    });
+
+    test("getPwmResolution", () => {
+        expect(pwmCalculator2.getPwmResolution()).toBe(2);
+    });
+
+    test("getCCPRValue", () => {
+        expect(pwmCalculator2.getCCPRValue()).toBe(0);
+    });
+
+    test("getActualDutyCycle", () => {
+        expect(pwmCalculator2.getActualDutyCycle()).toBe(0);
+    });
+
+    test("getActualPulseWidth", () => {
+        expect(pwmCalculator2.getActualPulseWidth()).toBe(0);
+    });
+});
+
+describe("Pwm Calculations: PR = 0x0, Prescaler = 0x0, fosc = 0, DC = 0", () => {
+    const pwmCalculator2 = new PwmCalculator(0x0, 0, 0, 0);
+
+    test("getPwmPeriod", () => {
+        expect(pwmCalculator2.getPwmPeriod()).toBe(0);
+    });
+
+    test("getPwmFrequency", () => {
+        expect(pwmCalculator2.getPwmFrequency()).toBe(0);
+    });
+
+    test("getPwmResolution", () => {
+        expect(pwmCalculator2.getPwmResolution()).toBe(2);
+    });
+
+    test("getCCPRValue", () => {
+        expect(pwmCalculator2.getCCPRValue()).toBe(0);
+    });
+
+    test("getActualDutyCycle", () => {
+        expect(pwmCalculator2.getActualDutyCycle()).toBe(0);
+    });
+
+    test("getActualPulseWidth", () => {
+        expect(pwmCalculator2.getActualPulseWidth()).toBe(0);
+    });
+});

package/src/interfaces/pwm_general_parameters.test.tsx

@@ -0,0 +1,40 @@
+import { ProcessedExportInterface, Interface } from "./pwm_general_parameters";
+
+describe("The pwm_general_parameters interface", () => {
+    it("doesn't explode", () => {
+        expect(Interface.getInterfaceId()).toBeDefined();
+        expect(Interface.createPrototypeImport()).toBeDefined();
+        expect(Interface.createPrototypeExport()).toBeDefined();
+        expect(
+            Interface.createFirmwareApi("MyModule", [
+                { name: "mymodule.h", path: "include/" },
+            ]),
+        ).toBeDefined();
+        expect(Interface.createMock()).toBeDefined();
+    });
+
+    it("Checks Interface ID", () => {
+        expect(Interface.getInterfaceId().name).toBe("pwm_general_parameters");
+        expect(Interface.getInterfaceId().version).toBe("0.1.0");
+    });
+
+    it("Create's api with name, headers, or custom API undefined", () => {
+        expect(Interface.createFirmwareApi("", [{ name: "", path: "" }])).toBeDefined();
+    });
+});
+
+export const createMock = (): ProcessedExportInterface => {
+    return {
+        interfaceId: Interface.getInterfaceId(),
+        payload: {
+            interfaceApi: Interface.createFirmwareApi("MyModule", [
+                { name: "mymodule.h", path: "include/" },
+            ]),
+        },
+        args: {
+            requestId: {
+                customName: "MyModule",
+            },
+        },
+    };
+};

package/src/moduleConfig.json

@@ -30,6 +30,10 @@
         "main": "Easy View",
         "register": "Register Initialization"
     },
+    "help": {
+        "url": "v2/keyword-lookup?keyword=scf-pic8-pwm-v2&redirect=true",
+        "tooltip": "Click here to open documentation."
+    },
     "analytics": {
         "logAlwaysComps": [
             "pwmenPwmcon",
@@ -134,6 +138,17 @@
             ],
             "category": "software"
         },
+        "tmr2Dependency": {
+            "name": "tmr2Dependency",
+            "description": "Timer Dependency Selector",
+            "category": "import",
+            "type": "ComboBox",
+            "group": "software",
+            "tabs": [
+                "main"
+            ],
+            "importId": "Timer"
+        },
         "timerSelection": {
             "name": "timerSelection",
             "description": "Select a Timer",
@@ -240,6 +255,19 @@
                 "version": "1.0.0"
             },
             "registers": {
+                "PWMTMRS": [
+                    {
+                        "setting": "CTSEL",
+                        "name": "ctselPwmtmrs",
+                        "category": "hardware",
+                        "description": "Insert Description Here",
+                        "type": "ComboBox",
+                        "group": "hardware",
+                        "tabs": [
+                            "register"
+                        ]
+                    }
+                ],
                 "CCPTMRS1": [
                     {
                         "setting": "CTSEL",