@mchp-mcc/scf-pic8-clc-v1 4.0.13 → 4.0.14

package/src/DerivedData.ts

@@ -1,444 +0,0 @@
-import * as Processor from "@microchip/scf-common/lib/Processor";
-import { getGeneratorModel, getHeaderFiles } from "./GeneratorModel";
-import * as initializer_system from "@microchip/initializer-system";
-import * as claClcStacked from "./interfaces/cla-clc-stacked";
-import * as trigger_source from "./interfaces/trigger-source";
-import * as signal_source from "./interfaces/signal-source";
-import { find } from "@microchip/scf-device/lib/util/Arrays";
-import { InputStateCalculator, LogicSelection } from "./InputStateCalculator";
-import { Module } from "@microchip/scf-device";
-import { GATES, DATA_INPUTS, OPTION_MODULES } from "./Constants";
-import {
-    getGatePolaritySetting,
-    getGateSourceSetting,
-    getGateNonInvertedSetting,
-    getGateInvertedSetting,
-} from "./SettingNameCalculator";
-import * as clcConnections from "./interfaces/clc-connections";
-import { Interface } from "@microchip/scf-interface";
-import { values } from "../generated_module/src/Utils";
-import {
-    AppModel,
-    DerivedData,
-    DerivedFunctions,
-} from "../generated_module/src/types/AutoModuleTypes";
-import CalculateRegisterValue from "@microchip/scf-device/lib/CalculateRegisterValue";
-
-export const getDerivedData = (dataModel: AppModel | undefined): DerivedData => {
-    if (dataModel) {
-        return new MyDerivedData(dataModel);
-    }
-    return new EmptyDerivedData();
-};
-
-//This data will be used at the creator stage and relies on only the state
-export class EmptyDerivedData implements DerivedData {
-    getMyFunctions = (): DerivedFunctions => {
-        return {};
-    };
-    getModel = (): AppModel | undefined => {
-        return undefined;
-    };
-}
-
-//This data will be used at the processor stage
-class MyDerivedData implements DerivedData {
-    private dataModel: AppModel;
-    private gateDerivedSettings: any;
-
-    constructor(dataModel: AppModel) {
-        this.dataModel = dataModel;
-    }
-
-    getMyFunctions = (): DerivedFunctions => {
-        return {
-            overrideDefaultValues: this.overrideDefaultValues,
-            moduleName: (): string | undefined => this.dataModel.getHardware()?.getName(),
-            componentName: this.componentName,
-            lcenClccon: this.lcenClccon,
-            lcmodeClccon: this.lcmodeClccon,
-            ...this.getGateDerivedSettings(),
-            lcpolClcpol: this.lcpolClcpol,
-            slctClcselect: this.getClcSelect,
-            clci: this.clci,
-            importName: this.friendlyImportName,
-            filterImports: this.filterImports,
-            "cla-clc-stacked_payload": this.cla_clc_payload,
-            "trigger-source_payload": this.trigger_source_payload,
-            "signal-source_payload": this.signal_source_payload,
-            templateData: (): any => getGeneratorModel(this.dataModel),
-            alerts: this.getMyAlerts,
-            showCanvasBased: (): boolean => false,
-            initializer_system_results: this.initializer_system_results,
-            isrCallback: this.isrCallback,
-            clc_connections_results: this.clc_connections_results,
-            isEnabled: this.isEnabled,
-            getRequestedModule: this.getRequestedModule,
-        };
-    };
-    private isEnabled = (compName: string): boolean | undefined => {
-        let status;
-        if (this.dataModel.getComponentValue("clci") === false) {
-            switch (compName) {
-                case "lcintnClccon":
-                    status = false;
-                    break;
-                case "lcintpClccon":
-                    status = false;
-                    break;
-                default:
-                    status = undefined;
-            }
-            return status;
-        }
-    };
-
-    private clc_connections_results = (): clcConnections.Results => {
-        const inputs: string[] = [];
-
-        GATES.forEach((gate) => {
-            const setting = getGateSourceSetting(gate);
-            const value = this.dataModel.getComponentValue(setting);
-            const input: string | undefined = OPTION_MODULES[value];
-
-            if (input && input.indexOf("CLC") !== -1) {
-                if (inputs.indexOf(input) === -1) {
-                    inputs.push(input);
-                }
-            }
-        });
-
-        return {
-            moduleName: this.dataModel.getName(),
-            inputs,
-        };
-    };
-
-    private getGateDerivedSettings = (): any => {
-        if (!this.gateDerivedSettings) {
-            this.gateDerivedSettings = this.createGateDerivedSettings();
-        }
-        return this.gateDerivedSettings;
-    };
-
-    private createGateDerivedSettings = (): any => {
-        const result = {};
-        type ReturnType = string | undefined;
-
-        GATES.forEach((gate: number) => {
-            DATA_INPUTS.forEach((input: number) => {
-                result[getGateInvertedSetting(gate, input)] = (): ReturnType =>
-                    this.getDataConfigInvertedProcessedArg(gate, input);
-
-                result[getGateNonInvertedSetting(gate, input)] = (): ReturnType =>
-                    this.getDataConfigNonInvertedProcessedArg(gate, input);
-            });
-
-            result[getGatePolaritySetting(gate)] = (): ReturnType =>
-                this.getOutputConfigProcessedArg(gate);
-
-            result[getGateSourceSetting(gate)] = (): ReturnType =>
-                this.getGateConfig(gate)?.inputSource;
-        });
-
-        return result;
-    };
-
-    private overrideDefaultValues = (componentName: string): any => {
-        switch (componentName) {
-            case "componentName":
-                return this.dataModel.getHardware()?.getName();
-            default:
-                return undefined;
-        }
-    };
-
-    public getModel = (): AppModel => {
-        return this.dataModel;
-    };
-
-    private componentName = (): string | undefined => {
-        return this.getFirstClaClcArgument()?.customName;
-    };
-
-    private lcenClccon = (): boolean | undefined => {
-        return this.getFirstClaClcArgument()?.enabled;
-    };
-
-    private lcmodeClccon = (): string | undefined => {
-        return this.getFirstClaClcArgument()?.mode;
-    };
-
-    private lcpolClcpol = (): string | undefined => {
-        const isInverted = this.getFirstClaClcArgument()?.isInverted;
-        if (isInverted === true) {
-            return "inverted";
-        } else if (isInverted === false) {
-            return "not_inverted";
-        } else {
-            return undefined;
-        }
-    };
-
-    private getClcSelect = (): string | undefined => {
-        const instance = this.dataModel.getPeripheralDescription()?.instance;
-        if (instance != undefined && instance != "") {
-            return CalculateRegisterValue.toHexString(parseInt(instance) - 1);
-        }
-
-        return undefined;
-    };
-
-    private clci = (): boolean | undefined => {
-        return this.getFirstClaClcArgument()?.interruptEnabled;
-    };
-
-    private getMyAlerts = (): Processor.Alert[] => {
-        const alerts: Processor.Alert[] = [];
-
-        const getValue = (name: string): any => this.dataModel.getComponentValue(name);
-        GATES.forEach((gate: number) => {
-            DATA_INPUTS.forEach((input: number) => {
-                const invertedSetting = getGateInvertedSetting(gate, input);
-                const nonInvertedSetting = getGateNonInvertedSetting(gate, input);
-                if (
-                    getValue(invertedSetting) === "enabled" &&
-                    getValue(nonInvertedSetting) === "enabled"
-                ) {
-                    alerts.push({
-                        type: Processor.AlertTypes.Warning,
-                        text: `Can't have both ${invertedSetting} and ${nonInvertedSetting} settings enabled.`,
-                    });
-                }
-            });
-        });
-
-        const inputs: string[] = [];
-        GATES.forEach((gate) => {
-            const setting = getGateSourceSetting(gate);
-            const value = this.dataModel.getComponentValue(setting);
-            const input: string | undefined = OPTION_MODULES[value];
-
-            if (input && inputs.indexOf(input) === -1) {
-                inputs.push(input);
-            }
-        });
-
-        inputs.forEach((input) => {
-            const name = this.dataModel.getName();
-            alerts.push({
-                type: Processor.AlertTypes.Hint,
-                text: `${name} uses ${input}. Ensure ${input} has been configured.`,
-            });
-        });
-
-        if (
-            !getValue("clci") &&
-            (getValue("lcintpClccon") === "enabled" ||
-                getValue("lcintnClccon") === "enabled")
-        ) {
-            let msg = "";
-            if (getValue("lcintpClccon") === "enabled") {
-                msg = "Rising Edge Interrupt";
-            }
-            if (getValue("lcintnClccon") === "enabled") {
-                msg =
-                    msg.length > 1
-                        ? "Rising and Falling Edge Interrupts"
-                        : "Falling Edge Interrupt";
-            }
-            alerts.push({
-                type: Processor.AlertTypes.Warning,
-                text: `CLC Interrupt is disabled, ${msg} API will not be generated.`,
-            });
-        }
-        return alerts;
-    };
-
-    private getDataConfigInvertedProcessedArg = (
-        gate: number,
-        input: number,
-    ): string | undefined => {
-        return this.boolToReg(this.getDataConfigProcessedArg(gate, input)?.inverted);
-    };
-
-    private getDataConfigNonInvertedProcessedArg = (
-        gate: number,
-        input: number,
-    ): string | undefined => {
-        return this.boolToReg(this.getDataConfigProcessedArg(gate, input)?.nonInverted);
-    };
-
-    private getDataConfigProcessedArg = (
-        gate: number,
-        input: number,
-    ): LogicSelection | undefined => {
-        const gateConfig = this.getGateConfig(gate);
-        const dataConfigs = gateConfig?.dataInputConfigs ?? [];
-        const dataConfig = find(dataConfigs, (config) => config.dataInput === input);
-
-        const config = dataConfig?.config;
-        if (config) {
-            return InputStateCalculator.getLogicSelection(config);
-        }
-
-        return undefined;
-    };
-
-    private getOutputConfigProcessedArg = (gate: number): string | undefined => {
-        const isInverted = this.getGateConfig(gate)?.isInverted;
-        if (isInverted === true) {
-            return "inverted";
-        } else if (isInverted === false) {
-            return "not_inverted";
-        } else {
-            return undefined;
-        }
-    };
-
-    private getGateConfig = (gate: number): claClcStacked.GateConfig | undefined => {
-        const gateConfigs = this.getFirstClaClcArgument()?.gateConfigs ?? [];
-        return find(gateConfigs, (config) => config.gate === gate);
-    };
-
-    private getFirstClaClcArgument = (): claClcStacked.Arguments | undefined => {
-        const args = this.getClaClcArguments();
-        return args?.[Object.keys(args)[0]];
-    };
-
-    private getClaClcArguments = ():
-        | Processor.Dictionary<claClcStacked.Arguments>
-        | undefined => {
-        return this.dataModel
-            .getExportInterfaces()
-            .getInterface("clc", claClcStacked.Interface.getInterfaceId())?.args;
-    };
-
-    private getExportArgs = (intf: Interface): Processor.Dictionary<any> | undefined => {
-        return this.dataModel
-            .getExportInterfaces()
-            .getInterface("clc", intf.getInterfaceId())?.args;
-    };
-
-    private getRequestedModule = (): string | undefined => {
-        let args: Processor.Dictionary<any> | undefined;
-
-        args = this.getExportArgs(claClcStacked.Interface);
-        if (args) {
-            return values<claClcStacked.Arguments>(args)[0]?.moduleName;
-        }
-
-        args = this.getExportArgs(trigger_source.Interface);
-        if (args) {
-            return values<trigger_source.Arguments>(args)?.[0]?.moduleName;
-        }
-
-        args = this.getExportArgs(signal_source.Interface);
-        if (args) {
-            return values<signal_source.Arguments>(args)?.[0]?.moduleName;
-        }
-
-        return undefined;
-    };
-
-    private friendlyImportName = (importKey: string): string | undefined => {
-        if (importKey === "scf_pic8_clc_v1") {
-            return "CLC Hardware";
-        }
-
-        return undefined;
-    };
-
-    private filterImports = (imports: Processor.Imports): Processor.Imports => {
-        const filteredImports: Processor.Imports = this.dataModel.filterImportBySetting(
-            imports,
-            "scf_pic8_clc_v1",
-            (option: Processor.Option<Module>): boolean => {
-                const moduleName = this.getRequestedModule();
-                return moduleName != undefined
-                    ? option?.payload?.name === moduleName
-                    : true;
-            },
-        );
-        return filteredImports;
-    };
-
-    private cla_clc_payload = (): claClcStacked.ProcessedPayload => {
-        this.dataModel.isComponentValue;
-        return {
-            interfaceApi: claClcStacked.Interface.createFirmwareApi(
-                this.getCustomName(),
-                getHeaderFiles(this.dataModel),
-            ),
-            customName: this.getCustomName(),
-            enabled: this.dataModel.isComponentValue("lcenClccon"),
-            mode: this.dataModel.getComponentValue(
-                "lcmodeClccon",
-            ) as claClcStacked.CLCMode,
-            gateConfigs: this.getGateConfigsPayload(),
-            isInverted: this.dataModel.getComponentValue("lcpolClcpol") === "inverted",
-            hasInterrupts: true,
-            moduleName: this.dataModel.getName(),
-            interruptEnabled: this.dataModel.isComponentValue("clci"),
-        };
-    };
-
-    private trigger_source_payload = (): trigger_source.ProcessedPayload => {
-        return {
-            moduleName: this.dataModel.getName(),
-            customName: this.getCustomName(),
-        };
-    };
-
-    private signal_source_payload = (): signal_source.ProcessedPayload => {
-        return {
-            moduleName: this.dataModel.getName(),
-            customName: this.getCustomName(),
-        };
-    };
-
-    private getCustomName = (): string => {
-        return this.dataModel.getComponentValue("componentName") ?? "CLC";
-    };
-
-    private getGateConfigsPayload = (): claClcStacked.GateConfig[] => {
-        const getValue = (name: string): any => this.dataModel.getComponentValue(name);
-
-        return GATES.map((gate: number) => ({
-            gate: gate,
-            isInverted: getValue(getGatePolaritySetting(gate)) === "inverted",
-            inputSource: getValue(getGateSourceSetting(gate)),
-            dataInputConfigs: DATA_INPUTS.map((input: number) => ({
-                dataInput: input,
-                config: InputStateCalculator.getInputState(
-                    this.dataModel.isComponentValue(
-                        getGateNonInvertedSetting(gate, input),
-                    ),
-                    this.dataModel.isComponentValue(getGateInvertedSetting(gate, input)),
-                ),
-            })),
-        }));
-    };
-
-    private initializer_system_results = (): initializer_system.Results => {
-        return {
-            initializer: {
-                name: this.getCustomName() + "_Initialize",
-                header: getHeaderFiles(this.dataModel)[0],
-            },
-        };
-    };
-
-    private isrCallback = (intName: string): any => {
-        return {
-            name: this.getCustomName() + "_ISR",
-            header: getHeaderFiles(this.dataModel)[0],
-        };
-    };
-
-    private boolToReg = (bool: boolean | undefined): string | undefined => {
-        if (bool === true) return "enabled";
-        else if (bool === false) return "disabled";
-        else return undefined;
-    };
-}

