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

package/src/DerivedData.ts

@@ -0,0 +1,507 @@
+import * as Processor from "@microchip/scf-common/lib/Processor";
+import { ModuleConfig } from "@microchip/melody-automodule-interface";
+import { Calculations } from "./Calculations";
+import {
+    AppModel,
+    DerivedData,
+    DerivedFunctions,
+} from "../generated_module/src/types/AutoModuleTypes";
+import * as InterfaceTypes from "@microchip/scf-interface";
+import * as opa from "./opa-output-parameters";
+import { MyTemplateData, getGeneratorModel } from "./GeneratorModel";
+import * as initializer_system from "@microchip/initializer-system";
+import { intf_args, QueryAdapterKey } from "@microchip/pin-standard/lib/pin-standard";
+import { Option } from "@microchip/scf-device";
+import { getInputPinsData } from "./PinsLogic";
+import { MyComponentNames } from "../generated_module/src/types";
+import * as image from "./ImageDataURLs";
+import { getPinsLogic } from "../generated_module/src/pins/PCPHelper";
+import { getCFunctionValidator, PatternValidator } from "@microchip/scf-validators/lib";
+
+export const getDerivedData = (dataModel: AppModel): 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
+export class MyDerivedData implements DerivedData {
+    private dataModel: AppModel;
+    private myTemplateData: MyTemplateData<opa.API>;
+    private gainCalc: Calculations;
+    private cValidator: PatternValidator = getCFunctionValidator();
+
+    constructor(dataModel: AppModel) {
+        this.dataModel = dataModel;
+    }
+
+    getGainCalculator = (): Calculations => {
+        if (!this.gainCalc) {
+            this.gainCalc = new Calculations();
+        }
+        return this.gainCalc;
+    };
+
+    getMyFunctions = (): DerivedFunctions => {
+        return {
+            getDynamicConfigData: this.getDynamicConfigData,
+            moduleName: this.getModuleName,
+            templateData: this.getMyTemplateData,
+            alerts: this.getMyAlerts,
+            ["opa-output-parameters_payload"]: this.getOpaInterfaceProcessedPayload,
+            nonInvGain: this.calcNonInvGain,
+            invGain: this.calcInvGain,
+            initializer_system_results: this.initializer_system_results,
+            pin_standard_args: this.getPinstandardArgs,
+            doNotShow: (): boolean => false,
+            overrideDefaultValues: this.overrideDefaultValue,
+            customNameValidator: this.customNameValidator,
+            getCustomUiErrors: this.getCustomUiErrors,
+            isEnabled: this.isEnabled,
+            isVisible: this.isVisible,
+            getPinsLogic: getPinsLogic,
+            importName: this.friendlyImportName,
+        };
+    };
+
+    public getModel = (): AppModel => {
+        return this.dataModel;
+    };
+
+    public getModuleName = (): string => {
+        return this.getModel().getHardware()?.getName() ?? "OPA";
+    };
+
+    private friendlyImportName = (importKey: string): string => {
+        if (importKey === "scf_pic8_opamp_v2") return "OpAmp Hardware";
+        if (importKey === "initializer_system") return "system.c Initialize()";
+        if (importKey === "pin_standard") return "Pins";
+        return importKey;
+    };
+
+    private customNameValidator = (): any => {
+        return {
+            pattern: this.cValidator.getRjsfValidation().pattern,
+        };
+    };
+
+    private getCustomUiErrors = (componentName: string): Error[] | undefined => {
+        switch (componentName) {
+            case "customName":
+                return [
+                    {
+                        name: "pattern",
+                        message: this.cValidator.getCustomErrorMessage(),
+                    },
+                ];
+            default:
+                return undefined;
+        }
+    };
+
+    private isEnabled = (componentName: string): any => {
+        if (componentName === "nssOpacon1") {
+            const customConfig = this.getModel().getComponentValue("customConfig");
+            const negChannel = this.getModel().getComponentValue("nchOpacon2");
+            if (
+                (customConfig === "Non-Inverting Programmable Gain Amplifier" ||
+                    customConfig === "Inverting Programmable Gain Amplifier") &&
+                negChannel === "GSEL"
+            )
+                return true;
+        }
+        return undefined;
+    };
+
+    private isVisible = (componentName: string): any => {
+        if (componentName === "ptresOpacon4") {
+            const hwch = this.getModel().getComponentValue("hwchOpahwc") ?? "";
+            const hwcl = this.getModel().getComponentValue("hwclOpahwc") ?? "";
+            if (hwch.indexOf("detect") != -1 || hwcl.indexOf("detect") != -1) return true;
+            else return false;
+        }
+        return undefined;
+    };
+
+    private getDynamicConfigData = (
+        config: ModuleConfig.MyModuleConfig<MyComponentNames>,
+    ): ModuleConfig.MyModuleConfig<MyComponentNames> => {
+        const links: MyComponentNames[] = ["mindiLink"];
+        links.forEach((name) => {
+            const component = config.softwareData?.[name];
+            if (component?.type === "string" && component?.format === "url") {
+                component.urlDescription = "Mindi\u2122 Schematic";
+            }
+        });
+        return config;
+    };
+
+    private overrideDefaultValue = (componentName: string): any => {
+        const module: string = this.getModuleName();
+        if (componentName === "customName") return this.getModuleName();
+
+        if (componentName === "schematic") {
+            switch (this.getModel().getComponentValue("customConfig")) {
+                case "Direct Connection to Pins":
+                    return image.DIRECT_CONN;
+                case "Unity Gain Buffer":
+                    return image.UNITY_GAIN;
+                case "Non-Inverting Programmable Gain Amplifier":
+                    return image.NON_INV_PGA;
+                case "Inverting Programmable Gain Amplifier":
+                    return image.INV_PGA;
+                default:
+                    return image.DIRECT_CONN;
+            }
+        }
+        if (componentName === "mindiLink") {
+            switch (this.getModel().getComponentValue("customConfig")) {
+                case "Direct Connection to Pins":
+                    return "https://kits.microchip.com/redirect/4/PIC18Q71-00";
+                case "Unity Gain Buffer":
+                    return "https://kits.microchip.com/redirect/4/PIC18Q71-01";
+                case "Non-Inverting Programmable Gain Amplifier":
+                    return "https://kits.microchip.com/redirect/4/PIC18Q71-02";
+                case "Inverting Programmable Gain Amplifier":
+                    return "https://kits.microchip.com/redirect/4/PIC18Q71-03";
+                default:
+                    return "https://kits.microchip.com/redirect/4/PIC18Q71-00";
+            }
+        }
+        if (componentName === "pchOpacon2") {
+            switch (this.getModel().getComponentValue("customConfig")) {
+                case "Direct Connection to Pins":
+                    return module + "IN+";
+                case "Unity Gain Buffer":
+                    return module + "IN+";
+                case "Non-Inverting Programmable Gain Amplifier":
+                    return module + "IN+";
+                case "Inverting Programmable Gain Amplifier":
+                    return "Vdd/2";
+                case "Custom Configuration":
+                    return "Vss";
+            }
+        }
+        if (componentName === "pssOpacon3") {
+            if (this.getModel().getComponentValue("customConfig")) return module + "IN0+";
+        }
+        if (componentName === "nchOpacon2") {
+            switch (this.getModel().getComponentValue("customConfig")) {
+                case "Direct Connection to Pins":
+                    return module + "IN-";
+                case "Unity Gain Buffer":
+                    return "No Connection";
+                case "Non-Inverting Programmable Gain Amplifier":
+                    return "GSEL";
+                case "Inverting Programmable Gain Amplifier":
+                    return "GSEL";
+                case "Custom Configuration":
+                    return "No Connection";
+            }
+        }
+        if (componentName === "nssOpacon1") {
+            return this.getModel().getComponentValue("customConfig") ===
+                "Non-Inverting Programmable Gain Amplifier"
+                ? "Vss"
+                : module + "IN0-";
+        }
+        if (componentName === "resonOpacon1") {
+            switch (this.getModel().getComponentValue("customConfig")) {
+                case "Non-Inverting Programmable Gain Amplifier":
+                    return "Enabled";
+                case "Inverting Programmable Gain Amplifier":
+                    return "Enabled";
+                default:
+                    return "Disabled";
+            }
+        }
+        if (componentName === "gselOpacon1") {
+            if (this.getModel().getComponentValue("customConfig"))
+                return "R1 = 15R and R2 = 1R, R2/R1 = 0.07";
+        }
+        if (componentName === "fmsOpacon3") {
+            switch (this.getModel().getComponentValue("customConfig")) {
+                case "Non-Inverting Programmable Gain Amplifier":
+                    return module + "OUT";
+                case "Inverting Programmable Gain Amplifier":
+                    return module + "OUT";
+                default:
+                    return "No Connection";
+            }
+        }
+        if (componentName === "ugOpacon0") {
+            return this.getModel().getComponentValue("customConfig") ===
+                "Unity Gain Buffer"
+                ? "OPA Output"
+                : "OPAIN- pin";
+        }
+        return undefined;
+    };
+
+    private getOpaInterfaceProcessedPayload = (): opa.ProcessedPayload => {
+        return {
+            moduleName: this.getModuleName(),
+            customName: this.dataModel.getComponentValue("customName"),
+            hasInterrupts: false,
+        };
+    };
+
+    private calcNonInvGain = (): string => {
+        const resSelect: string | undefined =
+            this.getModel().getComponentValue("gselOpacon1");
+        return this.getGainCalculator().calcNonInvGain(resSelect);
+    };
+
+    private calcInvGain = (): string => {
+        const resSelect: string | undefined =
+            this.getModel().getComponentValue("gselOpacon1");
+        return this.getGainCalculator().calcInvGain(resSelect);
+    };
+
+    private getMyAlerts = (): Processor.Alert[] => {
+        const alerts: Processor.Alert[] = [];
+        const module: string = this.getModuleName();
+        const customConfigValue = this.getModel().getComponentValue("customConfig");
+        const posChannel = this.getModel().getComponentValue("pchOpacon2");
+        const negChannel = this.getModel().getComponentValue("nchOpacon2");
+        const posSrc = this.getModel().getComponentValue("pssOpacon3");
+        const posSrc0 = posSrc?.substring(0, posSrc.length - 1);
+        const negSrc = this.getModel().getComponentValue("nssOpacon1");
+        const negSrc0 = negSrc?.substring(0, negSrc.length - 1);
+        const feedbackMode = this.getModel().getComponentValue("fmsOpacon3");
+
+        switch (customConfigValue) {
+            case "Direct Connection to Pins": {
+                if (posChannel === "GSEL") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Positive Channel in this configuration",
+                    });
+                }
+                if (negChannel === "GSEL") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Negative Channel in this configuration",
+                    });
+                }
+                if (posChannel === module + "IN+" && negChannel === module + "IN-") {
+                    if (posSrc0 === negSrc0) {
+                        alerts.push({
+                            type: Processor.AlertTypes.Warning,
+                            text: "Both the Positive and Negative Sources are mapped to the same pin",
+                        });
+                    } else {
+                        //do nothing
+                    }
+                }
+                break;
+            }
+            case "Unity Gain Buffer": {
+                if (posChannel === "GSEL") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Positive Channel in this configuration",
+                    });
+                }
+                break;
+            }
+            case "Non-Inverting Programmable Gain Amplifier": {
+                if (posChannel === "GSEL" || posChannel === "Vss") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Positive Channel in this configuration",
+                    });
+                }
+                if (negChannel !== "GSEL") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Negative Channel in this configuration",
+                    });
+                }
+                if (negSrc !== "Vss") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Negative Source in this configuration",
+                    });
+                }
+                if (feedbackMode !== module + "OUT") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Feedback Mode Selection in this configuration",
+                    });
+                }
+                break;
+            }
+            case "Inverting Programmable Gain Amplifier": {
+                if (posChannel === "GSEL" || posChannel === "Vss") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Positive Channel in this configuration",
+                    });
+                }
+                if (negChannel !== "GSEL") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Negative Channel in this configuration",
+                    });
+                }
+                if (feedbackMode !== module + "OUT") {
+                    alerts.push({
+                        type: Processor.AlertTypes.Warning,
+                        text: "Invalid selection for Feedback Mode Selection in this configuration",
+                    });
+                }
+                break;
+            }
+        }
+
+        if (posChannel?.indexOf("DAC") !== -1) {
+            const regexpNumber = /\d/;
+            const inst = posChannel?.match(regexpNumber);
+            if (!this.dataModel.getAssignedImport("DAC")) {
+                alerts.push({
+                    type: Processor.AlertTypes.Warning,
+                    text:
+                        this.dataModel.getName() +
+                        " uses DAC" +
+                        inst +
+                        " as Positive Channel. Ensure DAC" +
+                        inst +
+                        " has been configured.",
+                });
+            }
+        }
+        if (negChannel?.indexOf("DAC") !== -1) {
+            const regexpNumber = /\d/;
+            const inst = negChannel?.match(regexpNumber);
+            if (!this.dataModel.getAssignedImport("DAC")) {
+                alerts.push({
+                    type: Processor.AlertTypes.Warning,
+                    text:
+                        this.dataModel.getName() +
+                        " uses DAC" +
+                        inst +
+                        " as Negative Channel. Ensure DAC" +
+                        inst +
+                        " has been configured.",
+                });
+            }
+        }
+
+        const hwOverrideSrc = this.dataModel.getComponentValue("orsOpaors") ?? "LFINTOSC";
+        const moduleIgnoreList = [
+            "OPAxORPPS",
+            "LFINTOSC",
+            "SOSC",
+            "Logic low",
+            "Logic high",
+        ];
+
+        if (moduleIgnoreList.indexOf(hwOverrideSrc) != -1) {
+            //do nothing
+        } else {
+            alerts.push({
+                type: Processor.AlertTypes.Hint,
+                text: "Ensure that the module selected as Hardware Override Source is configured.",
+            });
+        }
+
+        return alerts;
+    };
+
+    private getMyTemplateData = (): MyTemplateData<opa.API> => {
+        if (this.myTemplateData == undefined) {
+            this.myTemplateData = getGeneratorModel(
+                this.getModel(),
+                this.getPositiveSources(),
+                this.getNegativeSources(),
+                this.getHeaderFiles(),
+            );
+        }
+        return this.myTemplateData;
+    };
+
+    private getHeaderFiles = (): InterfaceTypes.HeaderFile[] => {
+        return [
+            {
+                name: this.getModuleName().toLowerCase() + ".h",
+                path: "../",
+            },
+        ];
+    };
+
+    private getPinstandardArgs = (): intf_args => ({
+        queryAdapterMap: {
+            [QueryAdapterKey.ALLPINS]: "^OPA[0-9]$",
+        },
+    });
+
+    private initializer_system_results = (): initializer_system.Results => {
+        return {
+            initializer: {
+                name: this.getModuleName() + "_Initialize",
+                header: {
+                    name: this.getModuleName().toLowerCase() + ".h",
+                    path: "opa/",
+                },
+            },
+        };
+    };
+
+    private getPositiveSources = (): sourceSelect[] => {
+        const posSource = this.dataModel.getHardware()?.getPeripheral().registers.OPACON3
+            .settings.PSS.options;
+
+        let pinAttribs = this.dataModel.getComponentValue("cnameAttribforPosPins") ?? "";
+        if (typeof pinAttribs === "string") pinAttribs = JSON.parse(pinAttribs);
+
+        const pinPayload = this.dataModel.getImportValue("pin_standard");
+        const allPins = pinPayload?.[QueryAdapterKey.ALLPINS] ?? {};
+        const allPinsData = getInputPinsData(allPins, this.getModuleName());
+
+        const posSourceList = (posSource ?? []).map((o: Option) => ({
+            customName:
+                pinAttribs[allPinsData[o.alias]?.pinName]?.cname ??
+                allPinsData[o.alias]?.customName,
+            source: o.alias ?? "",
+        }));
+        return posSourceList;
+    };
+
+    private getNegativeSources = (): sourceSelect[] => {
+        const negSource = this.dataModel.getHardware()?.getPeripheral().registers.OPACON1
+            .settings.NSS.options;
+
+        let pinAttribs = this.dataModel.getComponentValue("cnameAttribforNegPins") ?? "";
+        if (typeof pinAttribs === "string") pinAttribs = JSON.parse(pinAttribs);
+
+        const pinPayload = this.dataModel.getImportValue("pin_standard");
+        const allPins = pinPayload?.[QueryAdapterKey.ALLPINS] ?? {};
+        const allPinsData = getInputPinsData(allPins, this.getModuleName());
+
+        const negSourceList = (negSource ?? []).map((o: Option) => ({
+            customName:
+                pinAttribs[allPinsData[o.alias]?.pinName]?.cname ??
+                allPinsData[o.alias]?.customName ??
+                "Vss",
+            source: o.alias ?? "",
+        }));
+        return negSourceList;
+    };
+}
+
+export type sourceSelect = {
+    customName: string;
+    source: string;
+};

