let Common   = system.getScript("/driverlib/Common.js");
let Pinmux   = system.getScript("/driverlib/pinmux.js");

let PGASignals = system.getScript("/driverlib/pga/pga_inputSignals.js")

let device_driverlib_peripheral =
    system.getScript("/driverlib/device_driverlib_peripherals/" +
        Common.getDeviceName().toLowerCase() + "_pga.js");

//For ADC sample+hold requirements
let device_pga_char =
    system.getScript("/driverlib/pga/pga_char.js");

var device_pga_SH = device_pga_char.SH[Common.getDeviceName()]
 
let device_driverlib_memmap =
    system.getScript("/driverlib/device_driverlib_peripherals/" +
        Common.getDeviceName().toLowerCase() + "_memmap.js");

var PGA_INSTANCE = [];
for (var pga of device_driverlib_memmap.PGAMemoryMap) {
    PGA_INSTANCE.push({
        name : pga.name,
        displayName : pga.displayName
    })
}

var numberOfInstance = {
    "F28004x"   : 7,
    "F28P55x"   : 3
}
var deviceNumberOfInstances = numberOfInstance[Common.getDeviceName()];
 
/* Intro splash on GUI */
let longDescription = "";

let internalGainResistorValue = [
    { name: "internalGainResistor16k", displayName: "FILTER_INTERNAL_GAIN_RESISTOR_16K_OHM" },
    { name: "internalGainResistor24k", displayName: "FILTER_INTERNAL_GAIN_RESISTOR_24K_OHM" },
    { name: "internalGainResistor56k", displayName: "FILTER_INTERNAL_GAIN_RESISTOR_56K_OHM" },
    { name: "internalGainResistor120k", displayName: "FILTER_INTERNAL_GAIN_RESISTOR_120K_OHM" },
    { name: "internalGainResistor248k", displayName: "FILTER_INTERNAL_GAIN_RESISTOR_248K_OHM" },
    { name: "internalGainResistor252k", displayName: "FILTER_INTERNAL_GAIN_RESISTOR_252K_OHM" },
]

if (["F28004x"].includes(Common.getDeviceName()))
{
var longDescriptionSignalConditionCalculator = `
An approximation of the new PGA input voltage range generated by applying a DC offset voltage and voltage divider to the signal source. This is given by the equation:

![an offline image](../../driverlib/.meta/pga/docs/offset_equation.png)

Block diagram/Pins:

![an offline image](../../driverlib/.meta/pga/docs/offset_diagram.png)

Where the following parameters are dependent on the application design:
*   SIGNAL = Input signal voltage (specify minimum/maximum of possible voltage range)
*	R1 = Resistance connected in series with SIGNAL; parallel to R2
*   R2 = Resistance connected in series with V_DCSOURCE; parallel to R1
*   V_DCSOURCE = DC Source output voltage
*   PGA_IN = Input applied to PGA (with new minimum/maximum voltage range)
`

var longDescriptionCutoffFreqCalculator = `
An approximation of the cutoff frequency resulting from the low-pass RC filter applied on the PGA output signal. This is given by the equation:

![an offline image](../../driverlib/.meta/pga/docs/cutoff_freq_equation.png)

Block diagram/Pins:

![an offline image](../../driverlib/.meta/pga/docs/cutoff_freq_diagram.png)

Where the following parameters are dependent on the application design:
*	Rfilter = Filter resistance configured internally by the PGA (in Ohms)
*	Cfilter = Filter capacitance applied externally to PGA_OF (in pF)
`
}
if (["F28P55x"].includes(Common.getDeviceName()))
{
var longDescriptionSignalConditionCalculator = `
An approximation of the new PGA input voltage range generated by applying a DC offset voltage and voltage divider to the signal source. This is given by the equation:
    
![an offline image](../../driverlib/.meta/pga/docs/offset_equation.png)

Block diagram/Pins:

Where the following parameters are dependent on the application design:
*   SIGNAL = Input signal voltage (specify minimum/maximum of possible voltage range)
*	Rea = Resistance connected in series with SIGNAL; parallel to Reb
*   Reb = Resistance connected in series with V_DCSOURCE; parallel to Rea
*   Ria = 
*   Rib = 
*   V_DCSOURCE = DC Source output voltage
*   PGA_IN = Input applied to PGA (with new minimum/maximum voltage range)
`
}

function onChangeEnableFilter(inst, ui)
{
    if (inst.enableFilter == true){
        ui.filterMode.hidden = false
        if (["F28004x"].includes(Common.getDeviceName()))
        {
            ui.PGA_OFPinInfo.hidden = false
        }
        ui.useCutoffFreqCalculator.hidden = false
    }
    else {
        ui.filterMode.hidden = true
        if (["F28004x"].includes(Common.getDeviceName()))
        {
            ui.PGA_OFPinInfo.hidden = true
        }
        ui.useCutoffFreqCalculator.hidden = true
        ui.filterResistance.hidden = true
        ui.filterCapacitance.hidden = true
        ui.calculatedCutoffFreq.hidden = true
    }   
}
function onChangeSelectMode(inst, ui)
{
    if(inst.modeSelection == "BufferMode"){
        ui.gainMode.hidden = true;
        ui.enableNEGShared.hidden = true;
    }
    else if (inst.modeSelection == "StandaloneMode")
    {
        ui.gainMode.hidden = true;
        ui.enableNEGShared.hidden = true;

    }
    else if (inst.modeSelection == "Non-invertingMode")
    {
        ui.gainMode.hidden = false;
        ui.enableNEGShared.hidden = true;

    }
    else if (inst.modeSelection == "SubtractorMode")
    {
        ui.gainMode.hidden = false;
        ui.enableNEGShared.hidden = false;
    }
}