package/src/GeneratorModel.test.ts

@@ -1,57 +0,0 @@
-import { getModel } from "../generated_module/tests/AppModel.test";
-import { mockState } from "../generated_module/tests/AppModel.test";
-import { mockAssignedModule } from "../generated_module/tests/processor.test";
-import { getDerivedData } from "../generated_module/src/autoProcessor";
-import { getGeneratorModel } from "./GeneratorModel";
-
-describe("getGeneratorModel  test Cases ", () => {
-    describe("getGeneratorModel  test case undefined getImportValue", () => {
-        const mockModule = mockAssignedModule(mockState());
-        const model = getModel(mockModule, getDerivedData);
-        if (model) {
-            model.getImportValue = (importName: string): any => {
-                return undefined;
-            };
-        }
-        it("Test componentName ", () => {
-            if (model) expect(getGeneratorModel(model)).toBeDefined();
-        });
-    });
-
-    describe("getGeneratorModel  test case defined getImportValue", () => {
-        const mockModule = mockAssignedModule(mockState());
-        const model = getModel(mockModule, getDerivedData);
-        if (model) {
-            model.getImportValue = (importName: string): any => {
-                return {
-                    isVectoredInterrupt: true,
-                    vectoredInterruptEnable: false,
-                    ivtBaseAddress: 8,
-                    isHighPriority: {
-                        CLCI: true,
-                    },
-                };
-            };
-        }
-        it("Test getGeneratorModel ", () => {
-            if (model) expect(getGeneratorModel(model)).toBeDefined();
-        });
-    });
-
-    describe("getGeneratorModel  test case undefined getInterrupts ", () => {
-        const mockModule = mockAssignedModule(mockState());
-        const model = getModel(mockModule, getDerivedData);
-        if (model) {
-            model.getInterrupts = (): any => {
-                return {
-                    CLCI: {
-                        handlerName: undefined,
-                    },
-                };
-            };
-        }
-        it("Test getGeneratorModel ", () => {
-            if (model) expect(getGeneratorModel(model)).toBeDefined();
-        });
-    });
-});

