@mchp-mcc/dspic33a-flash 1.0.1

package/src/DerivedData.ts

@@ -0,0 +1,975 @@
+import * as Processor from "@microchip/scf-common/lib/Processor";
+import {
+    AppModel,
+    DerivedData,
+    DerivedFunctions,
+} from "../generated_module/src/types/AutoModuleTypes";
+import { InterfaceId } from "@microchip/scf-common/lib/InterfaceId";
+import * as flash_interface from "@microchip/flash-interface";
+import { ExportArg } from "@microchip/melody-automodule-interface/lib/src/InterfaceTypes";
+import * as config_16bit_interface from "@microchip/config-16bit-interface";
+import * as interrupt16bitInterface from "@microchip/interrupt-16bit-interface";
+import * as system_16bit_initializer from "@microchip/system-16bit-initializer";
+import { nvm_ctrl_32bit_upb_v1 } from "@mchp-mcc/pic-16bit-types/types/nvm_ctrl_32bit_upb_v1/nvm_ctrl_32bit_upb_v1";
+import { generatableItems } from "./GeneratorModel";
+import _find from "lodash.find";
+import { HeaderFile } from "@microchip/scf-interface";
+
+const FLASH_UNLOCK_KEY = "0x00AA0055";
+export const FLASH_INSTRUCTION_TYPE = "uint32_t";
+export const MODULE_NAME = "FLASH";
+const FLASH_WRITE_INSTRUCTION_COUNT = "flashWriteInstructionCount";
+const DEFAULT_WRITE_SIZE = 4;
+const OPTION_BLOCKING = "Blocking";
+const OPTION_NON_BLOCKING = "Non-Blocking";
+const CONFIG_16BIT_INTERFACE = "config_16bit_interface";
+export const ARGUMENT_GENERATE_API = "generateAPI";
+export const ARGUMENT_INTERRUPT_DRIVEN = "interruptDriven";
+
+export const getDerivedData = (dataModel: AppModel): DerivedData => {
+    if (dataModel) {
+        return new MyDerivedData(dataModel);
+    }
+    return new EmptyDerivedData();
+};
+
+export const getMyDerivedData = (dataModel: AppModel): MyDerivedData | 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
+class EmptyDerivedData implements DerivedData {
+    getMyFunctions = (): DerivedFunctions => {
+        return {};
+    };
+    getModel = (): AppModel | undefined => {
+        return undefined;
+    };
+}
+
+//This data will be used at the processor stage
+export class MyDerivedData implements DerivedData {
+    private dataModel: AppModel;
+
+    constructor(dataModel: AppModel) {
+        this.dataModel = dataModel;
+    }
+
+    getMyFunctions = (): DerivedFunctions => {
+        return {
+            exportApi: this.getMyExportApi,
+            templateData: this.getMyTemplateData,
+            alerts: this.getMyAlerts,
+            blockingAPIGenerate: this.getBlockingAPIGenerationStatus,
+            nonBlockingAPIGenerate: this.getNonBlockingAPIGenerationStatus,
+            overrideOptions: this.overrideOptions,
+            overrideDefaultValues: this.overrideDefaultValue,
+            "flash-interface_payload": this.basic_flash_payload,
+            importName: this.friendlyImportName,
+            exportName: this.friendlyExportName,
+            isInterfaceUsed: this.isFlashInterfaceUsed,
+            enableInterfaceDefinitionGeneration: this.enableInterfaceDefinitionGeneration,
+            interrupt_service_results: this.getFlashInterruptData,
+            system_16bit_initializer_results: this.system_16bit_initializer_results,
+            config_16bit_interface_args: this.getConfigBitArgs,
+            config_16bit_interface_results: this.getConfigBitArgs,
+            calculatedFunction: this.calculatedFunction,
+        };
+    };
+
+    private getMyExportApi = (interfaceId: InterfaceId): any => {
+        if (
+            interfaceId.name === flash_interface.Interface.getInterfaceId().name &&
+            interfaceId.version === flash_interface.Interface.getInterfaceId().version
+        ) {
+            const firmwareApi = flash_interface.Interface.createFirmwareApi(MODULE_NAME);
+            return {
+                api: firmwareApi.api,
+                headerFiles: firmwareApi.headerFiles,
+            };
+        }
+    };
+
+    private getMyTemplateData = (): any => {
+        return generatableItems(this.dataModel).getGeneratableItems();
+    };
+
+    getMyProcessedArgValue = (
+        componentName: string,
+        exportArg: ExportArg[],
+    ): ExportArg | undefined => {
+        let processedArg: ExportArg | undefined;
+        exportArg.some((arg) => {
+            if (arg.interface === flash_interface.Interface.getInterfaceId().name) {
+                processedArg = this.basic_flash_args(componentName, arg);
+                if (processedArg != undefined) {
+                    return true;
+                }
+            }
+        });
+        return processedArg;
+    };
+
+    private overrideOptions = (componentName: string): any[] => {
+        const defaultValue = [];
+        switch (componentName) {
+            case FLASH_WRITE_INSTRUCTION_COUNT: {
+                const flashWriteSize = String(this.getFlashWordWriteSizeInInstructions());
+                const flashRowWriteSize = String(
+                    this.getFlashWriteRowSizeInInstructions(),
+                );
+                return [flashWriteSize, flashRowWriteSize];
+            }
+            default:
+                return defaultValue;
+        }
+    };
+
+    private overrideDefaultValue = (componentName: string): any => {
+        let retValue;
+        switch (componentName) {
+            case FLASH_WRITE_INSTRUCTION_COUNT: {
+                retValue = String(this.getFlashWordWriteSizeInInstructions());
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        return retValue;
+    };
+
+    private friendlyImportName = (importKey: string): string => {
+        let importName: string;
+        switch (importKey) {
+            case "nvm_ctrl_32bit_v1":
+                importName = "Flash Hardware";
+                break;
+            case "system_16bit_initializer":
+                importName = "System Initializer";
+                break;
+            case "config_16bit_interface":
+                importName = "Configuration Bits";
+                break;
+            default:
+                importName = importKey;
+        }
+        return importName;
+    };
+
+    private friendlyExportName = (exportKey: string): string => {
+        let exportName = exportKey;
+        if (exportKey === "flash") {
+            exportName = "Flash";
+        }
+        return exportName;
+    };
+
+    private getActiveName = (): string => {
+        return "Flash PLIB";
+    };
+
+    private isFlashInterfaceUsed = (): boolean => {
+        const exportData:
+            | ExportArg[]
+            | undefined = this.dataModel.getExportInterfaces().getInterfaceData();
+        const interfaceData = _find(
+            exportData,
+            (i) => i.interface === flash_interface.Interface.getInterfaceId().name,
+        );
+        const result = this.dataModel
+            ?.getExportInterfaces()
+            .getInterface("flash_interface", flash_interface.Interface.getInterfaceId())
+            ?.results;
+        if (interfaceData || result) {
+            return true;
+        }
+        return false;
+    };
+
+    private getModuleNameForInterrupt = (): string => {
+        return this.getFlashHardwareData()?.name.toLocaleUpperCase() ?? "FLASH";
+    };
+
+    private getInterruptData = (
+        interruptAliasList: string[],
+    ): interrupt16bitInterface.InterruptParameter[] => {
+        const interruptData: interrupt16bitInterface.InterruptParameter[] = [];
+        const isInterruptDriven = this.isInterruptMode();
+        interruptAliasList.forEach((interruptAlias) => {
+            interruptData.push({
+                interruptName:
+                    this.dataModel?.getHardware()?.getPeripheral()?.interrupts?.[
+                        interruptAlias
+                    ]?.name ?? "",
+                isEnabled: isInterruptDriven,
+            });
+        });
+        return interruptData;
+    };
+
+    private getFlashHardwareData = (): nvm_ctrl_32bit_upb_v1 | undefined => {
+        return this.getModel().getImportValue("nvm_ctrl_32bit_upb_v1");
+    };
+
+    private basic_flash_args = (
+        componentName: string,
+        arg: ExportArg | undefined,
+    ): ExportArg | undefined => {
+        let processedArg: ExportArg | undefined;
+        switch (componentName) {
+            case FLASH_WRITE_INSTRUCTION_COUNT:
+                if (arg != undefined && arg.name === FLASH_WRITE_INSTRUCTION_COUNT) {
+                    processedArg = {
+                        interface: arg.interface,
+                        name: arg.name,
+                        value: this.getFlashWriteInstructionCountToImpl(arg.value),
+                        module: arg.module,
+                    };
+                }
+                break;
+            default:
+                break;
+        }
+
+        return processedArg;
+    };
+
+    private getFlashWriteInstructionCountToImpl = (flashWriteInstCount: any): number => {
+        if (flashWriteInstCount != undefined) {
+            let flashWriteCount = flashWriteInstCount;
+            const minFlashWordSize = this.getFlashWordWriteSizeInInstructions();
+            const flashRowWriteSize = this.getFlashWriteRowSizeInInstructions();
+            if (
+                flashWriteInstCount != minFlashWordSize &&
+                flashWriteInstCount != flashRowWriteSize
+            ) {
+                flashWriteCount = minFlashWordSize;
+            }
+            return flashWriteCount;
+        } else {
+            return DEFAULT_WRITE_SIZE;
+        }
+    };
+
+    private isGenerateNonBlockingAPI = (): boolean => {
+        let generateNonBlockingAPI = false;
+        const flashInterfaceResult = this.getFlashResults(ARGUMENT_GENERATE_API);
+        if (flashInterfaceResult != undefined) {
+            if (flashInterfaceResult != OPTION_BLOCKING) {
+                generateNonBlockingAPI = true;
+            } else {
+                generateNonBlockingAPI = false;
+            }
+        }
+        return generateNonBlockingAPI;
+    };
+
+    private system_16bit_initializer_results = (): system_16bit_initializer.Results => {
+        if (this.isFlashInterfaceUsed()) {
+            if (
+                this.getNonBlockingAPIGenerationStatus() &&
+                this.getInterruptDrivenStatus()
+            ) {
+                return {
+                    initializer: [
+                        {
+                            funcName: "FLASH_Initialize",
+                            header: {
+                                name: "flash_nonblocking.h",
+                                path: "../flash/",
+                            },
+                        },
+                    ],
+                };
+            }
+        }
+        return {};
+    };
+
+    private getExportArg = (componentName: string): ExportArg | undefined => {
+        const exportData:
+            | ExportArg[]
+            | undefined = this.dataModel.getExportInterfaces().getInterfaceData();
+        const expArg = _find(
+            exportData,
+            (i) =>
+                i.interface === flash_interface.Interface.getInterfaceId().name &&
+                i.name === componentName,
+        );
+        return expArg;
+    };
+
+    private getConfigBitArgs = (): config_16bit_interface.Arguments => {
+        return {
+            configBitByAliasFilter: ["BTMODE"],
+            configBitSet: {},
+        };
+    };
+
+    private getDualPartitionDetails = ():
+        | flash_interface.DualPartitionDetails
+        | undefined => {
+        const hasDualPartition = this.getFlashHasDualPartition();
+        if (hasDualPartition) {
+            return {
+                flashFirstPartitionEndAddress: this.getFlashFirstPartitionEndAddress(),
+                flashSecondPartitionBeginAddress: this.getFlashSecondPartitionStartAddress(),
+                flashSecondPartitionProgramBeginAddress: this.getFlashSecondPartitionProgramStartAddress(),
+                flashSecondPartitionEndAddress: this.getFlashSecondPartitionEndAddress(),
+            };
+        }
+    };
+
+    private getMyAlerts = (): Processor.Alert[] => {
+        return [];
+    };
+
+    private calculatedFunction = (): any => {
+        return;
+    };
+
+    /********************public functions ************************** */
+
+    public basic_flash_payload = (): any => {
+        let headerFiles: HeaderFile[] | undefined = [];
+        if (this.getFlashHasDualPartition() && this.getFlashDualPartitionEnabled()) {
+            headerFiles = [{ name: "flash_nonblocking.h", path: "flash/" }];
+        } else {
+            headerFiles = flash_interface.Interface.createFirmwareApi(
+                this.dataModel.getName(),
+            ).headerFiles;
+        }
+        return {
+            interfaceApi: flash_interface.Interface.createFirmwareApi(
+                this.dataModel.getName(),
+                headerFiles,
+            ),
+            flashWriteInstructionCount: this.getFlashWriteInstructionCount(),
+            flashInterface: this.getFlashInterface(),
+            flashWordWriteSizeInInstructions: this.getFlashWordWriteSizeInInstructions(),
+            flashEraseInstructionCount: this.getFlashEraseInstructionCount(),
+            flashHasAuxiliary: this.getFlashHasAuxiliary(),
+            flashEnduranceMinimum: this.getFlashEnduranceMinimum(),
+            flashBytesPerInstruction: this.getFlashBytesPerInstruction(),
+            flashPcUnitsPerInstruction: this.getFlashPcUnitsPerInstruction(),
+            flashWordWriteOpCode: this.getFlashWordWriteOpCode(),
+            flashOpCodeMask: this.getFlashOpCodeMask(),
+            flashErasePageSizeInInstructions: this.getFlashErasePageSizeInInstructions(),
+            flashErasePageOpCode: this.getFlashErasePageOpCode(),
+            flashHasEcc: this.getFlashHasEcc(),
+            flashHasRowProgramming: this.getFlashHasRowProgramming(),
+            flashWriteRowSizeInInstructions: this.getFlashWriteRowSizeInInstructions(),
+            flashWriteRowOpCode: this.getFlashWriteRowOpCode(),
+            flashEndAddress: this.getFlashEndAddress(),
+            flashProgramBeginAddress: this.getFlashProgramBeginAddress(),
+            flashUnlockKey: this.getFlashUnlockKey(),
+            flashHasDualPartition: this.getFlashHasDualPartition(),
+            flashBootMode: this.getFlashBootModeValue(),
+            flashDualPartitionDetails: this.getDualPartitionDetails(),
+        };
+    };
+
+    public getFlashInterface = (): string => {
+        return "FLASH_UNIFIED_MEMORY_MAP_QUAD_WORD_v1.0";
+    };
+
+    public enableInterfaceDefinitionGeneration = (): boolean => {
+        let enableInterfaceGeneration = false;
+        if (
+            this.isFlashInterfaceUsed() &&
+            this.dataModel?.getImportValue("system_16bit_initializer")
+                ?.enableInterfaceDefinitionGeneration
+        ) {
+            enableInterfaceGeneration = true;
+        }
+        return enableInterfaceGeneration;
+    };
+
+    public getFlashInterruptData = (): interrupt16bitInterface.Results => {
+        const interruptList: string[] = [];
+        const interrupts = this.getFlashHardwareData()?.interrupts;
+        for (const key in interrupts) {
+            interruptList.push(key);
+        }
+        return {
+            moduleName: this.getModuleNameForInterrupt(),
+            interruptData: this.getInterruptData(interruptList),
+        };
+    };
+
+    public isInterruptMode = (): boolean => {
+        if (this.isFlashInterfaceUsed()) {
+            return this.getInterruptDrivenStatus();
+        } else {
+            return false;
+        }
+    };
+
+    public getInterruptDrivenStatus = (): boolean => {
+        let interruptDriven = false;
+        const flashInterfaceResult = this.getFlashResults(ARGUMENT_INTERRUPT_DRIVEN);
+        if (flashInterfaceResult != undefined) {
+            interruptDriven = flashInterfaceResult;
+        }
+        return interruptDriven;
+    };
+
+    public getFlashWordWriteSizeInInstructions = (): number | undefined => {
+        return this.getFlashWordWriteSizeInInstructionsValue(this.dataModel);
+    };
+
+    public getFlashWordWriteSizeInInstructionsValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashWordWriteSizeInInstructions: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_WORD_WRITE_SIZE_IN_INSTRUCTIONS?.value != undefined
+        ) {
+            flashWordWriteSizeInInstructions = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_WORD_WRITE_SIZE_IN_INSTRUCTIONS?.value,
+            );
+        }
+        return flashWordWriteSizeInInstructions;
+    };
+
+    public getFlashEraseInstructionCount = (): number | undefined => {
+        return this.getFlashEraseInstructionCountValue(this.dataModel);
+    };
+
+    public getFlashEraseInstructionCountValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashEraseInstructionCount: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_ERASE_PAGE_SIZE_IN_INSTRUCTIONS?.value != undefined
+        ) {
+            flashEraseInstructionCount = Number(
+                model?.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_ERASE_PAGE_SIZE_IN_INSTRUCTIONS?.value,
+            );
+        }
+        return flashEraseInstructionCount;
+    };
+
+    public getFlashHasAuxiliary = (): number | undefined => {
+        return this.getFlashHasAuxiliaryValue(this.dataModel);
+    };
+
+    public getFlashHasAuxiliaryValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashHasAuxiliary: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_HAS_AUXILIARY
+                ?.value != undefined
+        ) {
+            flashHasAuxiliary =
+                model?.getHardware()?.getPeripheral()?.properties?.FLASH_HAS_AUXILIARY
+                    ?.value == "TRUE"
+                    ? 1
+                    : 0;
+        }
+        return flashHasAuxiliary;
+    };
+
+    public getFlashEnduranceMinimum = (): number | undefined => {
+        return this.getFlashEnduranceMinimumValue(this.dataModel);
+    };
+
+    public getFlashEnduranceMinimumValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashMinEndurance: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_ENDURANCE_MINIMUM
+                ?.value != undefined
+        ) {
+            flashMinEndurance = Number(
+                model.getHardware()?.getPeripheral()?.properties?.FLASH_ENDURANCE_MINIMUM
+                    ?.value,
+            );
+        }
+        return flashMinEndurance;
+    };
+
+    public getFlashBytesPerInstruction = (): number | undefined => {
+        return this.getFlashBytesPerInstructionValue(this.dataModel);
+    };
+
+    public getFlashBytesPerInstructionValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashBytesPerInstruction = 4;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_BYTES_PER_INSTRUCTION
+                ?.value != undefined
+        ) {
+            flashBytesPerInstruction = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_BYTES_PER_INSTRUCTION?.value,
+            );
+        }
+        return flashBytesPerInstruction;
+    };
+
+    public getFlashPcUnitsPerInstruction = (): number | undefined => {
+        return this.getFlashPcUnitsPerInstructionValue(this.dataModel);
+    };
+
+    public getFlashPcUnitsPerInstructionValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashPcUnitsPerInstruction = 1;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_PC_UNITS_PER_INSTRUCTION?.value != undefined
+        ) {
+            flashPcUnitsPerInstruction = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_PC_UNITS_PER_INSTRUCTION?.value,
+            );
+        }
+        return flashPcUnitsPerInstruction;
+    };
+
+    public getFlashWordWriteOpCode = (): number | undefined => {
+        return this.getFlashWordWriteOpCodeValue(this.dataModel);
+    };
+
+    public getFlashWordWriteOpCodeValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashWordWriteOpcode: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_WORD_WRITE_OP_CODE
+                ?.value != undefined
+        ) {
+            flashWordWriteOpcode = Number(
+                model.getHardware()?.getPeripheral()?.properties?.FLASH_WORD_WRITE_OP_CODE
+                    ?.value,
+            );
+        }
+        return flashWordWriteOpcode;
+    };
+
+    public getFlashOpCodeMask = (): number | undefined => {
+        return this.getFlashOpCodeMaskValue(this.dataModel);
+    };
+
+    public getFlashOpCodeMaskValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashOpcodeMaks: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_OP_CODE_MASK
+                ?.value != undefined
+        ) {
+            flashOpcodeMaks = Number(
+                model.getHardware()?.getPeripheral()?.properties?.FLASH_OP_CODE_MASK
+                    ?.value,
+            );
+        }
+        return flashOpcodeMaks;
+    };
+
+    public getFlashErasePageSizeInInstructions = (): number | undefined => {
+        return this.getFlashErasePageSizeInInstructionsValue(this.dataModel);
+    };
+
+    public getFlashErasePageSizeInInstructionsValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashErasePageSizeInInstructions: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_ERASE_PAGE_SIZE_IN_INSTRUCTIONS?.value != undefined
+        ) {
+            flashErasePageSizeInInstructions = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_ERASE_PAGE_SIZE_IN_INSTRUCTIONS?.value,
+            );
+        }
+        return flashErasePageSizeInInstructions;
+    };
+
+    public getFlashErasePageOpCode = (): number | undefined => {
+        return this.getFlashErasePageOpCodeValue(this.dataModel);
+    };
+
+    public getFlashErasePageOpCodeValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashErasePageOpCode: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_ERASE_PAGE_OP_CODE
+                ?.value != undefined
+        ) {
+            flashErasePageOpCode = Number(
+                model.getHardware()?.getPeripheral()?.properties?.FLASH_ERASE_PAGE_OP_CODE
+                    ?.value,
+            );
+        }
+        return flashErasePageOpCode;
+    };
+
+    public getFlashHasEcc = (): number | undefined => {
+        return this.getFlashHasEccValue(this.dataModel);
+    };
+
+    public getFlashHasEccValue = (model: AppModel | undefined): number | undefined => {
+        let flashHasEcc: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_HAS_ECC?.value !=
+            undefined
+        ) {
+            flashHasEcc =
+                model.getHardware()?.getPeripheral()?.properties?.FLASH_HAS_ECC?.value ==
+                "TRUE"
+                    ? 1
+                    : 0;
+        }
+        return flashHasEcc;
+    };
+
+    public getFlashHasRowProgramming = (): number | undefined => {
+        return this.getFlashHasRowProgrammingValue(this.dataModel);
+    };
+
+    public getFlashHasRowProgrammingValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashHasRowProgramming: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_HAS_ROW_PROGRAMMING
+                ?.value != undefined
+        ) {
+            flashHasRowProgramming =
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_HAS_ROW_PROGRAMMING?.value == "TRUE"
+                    ? 1
+                    : 0;
+        }
+        return flashHasRowProgramming;
+    };
+
+    public getFlashWriteRowSizeInInstructions = (): number | undefined => {
+        return this.getFlashWriteRowSizeInInstructionsValue(this.dataModel);
+    };
+
+    public getFlashWriteRowSizeInInstructionsValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashWriteRowSizeInInstructions: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_WRITE_ROW_SIZE_IN_INSTRUCTIONS?.value != undefined
+        ) {
+            flashWriteRowSizeInInstructions = Number(
+                model?.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_WRITE_ROW_SIZE_IN_INSTRUCTIONS?.value,
+            );
+        }
+        return flashWriteRowSizeInInstructions;
+    };
+
+    public getFlashWriteRowOpCode = (): number | undefined => {
+        return this.getFlashWriteRowOpCodeValue(this.dataModel);
+    };
+
+    public getFlashWriteRowOpCodeValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashWriteRowOpCode;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_WRITE_ROW_OP_CODE
+                ?.value != undefined
+        ) {
+            flashWriteRowOpCode = Number(
+                model?.getHardware()?.getPeripheral()?.properties?.FLASH_WRITE_ROW_OP_CODE
+                    ?.value,
+            );
+        }
+        return flashWriteRowOpCode;
+    };
+
+    public getFlashEndAddress = (): number | undefined => {
+        return this.getFlashEndAddressValue(this.dataModel);
+    };
+
+    public getFlashEndAddressValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashEndAddress: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.FLASH_END_ADDRESS?.value !=
+            undefined
+        ) {
+            flashEndAddress = Number(
+                model.getHardware()?.getPeripheral()?.properties?.FLASH_END_ADDRESS
+                    ?.value,
+            );
+        }
+        return flashEndAddress;
+    };
+
+    public getFlashProgramBeginAddress = (): number | undefined => {
+        return this.getFlashProgramBeginAddressValue(this.dataModel);
+    };
+
+    public getFlashProgramBeginAddressValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashProgramBeginAddress: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties?.PROGRAM_BEGIN_ADDRESS
+                ?.value != undefined
+        ) {
+            flashProgramBeginAddress = Number(
+                model.getHardware()?.getPeripheral()?.properties?.PROGRAM_BEGIN_ADDRESS
+                    ?.value,
+            );
+        }
+        return flashProgramBeginAddress;
+    };
+
+    public getFlashUnlockKey = (): string => {
+        return FLASH_UNLOCK_KEY;
+    };
+
+    public getFlashHasDualPartition = (): boolean | undefined => {
+        return this.getHasDualPartitionValue(this.dataModel);
+    };
+
+    public getHasDualPartitionValue = (
+        model: AppModel | undefined,
+    ): boolean | undefined => {
+        let flashHasDualPartition: boolean | undefined;
+        const hasDualPartition = model?.getHardware()?.getPeripheral()?.properties
+            ?.FLASH_HAS_DUAL_PARTITION?.value;
+        if (hasDualPartition != undefined) {
+            if (hasDualPartition == "TRUE") {
+                flashHasDualPartition = true;
+            } else {
+                flashHasDualPartition = false;
+            }
+        }
+        return flashHasDualPartition;
+    };
+
+    public getFlashBootModeValue = (): string | undefined => {
+        let btMode: string | undefined;
+        const interfaceData: config_16bit_interface.ProcessedPayload = this.dataModel.getImportValue(
+            CONFIG_16BIT_INTERFACE,
+        );
+        if (interfaceData != undefined) {
+            btMode = interfaceData.configBitSettingValueAliasMap["BTMODE"];
+        }
+        return btMode;
+    };
+
+    public getFlashFirstPartitionEndAddress = (): number | undefined => {
+        return this.getFlashFirstPartitionEndAddressValue(this.dataModel);
+    };
+
+    public getFlashFirstPartitionEndAddressValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashFirstPartitionEndAddress: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_FIRST_PARTITION_END_ADDRESS?.value != undefined
+        ) {
+            flashFirstPartitionEndAddress = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_FIRST_PARTITION_END_ADDRESS?.value,
+            );
+        }
+        return flashFirstPartitionEndAddress;
+    };
+
+    public getFlashSecondPartitionStartAddress = (): number | undefined => {
+        return this.getFlashSecondPartitionStartAddressValue(this.getModel());
+    };
+
+    public getFlashSecondPartitionStartAddressValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashSecondPartitionStartAddress: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_SECOND_PARTITION_START_ADDRESS?.value != undefined
+        ) {
+            flashSecondPartitionStartAddress = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_SECOND_PARTITION_START_ADDRESS?.value,
+            );
+        }
+        return flashSecondPartitionStartAddress;
+    };
+
+    public getFlashSecondPartitionProgramStartAddress = (): number | undefined => {
+        return this.getFlashSecondPartitionProgramStartAddressValue(this.getModel());
+    };
+
+    public getFlashSecondPartitionProgramStartAddressValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashSecondPartitionProgramStartAddress: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_SECOND_PARTITION_PROGRAM_START_ADDRESS?.value != undefined
+        ) {
+            flashSecondPartitionProgramStartAddress = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_SECOND_PARTITION_PROGRAM_START_ADDRESS?.value,
+            );
+        }
+        return flashSecondPartitionProgramStartAddress;
+    };
+
+    public getFlashSecondPartitionEndAddress = (): number | undefined => {
+        return this.getFlashSecondPartitionEndAddressValue(this.getModel());
+    };
+
+    public getFlashSecondPartitionEndAddressValue = (
+        model: AppModel | undefined,
+    ): number | undefined => {
+        let flashSecondPartitionEndAddress: number | undefined;
+        if (
+            model?.getHardware()?.getPeripheral()?.properties
+                ?.FLASH_SECOND_PARTITION_END_ADDRESS?.value != undefined
+        ) {
+            flashSecondPartitionEndAddress = Number(
+                model.getHardware()?.getPeripheral()?.properties
+                    ?.FLASH_SECOND_PARTITION_END_ADDRESS?.value,
+            );
+        }
+        return flashSecondPartitionEndAddress;
+    };
+
+    public getFlashDualPartitionEnabled = (): boolean | undefined => {
+        return this.getDualPartitionEnabledValue(this.dataModel);
+    };
+
+    public getDualPartitionEnabledValue = (
+        model: AppModel | undefined,
+    ): boolean | undefined => {
+        let flashIsDualPartitionEnabled: boolean | undefined = false;
+        const btMode = this.getFlashBootModeValue();
+        if (btMode != undefined) {
+            if (btMode != "SINGLE") {
+                flashIsDualPartitionEnabled = true;
+            }
+        }
+        return flashIsDualPartitionEnabled;
+    };
+
+    public getFlashWriteInstructionCount = (): number => {
+        const flashWriteInstCount = this.basic_flash_args(
+            FLASH_WRITE_INSTRUCTION_COUNT,
+            this.getExportArg(FLASH_WRITE_INSTRUCTION_COUNT),
+        );
+        if (flashWriteInstCount != undefined) {
+            return Number(flashWriteInstCount.value);
+        } else {
+            return Number(this.getFlashWordWriteSizeInInstructions());
+        }
+    };
+
+    public getBlockingAPIGenerationStatus = (): boolean => {
+        let generateBlockingAPI = true;
+        const flashInterfaceResult = this.getFlashResults(ARGUMENT_GENERATE_API);
+        if (flashInterfaceResult != undefined) {
+            if (flashInterfaceResult != OPTION_NON_BLOCKING) {
+                generateBlockingAPI = true;
+            } else {
+                generateBlockingAPI = false;
+            }
+        }
+        return generateBlockingAPI;
+    };
+
+    public getNonBlockingAPIGenerationStatus = (): boolean | undefined => {
+        let nonBlockingAPIGenerate = this.isGenerateNonBlockingAPI();
+        if (nonBlockingAPIGenerate) {
+            if (this.getFlashHasDualPartition() == undefined) {
+                nonBlockingAPIGenerate = false;
+            }
+        }
+        return nonBlockingAPIGenerate;
+    };
+
+    public getFlashResults = (resultsArg: string): any => {
+        let result: any;
+        const flashResults = this.dataModel
+            ?.getExportInterfaces()
+            .getInterface("flash_interface", flash_interface.Interface.getInterfaceId())
+            ?.results;
+        if (flashResults != undefined) {
+            for (const moduleId in flashResults) {
+                result = flashResults[moduleId]?.[resultsArg];
+            }
+        }
+        return result;
+    };
+
+    public getProperties = (): any => {
+        return this.getPropertiesValue(this.dataModel);
+    };
+
+    public getPropertiesValue = (model: AppModel | undefined): any => {
+        if (model?.getHardware() != undefined) {
+            return model.getHardware()?.getPeripheral()?.properties;
+        }
+    };
+
+    public getFlashWordWriteOpCodeHexString = (): string => {
+        const opcode = this.getFlashWordWriteOpCode();
+        return this.getHexaDecimalString(opcode);
+    };
+
+    public getFlashOpCodeMaskHexString = (): string => {
+        const opcode = this.getFlashOpCodeMask();
+        return this.getHexaDecimalString(opcode);
+    };
+
+    public getFlashErasePageOpCodeHexString = (): string => {
+        const opcode = this.getFlashErasePageOpCode();
+        return this.getHexaDecimalString(opcode);
+    };
+
+    public getFlashWriteRowOpCodeHexString = (): string => {
+        const opcode = this.getFlashWriteRowOpCode();
+        return this.getHexaDecimalString(opcode);
+    };
+
+    public getFlashEndAddressHexString = (): string => {
+        const opcode = this.getFlashEndAddress();
+        return this.getHexaDecimalString(opcode);
+    };
+
+    public getFlashProgramBeginAddressHexString = (): string => {
+        const opcode = this.getFlashProgramBeginAddress();
+        return this.getHexaDecimalString(opcode);
+    };
+
+    private getHexaDecimalString = (opcode: number | undefined): string => {
+        if (opcode != undefined) {
+            return "0x" + opcode.toString(16);
+        } else {
+            opcode = 0;
+            return "0x" + opcode.toString(16);
+        }
+    };
+
+    public getModel = (): AppModel => {
+        return this.dataModel;
+    };
+}