function onChangeChopper(inst, ui)
{
    if(inst.enableChopper == true){
        ui.enableChopperMode.hidden = false;
    }
    else{
        ui.enableChopperMode.hidden = true;
    }
}

function onChangeFilterMode(inst, ui)
{

    if (["F28P55x"].includes(Common.getDeviceName()))
    {
        if(inst.enableFilterMode == true){
            ui.modeSelection.hidden = true;
            //ui.gainMode.hidden = true;
            ui.lockedRegisters.hidden = true;
            ui.useSignalConditionCalculator.hidden = true;
            ui.inputSignalMinVoltage.hidden = true;
            ui.inputSignalMaxVoltage.hidden = true;
            ui.signalConditionDCSourceVoltage.hidden = true;
            ui.signalConditionRea.hidden = true;
            ui.signalConditionReb.hidden = true;
            ui.signalConditionVDDA.hidden = true;
            ui.signalConditionVSSA.hidden = true;
            ui.calculatedInputSignalConditionMin.hidden = true;
            ui.calculatedInputSignalConditionMax.hidden = true;
            ui.calculatedOutputSignalConditionMin.hidden = true;
            ui.calculatedOutputSignalConditionMax.hidden = true;
            ui.enableFilter.hidden = true;
            ui.filterMode.hidden = true;
            ui.useCutoffFreqCalculator.hidden = true;
            ui.filterResistance.hidden = true;
            ui.calculatedCutoffFreq.hidden = true;
            ui.filterCapacitance.hidden = true;
            ui.enableChopper.hidden = true;
            ui.enableChopperMode.hidden = true;
            ui.internalGainResistor.hidden = false;
            ui.cutoffFreqCalculator.hidden = false;
            ui.selectResistance.hidden = false;
            ui.selectCapacitance.hidden = false;
            ui.calculatedFreq.hidden = false;
        }
        else{
            ui.modeSelection.hidden = false;
            //ui.gainMode.hidden = false;
            ui.lockedRegisters.hidden = false;
            ui.useSignalConditionCalculator.hidden = false;
            ui.inputSignalMinVoltage.hidden = false;
            ui.inputSignalMaxVoltage.hidden = false;
            ui.signalConditionDCSourceVoltage.hidden = false;
            ui.signalConditionRea.hidden = false;
            ui.signalConditionReb.hidden = false;
            ui.signalConditionVDDA.hidden = false;
            ui.signalConditionVSSA.hidden = false;
            ui.calculatedInputSignalConditionMin.hidden = false;
            ui.calculatedInputSignalConditionMax.hidden = false;
            ui.calculatedOutputSignalConditionMin.hidden = false;
            ui.calculatedOutputSignalConditionMax.hidden = false;
            ui.enableFilter.hidden = false;
            ui.filterMode.hidden = false;
            ui.useCutoffFreqCalculator.hidden = false;
            ui.filterResistance.hidden = false;
            ui.calculatedCutoffFreq.hidden = false;
            ui.filterCapacitance.hidden = false;
            ui.enableChopper.hidden = false;
            ui.enableChopperMode.hidden = false;
            ui.internalGainResistor.hidden = true;
            ui.cutoffFreqCalculator.hidden = true;
            ui.selectResistance.hidden = true;
            ui.selectCapacitance.hidden = true;
            ui.calculatedFreq.hidden = true;
        }
    }
}

function onChangeUseSignalConditionCalculator(inst, ui)
{
    if (inst.useSignalConditionCalculator == true){
        ui.inputSignalMinVoltage.hidden = false
        ui.inputSignalMaxVoltage.hidden = false
        ui.signalConditionDCSourceVoltage.hidden = false
        if (["F28004x"].includes(Common.getDeviceName()))
        {
        ui.signalConditionR1.hidden = false
        ui.signalConditionR2.hidden = false
        }
        if (["F28P55x"].includes(Common.getDeviceName()))
        {
        ui.signalConditionRea.hidden = false
        ui.signalConditionReb.hidden = false
        }
        ui.signalConditionVDDA.hidden = false
        ui.signalConditionVSSA.hidden = false
        ui.calculatedInputSignalConditionMin.hidden = false
        ui.calculatedInputSignalConditionMax.hidden = false
        ui.calculatedOutputSignalConditionMin.hidden = false
        ui.calculatedOutputSignalConditionMax.hidden = false
    }
    else {
        ui.inputSignalMinVoltage.hidden = true
        ui.inputSignalMaxVoltage.hidden = true
        ui.signalConditionDCSourceVoltage.hidden = true
        if (["F28004x"].includes(Common.getDeviceName()))
        {
        ui.signalConditionR1.hidden = true
        ui.signalConditionR2.hidden = true
        }
        if (["F28P55x"].includes(Common.getDeviceName()))
        {
        ui.signalConditionRea.hidden = true
        ui.signalConditionReb.hidden = true
        }
        ui.signalConditionVDDA.hidden = true
        ui.signalConditionVSSA.hidden = true
        ui.calculatedInputSignalConditionMin.hidden = true
        ui.calculatedInputSignalConditionMax.hidden = true
        ui.calculatedOutputSignalConditionMin.hidden = true
        ui.calculatedOutputSignalConditionMax.hidden = true
    }
}

