@mchp-mcc/clock-16bit-driver 1.0.3 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mchp-mcc/clock-16bit-driver",
-    "version": "1.0.3",
+    "version": "1.1.1",
     "scf": {
         "reducer": "output/reducer.js",
         "creator": "output/creator.js",
@@ -10,14 +10,18 @@
             "main": "auto"
         },
         "displayName": "Clock",
-        "category": "System"
+        "category": "System",
+        "autoProcessor": "output/autoProcessor.js",
+        "autoCreator": "output/autoCreator.js"
     },
     "scf-automodule": {
         "mode": "react",
         "hookPaths": {
-            "processor": "generated_module/src/processor.tsx",
-            "creator": "generated_module/src/creator.tsx",
-            "reducer": "src/reducer.tsx"
+            "processor": "generated_module/src/processor.ts",
+            "creator": "generated_module/src/creator.ts",
+            "reducer": "src/reducer.tsx",
+            "App": "src/App.tsx",
+            "view": "src/index.tsx"
         },
         "shouldNotifyOnDeploy": false
     },
@@ -39,7 +43,8 @@
         "update-auto-module": "yarn add @microchip/scf-automodule -D && yarn updateProject",
         "build-run-dir-future": "node config/extract-run-directory-future.js",
         "profile": "jest profile",
