@mchp-mcc/scf-pic8-opamp-v2 1.0.0

package/output/source-template.c.ftl

@@ -0,0 +1,149 @@
+/**
+ * ${moduleNameUpperCase} Generated Driver File
+ * 
+ * @file ${moduleNameLowerCase}.c
+ * 
+ * @ingroup  ${moduleNameLowerCase}
+ * 
+ * @brief This is the generated driver implementation file for the ${moduleNameUpperCase} driver.
+ *
+ * @version ${moduleNameUpperCase} Driver Version 1.0.0
+*/
+${disclaimer}
+
+/**
+   Section: Included Files
+*/
+
+#include <xc.h>
+#include "${header.path}${header.name}"
+
+/**
+  Section: ${moduleNameUpperCase} Module APIs
+*/
+
+void ${moduleNameUpperCase}_Initialize(void)
+{
+    <#if OPACON1??>
+    //${OPACON1.comment}
+    ${OPACON1.name} = ${OPACON1.valueAsHex};
+    </#if>
+
+    <#if OPACON2??>
+    //${OPACON2.comment}
+    ${OPACON2.name} = ${OPACON2.valueAsHex};
+    </#if>
+
+    <#if OPACON3??>
+    //${OPACON3.comment}
+    ${OPACON3.name} = ${OPACON3.valueAsHex};
+    </#if>
+
+    <#if OPACON4??>
+    //${OPACON4.comment}
+    ${OPACON4.name} = ${OPACON4.valueAsHex};
+    </#if>
+
+    <#if OPAHWC??>
+    //${OPAHWC.comment}
+    ${OPAHWC.name} = ${OPAHWC.valueAsHex};
+    </#if>
+
+    <#if OPAORS??>
+    //${OPAORS.comment}
+    ${OPAORS.name} = ${OPAORS.valueAsHex};
+    </#if>    
+
+    <#if OPACON0??>
+    //${OPACON0.comment}
+    ${OPACON0.name} = ${OPACON0.valueAsHex};
+    </#if>
+}
+
+inline void ${moduleNameUpperCase}_EnableChargePump(void)
+{
+    ${OPACON0.name}bits.${OPACON0.settings.CPON.alias} = 1;
+}
+ 
+inline void ${moduleNameUpperCase}_DisableChargePump(void)
+{
+    ${OPACON0.name}bits.${OPACON0.settings.CPON.alias} = 0;
+}
+
+inline void ${moduleNameUpperCase}_EnableSoftwareUnityGain(void)
+{
+    ${OPACON0.name}bits.${OPACON0.settings.UG.alias} = 1;
+}
+
+inline void ${moduleNameUpperCase}_DisableSoftwareUnityGain(void)
+{
+    ${OPACON0.name}bits.${OPACON0.settings.UG.alias} = 0;
+}
+
+inline void ${moduleNameUpperCase}_SetPositiveChannel(${moduleNameUpperCase}_posChannel_select posChannel)
+{
+    ${OPACON2.name}bits.${OPACON2.settings.PCH.alias} = posChannel;
+}
+
+inline void ${moduleNameUpperCase}_SetPositiveSource(${moduleNameUpperCase}_posSource_select posSource)
+{
+    ${OPACON3.name}bits.${OPACON3.settings.PSS.alias} = posSource;
+}
+
+inline void ${moduleNameUpperCase}_SetNegativeChannel(${moduleNameUpperCase}_negChannel_select negChannel)
+{
+    ${OPACON2.name}bits.${OPACON2.settings.NCH.alias} = negChannel;
+}
+
+inline void ${moduleNameUpperCase}_SetNegativeSource(${moduleNameUpperCase}_negSource_select negSource)
+{
+    ${OPACON1.name}bits.${OPACON1.settings.NSS.alias} = negSource;
+}
+
+void ${moduleNameUpperCase}_SetResistorLadder(${moduleNameUpperCase}_resistor_select resistorSelection)
+{
+    ${OPACON1.name}bits.${OPACON1.settings.RESON.alias} = 1;
+    ${OPACON1.name}bits.${OPACON1.settings.GSEL.alias} = resistorSelection;
+}
+
+inline void ${moduleNameUpperCase}_EnableHardwareOverride(void)
+{
+   ${OPAHWC.name}bits.${OPAHWC.settings.OREN.alias} = 1;
+}
+
+void ${moduleNameUpperCase}_SetHardwareOverrideSource(uint8_t overrideSource, uint8_t polarity)
+{
+    ${OPAORS.name} = overrideSource;
+    ${OPAHWC.name}bits.${OPAHWC.settings.ORPOL.alias} = polarity;
+}
+
+inline void ${moduleNameUpperCase}_DisableHardwareOverride(void)
+{
+    ${OPAHWC.name}bits.${OPAHWC.settings.OREN.alias} = 0;
+}
+
+inline void ${moduleNameUpperCase}_ManualInputOffsetCalibration(uint8_t offset)
+{
+    ${OPAOFFSET.name} = offset;
+}
+
+void ${moduleNameUpperCase}_StartAutomaticOffsetCalibration(void)
+{
+	${OPACON4.name}bits.${OPACON4.settings.OFCSEL.alias} = 2;
+    ${OPACON4.name}bits.${OPACON4.settings.OFCST.alias} = 1;
+}
+
+inline bool ${moduleNameUpperCase}_isAutomaticOffsetCalibrationDone(void)
+{
+    return (${OPACON4.name}bits.${OPACON4.settings.OFCST.alias});
+}
+
+inline void ${moduleNameUpperCase}_StartPeakTroughReset(void)
+{
+    ${OPACON4.name}bits.${OPACON4.settings.PTRES.alias} = 1;
+}
+
+inline void ${moduleNameUpperCase}_StopPeakTroughReset(void)
+{
+    ${OPACON4.name}bits.${OPACON4.settings.PTRES.alias} = 0;
+}