function onChangeUseCutoffFreqCalculator(inst, ui)
{
    //make rest of calculator visible
    if (inst.useCutoffFreqCalculator == true){
        ui.filterResistance.hidden = false
        ui.filterCapacitance.hidden = false
        ui.filterResistance.hidden = false
        ui.calculatedCutoffFreq.hidden = false
    }
    else {
        ui.filterResistance.hidden = true
        ui.filterCapacitance.hidden = true
        ui.filterResistance.hidden = true
        ui.calculatedCutoffFreq.hidden = true
    }
}

function onChangeFreqCalculator(inst, ui)
{
    if (["F28P55x"].includes(Common.getDeviceName()))
    {
        if (inst.cutoffFreqCalculator == true){
            ui.internalGainResistor.hidden = false;
            ui.selectResistance.hidden = false
            ui.selectCapacitance.hidden = false
            ui.calculatedFreq.hidden = false
        }
        else {
            ui.internalGainResistor.hidden = false;
            ui.selectResistance.hidden = true
            ui.selectCapacitance.hidden = true
            ui.calculatedFreq.hidden = true
        }
    }
}

function calculateGainModeNumeric(gainMode) {
    if (["F28004x"].includes(Common.getDeviceName()))
    {
        if (gainMode == "PGA_GAIN_3") {
            var tempgainNumber = 3
        }
        if (gainMode == "PGA_GAIN_6") {
            var tempgainNumber = 6
        }
        if (gainMode == "PGA_GAIN_12") {
            var tempgainNumber = 12
        }
        if (gainMode == "PGA_GAIN_24") {
            var tempgainNumber = 24
        }
    }
    else if (["F28P55x"].includes(Common.getDeviceName()))
    {
        if (gainMode == "PGA_GAIN_1") {
            var tempgainNumber = 1
        }
        if (gainMode == "PGA_GAIN_2") {
            var tempgainNumber = 2
        }
        if (gainMode == "PGA_GAIN_4") {
            var tempgainNumber = 4
        }
        if (gainMode == "PGA_GAIN_8") {
            var tempgainNumber = 8
        }
        if (gainMode == "PGA_GAIN_16") {
            var tempgainNumber = 16
        }
        if (gainMode == "PGA_GAIN_32") {
            var tempgainNumber = 32
        }
        if (gainMode == "PGA_GAIN_64") {
            var tempgainNumber = 64
        }
    }
    return tempgainNumber
}

function calculateFilterModeNumeric(inst, ui)
{
    if (["F28004x"].includes(Common.getDeviceName()))
        {
            //map enums to numeric resistance values
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_200_OHM") {
                var tempfilterNumber = 200
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_160_OHM") {
                var tempfilterNumber = 160
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_130_OHM") {
                var tempfilterNumber = 130
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_100_OHM") {
                var tempfilterNumber = 100
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_80_OHM") {
                var tempfilterNumber = 80
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_50_OHM") {
                var tempfilterNumber = 50
            }
        }
        else if (["F28P55x"].includes(Common.getDeviceName()))
        {
            //map enums to numeric resistance values
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_800_OHM") {
                var tempfilterNumber = 800
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_400_OHM") {
                var tempfilterNumber = 400
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_200_OHM") {
                var tempfilterNumber = 200
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_100_OHM") {
                var tempfilterNumber = 100
            }
            if (inst.filterMode == "PGA_LOW_PASS_FILTER_RESISTOR_50_OHM") {
                var tempfilterNumber = 50
            }
        }
        return tempfilterNumber
}

function calculateFilterResistorNumeric(inst, ui)
{
        // //map enums to numeric resistance values
        if (inst.internalGainResistor == "internalGainResistor16k") {
            var tempResistorNumber = 16
        }
        if (inst.internalGainResistor == "internalGainResistor24k") {
            var tempResistorNumber = 24
        }
        if (inst.internalGainResistor == "internalGainResistor56k") {
            var tempResistorNumber = 56
        }
        if (inst.internalGainResistor == "internalGainResistor120k") {
            var tempResistorNumber = 120
        }
        if (inst.internalGainResistor == "internalGainResistor248k") {
            var tempResistorNumber = 248
        }
        if (inst.internalGainResistor == "internalGainResistor252k") {
            var tempResistorNumber = 252
        }
        return tempResistorNumber
}

function calculateInputSignalConditionMin(inst, ui)
{
    var signalMin = inst.inputSignalMinVoltage;
    var DCsource = inst.signalConditionDCSourceVoltage;
    if(["F28004x"].includes(Common.getDeviceName()))
    {    
        var R1 = inst.signalConditionR1;
        var R2 = inst.signalConditionR2;
        var unrounded = (R2*(signalMin-DCsource))/(R1+R2)+DCsource
    }
    else if(["F28P55x"].includes(Common.getDeviceName()))
    {
        var Rea = inst.signalConditionRea;
        var Reb = inst.signalConditionReb;
        var unrounded = ((Reb*signalMin)+(Rea*DCsource))/(Rea+Reb);
        //var unrounded = (((Rib+Ria)/Ria)*((Reb*signalMin)+(Rea*DCsource))/(Rea+Reb));
    }
    return Math.round(unrounded * 1000) / 1000

}

function calculateInputSignalConditionMax(inst, ui)
{
    var signalMax = inst.inputSignalMaxVoltage;
    var DCsource = inst.signalConditionDCSourceVoltage;
    if(["F28004x"].includes(Common.getDeviceName()))
    { 
        var R1 = inst.signalConditionR1;
        var R2 = inst.signalConditionR2;
        var unrounded = (R2*(signalMax-DCsource))/(R1+R2)+DCsource
    }
    else if(["F28P55x"].includes(Common.getDeviceName()))
    {
        var Rea = inst.signalConditionRea;
        var Reb = inst.signalConditionReb;
        var unrounded = ((Reb*signalMax)+(Rea*DCsource))/(Rea+Reb);
        //var unrounded = (((Rib+Ria)/Ria)*((Reb*signalMax)+(Rea*DCsource))/(Rea+Reb));
    }
    return Math.round(unrounded * 1000) / 1000
}