package/src/GeneratorModel.ts

@@ -1,60 +0,0 @@
-import * as claClcStacked from "./interfaces/cla-clc-stacked";
-//import { HeaderFile } from "@microchip/scf-interface";
-import * as interrupt_standard from "@microchip/interrupt-standard";
-import { AppModel } from "../generated_module/src/types/AutoModuleTypes";
-import { values } from "../generated_module/src/Utils";
-import { HeaderFile } from "@microchip/scf-interface";
-
-export const getGeneratorModel = (model: any): any => {
-    if (!model.getHardware()) return {};
-    const interrupts = model.getInterrupts();
-    const registerValues = model.getRegisterValues();
-    if (!registerValues || !interrupts) return {};
-
-    const initRegisters = values(registerValues).filter(
-        (reg) => reg.alias !== registerValues.CLCCON.alias,
-    );
-    initRegisters.push(registerValues.CLCCON); // should be the last register to be initialized
-
-    const clcInterface = claClcStacked.Interface.createFirmwareApi(
-        model.getComponentValue("componentName"),
-        getHeaderFiles(model),
-    );
-
-    const intPayload:
-        | interrupt_standard.ProcessedPayload
-        | undefined = model.getImportValue("interrupt_standard");
-
-    return {
-        compiler: "XC8 v2.20",
-        tool: "MPLABX v5.40",
-
-        componentName: model.getComponentValue("componentName"),
-        moduleNameLowerCase: model.getName().toLowerCase(),
-        moduleNameUpperCase: model.getName().toUpperCase(),
-        header: clcInterface.headerFiles?.[0],
-        api: clcInterface.api,
-        simpleApi: clcInterface.simpleApi,
-
-        interruptEnabled: model.isComponentValue("clci"),
-        isVectoredInterruptEnabled: intPayload?.vectoredInterruptEnable ?? false,
-        isHighPriority: intPayload?.isHighPriority?.["CLCI"] ?? true,
-        IVTBaseAddress: String(intPayload?.ivtBaseAddress ?? 8),
-        interruptFlagName: interrupts["CLCI"].flag,
-        interruptEnableBitName: interrupts["CLCI"].enable,
-        IRQname: interrupts["CLCI"].handlerName?.replace("_", "") ?? "",
-
-        initRegisters,
-        CLCDATA: registerValues.CLCDATA,
-        CLCCON: registerValues.CLCCON,
-    };
-};
-
-export const getHeaderFiles = (model: AppModel): HeaderFile[] => {
-    return [
-        {
-            name: model.getName().toLowerCase() + ".h",
-            path: "clc/",
-        },
-    ];
-};