package/src/GeneratorModel.ts

@@ -0,0 +1,80 @@
+import { AppModel } from "../generated_module/src/types/AutoModuleTypes";
+import * as InterfaceTypes from "@microchip/scf-interface";
+import { getOptionByAlias } from "@microchip/scf-device/lib/Setting";
+
+export type MyTemplateData<API extends InterfaceTypes.CFunctions> = {
+    header: InterfaceTypes.HeaderFile;
+    moduleNameUpperCase: string;
+    moduleNameLowerCase: string;
+    componentName: string | undefined;
+    compiler: string;
+    tool: string;
+    [key: string]: any;
+};
+
+export const getGeneratorModel = <API extends InterfaceTypes.CFunctions>(
+    model: AppModel,
+    posSourceModel: sourceSelect[],
+    negSourceModel1: sourceSelect[],
+    header: InterfaceTypes.HeaderFile[],
+): MyTemplateData<API> => {
+    const customName_1 = model.getComponentValue("customName");
+    const moduleName = model.getName();
+    const registers = model.getRegisterValues();
+
+    return {
+        moduleNameLowerCase: moduleName.toLowerCase(),
+        moduleNameUpperCase: moduleName.toUpperCase(),
+        componentName: customName_1,
+        moduleInstance: moduleName,
+        posSources: convertToTemplatePosSrc(model, posSourceModel),
+        negSources: convertToTemplateNegSrc(model, negSourceModel1),
+
+        header: header?.[0],
+        compiler: "XC8 v2.32",
+        tool: "MPLAB X v5.50",
+        ...registers,
+    };
+};
+
+export type sourceTemplate = {
+    name: string;
+    value: string;
+};
+
+export type sourceSelect = {
+    customName: string;
+    source: string;
+};
+
+const convertToTemplatePosSrc = (
+    model: AppModel,
+    source: sourceSelect[],
+): sourceTemplate[] => {
+    const pss = model.getHardware()?.getPeripheral().registers.OPACON3.settings.PSS;
+    if (pss == undefined) {
+        return [];
+    } else {
+        return source.map((sourceData) => ({
+            name: sourceData.customName + "_pos",
+            value: getOptionByAlias(sourceData.source, pss)?.value ?? "",
+        }));
+    }
+};
+
+const convertToTemplateNegSrc = (
+    model: AppModel,
+    source: sourceSelect[],
+): sourceTemplate[] => {
+    const nss = model.getHardware()?.getPeripheral().registers.OPACON1.settings.NSS;
+    if (nss == undefined) {
+        return [];
+    } else {
+        return source.map((sourceData) => ({
+            name: sourceData.customName.match(/Vss/)
+                ? sourceData.customName
+                : sourceData.customName + "_neg",
+            value: getOptionByAlias(sourceData.source, nss)?.value ?? "",
+        }));
+    }
+};