function calculateOutputSignalConditionMin(inst, ui)
{
    var unrounded = inst.calculatedInputSignalConditionMin * calculateGainModeNumeric(inst.gainMode)
    return Math.round(unrounded * 1000) / 1000
}

function calculateOutputSignalConditionMax(inst, ui)
{
    var unrounded = inst.calculatedInputSignalConditionMax * calculateGainModeNumeric(inst.gainMode)
    return Math.round(unrounded * 1000) / 1000
}

function calculateCutoffFreq(inst, ui)
{
    var Rfilt = inst.filterResistance; //Ohms
    var Cfilt = inst.filterCapacitance; //pF (10^-12)
    var unrounded = 1/(2*Math.PI*Rfilt*Cfilt) * Math.pow(10, 6) //convert THz to MHz (10^12 to 10^6)
    return Math.round(unrounded * 1000) / 1000
}

function calculateFilterFreq(inst, ui)
{
    if(["F28P55x"].includes(Common.getDeviceName()))
    {
        var Rfilt = inst.selectResistance; //Ohms
        var Cfilt = inst.selectCapacitance; //pF (10^-12)
        var unrounded = 1/(2*Math.PI*Rfilt*Cfilt) * Math.pow(10, 6) //convert THz to MHz (10^12 to 10^6)
        return Math.round(unrounded * 1000) / 1000
    }
}

function calculateDevicePinNameOF(inst, ui)
{
    var tempPinName = inst.pgaBase.substr(0, inst.pgaBase.indexOf('_')) + "_OF"
    var tempPinInfo = Pinmux.findAllAnalogPin(tempPinName);
    var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo) 
    return tempPinInfoDesc
}

function calculateDevicePinNameIN(inst, ui)
{
    if(["F28004x"].includes(Common.getDeviceName()))
    {
        var tempPinName = inst.pgaBase.substr(0, inst.pgaBase.indexOf('_')) + "_IN"
        var tempPinInfo = Pinmux.findAllAnalogPin(tempPinName);
        var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo) 
        return tempPinInfoDesc
    }
    else if(["F28P55x"].includes(Common.getDeviceName()))
    {
        var tempPinName = inst.pgaBase.substr(0, inst.pgaBase.indexOf('_')) + "_INP"
        var tempPinInfo = Pinmux.findAllAnalogPin(tempPinName);
        var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo) 
        return tempPinInfoDesc
    }
}

function calculateDevicePinNameGND(inst, ui)
{
    if(["F28004x"].includes(Common.getDeviceName()))
    {
        var tempPinName = inst.pgaBase.substr(0, inst.pgaBase.indexOf('_')) + "_GND"
        var tempPinInfo = Pinmux.findAllAnalogPin(tempPinName);
        var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo) 
        return tempPinInfoDesc
    }
    else if(["F28P55x"].includes(Common.getDeviceName()))
    {
        var tempPinName = inst.pgaBase.substr(0, inst.pgaBase.indexOf('_')) + "_INM"
        var tempPinInfo = Pinmux.findAllAnalogPin(tempPinName);
        var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo) 
        return tempPinInfoDesc
    }
}

function calculateDevicePinNameOUT(inst, ui)
{
    if(["F28004x"].includes(Common.getDeviceName()))
    {
        var instNum = inst.pgaBase[3]
        var tempPinInfoDesc = PGASignals.PGAInputSignals["PGA_OUT"][instNum-1].displayName
        return tempPinInfoDesc
    }
    else if(["F28P55x"].includes(Common.getDeviceName()))
    {
        var tempPinName = inst.pgaBase.substr(0, inst.pgaBase.indexOf('_')) + "_OUT"
        var tempPinInfo = Pinmux.findAllAnalogPin(tempPinName);
        var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo) 
        return tempPinInfoDesc
    }
}

if(["F28004x"].includes(Common.getDeviceName()))
{
    var PGA_OF_PinInfos = Pinmux.findAllAnalogPin("PGA1_OF");
    var PGA_IN_PinInfos = Pinmux.findAllAnalogPin("PGA1_IN");
    var PGA_GND_PinInfos = Pinmux.findAllAnalogPin("PGA1_GND");
    var PGA_OUT_PinInfos = PGASignals.PGAInputSignals["PGA_OUT"][0].displayName
}
if(["F28P55x"].includes(Common.getDeviceName()))
{
    var PGA_IN_PinInfos = Pinmux.findAllAnalogPin("PGA1_INP");
    var PGA_GND_PinInfos = Pinmux.findAllAnalogPin("PGA1_INM");
    var PGA_OUT_PinInfos = Pinmux.findAllAnalogPin("PGA1_OUT");
}

/* Array of PGA configurables that are common across device families */
let config = [
    {
        name        : "pgaBase",
        displayName : "PGA Instance",
        description : 'Instance of the PGA used.',
        hidden      : false,
        default     : PGA_INSTANCE[0].name,
        options     : PGA_INSTANCE
    },

    {
        name        : "pgaEnable",
        displayName : "PGA Enable",
        description : 'Whether or not to enable this PGA instance.',
        hidden      : false,
        default     : false,
    },
];