package/package.json

@@ -0,0 +1,172 @@
+{
+    "name": "@mchp-mcc/scf-pic8-opamp-v2",
+    "version": "1.0.0",
+    "scf": {
+        "reducer": "output/reducer.js",
+        "creator": "output/creator.js",
+        "processor": "output/processor.js",
+        "nullPrototype": "output/nullPrototype.json",
+        "views": {
+            "main": "auto"
+        },
+        "displayName": "OPA",
+        "category": "Drivers/OPAMP",
+        "autoProcessor": "output/autoProcessor.js",
+        "autoCreator": "output/autoCreator.js"
+    },
+    "jenkinsPipeline": "MCU8_DS_PIPELINE_2XY",
+    "scf-automodule": {
+        "peripheral": {
+            "deviceName": "PIC18F56Q71",
+            "interfaceId": {
+                "name": "scf-pic8-opamp-v2",
+                "version": "1.0.0"
+            },
+            "instance": "OPA"
+        },
+        "shouldNotifyOnDeploy": false,
+        "mode": "standard",
+        "hookPaths": {
+            "processor": "generated_module/src/processor.ts",
+            "creator": "generated_module/src/creator.ts",
+            "reducer": "src/reducer.ts"
+        }
+    },
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "scripts": {
+        "build": "gulp build --gulpfile config/gulpfile.js --cwd .",
+        "build-dev": "gulp build --gulpfile config/gulpfile.js --buildDev --cwd .",
+        "build-prod": "gulp build --gulpfile config/gulpfile.js --production --cwd .",
+        "start": "gulp start --gulpfile config/gulpfile.js --cwd .",
+        "test": "jest",
+        "test:itf:all": "node ./node_modules/@microchip/ccl-itf/lib/index.js --sp=tests/itf --rd=run --sf=opamp.major.test.ts --df=\"PIC18F.*Q71\"",
+        "test:itf:dev": "node ./node_modules/@microchip/ccl-itf/lib/index.js --sp=tests/itf --rd=run --sf=opamp.major.test.ts --df=\"PIC18F56Q71\"",
+        "test:itf:interface": "node ./node_modules/@microchip/ccl-itf/lib/index.js --sp=tests/itf --rd=run --intf=scf-pic8-opamp-v2 --intV=1.0.0",
+        "create-auto-module": "gulp create-auto-module --gulpfile config/gulpfile.js --cwd .",
+        "build-run-dir": "node config/extract-run-directory.js",
+        "build-latest-run-dir": "yarn add @microchip/run-directory && yarn build-run-dir",
+        "dist": "gulp dist --gulpfile config/gulpfile.js --cwd .",
+        "lint:nofix": "eslint \"./src/**/*.{ts,tsx}\" --quiet",
+        "lint": "tsc --noEmit && yarn lint:nofix --fix",
+        "updateProject": "node config/create-auto-module.js --updateProject=true",
+        "update-auto-module": "yarn add @microchip/scf-automodule -D && yarn updateProject",
+        "profile": "jest profile",
+        "release": "yarn build && yarn test && node -e 'require(\"./config/scf-project-scripts\").releaseProject()'",
+        "postprocess": "node config/appendPrototype.js"
+    },
+    "husky": {
+        "hooks": {
+            "pre-commit": "tsc --noEmit && lint-staged"
+        }
+    },
+    "lint-staged": {
+        "./src/**/*.{ts,tsx}": [
+            "eslint --fix"
+        ]
+    },
+    "files": [
+        "output/**/*",
+        "config.json",
+        "src/**/*"
+    ],
+    "jest": {
+        "testPathIgnorePatterns": [
+            "/node_modules/",
+            "/run/",
+            "/generated_module/examples/",
+            "/lib/",
+            "/tests/itf/"
+        ],
+        "modulePathIgnorePatterns": [
+            "<rootDir>/run"
+        ],
+        "preset": "ts-jest",
+        "collectCoverage": true,
+        "coverageThreshold": {
+            "./src": {
+                "branches": 80,
+                "functions": 80,
+                "lines": 80,
+                "statements": 80
+            }
+        }
+    },
+    "dependencies": {
+        "@microchip/api-prefix-registration": "^0.1.0",
+        "@microchip/fosc-hz": "^0.1.2",
+        "@microchip/pin-standard": "^0.4.1",
+        "@microchip/scf-autoview-impl": "^3.7.1",
+        "@microchip/scf-common": "^3.17.0",
+        "@microchip/scf-device": "^8.5.0",
+        "@microchip/scf-integration-test": "^1.0.0",
+        "@microchip/scf-interface": "^1.4.0",
+        "@microchip/scf-register-view-helper": "^2.5.0",
+        "babel-jest": "^27.5.1"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.9.6",
+        "@babel/plugin-proposal-class-properties": "^7.8.3",
+        "@microchip/ccl-itf": "^1.3.0",
+        "@babel/preset-env": "^7.9.6",
+        "@babel/preset-react": "^7.9.4",
+        "@babel/preset-typescript": "^7.9.0",
+        "@mchp-mcc/pic-8bit": "^5.10.0-dev.2",
+        "@mchp-mcc/pic-8bit-types": "^5.10.0-dev.2",
+        "@microchip/initializer-system": "^0.5.3",
+        "@microchip/melody-automodule-interface": "^1.6.3",
+        "@microchip/run-directory": "^4.2.1",
+        "@microchip/scf-automodule": "^5.6.5",
+        "@microchip/scf-automodule-impl": "^1.8.3",
+        "@microchip/scf-autoview": "^3.26.1",
+        "@microchip/scf-project-scripts": "^1.0.0",
+        "@types/core-js": "^2.5.1",
+        "@types/enzyme": "^3.9.3",
+        "@types/jest": "^24.0.14",
+        "@types/lodash.filter": "^4.6.6",
+        "@types/lodash.find": "^4.6.6",
+        "@types/lodash.map": "^4.6.13",
+        "@types/node": "^12.0.10",
+        "@types/properties-reader": "^0.0.1",
+        "@types/semver": "^7.1.0",
+        "@typescript-eslint/eslint-plugin": "^3.2.0",
+        "@typescript-eslint/parser": "^3.6.0",
+        "babel-eslint": "^10.1.0",
+        "babel-loader": "^8.0.6",
+        "babel-plugin-named-asset-import": "^0.3.2",
+        "babel-preset-react-app": "^9.0.0",
+        "del": "^4.1.1",
+        "eslint": "^7.4.0",
+        "eslint-config-prettier": "^6.11.0",
+        "eslint-friendly-formatter": "^4.0.1",
+        "eslint-loader": "^4.0.2",
+        "eslint-plugin-prettier": "^3.1.3",
+        "eslint-plugin-react": "^7.20.0",
+        "fork-ts-checker-webpack-plugin": "^1.3.7",
+        "fs": "^0.0.1-security",
+        "gulp": "^4.0.2",
+        "gulp-changed": "^4.0.2",
+        "gulp-cli": "^2.2.0",
+        "gulp-if": "^3.0.0",
+        "gulp-typescript": "^5.0.1",
+        "hard-source-webpack-plugin": "^0.13.1",
+        "husky": "^4.2.4",
+        "is-wsl": "^2.1.0",
+        "jest": "^24.8.0",
+        "jest-html-reporter": "^2.5.0",
+        "jest-pnp-resolver": "^1.2.1",
+        "lint-staged": "^10.1.3",
+        "pnp-webpack-plugin": "^1.5.0",
+        "prettier": "^2.0.5",
+        "ts-jest": "^24.0.2",
+        "ts-pnp": "^1.1.2",
+        "typescript": "~4.5.5",
+        "webpack": "^4.34.0",
+        "webpack-cli": "^3.3.4",
+        "webpack-merge": "^4.2.2",
+        "webpack-stream": "^5.2.1",
+        "yargs": "^13.2.4"
+    },
+    "description": "- Download & Install [nodejs](https://nodejs.org/en/download/)\r - Download & Install npm\r - Setup node & npm in enviroment path",
+    "main": "lib/generated_module/src/index.js",
+    "author": ""
+}