package/src/InputStateCalculator.test.ts

@@ -1,64 +0,0 @@
-import { InputStateCalculator, LogicSelection } from "./InputStateCalculator";
-import { GateInputState } from "./gates/GateInputState";
-
-describe("Input state calculator", () => {
-    it("calculates grounded state", () => {
-        const result = InputStateCalculator.getInputState(false, false);
-        expect(result).toBe<GateInputState>("Grounded");
-    });
-
-    it("calculates normal state", () => {
-        const result = InputStateCalculator.getInputState(true, false);
-        expect(result).toBe<GateInputState>("Normal");
-    });
-
-    it("calculates inverted state", () => {
-        const result = InputStateCalculator.getInputState(false, true);
-        expect(result).toBe<GateInputState>("Inverted");
-    });
-
-    it("calculates illegal state", () => {
-        const result = InputStateCalculator.getInputState(true, true);
-        expect(result).toBe<GateInputState>("Illegal");
-    });
-
-    it("calculates logic selection for grounded state", () => {
-        const result = InputStateCalculator.getLogicSelection("Grounded");
-        expect(result).toEqual<LogicSelection>({ inverted: false, nonInverted: false });
-    });
-
-    it("calculates logic selection for normal state", () => {
-        const result = InputStateCalculator.getLogicSelection("Normal");
-        expect(result).toEqual<LogicSelection>({ inverted: false, nonInverted: true });
-    });
-
-    it("calculates logic selection for inverted state", () => {
-        const result = InputStateCalculator.getLogicSelection("Inverted");
-        expect(result).toEqual<LogicSelection>({ inverted: true, nonInverted: false });
-    });
-
-    it("calculates logic selection for illegal state", () => {
-        const result = InputStateCalculator.getLogicSelection("Illegal");
-        expect(result).toEqual<LogicSelection>({ inverted: true, nonInverted: true });
-    });
-
-    it("calculates next state after grounded", () => {
-        const result = InputStateCalculator.getNextState("Grounded");
-        expect(result).toBe<GateInputState>("Normal");
-    });
-
-    it("calculates next state after normal", () => {
-        const result = InputStateCalculator.getNextState("Normal");
-        expect(result).toBe<GateInputState>("Inverted");
-    });
-
-    it("calculates next state after inverted", () => {
-        const result = InputStateCalculator.getNextState("Inverted");
-        expect(result).toBe<GateInputState>("Grounded");
-    });
-
-    it("calculates next state after illegal", () => {
-        const result = InputStateCalculator.getNextState("Illegal");
-        expect(result).toBe<GateInputState>("Normal");
-    });
-});