if(["F28P55x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
            name    : "enableFilterMode",
            displayName : "Enable Filter Mode",
            description : "Enable PGA in Filter Mode",
            hidden      : false,
            onChange    : onChangeFilterMode,
            default     : false
    }]);

    config = config.concat([{
        name        : "modeSelection",
        displayName : "PGA Mode Selection",
        hidden      : false,
        default     : "Non-invertingMode",
        options: [
            {name:"BufferMode", displayName:"Buffer Mode"},
            {name:"StandaloneMode", displayName:"Standalone Mode"},
            {name:"Non-invertingMode", displayName:"Non-inverting Mode"},
            {name:"SubtractorMode", displayName:"Subtractor Mode"},
        ],
        onChange    : onChangeSelectMode
    }]);

    config = config.concat([{
        name        : "internalGainResistor",
        displayName : "Low-pass filter using the gain resistor",
        description : 'Internal Gain Resistance value for low-pass filtering.',
        hidden      : true,
        default     : "internalGainResistor16k",
        options     : internalGainResistorValue
    }]);
}
if(["F28004x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
            name        : "gainMode",
            displayName : "Gain Value",
            description : 'Gain value applied to input signal.',
            hidden      : false,
            default     : device_driverlib_peripheral.PGA_GainValue[0].name,
            options     : device_driverlib_peripheral.PGA_GainValue
    }]);
}
if(["F28P55x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
            name        : "gainMode",
            displayName : "Gain Value",
            description : 'Gain value applied to input signal.',
            hidden      : false,
            default     : device_driverlib_peripheral.PGA_GainValue[0].name,
            options     : device_driverlib_peripheral.PGA_GainValue
    }]);

    config = config.concat([{
        name        : "GROUP_FreqCalculator",
        displayName : "Cutoff Frequency Calculator",
        config      : [
            {
                name: "cutoffFreqCalculator",
                displayName: "Use Cutoff Frequency Calculator",
                hidden: true,
                default: false,
                onChange: onChangeFreqCalculator,
            },
            {
                name: "selectResistance",
                displayName: "Filtering Resistance (Ω)",
                hidden: true,
                default: 16,
                getValue: calculateFilterResistorNumeric,
            },
            {
                name: "selectCapacitance",
                displayName: "Filtering Capacitance (pF)",
                hidden: true,
                default: 10,
            },
            {
                name: "calculatedFreq",
                displayName: "Cutoff Frequency (MHz)",
                hidden: true,
                default: 0,
                getValue: calculateFilterFreq,
            },
        ]
    }]);

    config = config.concat([{
        name        : "enableNEGShared",
        displayName : "Enable PGA_INM Sharing",
        description : 'Enable PGA_INM pin sharing for all PGA',
        hidden      : true,
        default     : false,
    }]);
}
config = config.concat([{
    name        : "lockedRegisters",
    displayName : "Lock PGA Registers",
    description : 'Select PGA Registers to lock.',
    hidden      : false,
    default     : [],
    minSelections: 0,
    options     : device_driverlib_peripheral.PGA_REGISTER
}]);

if(["F28004x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
        name        : "GROUP_signalConditionCalculator",
        displayName : "Signal Conditioning Calculator",
        longDescription : longDescriptionSignalConditionCalculator,
        config      : [
            {
                name: "useSignalConditionCalculator",
                displayName: "Use Signal Conditioning Calculator",
                hidden: false,
                default: false,
                onChange: onChangeUseSignalConditionCalculator,
            },
            {
                name: "inputSignalMinVoltage",
                displayName: "Input Signal Minimum Voltage (V)",
                hidden: true,
                default: -0.5,
            },
            {
                name: "inputSignalMaxVoltage",
                displayName: "Input Signal Maximum Voltage (V)",
                hidden: true,
                default: 0.5,
            },
            {
                name: "signalConditionDCSourceVoltage",
                displayName: "DC Source Output Voltage (V)",
                hidden: true,
                default: 1.65,
            },
            {
                name: "signalConditionR1",
                displayName: "R1 resistance (Ω)",
                hidden: true,
                default: 10000,
            },
            {
                name: "signalConditionR2",
                displayName: "R2 resistance (Ω)",
                hidden: true,
                default: 20000,
            },
            {
                name: "signalConditionVDDA",
                displayName: "VDDA Voltage (V)",
                hidden: true,
                readOnly: true,
                default: 3.3,
            },
            {
                name: "signalConditionVSSA",
                displayName: "VSSA Voltage (V)",
                hidden: true,
                readOnly: true,
                default: 0,
            },
            {
                name: "calculatedInputSignalConditionMin",
                displayName: "PGA Input Minimum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateInputSignalConditionMin,
            },
            {
                name: "calculatedInputSignalConditionMax",
                displayName: "PGA Input Maximum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateInputSignalConditionMax,
            },
            {
                name: "calculatedOutputSignalConditionMin",
                displayName: "PGA Output Minimum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateOutputSignalConditionMin,
            },
            {
                name: "calculatedOutputSignalConditionMax",
                displayName: "PGA Output Maximum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateOutputSignalConditionMax,
            },
        ]
    }]);
}
else if(["F28P55x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
        name        : "GROUP_signalConditionCalculator",
        displayName : "Signal Conditioning Calculator",
        longDescription : longDescriptionSignalConditionCalculator,
        config      : [
            {
                name: "useSignalConditionCalculator",
                displayName: "Use Signal Conditioning Calculator",
                hidden: false,
                default: false,
                onChange: onChangeUseSignalConditionCalculator,
            },
            {
                name: "inputSignalMinVoltage",
                displayName: "Input Signal Minimum Voltage (V)",
                hidden: true,
                default: -0.5,
            },
            {
                name: "inputSignalMaxVoltage",
                displayName: "Input Signal Maximum Voltage (V)",
                hidden: true,
                default: 0.5,
            },
            {
                name: "signalConditionDCSourceVoltage",
                displayName: "DC Source Output Voltage (V)",
                hidden: true,
                default: 1.65,
            },
            {
                name: "signalConditionRea",
                displayName: "Rea resistance (Ω)",
                hidden: true,
                default: 10000,
            },
            {
                name: "signalConditionReb",
                displayName: "Reb resistance (Ω)",
                hidden: true,
                default: 20000,
            },
            {
                name: "signalConditionVDDA",
                displayName: "VDDA Voltage (V)",
                hidden: true,
                readOnly: true,
                default: 3.3,
            },
            {
                name: "signalConditionVSSA",
                displayName: "VSSA Voltage (V)",
                hidden: true,
                readOnly: true,
                default: 0,
            },
            {
                name: "calculatedInputSignalConditionMin",
                displayName: "PGA Input Minimum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateInputSignalConditionMin,
            },
            {
                name: "calculatedInputSignalConditionMax",
                displayName: "PGA Input Maximum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateInputSignalConditionMax,
            },
            {
                name: "calculatedOutputSignalConditionMin",
                displayName: "PGA Output Minimum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateOutputSignalConditionMin,
            },
            {
                name: "calculatedOutputSignalConditionMax",
                displayName: "PGA Output Maximum Voltage (V)",
                hidden: true,
                default: 0,
                getValue: calculateOutputSignalConditionMax,
            },
        ]
    }]);
}