package/src/Calculations.test.tsx

@@ -0,0 +1,83 @@
+import { Calculations } from "./Calculations";
+
+describe("Testing the calculated Non-inverting Gain values", () => {
+    test("Test with Register selection  R1 = 15R and R2 = 1R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain("R1 = 15R and R2 = 1R, R2/R1 = 0.07")).toEqual("1.07");
+    });
+
+    test("Test with Register selection  R1 = 8R and R2 = 8R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain("R1 = 8R and R2 = 8R, R2/R1 = 1")).toEqual("2.00");
+    });
+
+    test("Test with Register selection  R1 = 1R and R2 = 15R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain("R1 = 1R and R2 = 15R, R2/R1 = 15")).toEqual("16.00");
+    });
+
+    test("Test with Register selection  R1 = 15r and R2 = 1r", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain("R1 = 15r and R2 = 1r, R2/R1 = 0.07")).toEqual("1.07");
+    });
+
+    test("Test with Register selection  is undefined", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain(undefined)).toEqual("0");
+    });
+
+    test("Test with Register selection  R1 = 1 and R2 = 15", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain("R1 = 1 and R2 = 15, R2/R1 = 15")).toEqual("0");
+    });
+
+    test("Test with Register selection  R1 = 1R and R2 = 15R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcNonInvGain("R1 = 1R and R2 = 15R")).toEqual("0");
+    });
+});
+
+describe("Testing the calculated Inverting Gain values", () => {
+    test("Test with Register selection  R1 = 15R and R2 = 1R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain("R1 = 15R and R2 = 1R, R2/R1 = 0.07")).toEqual(
+            "1.07(Vref/Vin) - 0.07",
+        );
+    });
+
+    test("Test with Register selection  R1 = 8R and R2 = 8R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain("R1 = 8R and R2 = 8R, R2/R1 = 1")).toEqual(
+            "2.00(Vref/Vin) - 1",
+        );
+    });
+
+    test("Test with Register selection  R1 = 15R and R2 = 1R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain("R1 = 15R and R2 = 1R, R2/R1 = 15")).toEqual(
+            "16.00(Vref/Vin) - 15",
+        );
+    });
+
+    test("Test with Register selection  R1 = 15r and R2 = 1r", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain("R1 = 15r and R2 = 1r, R2/R1 = 0.07")).toEqual(
+            "1.07(Vref/Vin) - 0.07",
+        );
+    });
+
+    test("Test with Register selection  is undefined", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain(undefined)).toEqual("0");
+    });
+
+    test("Test with Register selection  R1 = 1 and R2 = 15", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain("R1 = 1 and R2 = 15, R2/R1 = 15")).toEqual("0");
+    });
+
+    test("Test with Register selection  R1 = 1R and R2 = 15R", () => {
+        const calc: Calculations = new Calculations();
+        expect(calc.calcInvGain("R1 = 1R and R2 = 15R")).toEqual("0");
+    });
+});