-        "release": "yarn build && yarn test && node -e 'require(\"./config/scf-project-scripts\").releaseProject()'"
+        "release": "yarn build && yarn test && node -e 'require(\"./config/scf-project-scripts\").releaseProject()'",
+        "postprocess": "node config/appendPrototype.js"
     },
     "husky": {
         "hooks": {
@@ -76,16 +81,15 @@
         "@mchp-mcc/pic-8bit-types": "^5.4.1",
         "@microchip/api-prefix-registration": "^0.1.0",
         "@microchip/canfd-clock-interface": "^1.0.0",
-        "@microchip/clock-16bit-config-interface": "^1.1.0",
+        "@microchip/clock-16bit-config-interface": "^1.1.5",
         "@microchip/clock-16bit-interface": "^1.1.0",
         "@microchip/fosc-hz": "^0.1.2",
-        "@microchip/pin-standard": "^0.2.14",
-        "@microchip/scf-automodule-interface": "^0.17.0",
-        "@microchip/scf-common": "^3.16.0",
-        "@microchip/scf-device": "^8.2.0",
+        "@microchip/pin-standard": "^0.4.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.4.0"
+        "@microchip/scf-register-view-helper": "^2.5.0"
     },
     "devDependencies": {
         "@babel/core": "^7.9.6",
@@ -94,12 +98,13 @@
         "@babel/preset-react": "^7.9.4",
         "@babel/preset-typescript": "^7.9.0",
         "@microchip/initializer-system": "^0.5.3",
+        "@microchip/melody-automodule-interface": "^1.6.2",
         "@microchip/pic-8bit-types": "^5.0.1",
-        "@microchip/run-directory": "^2.3.58",
-        "@microchip/run-directory-future": "^1.0.5",
-        "@microchip/scf-automodule": "4.14.6",
-        "@microchip/scf-autoview": "^3.20.0",
-        "@microchip/scf-autoview-impl": "^3.3.1",
+        "@microchip/run-directory": "^4.2.0",
+        "@microchip/scf-automodule": "^5.6.3",
+        "@microchip/scf-automodule-impl": "^1.8.2",
+        "@microchip/scf-autoview": "^3.26.1",
+        "@microchip/scf-autoview-impl": "^3.9.2",
         "@microchip/scf-project-scripts": "^1.0.0",
         "@types/core-js": "^2.5.1",
         "@types/enzyme": "^3.9.3",
@@ -151,9 +156,10 @@
         "postcss-loader": "^3.0.0",
         "postcss-safe-parser": "^4.0.2",
         "prettier": "^2.0.5",
-        "react": "^16.13.1",
-        "react-dom": "^16.13.1",
+        "react": "^17.0.1",
+        "react-dom": "^17.0.1",
         "react-redux": "^7.2.0",
+        "sass": "~1.32.0",
         "sass-loader": "^9.0.2",
         "style-loader": "^1.2.1",
         "ts-jest": "^24.0.2",

package/src/CreatorFunctions.ts

@@ -1,4 +1,4 @@
-import { CreatorFunctions } from "@microchip/scf-automodule-interface";
+import { CreatorFunctions } from "@microchip/melody-automodule-interface";
 import { MyState } from "../generated_module/src/types/AutoModuleTypes";
 
 export const getCreatorFunctions = (): CreatorFunctions => {

package/src/{DerivedData.tsx → DerivedData.ts}

@@ -8,8 +8,8 @@ import {
 } from "../generated_module/src/types/AutoModuleTypes";
 import { forEach, getKeys } from "../generated_module/src/Utils";
 import { getCanClkDivFreq, getCanfdClockFrequency, MAX_CANFD_CLK_SRC_FREQ } from "./Util";
-import * as clock_16bit_ux_interface from "@microchip/clock-16bit-interface";
-import { ExportArg } from "@microchip/scf-automodule-interface/lib/src/InterfaceTypes";
+import * as clock_16bit_drv_interface from "@microchip/clock-16bit-config-interface";
+import { ExportArg } from "@microchip/melody-automodule-interface/lib/src/InterfaceTypes";
 import _find from "lodash.find";
 import { InterfaceId } from "@microchip/scf-common";
 
@@ -20,12 +20,17 @@ const CLOCK_16BIT_CONFIG_INTERFACE = "clock_16bit_config_interface";
 const DIGITS_AFTER_DECIMAL_POINT = 2;
 const COMPONENT_AUX_CLOCK_SOURCE = "auxClockSource";
 const COMPONENT_MAIN_CLOCK_SOURCE = "mainClockSource";
+const COMPONENT_CAN_FD_CLOCK_SOURCE_FREQ = "canfdClkSrcFreq";
 export const COMPONENT_AUX_CLOCK_INPUT_FREQUENCY = "auxClockInputFrequency_Hz";
 export const COMPONENT_MAIN_CLOCK_INPUT_FREQUENCY = "mainClockInputFrequency_Hz";
 const COMPONENT_REF_CLOCK_SOURCE = "refClockSource";
+const COMPONENT_REF_CLOCK_ENABLE = "refClockEnable";
+export const COMPONENT_CALCULATED_REF_OUTPUT_FREQUENCY =
+    "calculatedRefOutputFrequency_Hz";
 const COMPONENT_CANFD_CLOCK_SOURCE = "canfdClockSource";
 export const COMPONENT_REQUESTED_SYSTEM_FREQUENCY = "requestedSystemFrequency_Hz";
 const COMPONENT_FVCO_DIVIDER = "fvcoDivider";
+export const COMPONENT_SET_MAX_FREQUENCY = "setMaximumSystemFrequency";
 export const COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY =
     "requestedAuxClockOutputFrequency_Hz";
 const COMPONENT_AFVCO_DIVIDER = "afvcoDivider";
@@ -38,6 +43,7 @@ const PRIMARY = "Primary";
 const PLL = "PLL";
 const POSTSCALER = "Postscaler";
 const EXTERNAL = "External";
+const CLOCK_16BIT_DRV_INTERFACE = "clock-16bit-drv-interface";
 
 const MEGA_HERTZ = 1000000;
 const KILO_HERTZ = 1000;
@@ -100,6 +106,7 @@ class MyDerivedData implements DerivedData {
             requestedCanfdClockOutputFrequency_Hz: this
                 .getRequestedCanfdClockOutputFrequency_Hz,
             getUiBehavior: this.getUiBehavior,
+            isEnabled: this.isComponentEnabled,
             mainClockInputFrequency_HzValidator: this.mainClockInputFrequency_HzValidator,
             auxClockInputFrequency_HzValidator: this.auxClockInputFrequency_HzValidator,
             requestedAuxClockOutputFrequency_HzValidator: this
@@ -109,12 +116,45 @@ class MyDerivedData implements DerivedData {
             requestedRefClockOutputFrequency_HzValidator: this
                 .requestedRefClockOutputFrequency_HzValidator,
             getCustomUiErrors: this.getCustomUiErrors,
-            "clock-16bit-ux-interface_payloads": this.getClockApplicationInterfacePayload,
+            "clock-16bit-drv-interface_payloads": this
+                .getClockApplicationInterfacePayload,
             importName: this.friendlyImportName,
             exportName: this.friendlyExportName,
         };
     };
 
+    private isComponentEnabled = (componentName: string): boolean => {
+        let isComponentEnabled = false;
+        if (
+            componentName === COMPONENT_REF_CLOCK_SOURCE ||
+            componentName === COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY
+        ) {
+            if (this.dataModel?.getComponentValue(COMPONENT_REF_CLOCK_ENABLE) === true) {
+                isComponentEnabled = true;
+            }
+        } else if (
+            componentName === COMPONENT_REF_CLOCK_ENABLE ||
+            componentName === COMPONENT_MAIN_CLOCK_SOURCE ||
+            componentName === COMPONENT_MAIN_CLOCK_INPUT_FREQUENCY ||
+            componentName === COMPONENT_SET_MAX_FREQUENCY ||
+            componentName === COMPONENT_FVCO_DIVIDER ||
+            componentName === COMPONENT_AUX_CLOCK_SOURCE ||
+            componentName === COMPONENT_CANFD_CLOCK_SOURCE ||
+            componentName === COMPONENT_AFVCO_DIVIDER ||
+            componentName === COMPONENT_AUX_CLOCK_INPUT_FREQUENCY ||
+            componentName === COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY
+        ) {
+            isComponentEnabled = true;
+        } else if (componentName === COMPONENT_REQUESTED_SYSTEM_FREQUENCY) {
+            if (
+                this.dataModel?.getComponentValue(COMPONENT_SET_MAX_FREQUENCY) === false
+            ) {
+                isComponentEnabled = true;
+            }
+        }
+        return isComponentEnabled;
+    };
+
     private getCustomUiErrors = (componentName: string): Error[] | undefined => {
         let customErrors: Error[];
         switch (componentName) {
@@ -204,6 +244,17 @@ class MyDerivedData implements DerivedData {
         return minClockFrequency;
     };
 
+    private getClockPropertiesFromPayLoad = (): any => {
+        let clockProperties: unknown;
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            clockProperties = interfaceData?.clockProperties;
+        }
+        return clockProperties;
+    };
+
     private getMaxClockFrequency = (): number => {
         let maxClockFrequency = 0;
         const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
@@ -221,10 +272,24 @@ class MyDerivedData implements DerivedData {
         const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
             CLOCK_16BIT_CONFIG_INTERFACE,
         );
-        if (interfaceData != undefined) {
+        if (
+            interfaceData != undefined &&
+            this.dataModel?.getComponentValue("mainClockSource") !=
+                "FRC Oscillator with Postscaler"
+        ) {
             maxSystemClockFrequency =
                 interfaceData?.mainClockPayload?.maxSystemClockFrequency ?? 0;
         }
+        if (
+            this.dataModel?.getComponentValue("mainClockSource") ==
+            "FRC Oscillator with Postscaler"
+        ) {
+            if (this.getClockPropertiesFromPayLoad()["FRC_CLOCK"] != undefined) {
+                maxSystemClockFrequency = Number(
+                    this.getClockPropertiesFromPayLoad()["FRC_CLOCK"]?.value,
+                );
+            }
+        }
         return maxSystemClockFrequency;
     };
 
@@ -237,7 +302,7 @@ class MyDerivedData implements DerivedData {
                         "Requested FCAN frequency can be configured from CAN 2.0/CAN-FD modules in Drivers category",
                 };
                 break;
-            case "canfdClkSrcFreq":
+            case COMPONENT_CAN_FD_CLOCK_SOURCE_FREQ:
                 uiBehavior = {
                     ["ui:help"]:
                         "CAN FD clock source frequency should be less than or equal to 640 MHz",
@@ -309,15 +374,17 @@ class MyDerivedData implements DerivedData {
 
     private isRequestedSystemFrequencyVisible = (): boolean => {
         let visible = false;
-        const mainClockSource = this.dataModel.getComponentValue(
-            COMPONENT_MAIN_CLOCK_SOURCE,
-        );
-        if (mainClockSource != undefined) {
-            if (
-                mainClockSource?.indexOf(PLL) >= 0 ||
-                mainClockSource.indexOf(POSTSCALER) >= 0
-            ) {
-                visible = true;
+        if (this.dataModel?.getComponentValue(COMPONENT_SET_MAX_FREQUENCY) === false) {
+            const mainClockSource = this.dataModel.getComponentValue(
+                COMPONENT_MAIN_CLOCK_SOURCE,
+            );
+            if (mainClockSource != undefined) {
+                if (
+                    mainClockSource?.indexOf(PLL) >= 0 ||
+                    mainClockSource.indexOf(POSTSCALER) >= 0
+                ) {
+                    visible = true;
+                }
             }
         }
         return visible;
@@ -383,14 +450,15 @@ class MyDerivedData implements DerivedData {
         } else if (
             componentName === COMPONENT_REF_CLOCK_SOURCE ||
             componentName === COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY ||
-            componentName === "calculatedRefOutputFrequency_Hz"
+            componentName === COMPONENT_CALCULATED_REF_OUTPUT_FREQUENCY ||
+            componentName === COMPONENT_REF_CLOCK_ENABLE
         ) {
             return this.isRefClockSupported();
         } else if (
             componentName === COMPONENT_CANFD_CLOCK_SOURCE ||
             componentName === COMPONENT_REQUESTED_CANFD_CLOCK_OUTPUT_FREQUENCY ||
             componentName === "calculatedCanfdOutputFrequency_Hz" ||
-            componentName === "canfdClkSrcFreq"
+            componentName === COMPONENT_CAN_FD_CLOCK_SOURCE_FREQ
         ) {
             return this.isCanfdClockSupported();
         }
@@ -461,6 +529,17 @@ class MyDerivedData implements DerivedData {
                 });
             }
         }
+        if (this.dataModel?.getComponentValue(COMPONENT_SET_MAX_FREQUENCY)) {
+            const mainClockSource = this.dataModel?.getComponentValue(
+                COMPONENT_MAIN_CLOCK_SOURCE,
+            );
+            if (mainClockSource != undefined && mainClockSource?.indexOf(PLL) < 0) {
+                alerts.push({
+                    type: Processor.AlertTypes.Warning,
+                    text: "Please select PLL as clock source.",
+                });
+            }
+        }
 
         return alerts;
     };
@@ -469,6 +548,16 @@ class MyDerivedData implements DerivedData {
         return;
     };
 
+    private getActualMainClockSource = (): string | undefined => {
+        const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CLOCK_16BIT_CONFIG_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            return interfaceData.mainClockPayload?.mainClockSource;
+        }
+        return undefined;
+    };
+
     private getActualSystemFrequency = (): string => {
         let systemFrequency: number | undefined;
         const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
@@ -868,6 +957,8 @@ class MyDerivedData implements DerivedData {
                 return this.getRefClockSource();
             case COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY:
                 return this.getRequestedRefClockOutputFrequencyInHz();
+            case COMPONENT_SET_MAX_FREQUENCY:
+                return this.getMaxFrequencySetFlag();
             default:
                 break;
         }
@@ -910,31 +1001,45 @@ class MyDerivedData implements DerivedData {
                 COMPONENT_REQUESTED_SYSTEM_FREQUENCY,
             ),
             fvcoDivider: Number(this.dataModel.getComponentValue(COMPONENT_FVCO_DIVIDER)),
+            setMaximumSystemFrequency: this.dataModel.getComponentValue(
+                COMPONENT_SET_MAX_FREQUENCY,
+            ),
         };
     };
 
     private auxClockArg = (): any => {
-        return {
-            auxClockSource: this.dataModel.getComponentValue(COMPONENT_AUX_CLOCK_SOURCE),
-            auxClockInputFrequency_Hz: this.dataModel.getComponentValue(
-                COMPONENT_AUX_CLOCK_INPUT_FREQUENCY,
-            ),
-            requestedAuxClockOutputFrequency_Hz: this.dataModel.getComponentValue(
-                COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY,
-            ),
-            afvcoDivider: Number(
-                this.dataModel.getComponentValue(COMPONENT_AFVCO_DIVIDER),
-            ),
-        };
+        if (
+            this.dataModel.getComponentValue(COMPONENT_AUX_CLOCK_SOURCE) !=
+            "FRC Oscillator"
+        ) {
+            return {
+                auxClockSource: this.dataModel.getComponentValue(
+                    COMPONENT_AUX_CLOCK_SOURCE,
+                ),
+                auxClockInputFrequency_Hz: this.dataModel.getComponentValue(
+                    COMPONENT_AUX_CLOCK_INPUT_FREQUENCY,
+                ),
+                requestedAuxClockOutputFrequency_Hz: this.dataModel.getComponentValue(
+                    COMPONENT_REQUESTED_AUX_CLOCK_OUTPUT_FREQUENCY,
+                ),
+                afvcoDivider: Number(
+                    this.dataModel.getComponentValue(COMPONENT_AFVCO_DIVIDER),
+                ),
+            };
+        }
     };
 
     private refClockArg = (): any => {
-        return {
-            refClockSource: this.dataModel.getComponentValue(COMPONENT_REF_CLOCK_SOURCE),
-            requestedRefClockOutputFrequency_Hz: this.dataModel.getComponentValue(
-                COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY,
-            ),
-        };
+        if (this.dataModel.getComponentValue(COMPONENT_REF_CLOCK_ENABLE) === true) {
+            return {
+                refClockSource: this.dataModel.getComponentValue(
+                    COMPONENT_REF_CLOCK_SOURCE,
+                ),
+                requestedRefClockOutputFrequency_Hz: this.dataModel.getComponentValue(
+                    COMPONENT_REQUESTED_REF_CLOCK_OUTPUT_FREQUENCY,
+                ),
+            };
+        }
     };
 
     private canfdClockArg = (): any => {
@@ -961,112 +1066,125 @@ class MyDerivedData implements DerivedData {
         return getCanClkDivFreq(canClkSrc, canClkFreq);
     };
 
-    public getExportArg = (componentName: string): ExportArg | undefined => {
+    public getExportArgFromDriverInterface = (
+        componentName: string,
+    ): ExportArg | undefined => {
         const exportData = this.dataModel.getExportInterfaces().getInterfaceData();
         if (exportData != undefined) {
             const expArg = _find(
                 exportData,
                 (i) =>
-                    i.interface === "clock-16bit-ux-interface" &&
-                    i.name === componentName,
+                    i.interface === CLOCK_16BIT_DRV_INTERFACE && i.name === componentName,
             );
             return expArg;
         }
     };
 
     private getMainClockSource = (): any => {
-        const mainClockArg = this.getExportArg(ARGUMENT_MAIN_CLK)?.value;
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
         if (mainClockArg != undefined) {
             return mainClockArg?.mainClockSource;
         }
     };
 
+    private getMaxFrequencySetFlag = (): any => {
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
+        if (mainClockArg != undefined) {
+            return Boolean(mainClockArg?.setMaximumSystemFrequency);
+        }
+    };
+
     private getMainClockInputFrequencyInHz = (): any => {
-        const mainClockArg = this.getExportArg(ARGUMENT_MAIN_CLK)?.value;
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
         if (mainClockArg != undefined) {
             return mainClockArg?.mainClockInputFrequency_Hz;
         }
     };
 
     private getRequestedSystemFrequencyInHz = (): any => {
-        const mainClockArg = this.getExportArg(ARGUMENT_MAIN_CLK)?.value;
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
         if (mainClockArg != undefined) {
             return mainClockArg?.requestedSystemFrequency_Hz;
         }
     };
 
     private getFvcoDivider = (): any => {
-        const mainClockArg = this.getExportArg(ARGUMENT_MAIN_CLK)?.value;
+        const mainClockArg = this.getExportArgFromDriverInterface(ARGUMENT_MAIN_CLK)
+            ?.value;
         if (mainClockArg != undefined) {
             return String(mainClockArg.fvcoDivider);
         }
     };
 
     private getAuxClockSource = (): any => {
-        const auxClockArg = this.getExportArg(ARGUMENT_AUX_CLK)?.value;
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
         if (auxClockArg != undefined) {
             return auxClockArg.auxClockSource;
         }
     };
 
     private getAuxClockInputFrequencyInHz = (): any => {
-        const auxClockArg = this.getExportArg(ARGUMENT_AUX_CLK)?.value;
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
         if (auxClockArg != undefined) {
             return auxClockArg.auxClockInputFrequency_Hz;
         }
     };
 
     private getRequestedAuxClockOutputFrequencyInHz = (): any => {
-        const auxClockArg = this.getExportArg(ARGUMENT_AUX_CLK)?.value;
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
         if (auxClockArg != undefined) {
             return auxClockArg.requestedAuxClockOutputFrequency_Hz;
         }
     };
 
     private getAfvcoDivider = (): any => {
-        const auxClockArg = this.getExportArg(ARGUMENT_AUX_CLK)?.value;
+        const auxClockArg = this.getExportArgFromDriverInterface(ARGUMENT_AUX_CLK)?.value;
         if (auxClockArg != undefined) {
             return auxClockArg.afvcoDivider;
         }
     };
 
     private getRefClockSource = (): any => {
-        const refClockArg = this.getExportArg(ARGUMENT_REF_CLK)?.value;
+        const refClockArg = this.getExportArgFromDriverInterface(ARGUMENT_REF_CLK)?.value;
         if (refClockArg != undefined) {
             return refClockArg.refClockSource;
         }
     };
 
     private getRequestedRefClockOutputFrequencyInHz = (): any => {
-        const refClockArg = this.getExportArg(ARGUMENT_REF_CLK)?.value;
+        const refClockArg = this.getExportArgFromDriverInterface(ARGUMENT_REF_CLK)?.value;
         if (refClockArg != undefined) {
             return refClockArg.requestedRefClockOutputFrequency_Hz;
         }
     };
 
     private getCanfdClockSource = (): any => {
-        const refClockArg = this.getExportArg("canfdClockArg")?.value;
+        const refClockArg = this.getExportArgFromDriverInterface("canfdClockArg")?.value;
         if (refClockArg != undefined) {
             return refClockArg.canfdClockSource;
         }
     };
 
-    private getClock16bitUxInterfaceId = (): InterfaceId => {
+    private getClock16bitDrvInterfaceId = (): InterfaceId => {
         return {
-            name: "clock-16bit-ux-interface",
-            version: "0.1.0",
+            name: CLOCK_16BIT_DRV_INTERFACE,
+            version: "1.0.0",
         };
     };
 
     private getClockApplicationInterfacePayload = ():
         | Processor.Dictionary<clock_16bit_config_interface.ProcessedPayload>
         | undefined => {
-        const clockApplicationInterfacePayloads: Processor.Dictionary<clock_16bit_ux_interface.ProcessedPayload> = {};
+        const clockApplicationInterfacePayloads: Processor.Dictionary<clock_16bit_drv_interface.ProcessedPayload> = {};
         const clockApplicationInterfaceRequests:
-            | Processor.Dictionary<clock_16bit_ux_interface.Arguments>
+            | Processor.Dictionary<clock_16bit_drv_interface.Arguments>
             | undefined = this.dataModel
             .getExportInterfaces()
-            .getInterface("clock_16bit_ux_interface", this.getClock16bitUxInterfaceId())
+            .getInterface("clock_16bit_drv_interface", this.getClock16bitDrvInterfaceId())
             ?.args;
         const interfaceData: clock_16bit_config_interface.ProcessedPayload = this.dataModel.getImportValue(
             CLOCK_16BIT_CONFIG_INTERFACE,
@@ -1100,7 +1218,7 @@ class MyDerivedData implements DerivedData {
             case "canfd_clock":
                 exportName = "CAN FD Clock";
                 break;
-            case "clock_16bit_ux_interface":
+            case "clock_16bit_drv_interface":
                 exportName = "Clock Drv Config";
                 break;
             default:

package/src/catalog.json

@@ -10,6 +10,8 @@
                     "avr",
                     "pic8",
                     "driver",
+                    "pic24",
+                    "dspic",
                     ""
                 ],
                 "name": "Clock",

package/src/moduleConfig.json

@@ -6,7 +6,7 @@
         "false": "disabled"
     },
     "help": {
-        "url": "v2/keyword-lookup?keyword=SYSTEM_16BIT_MELODY_DRIVER&version=latest&redirect=true",
+        "url": "v2/keyword-lookup?keyword=CLOCK_16BIT_MELODY_DRIVER&version=latest&redirect=true",
         "tooltip": "Click here to open documentation"
     },
     "UIGroups": {
@@ -41,7 +41,7 @@
             "import": {
                 "interfaceId": {
                     "name": "clock-16bit-config-interface",
-                    "version": "^1.1.0"
+                    "version": "^1.1.5"
                 },
                 "isRequired": true
             }
@@ -58,12 +58,12 @@
                 }
             ]
         },
-        "clock_16bit_ux_interface": {
+        "clock_16bit_drv_interface": {
             "interfaces": [
                 {
                     "interfaceId": {
-                        "name": "clock-16bit-ux-interface",
-                        "version": "0.1.0"
+                        "name": "clock-16bit-drv-interface",
+                        "version": "1.0.0"
                     }
                 }
             ]
@@ -117,6 +117,17 @@
             "validation": true,
             "category": "software"
         },
+        "setMaximumSystemFrequency": {
+            "name": "setMaximumSystemFrequency",
+            "description": "Set System(FOSC) Frequency to Maximum",
+            "type": "boolean",
+            "defaultValue": false,
+            "group": "systemClock",
+            "tabs": [
+                "main"
+            ],
+            "category": "software"
+        },
         "calculatedSystemFrequency_Hz": {
             "name": "calculatedSystemFrequency_Hz",
             "description": "Calculated System Frequency(FOSC)",
@@ -324,6 +335,17 @@
                 "readonly": true
             }
         },
+        "refClockEnable": {
+            "name": "refClockEnable",
+            "description": "Reference Clock Enable",
+            "type": "boolean",
+            "defaultValue": false,
+            "group": "refClock",
+            "tabs": [
+                "main"
+            ],
+            "category": "software"
+        },
         "refClockSource": {
             "name": "refClockSource",
             "description": "REFO Clock Source",