config = config.concat([{
    name: "GROUP_FILTERING",
    displayName: "Low-Pass Filtering",
    description: "PGA low-pass filtering configuration",
    longDescription: "",
    config: [
        {
            name        : "enableFilter",
            displayName : "Enable Low-Pass Filtering",
            description : 'Whether or not to enable low-pass filtering of output signal.',
            hidden      : false,
            onChange    : onChangeEnableFilter,
            default     : false
        },
        
        {
            name        : "filterMode",
            displayName : "Low-Pass Resistor Value",
            description : 'Resistance value for low-pass filtering of output signal.',
            hidden      : true,
            default     : device_driverlib_peripheral.PGA_LowPassResistorValue[1].name,
            options     : device_driverlib_peripheral.PGA_LowPassResistorValue.slice(1)
        },

        {
            name        : "GROUP_cutoffFreqCalculator",
            displayName : "Cutoff Frequency Calculator",
            longDescription : longDescriptionCutoffFreqCalculator,
            config      : [
                {
                    name: "useCutoffFreqCalculator",
                    displayName: "Use Cutoff Frequency Calculator",
                    hidden: true,
                    default: false,
                    onChange: onChangeUseCutoffFreqCalculator,
                },
                {
                    name: "filterResistance",
                    displayName: "Filtering Resistance (Ω)",
                    hidden: true,
                    default: 200,
                    getValue: calculateFilterModeNumeric,
                },
                {
                    name: "filterCapacitance",
                    displayName: "Filtering Capacitance (pF)",
                    hidden: true,
                    default: 10,
                },
                {
                    name: "calculatedCutoffFreq",
                    displayName: "Cutoff Frequency (MHz)",
                    hidden: true,
                    default: 0,
                    getValue: calculateCutoffFreq,
                },
            ]
        },
    ]
}]);

if(["F28P55x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
        name        : "GROUP_CHOPPER",
        displayName : "PGA Chopper",
        description : 'Check to configure the Chopper Submodule',
        config      : [
            {
                name        : "enableChopper",
                displayName : "Enable PGA Chopper",
                description : 'Whether or not to enable PGA Chopper.',
                hidden      : false,
                onChange    : onChangeChopper,
                default     : false
            },
            {
                name        : "enableChopperMode",
                displayName : "Enable Chopper Mode",
                description : 'PGA Output Chopping Control.',
                hidden      : true,
                default     : device_driverlib_peripheral.PGA_Chop[1].name,
                options     : device_driverlib_peripheral.PGA_Chop.slice(1)
            }
        ]
    }]);
}

if(["F28004x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
        name: "GROUP_PIN_INFO",
        displayName: "Pin Info",
        description: "PGA Pin Assignment Info",
        longDescription: "",
        config: [
            {
                name        : "PGA_INPinInfo",
                displayName : "Input Pin Info",
                description : 'Pin Number and Name for selected PGA instance.',
                hidden      : false,
                default     : Pinmux.getDevicePinInfoDescription(PGA_IN_PinInfos),
                getValue    : calculateDevicePinNameIN
            },
        
            {
                name        : "PGA_GNDPinInfo",
                displayName : "Ground Pin Info",
                description : 'Pin Number and Name for selected PGA instance.',
                hidden      : false,
                default     : Pinmux.getDevicePinInfoDescription(PGA_GND_PinInfos),
                getValue    : calculateDevicePinNameGND
            },

            {
                name        : "PGA_OUTPinInfo",
                displayName : "Output Pin Info (Internal)",
                description : 'Pin Number and Name for selected PGA instance. This is an internal signal.',
                hidden      : false,
                default     : Pinmux.getDevicePinInfoDescription(PGA_OUT_PinInfos),
                getValue    : calculateDevicePinNameOUT
            },

            {
                name        : "PGA_OFPinInfo",
                displayName : "Filtered Output Pin Info",
                description : 'Pin Number and Name for selected PGA instance.',
                hidden      : true,
                default     : Pinmux.getDevicePinInfoDescription(PGA_OF_PinInfos),
                getValue    : calculateDevicePinNameOF
            },
        ]
    }]);
}

