1260 lines
46 KiB
JavaScript
1260 lines
46 KiB
JavaScript
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:
|
|
|
|
|
|
|
|
Block diagram/Pins:
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
|
|
|
Block diagram/Pins:
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
|
|
|
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; |