package/src/Calculations.tsx

@@ -0,0 +1,20 @@
+export class Calculations {
+    public calcNonInvGain = (resSelect: string | undefined): string => {
+        if (resSelect == undefined) return "0";
+        const regExp = /^([Rr]1 = [0-9]{0,2}[rR] and [Rr]2 = [0-9]{0,2}[Rr], [Rr]2\/[Rr]1 = )(.*)$/;
+        const ratio = resSelect.match(regExp)?.[2];
+        if (ratio == undefined) return "0";
+        const gain = (parseFloat(ratio) + 1).toFixed(2);
+        return gain;
+    };
+
+    public calcInvGain = (resSelect: string | undefined): string => {
+        if (resSelect == undefined) return "0";
+        const regExp = /^([Rr]1 = [0-9]{0,2}[rR] and [Rr]2 = [0-9]{0,2}[Rr], [Rr]2\/[Rr]1 = )(.*)$/;
+        const ratio = resSelect.match(regExp)?.[2];
+        if (ratio == undefined) return "0";
+        const constValue = "(Vref/Vin) - ";
+        const gain = (parseFloat(ratio) + 1).toFixed(2) + constValue + ratio;
+        return gain;
+    };
+}

package/src/CreatorFunctions.test.ts

@@ -0,0 +1,214 @@
+import { getCreatorFunctions } from "./CreatorFunctions";
+import { mockState } from "../generated_module/tests/AppModel.test";
+
+describe("Test for shouldImport", () => {
+    const state = mockState();
+
+    test("Testing TMR0 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("TMR0", state)).toEqual(false);
+    });
+
+    test("Testing TMR1 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("TMR1", state)).toEqual(false);
+    });
+
+    test("Testing TMR2 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("TMR2", state)).toEqual(false);
+    });
+
+    test("Testing CCP shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CCP", state)).toEqual(false);
+    });
+
+    test("Testing PWM shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("PWM", state)).toEqual(false);
+    });
+
+    test("Testing NCO shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("NCO", state)).toEqual(false);
+    });
+
+    test("Testing CMP shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CMP", state)).toEqual(false);
+    });
+
+    test("Testing ZCD shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("ZCD", state)).toEqual(false);
+    });
+
+    test("Testing CLC shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CLC", state)).toEqual(false);
+    });
+
+    test("Testing System shouldImport", () => {
+        expect(
+            getCreatorFunctions?.()?.shouldImport?.("initializer_system", state),
+        ).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for TMR0 and Hardware Override", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "TMR0_OUT",
+            },
+        },
+    };
+
+    test("Testing TMR0 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("TMR0", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for TMR1", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "TMR1_OUT",
+            },
+        },
+    };
+
+    test("Testing TMR1 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("TMR1", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for TMR2", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "TMR2_OUT",
+            },
+        },
+    };
+
+    test("Testing TMR2 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("TMR2", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for CCP", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "CCP_OUT",
+            },
+        },
+    };
+
+    test("Testing CCP1 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CCP", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for PWM", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "PWM1_S1P2",
+            },
+        },
+    };
+
+    test("Testing PWM1_S1P2 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("PWM", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for NCO", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "NCO1_OUT",
+            },
+        },
+    };
+
+    test("Testing NCO1 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("NCO", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for CMP", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "CM1_OUT",
+            },
+        },
+    };
+
+    test("Testing CMP1 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CMP", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for ZCD", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "ZCD_OUT",
+            },
+        },
+    };
+
+    test("Testing ZCD shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("ZCD", state)).toEqual(true);
+    });
+});
+
+describe("Test for shouldImport for CLC", () => {
+    let state = mockState();
+    state = {
+        ...state,
+        main: {
+            overrideSel: {
+                orsOpaors: "CLC1_OUT",
+            },
+        },
+    };
+
+    test("Testing CLC1 shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CLC", state)).toEqual(true);
+    });
+});
+
+describe("Test for undefined state", () => {
+    test("Testing CLC shouldImport", () => {
+        expect(getCreatorFunctions?.()?.shouldImport?.("CLC", undefined)).toEqual(false);
+    });
+
+    test("Testing System shouldImport", () => {
+        expect(
+            getCreatorFunctions?.()?.shouldImport?.("initializer_system", undefined),
+        ).toEqual(true);
+    });
+});
+
+describe("Test for getCreatorImportArgs", () => {
+    const state = mockState();
+
+    test("Testing TMR0 getCreatorImportArgs", () => {
+        expect(
+            getCreatorFunctions?.()?.getCreatorImportArgs?.("TMR0", state),
+        ).toBeUndefined();
+    });
+});