if(["F28P55x"].includes(Common.getDeviceName()))
{
    config = config.concat([{
        name: "GROUP_PIN_INFO",
        displayName: "Pin Info",
        description: "PGA Pin Assignment Info",
        longDescription: "",
        config: [
            {
                name        : "PGA_INPinInfo",
                displayName : "Input Pin Info",
                description : 'Pin Number and Name for selected PGA instance.',
                hidden      : false,
                default     : Pinmux.getDevicePinInfoDescription(PGA_IN_PinInfos),
                getValue    : calculateDevicePinNameIN
            },
        
            {
                name        : "PGA_GNDPinInfo",
                displayName : "Ground Pin Info",
                description : 'Pin Number and Name for selected PGA instance.',
                hidden      : false,
                default     : Pinmux.getDevicePinInfoDescription(PGA_GND_PinInfos),
                getValue    : calculateDevicePinNameGND
            },

            {
                name        : "PGA_OUTPinInfo",
                displayName : "Output Pin Info (Internal)",
                description : 'Pin Number and Name for selected PGA instance. This is an internal signal.',
                hidden      : false,
                default     : Pinmux.getDevicePinInfoDescription(PGA_OUT_PinInfos),
                getValue    : calculateDevicePinNameOUT
            },
        ]
    }]);
}
 