package/src/InputStateCalculator.ts

@@ -1,50 +0,0 @@
-import { GateInputState } from "./gates/GateInputState";
-
-export type LogicSelection = {
-    nonInverted: boolean;
-    inverted: boolean;
-};
-
-export class InputStateCalculator {
-    static getInputState = (nonInverted: boolean, inverted: boolean): GateInputState => {
-        if (!nonInverted && !inverted) {
-            return "Grounded";
-        } else if (!nonInverted && inverted) {
-            return "Inverted";
-        } else if (nonInverted && !inverted) {
-            return "Normal";
-        } else {
-            return "Illegal";
-        }
-    };
-
-    static getLogicSelection = (gateInputState: GateInputState): LogicSelection => {
-        switch (gateInputState) {
-            case "Grounded":
-                return { nonInverted: false, inverted: false };
-            case "Inverted":
-                return { nonInverted: false, inverted: true };
-            case "Normal":
-                return { nonInverted: true, inverted: false };
-            case "Illegal":
-                return { nonInverted: true, inverted: true };
-            default:
-                throw new Error("Invalid input state");
-        }
-    };
-
-    static getNextState = (gateInputState: GateInputState): GateInputState => {
-        switch (gateInputState) {
-            case "Grounded":
-                return "Normal";
-            case "Inverted":
-                return "Grounded";
-            case "Normal":
-                return "Inverted";
-            case "Illegal":
-                return "Normal";
-            default:
-                throw new Error("Invalid input state");
-        }
-    };
-}