package/src/CreatorFunctions.ts

@@ -0,0 +1,48 @@
+import { CreatorFunctions } from "@microchip/melody-automodule-interface";
+import { MyState } from "../generated_module/src/types/AutoModuleTypes";
+
+export const getCreatorFunctions = (): CreatorFunctions => {
+    return {
+        shouldImport: shouldImport,
+        getCreatorImportArgs: getCreatorImportArgs,
+    };
+};
+
+const shouldImport = (importKey: string, state: MyState | undefined): boolean => {
+    const hwOverrideSrc = state?.main?.overrideSel?.orsOpaors ?? "LFINTOSC";
+
+    switch (importKey) {
+        case "TMR0":
+            return hwOverrideSrc.indexOf("TMR0") != -1 ? true : false;
+        case "TMR1":
+            return hwOverrideSrc.indexOf(
+                hwOverrideSrc.match(/(TMR[135])_OUT/)?.[1] ?? "TMR1",
+            ) != -1
+                ? true
+                : false;
+        case "TMR2":
+            return hwOverrideSrc.indexOf(
+                hwOverrideSrc.match(/(TMR[246])_OUT/)?.[1] ?? "TMR2",
+            ) != -1
+                ? true
+                : false;
+        case "CCP":
+            return hwOverrideSrc.indexOf("CCP") != -1 ? true : false;
+        case "PWM":
+            return hwOverrideSrc.indexOf("PWM") != -1 ? true : false;
+        case "NCO":
+            return hwOverrideSrc.indexOf("NCO") != -1 ? true : false;
+        case "CMP":
+            return hwOverrideSrc.indexOf("CM") != -1 ? true : false;
+        case "ZCD":
+            return hwOverrideSrc.indexOf("ZCD") != -1 ? true : false;
+        case "CLC":
+            return hwOverrideSrc.indexOf("CLC") != -1 ? true : false;
+        default:
+            return true;
+    }
+};
+
+const getCreatorImportArgs = (importKey: string, state: MyState): any | undefined => {
+    return undefined;
+};