package/src/ImageDataURLs.ts

@@ -0,0 +1,8 @@
+export const DIRECT_CONN =
+    "data:image/png;base64,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";
+export const UNITY_GAIN =
+    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAATAAAABeBAMAAABWXFVeAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAqUExURf///z09PQICAqqqqtTU1CUlJVlZWefn5xISEomJiZubm729vfb29nV1dR8w18cAAASySURBVGje7dnvSxtnAAfwb5ZLziQXSKpxlbYv4qxaQiFdqHPK4LShMjbBNkSs7sVFR9yUA+mcrmO+sFWJq4VoyzCuL651dk4txLSuP8IgnYjaTVDnHGP6v+y5xGgyY7W1xmflvkSRPLnkk+f3PQJKlChRokSJEiV0hXW2z0ZohKly5fh8brfZbM72ekVx/e/A0NiwozT80FlR0f7NocFWnM5w2OEYGwsE1tdFr9dLgBZ3je9qbjybajGtMP+ORVx7a2ui2muhBBZNYv8boQkGBabAFJgCe4NgxbTCRpUa+5/AuAZKYWxuFqUwW30jnbA85sganTCoa/x0wjDfbacThg4rTycM5/Nb6IRh6nSEThjOfkspjBusoxMGtj6LAtgfDjnD5KckD62t0f7FHGk8fJgvmkL5l40zm6Xos4aatcOGJWSzKUn03RKdMCxYg9te8JgGGNryty0B71IBQ9m2iTZEBwxneyN0wjDqorIpyRPLx+isMTDJe+1k2EjhGizuHBiPA2oBCxcvQcOjaMbtrj5wGAxJe+0kmLGO9aDWOWWfywTuCvDwZcJbPO4w57oqDh6WvNfehFWS2fcyjxm7C0bhzBnoTwiGPrBdMgyGKqQBlrTXjsO4tadkzJJKE1x45s+c4zm9oDMBn6cThrZCN0m3OzETRhABdILb0jnbp12EXjAKgJhOGLd8YozkpiMhJf6F6PqkXbzkjBhP1vQhVmM5GTy+SxOMG61N8crAX8CcHV8FyUSnea+9lsDIxUyBxg4xTbCp3lQ3AKw8YHsfVIPApoB+AsPg+KhfV/ukKz2wsp1vmVCZbccKMEa6YYvBD4OnGSjK5sEsHjys7QU3mYc58893Bl/93b5wlG7W9kPS8glf0RAI4qPtV0xH9gjT+6R9fM2Q+eip+N+iQVBtvRd71NsZ6d9+RfkeYan3/XuHRTAQr7Lf9SZu61NVx/Hl4qvDmF0Oy/YAK+c7soPcUhNulvUYwwLO416OXNICtdR/JxPznka22eNXD2UHUZQTicF+41PCIltbnizsF3Z3tueJTdtcbBc76lQ/5mHV6JokQ/ZPuXigYZn3hC2staRX1/NBge7apBCD/fN9KhgjxCfWQdc+h1LI6zmlq8KSao3hRb1JJYnc9V+DTAGwJBcPIsN+CyHWBq+uD9cy7GxeFMZI2hLH8NZjiCw7P+Xh6bGW+LZ6v2M8FBjitQKKDb4GEJhGeqyuKjebbRs11g+N9NxzlS3AKlnNXJfN5nc2YCpzYi7I/6K3cavVsb3E5I4nPi/TlJBhmP5sMVpjGT/7y0vDj2J9zCTDLLdCm7Dx8KNYU66kbkoTdjkjeymY/hN4tEFdlaiv0kjG+pY5O/M2MCOQB4GRXjcwuwHLkNisGGw6ZefnojNqhzWI1wLjLty/bqwd8YuG088kxgpd7wjpxEz3upvMY5qJnvcvtm/A1DdGTLtOF89fdA6753wYXTtEHvcaUIr7X/MYB35pkj/8ijiBc9DzlU3zH9/GA8aOH+SSK7vA1DW3QVdisF3O+g8NxtZ/Chph3H/ucamBpdxJUwCbuhGhElb2GibWg4BZ83lQCTsZBJ3hoUSJEiVKlLxp+RcOfYAxQu3JIwAAAABJRU5ErkJggg==";
+export const NON_INV_PGA =
+    "data:image/png;base64,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";
+export const INV_PGA =
+    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXsAAABqBAMAAACv7eyyAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAqUExURf///woKCkhISF1dXTMzM8TExJmZmYaGhh0dHa2trXJycvT09NfX1+fn57FfLu4AAAhxSURBVHja7Zr9TxN5HsfftJ2285SIlocCJkNdXRY1KaCroiRTRRddTaZK18dL6p3U4nlJZRU8vR9aZdmqRzJezpW6XjKsu+IBPwzr3fq0m4wP7K2nmxRZblm9P+a+U54KlMoJnJ1c3ynJMO1MX31/v9/Pw7cFssoqq6yyyiqrrLLKKqsM1WcBjWs0Lv6Fz/740zXFsPhhNPezomHx247thC1k3MkT1PCxced+mBYZxcD4WNfR4jcsvox/fRSQswkkq/8/8YBqYPwDYAWYDIt/EvQiDEhGxXfFmeU4ZtTExb4vm66ixgg129GWCZ3pamkONMZk+rgyeBtCrwHwHa4kvVNbF43k5jGa0GiiFG9ubm40WjuhbRlYXKaIOyasrGH+IVG+WCwQSBqc84bAtzzGKYH+9fTI/0Hm4Tunn2I2YHeIXwYj4KdwnypGn4Q2GNR9uPWMu8mo7o9INaz7M8lI7iPrftb9eXR/x1tm/bNrOczxN3b/beMfxRO+LG5Y9wk+98i47gfrlsM0s/uva8/L37b71IdT8ZPcZ9oyHR830rhvjmzNdPy/STNHHnNN56qMxk8f981urrTGYPjJ7rtBec4a2H3AGvVnLj77OveBOw5pXvCDGixy8gnZNPEvV+pI5dKD8aNXKWO4Se+kbPE07gODi7X5wD8swp6MbxWtE77cXft9foprNi2FTUmQbHenuqdXZUtg8adzH9i9JD4P+KcLkCOjPw7+V9+BP6Te2ck/iONbUAd1DuALchJ8HM/4v2vkCENxUEoXLAnv7OrvU92zSaJXYFBI6z5QX6DOHf/IZc0uvziXj8t1ZWxZWfs+h6WhGEe41joyCA/1AHGibjXjRp69QuwsczOLL8Is1WO3rWJ/7cZO4RF5Ad89ZR4vDzF70Lg6vftggxfmjn/SJNrlStX7o5Otoy+xbVbR4m/DNotiDZOZlPuuRuWxWxL4Hw6V8M5gfFi2qxbtJrNyOH7TTvwnVYDaFWg+qj9isSs+30HWLZhMqAm8xn2wnVvn7j5fYJcv+vY1hhEE+/2nOn4Tt/Thlf0l5Nl76/MZAR0JfD85Uit9u919sJ29xIT2VW2xJyYRg2BUV2s0kktUQPtXPjZrwoC+cTm2rZkbHVdEpFpaEu/NV2yas/u4/IPscLkCYXSwpTsS+AMvBa+LtBx4DnTedsObwJd12+pcLsUOfrti89c/f07cj+vuK8lh6QWjnWq0NiiUvnHZ3V3drWt097WV/HkELjA6MpSnZ67uw+SR20ANFeM0swsJfFNQfqiBrN0vyfT/WUCQEXiCbxPQUAVOI8hrJMZ/9y8rCL4+CSbPfdML7K3h180Y181J0YqO+OfqPh+Rb8W90pahqFmgi+h2i5+OwrLRVkzYe799h3LyO6zt9wk+l8flXZaGQ4yMA6AlrjLEYM/0O1q78bUAF2aDj28K5Tm6j8vy7cJ8PHJ8yUXPV3KRn/xsEUlYUWIf7cldjY7IRra06BOSHQ5HQrbCIvBJITHF5GWdsIRQNTt8vJyevv77ouE7sDKawKvjGZ9NJBX+mZ5aoQd+jB6Rl/xh/DpeSXGzlWAkBGaJj8fT0teb1DxswdM2zI9U3YIHs8VHfZE6DyXb7lb//6agm4qPjim+LUMmaxo+e2J7GvxfroP3HVJBkTHiVPCxOP4NPBvqP3QwM/BJ+prUPU5a9dbF6zfSjtp8eMkyI+G8c1mB/gusvJOe1p0Zgo/J3eMk9/dp7A5aJMXjukuwRjTrLgz7dfwpFe1bxZ/cPY65z3cTwndJ3XtPxMCrpStg/oGUl6SkJ/ifwJRB+Pgmeqr/kK/fp8vlG9EB9WyiVM15utW3xiqQDGXX+jRwizLOfWJx7jQ51OsJ/L6njtoayymvloRfklnup+odbVrP+OTBQ1eZm+AnJk+Tjp9J7qfs3Nkz5KR3ZOnihv5Fqn1k6e5T6UWZ5H6afRPrEhI4RX2too3g41YVaffOl8oZ5H7aXatfjoOXwEp690FSFxcgJdJHvyMXxTMEn6uogXE0FZ9/zY7tG4uKXRmPB/fI+yR1FuzVz0FPHz5Km9hiU2eHzx7evkA+WQqjjjEIL9bS4aTdrS0eKWd6tDArGPwNsEt/5Vezw+9oW6hhJk3TsDK+b+lM8pN2gilOjb9pWKUFfVxezAp/WrU/r/ik/a0MYU95fNC2+LryFWzSy3LCZnGD7c25Vq5yX2xAY9Mm9Faexf1yzazwolk2y2J3rWTSP90ZLRU+pU70WhoWEP+ucrpxM5f/J9FLFT0N38DAjxevtZM8ri+DnE+DysNTJ6SKv5ahsPkie/5qiVmxKrRwF+FqWrCFSNTWelLhm8aY76fZaJ47/paq6CsnBva3s7IXF+iwV21iBL2ZS/x2NCdkFfeSz7iG1OH5OGkTUWVWCPSlYwhv4ETare9gHUn+DZ5L3+upE+n11epoupIXMMRZdnR9zi2F5beeD+JeOOmwxb/NdM51bsx9mQ5zH3tCVejT8nDEfM7VmsC/uSqBbyXLxqZ2BZLV1dLSclLg6xtGd3nOLmSEJpMHOr6futWecN+2qti01ucjzxC093IkMh7vPwlVj+Iv9/nMCvH8iZjAt/lHS/aZJg9V2oOFxkc+mTwKnAl8fombEdFMRr2EPHT8KrI6RvFtYbSYFVYEI8PdwCsmbcbIw6ZoERcI/0TzZq7oGnF/cyyMUok/fy2PnC3tqvDr+KdjZWP47LmreSRwjof7x+kDJ3ti6wKn98T3LFSVH/+s1l7iwPEQ9gI/V+uu0pUkiGpcyFbt88fAxHvJU3eqJauM22NX96bHD7bBkBrBn/G7FUPgP1oSh3Hx03yvaAD8Ow4ZxsWno34YF3+tpwcGxs+tMTA9bKuQVVZZZZXVW9J/AIvebuUe8PLBAAAAAElFTkSuQmCC";