function onValidate(inst, validation)
{
    var usedPGAInsts = [];
    for (var instance_index in inst.$module.$instances)
    {
        var instance_obj = inst.$module.$instances[instance_index];
        usedPGAInsts.push(instance_obj.pgaBase);
    }
    
    var duplicatesResult = Common.findDuplicates(usedPGAInsts)
    
    if (duplicatesResult.duplicates.length != 0)
    {
        var allDuplicates = "";
        for (var duplicateNamesIndex in duplicatesResult.duplicates)
        {
            allDuplicates = allDuplicates + Common.stringOrEmpty(allDuplicates, ", ")
                            + duplicatesResult.duplicates[duplicateNamesIndex];
        }
        validation.logError(
            "This PGA Instance is already in use! Duplicates: " + allDuplicates,
            inst, "pgaBase");
    }

    if(inst.modeSelection) {
        if (["F28P55x"].includes(Common.getDeviceName()))
        {
            if ((inst["modeSelection"] == "BufferMode") && (inst["gainMode"] != "PGA_GAIN_1"))
            {
                validation.logError("Buffer Mode should have gain value 1", inst, "gainMode");
            }
            else if ((inst["modeSelection"] == "StandaloneMode") && (inst["gainMode"] != "PGA_GAIN_1"))
            {
                validation.logError("Standalone Mode should have gain value 1", inst, "gainMode");
            }

        }
    }

    if(inst.enableFilterMode)
    {
        if (["F28P55x"].includes(Common.getDeviceName()))
        {
            if((inst["gainMode"] != "PGA_GAIN_2") && (inst["internalGainResistor"] == "internalGainResistor16k"))
            {
                validation.logError("Select PGA Gain 2 for 16K internal gain resistor", inst, "gainMode");
            }
            if((inst["gainMode"] != "PGA_GAIN_4") && (inst["internalGainResistor"] == "internalGainResistor24k"))
            {
                validation.logError("Select PGA Gain 4 for 24K internal gain resistor", inst, "gainMode");
            }
            if((inst["gainMode"] != "PGA_GAIN_8") && (inst["internalGainResistor"] == "internalGainResistor56k"))
            {
                validation.logError("Select PGA Gain 8 for 56K internal gain resistor", inst, "gainMode");
            }
            if((inst["gainMode"] != "PGA_GAIN_16") && (inst["internalGainResistor"] == "internalGainResistor120k"))
            {
                validation.logError("Select PGA Gain 16 for 128K internal gain resistor", inst, "gainMode");
            }
            if((inst["gainMode"] != "PGA_GAIN_32") && (inst["internalGainResistor"] == "internalGainResistor248k"))
            {
                validation.logError("Select PGA Gain 32 for 248K internal gain resistor", inst, "gainMode");
            }
            if((inst["gainMode"] != "PGA_GAIN_64") && (inst["internalGainResistor"] == "internalGainResistor252k"))
            {
                validation.logError("Select PGA Gain 64 for 252K internal gain resistor", inst, "gainMode");
            }
        }
    }

    //Signal Conditioning Calculator Conditions
    if (inst.useSignalConditionCalculator) {
        if (inst.inputSignalMinVoltage > inst.inputSignalMaxVoltage) {
            validation.logError("Maximum voltage must be greater than minimum voltage!", inst, "inputSignalMaxVoltage");
        }

        if (inst.inputSignalMinVoltage < -999999 || inst.inputSignalMinVoltage > 999999) {
            validation.logError("Input voltage must not have magnitude greater than 999,999V!", inst, "inputSignalMinVoltage");
        }
    
        if (inst.inputSignalMaxVoltage < -999999 || inst.inputSignalMaxVoltage > 999999) {
            validation.logError("Input voltage must not have magnitude greater than 999,999V!", inst, "inputSignalMaxVoltage");
        }
    
        if (inst.signalConditionDCSourceVoltage > 999999 || inst.signalConditionDCSourceVoltage < -999999) {
            validation.logError("Input voltage must not have magnitude greater than 999,999V!", inst, "signalConditionDCSourceVoltage");
        }
    
        if (inst.signalConditionR1 > 999999 || inst.signalConditionR1 <= 0) {
            validation.logError("Resistance must be nonzero positive value up to 999,999Ω!", inst, "signalConditionR1");
        }
    
        if (inst.signalConditionR2 > 999999 || inst.signalConditionR2 <= 0) {
            validation.logError("Resistance must be nonzero positive value up to 999,999Ω!", inst, "signalConditionR2");
        }
        if (["F28004x"].includes(Common.getDeviceName()))
        {
            if (inst.calculatedOutputSignalConditionMax > inst.signalConditionVDDA - 0.35 && inst.calculatedOutputSignalConditionMax < inst.signalConditionVDDA) {
                validation.logWarning("Maximum voltage extends outside linear range of PGA.", inst, "calculatedOutputSignalConditionMax");
            }
    
            if (inst.calculatedOutputSignalConditionMin < inst.signalConditionVSSA + 0.35 && inst.calculatedOutputSignalConditionMin > inst.signalConditionVSSA) {
                validation.logWarning("Minimum voltage extends outside linear range of PGA.", inst, "calculatedOutputSignalConditionMin");
            }
        }
        if (["F28P55x"].includes(Common.getDeviceName()))
        {
            if (inst.calculatedOutputSignalConditionMax > inst.signalConditionVDDA - 0.025 && inst.calculatedOutputSignalConditionMax < inst.signalConditionVDDA) {
                validation.logWarning("Maximum voltage extends outside linear range of PGA.", inst, "calculatedOutputSignalConditionMax");
            }
    
            if (inst.calculatedOutputSignalConditionMin < inst.signalConditionVSSA + 0.025 && inst.calculatedOutputSignalConditionMin > inst.signalConditionVSSA) {
                validation.logWarning("Minimum voltage extends outside linear range of PGA.", inst, "calculatedOutputSignalConditionMin");
            }
        }

        if (inst.calculatedOutputSignalConditionMax > inst.signalConditionVDDA) {
            validation.logError("Maximum voltage exceeds VDDA!", inst, "calculatedOutputSignalConditionMax");
        }

        if (inst.calculatedOutputSignalConditionMin < inst.signalConditionVSSA) {
            validation.logError("Minimum voltage is less than VSSA!", inst, "calculatedOutputSignalConditionMin");
        }
    }
    
    //Filtering conditions
    if (inst.enableFilter) {
        if (["F28004x"].includes(Common.getDeviceName()))
        {
            if (inst.gainMode == device_driverlib_peripheral.PGA_GainValue[2].name
                && inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[6].name)
            {
                validation.logError("Minimum resistance value for 12x gain mode is 80Ω!", inst, "filterMode");
            }
        
            if (inst.gainMode == device_driverlib_peripheral.PGA_GainValue[3].name
                && (inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[5].name 
                    || inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[6].name))
            {
                validation.logError("Minimum resistance value for 24x gain mode is 100Ω!", inst, "filterMode");
            }
        }
        else if (["F28P55x"].includes(Common.getDeviceName()))
        {
            if (inst.gainMode == device_driverlib_peripheral.PGA_GainValue[3].name
                && inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[1].name)
            {
                validation.logError("Minimum resistance value for 8x or -7x gain mode is 100Ω!", inst, "filterMode");
            }
        
            if (inst.gainMode == device_driverlib_peripheral.PGA_GainValue[4].name
                && inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[1].name) 
            {
                validation.logError("Minimum resistance value for 16x or -15x gain mode is 100Ω!", inst, "filterMode");
            }

            if (inst.gainMode == device_driverlib_peripheral.PGA_GainValue[5].name
                && (inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[1].name 
                    || inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[2].name)) 
            {
                validation.logError("Minimum resistance value for 32x or -31x gain mode is 200Ω!", inst, "filterMode");
            }

            if (inst.gainMode == device_driverlib_peripheral.PGA_GainValue[6].name
                && (inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[1].name 
                    || inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[2].name 
                    || inst.filterMode == device_driverlib_peripheral.PGA_LowPassResistorValue[3].name)) 

            {
                validation.logError("Minimum resistance value for 64x or -63x gain mode is 400Ω!", inst, "filterMode");
            }
        }

        //Cutoff Freq calculator conditions
        if (inst.useCutoffFreqCalculator) {
            if (inst.filterCapacitance > 999999 || inst.filterCapacitance <= 0 ) {
                validation.logError("Capacitance must be nonzero positive value up to 999,999pF!", inst, "filterCapacitance");
            }
        }
    }

    

    //Pin out conditions
    if (inst.PGA_INPinInfo == Pinmux.NO_DEVICE_PIN_FOUND) {
        validation.logError("Selected PGA instance not available on current device package!", inst, "pgaBase");
    }
}

function filterHardware(component)
{
    return (Common.typeMatches(component.type, ["PGA"]));
}
 
var pgaModule = {
    peripheralName: "PGA",
    displayName: "PGA",
    maxInstances: deviceNumberOfInstances,
    defaultInstanceName: "myPGA",
    description: "PGA Peripheral",
    filterHardware : filterHardware,
    config: config,
    templates: {
        boardc : "/driverlib/pga/pga.board.c.xdt",
        boardh : "/driverlib/pga/pga.board.h.xdt"
    },
    validate  :  onValidate
};

if (pgaModule.maxInstances <= 0)
{
    delete pgaModule.pinmuxRequirements;
}
 
exports = pgaModule;