1833 lines
71 KiB
JavaScript
1833 lines
71 KiB
JavaScript
let Common = system.getScript("/driverlib/Common.js");
|
|
let Pinmux = system.getScript("/driverlib/pinmux.js");
|
|
|
|
let ComparatorInputs = system.getScript("/driverlib/cmpss/cmpss_inputSignals.js")
|
|
|
|
let device_driverlib_peripheral =
|
|
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
|
Common.getDeviceName().toLowerCase() + "_cmpss.js");
|
|
|
|
let device_driverlib_memmap =
|
|
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
|
Common.getDeviceName().toLowerCase() + "_memmap.js");
|
|
|
|
var deviceNumberOfInstances = device_driverlib_memmap.CMPSSMemoryMap.length
|
|
|
|
let CMPSS_INSTANCE = device_driverlib_memmap.CMPSSMemoryMap;
|
|
CMPSS_INSTANCE = CMPSS_INSTANCE.map(({baseAddress, ...rest}) => {
|
|
return rest;
|
|
});
|
|
|
|
|
|
if (["F28004x","F28002x","F28003x","F28P55x","F280013x", "F280015x", "F28P65x"].includes(Common.getDeviceName())){
|
|
var defaultCMPSSPinInfos = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()]["CMPSS1_BASE"][0].displayName.split("/")[0]));
|
|
|
|
var defaultCMPSSNegPinInfos = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()]["CMPSS1_BASE"][1].displayName.split("/")[0]));
|
|
}
|
|
|
|
var rampDirections = [
|
|
{name: "CMPSS_RAMP_DIR_DOWN", displayName: "Count Down"},
|
|
{name: "CMPSS_RAMP_DIR_UP", displayName: "Count Up"}
|
|
]
|
|
|
|
var CMPSS_TRIPOUT = [
|
|
{name: "CMPSS_TRIPOUT_ASYNC_COMP", displayName: "Asynchronous comparator output drives CTRIPOUT"},
|
|
{name: "CMPSS_TRIPOUT_SYNC_COMP", displayName: "Synchronous comparator output drives CTRIPOUT"},
|
|
{name: "CMPSS_TRIPOUT_FILTER", displayName: "Filter output drives CTRIPOUT"},
|
|
{name: "CMPSS_TRIPOUT_LATCH", displayName: "Latched filter output drives CTRIPOUT"},
|
|
];
|
|
|
|
var CMPSS_TRIP = [
|
|
{name: "CMPSS_TRIP_ASYNC_COMP", displayName: "Asynchronous comparator output drives CTRIP"},
|
|
{name: "CMPSS_TRIP_SYNC_COMP", displayName: "Synchronous comparator output drives CTRIP"},
|
|
{name: "CMPSS_TRIP_FILTER", displayName: "Filter output drives CTRIP"},
|
|
{name: "CMPSS_TRIP_LATCH", displayName: "Latched filter output drives CTRIP"},
|
|
];
|
|
|
|
function calculateDevicePinNameHigh(inst,ui){
|
|
if (["F28P65x"].includes(Common.getDeviceName())){
|
|
if(((inst.cmpssBase == "CMPSS9_BASE") || (inst.cmpssBase == "CMPSS10_BASE") || (inst.cmpssBase == "CMPSS11_BASE")) && (inst.asysCMPHPMXSELValue == 3))
|
|
{
|
|
var tempPinInfoDesc = "No Device Pin Found"
|
|
return tempPinInfoDesc
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHPMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if(tempPinInfo.length == 0) //SysConfig was unable to find any pins with this name, even though it exists as an input; remove error detection
|
|
{
|
|
if(tempPinName.includes("TempSensor"))
|
|
{
|
|
return "Temperature Sensor";
|
|
}
|
|
else if(tempPinName.includes("VREF"))
|
|
{
|
|
return tempPinName
|
|
}
|
|
}
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
else if (["F28P55x"].includes(Common.getDeviceName())){
|
|
if((inst.cmpssBase == "CMPSS4_BASE") && (inst.asysCMPHPMXSELValue == 6))
|
|
{
|
|
var tempPinInfoDesc = "No Device Pin Found"
|
|
return tempPinInfoDesc
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHPMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if(tempPinInfo.length == 0) //SysConfig was unable to find any pins with this name, even though it exists as an input; remove error detection
|
|
{
|
|
if(tempPinName.includes("TempSensor"))
|
|
{
|
|
return "Temperature Sensor";
|
|
}
|
|
else if(tempPinName.includes("VREF"))
|
|
{
|
|
return tempPinName
|
|
}
|
|
}
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHPMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if ((["F28004x"].includes(Common.getDeviceName())) && (tempPinInfoDesc == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPHPMXSELValue == 4)){
|
|
return "PGA"+(inst.cmpssBase.match(/\d+/)[0])+"_OUT"
|
|
}
|
|
else{
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
}
|
|
|
|
function calculateDevicePinNameHighNeg(inst,ui){
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHNMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if ((["F28004x"].includes(Common.getDeviceName())) && (tempPinInfoDesc == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPHNMXSELValue == 4)){
|
|
return "PGA"+(inst.cmpssBase.match(/\d+/)[0])+"_OUT"
|
|
}
|
|
else if ((["F28P55x"].includes(Common.getDeviceName())) && (tempPinInfoDesc == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPHNMXSELValue == 6) && (inst.cmpssBase!= "CMPSS4_BASE")){
|
|
return "PGA"+(inst.cmpssBase.match(/\d+/)[0])+"_OUT"
|
|
}
|
|
else{
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
|
|
function calculateDevicePinNameLow(inst,ui){
|
|
if(["F28P65x"].includes(Common.getDeviceName()))
|
|
{
|
|
if(((inst.cmpssBase == "CMPSS9_BASE") || (inst.cmpssBase == "CMPSS10_BASE") || (inst.cmpssBase == "CMPSS11_BASE")) && (inst.asysCMPLPMXSELValue == 3))
|
|
{
|
|
var tempPinInfoDesc = "No Device Pin Found"
|
|
return tempPinInfoDesc
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorLowPositiveInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if((tempPinInfo.length == 0) && tempPinName.includes("VREF")) //SysConfig was unable to find any pins with this name, even though it exists as an input; remove error detection
|
|
{
|
|
return tempPinName
|
|
}
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
else if(["F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
if((inst.cmpssBase == "CMPSS4_BASE") && (inst.asysCMPLPMXSELValue == 6))
|
|
{
|
|
var tempPinInfoDesc = "No Device Pin Found"
|
|
return tempPinInfoDesc
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorLowPositiveInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if((tempPinInfo.length == 0) && tempPinName.includes("VREF")) //SysConfig was unable to find any pins with this name, even though it exists as an input; remove error detection
|
|
{
|
|
return tempPinName
|
|
}
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if ((["F28004x"].includes(Common.getDeviceName())) && (tempPinInfoDesc == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPLPMXSELValue == 4)){
|
|
return "PGA"+(inst.cmpssBase.match(/\d+/)[0])+"_OUT"
|
|
}
|
|
else{
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
}
|
|
|
|
function calculateDevicePinNameLowNeg(inst,ui){
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLNMXSELValue].displayName
|
|
var tempPinInfo = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
var tempPinInfoDesc = Pinmux.getDevicePinInfoDescription(tempPinInfo)
|
|
if ((["F28004x"].includes(Common.getDeviceName())) && (tempPinInfoDesc == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPLNMXSELValue == 4)){
|
|
return "PGA"+(inst.cmpssBase.match(/\d+/)[0])+"_OUT"
|
|
}
|
|
else if ((["F28P55x"].includes(Common.getDeviceName())) && (tempPinInfoDesc == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPLNMXSELValue == 6) && (inst.cmpssBase!= "CMPSS4_BASE") ){
|
|
return "PGA"+(inst.cmpssBase.match(/\d+/)[0])+"_OUT_INT"
|
|
}
|
|
else{
|
|
return tempPinInfoDesc
|
|
}
|
|
}
|
|
|
|
/* Array of possible ePWM sync signals */
|
|
var ePWMInstances = Common.peripheralCount("EPWM")
|
|
var ePWMArraySync = [];
|
|
var ePWMArrayBlank = [];
|
|
for(var i = 0; i < ePWMInstances; i++) {
|
|
ePWMArraySync.push()
|
|
ePWMArraySync.push({ name: ""+(i+1), displayName: "EPWM"+(i+1)+"SYNCPER" })
|
|
ePWMArrayBlank.push()
|
|
ePWMArrayBlank.push({ name: ""+(i+1), displayName: "EPWM"+(i+1)+"BLANK" })
|
|
}
|
|
|
|
/*Generate array for input signals*/
|
|
var numberOfPosInputSignals = 0
|
|
var numberOfNegInputSignals = 0
|
|
var asysPosSignalOptions = []
|
|
var asysNegSignalOptions = []
|
|
if (["F28002x","F28004x", "F280013x", "F280015x"].includes(Common.getDeviceName())){
|
|
numberOfPosInputSignals = 5
|
|
}
|
|
else if (["F28003x"].includes(Common.getDeviceName())){
|
|
numberOfPosInputSignals = 6
|
|
}
|
|
else if (["F28P65x"].includes(Common.getDeviceName())){
|
|
numberOfPosInputSignals = 4
|
|
}
|
|
else if (["F28P55x"].includes(Common.getDeviceName())){
|
|
numberOfPosInputSignals = 8
|
|
}
|
|
|
|
numberOfNegInputSignals = 2
|
|
|
|
for(var i=0;i<numberOfPosInputSignals;i++){
|
|
asysPosSignalOptions.push(
|
|
{name:""+i,displayName:"Input Signal "+i},
|
|
)
|
|
}
|
|
|
|
for(var i=0;i<numberOfNegInputSignals;i++){
|
|
asysNegSignalOptions.push(
|
|
{name:""+i,displayName:"Input Signal "+i},
|
|
)
|
|
}
|
|
|
|
|
|
var highConfig =[
|
|
// configHighComparator: Sets the configuration for the high comparator.
|
|
{
|
|
name: "cmpssHighName",
|
|
displayName : "Name",
|
|
description : 'Select the CMPSS name for High Comparator',
|
|
hidden : false,
|
|
default : ""
|
|
},
|
|
{
|
|
name : "highCompNegative",
|
|
displayName : "Negative input source",
|
|
description : 'Specify high comparator negative input source',
|
|
hidden : false,
|
|
default : "CMPSS_INSRC_DAC",
|
|
options : [
|
|
{name: "CMPSS_INSRC_DAC", displayName: "Input driven by internal DAC"},
|
|
{name: "CMPSS_INSRC_PIN", displayName: "Input driven by external pin"},
|
|
],
|
|
onChange : onChangeHighCompDAC
|
|
},
|
|
{
|
|
name : "highCompInvert",
|
|
displayName : "Output is inverted",
|
|
description : 'High comparator output is inverted',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "highCompAsynch",
|
|
displayName : "Asynch OR Latch",
|
|
description : 'Asynchronous high comparator output should be fed into an OR gate with the latched digital filter output before it is made available for CTRIPH or CTRIPOUTH.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// configOutputsHigh
|
|
{
|
|
name : "highCTRIPOUT",
|
|
displayName : "Signal driving CTRIPOUTH",
|
|
description : 'Specify which signal drives CTRIPOUTH',
|
|
hidden : false,
|
|
default : CMPSS_TRIPOUT[0].name,
|
|
options : CMPSS_TRIPOUT
|
|
},
|
|
{
|
|
name : "highCTRIP",
|
|
displayName : "Signal driving CTRIPH",
|
|
description : 'Specify which signal drives CTRIPH',
|
|
hidden : false,
|
|
default : CMPSS_TRIP[0].name,
|
|
options : CMPSS_TRIP
|
|
},
|
|
// setDACValueHigh
|
|
{
|
|
name : "dacValHigh",
|
|
displayName : "Set high comparator DAC value",
|
|
description : 'Sets the value of the internal DAC of the high comparator.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name: "GROUP_HIGH_DIGITAL_FILTER",
|
|
displayName: "Digital Filter Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: [
|
|
// initFilterHigh
|
|
{
|
|
name : "initFilterHigh",
|
|
displayName : "Initialize Digital Filter",
|
|
description : 'Initializes the digital filter of the high comparator.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// clearFilterLatchHigh
|
|
{
|
|
name : "clearFilterLatchHigh",
|
|
displayName : "Clear Filter Latch",
|
|
description : 'Causes a software reset of the high comparator digital filter output latch.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// enableLatchResetOnPWSYNCHigh / disableLatchResetOnPWMSYNCHigh
|
|
{
|
|
name : "latchResetHigh",
|
|
displayName : "Reset output latch on EPWMSYNCPER",
|
|
description : 'Enables reset of HIGH comparator digital filter output latch on EPWMSYNCPER',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// configFilterHigh
|
|
{
|
|
name : "samplePrescaleHigh",
|
|
displayName : "Digital Filter Sample Prescale",
|
|
description : 'The number of system clock cycles between samples.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "sampleWindowHigh",
|
|
displayName : "Digital Filter Sample Window",
|
|
description : 'The number of FIFO samples to monitor.',
|
|
hidden : false,
|
|
default : 1
|
|
},
|
|
{
|
|
name : "thresholdHigh",
|
|
displayName : "Digital Filter Threshold",
|
|
description : 'The majority threshold of samples to change state.',
|
|
hidden : false,
|
|
default : 1
|
|
},
|
|
// configLatchOnPWMSYNC
|
|
{
|
|
name : "configLatchHigh",
|
|
displayName : "Reset Digital Filter Latch",
|
|
description : 'Configures whether or not the digital filter latches are reset by EPWMSYNCPER in the high comparator.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
]
|
|
},
|
|
]
|
|
var highConfigDevice = []
|
|
if (["F280015x", "F28P65x", "F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
highConfigDevice = highConfigDevice.concat([
|
|
{
|
|
name : "rampHighDir",
|
|
displayName : "Ramp Direction",
|
|
description : "Sets the ramp direction for the high comparator",
|
|
hidden : false,
|
|
default : rampDirections[0].name,
|
|
options : rampDirections
|
|
},
|
|
])
|
|
}
|
|
highConfigDevice = highConfigDevice.concat([
|
|
// -setMaxRampValue
|
|
{
|
|
name : "maxRampVal",
|
|
displayName : "Max Ramp Generator Reference Value",
|
|
description : 'Sets the ramp generator maximum reference value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
])
|
|
if (["F280015x", "F28P65x", "F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
highConfigDevice = highConfigDevice.concat([
|
|
// -setRampDecValue
|
|
{
|
|
name : "ramDecVal",
|
|
displayName : "Ramp Generator Step Value",
|
|
description : 'Sets the ramp generator decrement or increment value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
])
|
|
}
|
|
if (["F2807x", "F2837xS", "F2837xD", "F2838x", "F280013x", "F28002x", "F28003x","F28004x"].includes(Common.getDeviceName())){
|
|
highConfigDevice = highConfigDevice.concat([
|
|
// -setRampDecValue
|
|
{
|
|
name : "ramDecVal",
|
|
displayName : "Ramp Generator Decrement Value",
|
|
description : 'Sets the ramp generator decrement value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
])
|
|
}
|
|
highConfigDevice = highConfigDevice.concat([
|
|
// -setRampDelayValue
|
|
{
|
|
name : "rampDelayVal",
|
|
displayName : "Ramp Generator Delay Value",
|
|
description : 'Sets the ramp generator delay value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
])
|
|
|
|
if (["F28P65x","F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
highConfigDevice = highConfigDevice.concat([
|
|
// -CMPSS_setRampClockDividerHigh/CMPSS_setRampClockDividerLow
|
|
{
|
|
name : "rampClkDiv",
|
|
displayName : "Ramp Generator Clock Divider Value",
|
|
description : 'Sets the divider value to slow down the ramp clock; this increases the periods between steps. RAMPCLK = SYSCLK/(RAMPCLKDIV+1), where RAMPCLKDIV = {0...15}.',
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.CMPSS_RampClockDiv[0].name,
|
|
options : device_driverlib_peripheral.CMPSS_RampClockDiv
|
|
},
|
|
{
|
|
name: "rampClkFreq",
|
|
displayName : "Ramp Clock Frequency [MHz]",
|
|
getValue : (inst) => {
|
|
var dividerVal =1
|
|
for(var divIndex in device_driverlib_peripheral.CMPSS_RampClockDiv)
|
|
{
|
|
var currentDIV = device_driverlib_peripheral.CMPSS_RampClockDiv[divIndex].name
|
|
let divi = (currentDIV).replace(/[^0-9]/g,'')
|
|
if (inst.rampClkDiv == ("CMPSS_RAMP_CLOCK_DIV"+divi.toString()))
|
|
{
|
|
dividerVal = divi
|
|
}
|
|
}
|
|
return (Common.getSYSCLK() / dividerVal);
|
|
},
|
|
default : Common.SYSCLK_getMaxMHz(),
|
|
},
|
|
])
|
|
}
|
|
highConfigDevice = highConfigDevice.concat([
|
|
|
|
{
|
|
name : "pwmSyncSrc",
|
|
displayName : "EPWMSYNCPER source number",
|
|
description : 'Specify the number of the EPWMSYNCPER source',
|
|
hidden : false,
|
|
default : ePWMArraySync[0].name,
|
|
options : ePWMArraySync
|
|
},
|
|
{
|
|
name : "useRampValShdw",
|
|
displayName : "Ramp Generator Reset",
|
|
description : 'Indicate whether the ramp generator should reset with the value from the ramp max reference value shadow register or with the latched ramp max reference value',
|
|
hidden : false,
|
|
default : "true",
|
|
options : [
|
|
{name: "true", displayName: "load the ramp generator from the shadow register"},
|
|
{name: "false", displayName: "load the ramp generator from the latched value."},
|
|
],
|
|
},
|
|
])
|
|
|
|
|
|
highConfig = highConfig.concat([
|
|
{
|
|
name: "GROUP_RAMP_GENERATOR",
|
|
displayName: "Ramp Generator Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: highConfigDevice
|
|
},
|
|
])
|
|
|
|
if (["F28002x","F28003x","F28P55x","F280013x","F280015x","F28004x", "F28P65x"].includes(Common.getDeviceName())){
|
|
highConfig = highConfig.concat([
|
|
{
|
|
name: "GROUP_CMPSS_MUX_HIGH",
|
|
displayName: "CMPSS MUX Select",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: [
|
|
// ASysCtl_selectCMPHPMux : options vary per device
|
|
{
|
|
name : "asysCMPHPMXSELValue",
|
|
displayName : "CMPHPMXSEL",
|
|
description : 'Select the value for CMPHPMXSEL.',
|
|
hidden : false,
|
|
default : asysPosSignalOptions[0].name,
|
|
options : asysPosSignalOptions
|
|
},
|
|
{
|
|
name : "asysCMPHPMXSELPinInfo",
|
|
displayName : "Selected MUX Signal for HP input",
|
|
description : 'Pin Number and Name for selected HP signal.',
|
|
hidden : false,
|
|
default : Pinmux.getDevicePinInfoDescription(defaultCMPSSPinInfos),
|
|
getValue : calculateDevicePinNameHigh
|
|
},
|
|
|
|
// ASysCtl_selectCMPHNMux : options vary per device
|
|
{
|
|
name : "asysCMPHNMXSELValue",
|
|
displayName : "CMPHNMXSEL",
|
|
description : 'Select the value for CMPHNMXSEL.',
|
|
hidden : true,
|
|
default : asysNegSignalOptions[1].name,
|
|
options : asysNegSignalOptions
|
|
},
|
|
{
|
|
name : "asysCMPHNMXSELPinInfo",
|
|
displayName : "Selected MUX Signal for HN input",
|
|
description : 'Pin Number and Name for selected HN signal.',
|
|
hidden : true,
|
|
default : Pinmux.getDevicePinInfoDescription(defaultCMPSSNegPinInfos),
|
|
getValue : calculateDevicePinNameHighNeg
|
|
},
|
|
]
|
|
},
|
|
])
|
|
}
|
|
var lowConfig =[
|
|
// configLowComparator: Sets the configuration for the low comparator.
|
|
{
|
|
name: "cmpssLowName",
|
|
displayName : "Name",
|
|
description : 'Select the CMPSS name for Low Comparator',
|
|
hidden : false,
|
|
default : ""
|
|
},
|
|
{
|
|
name : "lowCompNegative",
|
|
displayName : "Negative input source",
|
|
description : 'Specify the high comparator negative input source',
|
|
hidden : false,
|
|
default : "CMPSS_INSRC_DAC",
|
|
options : [
|
|
{name: "CMPSS_INSRC_DAC", displayName: "Input driven by internal DAC"},
|
|
{name: "CMPSS_INSRC_PIN", displayName: "Input driven by external pin"},
|
|
],
|
|
onChange : onChangeLowCompDAC
|
|
},
|
|
{
|
|
name : "lowCompInvert",
|
|
displayName : "Output is inverted",
|
|
description : 'Low comparator output is inverted',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "lowCompAsynch",
|
|
displayName : "Asynch OR Latch",
|
|
description : 'Asynchronous low comparator output should be fed into an OR gate with the latched digital filter output before it is made available for CTRIPH or CTRIPOUTH.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// configOutputsLow
|
|
{
|
|
name : "lowCTRIPOUT",
|
|
displayName : "Signal driving CTRIPOUTL",
|
|
description : 'Specify which signal drives CTRIPOUTL',
|
|
hidden : false,
|
|
default : CMPSS_TRIPOUT[0].name,
|
|
options : CMPSS_TRIPOUT,
|
|
},
|
|
{
|
|
name : "lowCTRIP",
|
|
displayName : "Signal driving CTRIPL",
|
|
description : 'Specify which signal drives CTRIPL',
|
|
hidden : false,
|
|
default : CMPSS_TRIP[0].name,
|
|
options : CMPSS_TRIP,
|
|
},
|
|
// setDACValueLow
|
|
{
|
|
name : "dacValLow",
|
|
displayName : "Set low comparator DAC value",
|
|
description : 'Sets the value of the internal DAC of the low comparator.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name: "GROUP_LOW_DIGITAL_FILTER",
|
|
displayName: "Digital Filter Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: [
|
|
// initFilterLow
|
|
{
|
|
name : "initFilterLow",
|
|
displayName : "Initialize Digital Filter",
|
|
description : 'Initializes the digital filter of the low comparator.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// clearFilterLatchLow
|
|
{
|
|
name : "clearFilterLatchLow",
|
|
displayName : "Clear Filter Latch",
|
|
description : 'Causes a software reset of the low comparator digital filter output latch.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// enableLatchResetOnPWMSYNCLow / enableLatchResetOnPWMSYNCLow
|
|
{
|
|
name : "latchResetLow",
|
|
displayName : "Reset output latch on EPWMSYNCPER",
|
|
description : 'Enables reset of LOW comparator digital filter output latch on EPWMSYNCPER',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// configFilterLow
|
|
{
|
|
name : "samplePrescaleLow",
|
|
displayName : "Digital Filter Sample Prescale",
|
|
description : 'The number of system clock cycles between samples.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "sampleWindowLow",
|
|
displayName : "Digital Filter Sample Window",
|
|
description : 'The number of FIFO samples to monitor.',
|
|
hidden : false,
|
|
default : 1
|
|
},
|
|
{
|
|
name : "thresholdLow",
|
|
displayName : "Digital Filter Threshold",
|
|
description : 'The majority threshold of samples to change state.',
|
|
hidden : false,
|
|
default : 1
|
|
},
|
|
// configLatchOnPWMSYNC
|
|
{
|
|
name : "configLatchLow",
|
|
displayName : "Reset Digital Filter Latch",
|
|
description : 'Configures whether or not the digital filter latches are reset by EPWMSYNCPER in the low comparator.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
]
|
|
},
|
|
]
|
|
|
|
var lowConfigDevice = []
|
|
if (["F280015x", "F28P65x" , "F28P55x"].includes(Common.getDeviceName())){
|
|
lowConfigDevice = lowConfigDevice.concat([
|
|
{
|
|
name : "rampLowDir",
|
|
displayName : "Ramp Direction",
|
|
description : "Sets the ramp direction for the low comparator",
|
|
hidden : false,
|
|
default : rampDirections[0].name,
|
|
options : rampDirections
|
|
},
|
|
// -setMaxRampValue
|
|
{
|
|
name : "maxRampValLow",
|
|
displayName : "Max Ramp Generator Reference Value",
|
|
description : 'Sets the ramp generator maximum reference value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
// -setRampDecValue
|
|
{
|
|
name : "ramDecValLow",
|
|
displayName : "Ramp Generator Decrement Value",
|
|
description : 'Sets the ramp generator decrement value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
// -setRampDelayValue
|
|
{
|
|
name : "rampDelayValLow",
|
|
displayName : "Ramp Generator Delay Value",
|
|
description : 'Sets the ramp generator delay value.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
])
|
|
}
|
|
|
|
if (["F28P65x","F28P55x"].includes(Common.getDeviceName())){
|
|
lowConfigDevice = lowConfigDevice.concat([
|
|
// -CMPSS_setRampClockDividerHigh/CMPSS_setRampClockDividerLow
|
|
{
|
|
name : "rampClkDivLow",
|
|
displayName : "Ramp Generator Clock Divider Value",
|
|
description : 'Sets the divider value to slow down the ramp clock; this increases the periods between steps. RAMPCLK = SYSCLK/(RAMPCLKDIV+1), where RAMPCLKDIV = {0...15}.',
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.CMPSS_RampClockDiv[0].name,
|
|
options : device_driverlib_peripheral.CMPSS_RampClockDiv
|
|
},
|
|
{
|
|
name: "rampClkFreqLow",
|
|
displayName : "Ramp Clock Frequency [MHz]",
|
|
getValue : (inst) => {
|
|
var dividerVal =1
|
|
for(var divIndex in device_driverlib_peripheral.CMPSS_RampClockDiv)
|
|
{
|
|
var currentDIV = device_driverlib_peripheral.CMPSS_RampClockDiv[divIndex].name
|
|
let divi = (currentDIV).replace(/[^0-9]/g,'')
|
|
if (inst.rampClkDiv == ("CMPSS_RAMP_CLOCK_DIV"+divi.toString()))
|
|
{
|
|
dividerVal = divi
|
|
}
|
|
}
|
|
return (Common.getSYSCLK() / dividerVal);
|
|
},
|
|
default : Common.SYSCLK_getMaxMHz(),
|
|
},
|
|
])
|
|
}
|
|
|
|
if (["F280015x", "F28P65x" , "F28P55x"].includes(Common.getDeviceName())){
|
|
lowConfigDevice = lowConfigDevice.concat([
|
|
{
|
|
name : "pwmSyncSrcLow",
|
|
displayName : "EPWMSYNCPER source number",
|
|
description : 'Specify the number of the EPWMSYNCPER source',
|
|
hidden : false,
|
|
default : ePWMArraySync[0].name,
|
|
options : ePWMArraySync
|
|
},
|
|
{
|
|
name : "useRampValShdwLow",
|
|
displayName : "Ramp Generator Reset",
|
|
description : 'Indicate whether the ramp generator should reset with the value from the ramp max reference value shadow register or with the latched ramp max reference value',
|
|
hidden : false,
|
|
default : "true",
|
|
options : [
|
|
{name: "true", displayName: "load the ramp generator from the shadow register"},
|
|
{name: "false", displayName: "load the ramp generator from the latched value."},
|
|
],
|
|
},
|
|
])
|
|
}
|
|
lowConfig = lowConfig.concat([
|
|
{
|
|
name: "GROUP_RAMP_GENERATOR",
|
|
displayName: "Ramp Generator Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: lowConfigDevice
|
|
},
|
|
])
|
|
|
|
|
|
|
|
|
|
|
|
if (["F28002x","F28003x","F280013x","F280015x","F28004x", "F28P65x","F28P55x"].includes(Common.getDeviceName())){
|
|
lowConfig = lowConfig.concat([
|
|
{
|
|
name: "GROUP_CMPSS_MUX_LOW",
|
|
displayName: "CMPSS MUX Select",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: [
|
|
// ASysCtl_selectCMPLPMux : options vary per device
|
|
{
|
|
name : "asysCMPLPMXSELValue",
|
|
displayName : "CMPLPMXSEL",
|
|
description : 'Select the value for CMPLPMXSEL.',
|
|
hidden : false,
|
|
default : asysPosSignalOptions[0].name,
|
|
options : asysPosSignalOptions
|
|
},
|
|
{
|
|
name : "asysCMPLPMXSELPinInfo",
|
|
displayName : "Selected MUX Signal for LP input",
|
|
description : 'Pin Number and Name for selected LP signal.',
|
|
hidden : false,
|
|
default : Pinmux.getDevicePinInfoDescription(defaultCMPSSPinInfos),
|
|
getValue : calculateDevicePinNameLow
|
|
},
|
|
|
|
// ASysCtl_selectCMPLNMux : options vary per device
|
|
{
|
|
name : "asysCMPLNMXSELValue",
|
|
displayName : "CMPLNMXSEL",
|
|
description : 'Select the value for CMPLNMXSEL.',
|
|
hidden : true,
|
|
default : asysNegSignalOptions[1].name,
|
|
options : asysNegSignalOptions
|
|
},
|
|
{
|
|
name : "asysCMPLNMXSELPinInfo",
|
|
displayName : "Selected MUX Signal for LN input",
|
|
description : 'Pin Number and Name for selected LN signal.',
|
|
hidden : true,
|
|
default : Pinmux.getDevicePinInfoDescription(defaultCMPSSNegPinInfos),
|
|
getValue : calculateDevicePinNameLowNeg
|
|
},
|
|
]
|
|
},
|
|
])
|
|
}
|
|
|
|
/* Array of CAN configurables that are common across device families */
|
|
let config = [
|
|
{
|
|
name : "cmpssBase",
|
|
displayName : "CMPSS Instance",
|
|
description : 'Instance of the CMPSS used.',
|
|
hidden : false,
|
|
default : CMPSS_INSTANCE[0].name,
|
|
options : CMPSS_INSTANCE,
|
|
},
|
|
// enableModule / disableModule
|
|
{
|
|
name : "enableModule",
|
|
displayName : "Enable module",
|
|
description : 'Enables the CMPSS module.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
];
|
|
config = config.concat([
|
|
// setHysteresis
|
|
{
|
|
name : "hysteresisVal",
|
|
displayName : "Hysteresis",
|
|
description : 'Sets the the amount of hysteresis on the comparator inputs.',
|
|
hidden : false,
|
|
default : "0",
|
|
options: [
|
|
{name:"0",displayName:"None"},
|
|
{name:"1",displayName:"1x"},
|
|
{name:"2",displayName:"2x"},
|
|
{name:"3",displayName:"3x"},
|
|
{name:"4",displayName:"4x"},
|
|
]
|
|
},
|
|
]);
|
|
|
|
if (["F28002x","F28003x","F280013x","F280015x","F28004x","F2838x","F28P55x","F28P65x"].includes(Common.getDeviceName())){
|
|
config = config.concat([
|
|
// configBlanking
|
|
{
|
|
name : "configBlanking",
|
|
displayName : "Blanking Signal",
|
|
description : 'Sets the ePWM module blanking signal that holds trip in reset.',
|
|
hidden : false,
|
|
default : ePWMArrayBlank[0].name,
|
|
options : ePWMArrayBlank
|
|
},
|
|
// enableBlanking / disableBlanking
|
|
{
|
|
name : "enableBlanking",
|
|
displayName : "Enable Blanking Signal",
|
|
description : 'Enables an ePWM blanking signal to hold trip in reset.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
]);
|
|
}
|
|
|
|
config = config.concat([
|
|
// Group for High Comparator Configuration Functions
|
|
{
|
|
name: "GROUP_HIGH_COMPARATOR",
|
|
displayName: "High Comparator Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
config: highConfig
|
|
},
|
|
// Group for Low Comparator Configuration Functions
|
|
{
|
|
name: "GROUP_LOW_COMPARATOR",
|
|
displayName: "Low Comparator Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
config: lowConfig
|
|
},
|
|
]);
|
|
|
|
// configDAC
|
|
var cmpss_dac_config = [
|
|
{
|
|
name : "dacValLoad",
|
|
displayName : "DAC value load",
|
|
description : 'When is DAC value loaded from shadow register',
|
|
hidden : false,
|
|
default : "CMPSS_DACVAL_SYSCLK",
|
|
options : [
|
|
{name: "CMPSS_DACVAL_SYSCLK", displayName: "DAC value updated from SYSCLK"},
|
|
{name: "CMPSS_DACVAL_PWMSYNC", displayName: "DAC value updated from EPWMSYNCPER"},
|
|
],
|
|
},
|
|
]
|
|
|
|
if (!["F280013x", "F280015x", "F28P55x"].includes(Common.getDeviceName())){
|
|
cmpss_dac_config.push(
|
|
{
|
|
name : "dacRefVoltage",
|
|
displayName : "DAC reference voltage",
|
|
description : 'Specify DAC reference voltage',
|
|
hidden : false,
|
|
default : "CMPSS_DACREF_VDDA",
|
|
options : [
|
|
{name: "CMPSS_DACREF_VDDA", displayName: "VDDA is the voltage reference"},
|
|
{name: "CMPSS_DACREF_VDAC", displayName: "VDAC is the voltage reference"},
|
|
],
|
|
},
|
|
);
|
|
}
|
|
cmpss_dac_config.push(
|
|
{
|
|
name : "dacValSource",
|
|
displayName : "DAC value source",
|
|
description : 'Specify DAC value source',
|
|
hidden : false,
|
|
default : "CMPSS_DACSRC_SHDW",
|
|
options : [
|
|
{name: "CMPSS_DACSRC_SHDW", displayName: "DAC value updated from shadow register"},
|
|
{name: "CMPSS_DACSRC_RAMP", displayName: "DAC value is updated from the ramp register"},
|
|
],
|
|
},
|
|
)
|
|
if (["F2807x", "F2837xS", "F2837xD", "F2838x", "F280013x", "F28002x", "F28003x","F28004x"].includes(Common.getDeviceName())){
|
|
config = config.concat([
|
|
// DAC Group
|
|
{
|
|
name: "GROUP_CMP_DAC",
|
|
displayName: "DAC Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: true,
|
|
config: cmpss_dac_config
|
|
},
|
|
]);
|
|
}
|
|
if (["F280015x", "F28P55x", "F28P65x"].includes(Common.getDeviceName())){
|
|
config = config.concat([
|
|
// DAC Group
|
|
{
|
|
name: "GROUP_CMP_DAC",
|
|
displayName: "High DAC Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: true,
|
|
config: cmpss_dac_config
|
|
},
|
|
]);
|
|
}
|
|
|
|
if (["F280015x", "F28P65x", "F28P55x"].includes(Common.getDeviceName())){
|
|
// configDACLow
|
|
var cmpss_dac_lowConfig = [
|
|
{
|
|
name : "lowDacValSource",
|
|
displayName : "DAC value source",
|
|
description : 'Specify Low DAC value source',
|
|
hidden : false,
|
|
default : "CMPSS_DACSRC_SHDW",
|
|
options : [
|
|
{name: "CMPSS_DACSRC_SHDW", displayName: "DAC value updated from shadow register"},
|
|
{name: "CMPSS_DACSRC_RAMP", displayName: "DAC value is updated from the ramp register"},
|
|
],
|
|
},
|
|
]
|
|
config = config.concat([
|
|
// DAC Group
|
|
{
|
|
name: "GROUP_CMP_DAC",
|
|
displayName: "Low DAC Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: true,
|
|
config: cmpss_dac_lowConfig
|
|
},
|
|
]);
|
|
}
|
|
if (["F28P65x"].includes(Common.getDeviceName())){
|
|
// configDE
|
|
var cmpss_de_config = [
|
|
{
|
|
name : "deEnable",
|
|
displayName : "Enable Diode Emulation Support",
|
|
longDescription : "Using Diode Emulation allows a PWMSYNC signal to determine when to use different threshold register for the DAC values; this threshold can be made to have a tighter limit.",
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "deDACValHigh",
|
|
displayName : "Set high comparator DAC value in Diode Emulation",
|
|
description : 'Sets the value of the internal DAC of the high comparator when using Diode Emulation.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "deDACValLow",
|
|
displayName : "Set low comparator DAC value in Diode Emulation",
|
|
description : 'Sets the value of the internal DAC of the low comparator when using Diode Emulation.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "deactiveSel",
|
|
displayName : "Select Input for Diode Emulation",
|
|
description : 'Selects the Diode Emulation Active signal from the ePWM.',
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.CMPSS_DEActiveSelect[0].name,
|
|
options : device_driverlib_peripheral.CMPSS_DEActiveSelect
|
|
},
|
|
]
|
|
|
|
config = config.concat([
|
|
// Diode Emulation Group
|
|
{
|
|
name: "GROUP_CMP_DE",
|
|
displayName: "Diode Emulation Support Configuration",
|
|
collapsed: true,
|
|
config: cmpss_de_config
|
|
},
|
|
]);
|
|
}
|
|
|
|
function onChangeHighCompDAC(inst, ui)
|
|
{
|
|
if((ui.asysCMPHNMXSELValue) && (ui.asysCMPHNMXSELPinInfo) && (inst.highCompNegative == "CMPSS_INSRC_DAC"))
|
|
{
|
|
ui.asysCMPHNMXSELValue.hidden = true;
|
|
ui.asysCMPHNMXSELPinInfo.hidden = true;
|
|
}
|
|
else if((ui.asysCMPHNMXSELValue) && (ui.asysCMPHNMXSELPinInfo))
|
|
{
|
|
ui.asysCMPHNMXSELValue.hidden = false;
|
|
ui.asysCMPHNMXSELPinInfo.hidden = false;
|
|
}
|
|
}
|
|
|
|
function onChangeLowCompDAC(inst, ui)
|
|
{
|
|
if((ui.asysCMPLNMXSELValue) && (ui.asysCMPLNMXSELPinInfo) && (inst.lowCompNegative == "CMPSS_INSRC_DAC"))
|
|
{
|
|
ui.asysCMPLNMXSELValue.hidden = true;
|
|
ui.asysCMPLNMXSELPinInfo.hidden = true;
|
|
}
|
|
else if((ui.asysCMPLNMXSELValue) && (ui.asysCMPLNMXSELPinInfo))
|
|
{
|
|
ui.asysCMPLNMXSELValue.hidden = false;
|
|
ui.asysCMPLNMXSELPinInfo.hidden = false;
|
|
}
|
|
}
|
|
|
|
function onValidate(inst, validation) {
|
|
//
|
|
// Check Multicontext
|
|
//
|
|
if (Common.isContextCPU2()) {
|
|
if (Common.isMultiCoreSysConfig()) {
|
|
//
|
|
// Check if the analog module is added on CPU1 if the current context is CPU2
|
|
//
|
|
if (Common.isModuleOnOtherContext("/driverlib/analog.js") == false) {
|
|
validation.logError(
|
|
"The ANALOG PinMux module needs to be added on CPU1 when a CMPSS instance is added on CPU2",inst,"cmpssBase");
|
|
}
|
|
}
|
|
else {
|
|
validation.logWarning(
|
|
"The ANALOG PinMux module needs to be added on CPU1 when a CMPSS instance is added on CPU2",inst,"cmpssBase");
|
|
}
|
|
}
|
|
var usedCMPSSInsts = [];
|
|
for (var instance_index in inst.$module.$instances)
|
|
{
|
|
var instance_obj = inst.$module.$instances[instance_index];
|
|
usedCMPSSInsts.push(instance_obj.cmpssBase);
|
|
}
|
|
|
|
var otherContexts = Common.getOtherContextNames()
|
|
for (var cntx of otherContexts)
|
|
{
|
|
var onOtherCntx = Common.getModuleForCore(inst.$module.$name, cntx);
|
|
if (onOtherCntx)
|
|
{
|
|
for (var instance_index in onOtherCntx.$instances)
|
|
{
|
|
var instance_obj = onOtherCntx.$instances[instance_index];
|
|
usedCMPSSInsts.push(instance_obj.cmpssBase);
|
|
}
|
|
}
|
|
}
|
|
|
|
var duplicatesResult = Common.findDuplicates(usedCMPSSInsts)
|
|
|
|
if (duplicatesResult.duplicates.length != 0)
|
|
{
|
|
var allDuplicates = "";
|
|
for (var duplicateNamesIndex in duplicatesResult.duplicates)
|
|
{
|
|
allDuplicates = allDuplicates + Common.stringOrEmpty(allDuplicates, ", ")
|
|
+ duplicatesResult.duplicates[duplicateNamesIndex];
|
|
}
|
|
validation.logError(
|
|
"The CMPSS Instance used. Duplicates: " + allDuplicates,
|
|
inst, "cmpssBase");
|
|
}
|
|
|
|
if (inst.dacValHigh < 0 || inst.dacValHigh > 4095)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for high comparator DAC value between 0 and 4,095!",
|
|
inst, "dacValHigh");
|
|
}
|
|
if (!Number.isInteger(inst.dacValHigh))
|
|
{
|
|
validation.logError(
|
|
"High comparator DAC value must be an integer",
|
|
inst, "dacValHigh");
|
|
}
|
|
|
|
if (inst.dacValLow < 0 || inst.dacValLow > 4095)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for low comparator DAC value between 0 and 4,095!",
|
|
inst, "dacValLow");
|
|
}
|
|
if (!Number.isInteger(inst.dacValLow))
|
|
{
|
|
validation.logError(
|
|
"Low comparator DAC value must be an integer",
|
|
inst, "dacValLow");
|
|
}
|
|
if((["F28P65x"].includes(Common.getDeviceName())))
|
|
{
|
|
if(inst.asysCMPHPMXSELValue == "No Device Pin Found")
|
|
{
|
|
validation.logError("There is no connection for the selected input!", inst, "asysCMPHPMXSELValue");
|
|
}
|
|
if(inst.asysCMPLPMXSELValue == "No Device Pin Found")
|
|
{
|
|
validation.logError("There is no connection for the selected input!", inst, "asysCMPLPMXSELValue");
|
|
}
|
|
if (inst.deDACValLow < 0 || inst.deDACValLow > 4095)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for low comparator DAC value between 0 and 4,095!",
|
|
inst, "deDACValLow");
|
|
}
|
|
if (!Number.isInteger(inst.deDACValLow))
|
|
{
|
|
validation.logError(
|
|
"Low comparator DAC value must be an integer",
|
|
inst, "deDACValLow");
|
|
}
|
|
if (inst.deDACValHigh < 0 || inst.deDACValHigh > 4095)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for low comparator DAC value between 0 and 4,095!",
|
|
inst, "deDACValHigh");
|
|
}
|
|
if (!Number.isInteger(inst.deDACValHigh))
|
|
{
|
|
validation.logError(
|
|
"Low comparator DAC value must be an integer",
|
|
inst, "deDACValHigh");
|
|
}
|
|
}
|
|
|
|
if (inst.maxRampVal < 0 || inst.maxRampVal > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Max Ramp Generator Reference Value between 0 and 65,535!",
|
|
inst, "maxRampVal");
|
|
}
|
|
if (!Number.isInteger(inst.maxRampVal))
|
|
{
|
|
validation.logError(
|
|
"Max Ramp Generator Reference Value must be an integer",
|
|
inst, "maxRampVal");
|
|
}
|
|
|
|
if (inst.ramDecVal < 0 || inst.ramDecVal > 8191)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Ramp Generator Decrement Value between 0 and 8,191!",
|
|
inst, "ramDecVal");
|
|
}
|
|
if (!Number.isInteger(inst.ramDecVal))
|
|
{
|
|
validation.logError(
|
|
"Ramp Generator Decrement Value must be an integer",
|
|
inst, "ramDecVal");
|
|
}
|
|
|
|
if (inst.rampDelayVal < 0 || inst.rampDelayVal > 8191)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Ramp Generator Delay Value between 0 and 8,191!",
|
|
inst, "rampDelayVal");
|
|
}
|
|
if (!Number.isInteger(inst.rampDelayVal))
|
|
{
|
|
validation.logError(
|
|
"Ramp Generator Delay Value must be an integer",
|
|
inst, "rampDelayVal");
|
|
}
|
|
|
|
if((["F28P65x"].includes(Common.getDeviceName())) && (inst.deEnable == false))
|
|
{
|
|
validation.logInfo("Diode Emulation support is not enabled; the settings can be configured and then Diode Emulation can be enabled at any point", inst, "deEnable");
|
|
}
|
|
|
|
if(["F280015x", "F28P65x", "F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
if (inst.maxRampValLow < 0 || inst.maxRampValLow > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Max Ramp Generator Reference Value between 0 and 65,535!",
|
|
inst, "maxRampValLow");
|
|
}
|
|
if (!Number.isInteger(inst.maxRampValLow))
|
|
{
|
|
validation.logError(
|
|
"Max Ramp Generator Reference Value must be an integer",
|
|
inst, "maxRampValLow");
|
|
}
|
|
|
|
if (inst.ramDecValLow < 0 || inst.ramDecValLow > 8191)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Ramp Generator Decrement Value between 0 and 8,191!",
|
|
inst, "ramDecValLow");
|
|
}
|
|
if (!Number.isInteger(inst.ramDecValLow))
|
|
{
|
|
validation.logError(
|
|
"Ramp Generator Decrement Value must be an integer",
|
|
inst, "ramDecValLow");
|
|
}
|
|
|
|
if (inst.rampDelayValLow < 0 || inst.rampDelayValLow > 8191)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Ramp Generator Delay Value between 0 and 8,191!",
|
|
inst, "rampDelayValLow");
|
|
}
|
|
if (!Number.isInteger(inst.rampDelayValLow))
|
|
{
|
|
validation.logError(
|
|
"Ramp Generator Delay Value must be an integer",
|
|
inst, "rampDelayValLow");
|
|
}
|
|
}
|
|
|
|
if (["F28002x","F28003x","F280013x","F280015x","F28004x","F2838x", "F28P65x","F28P55x"].includes(Common.getDeviceName())){
|
|
if (inst.configBlanking < 1 || inst.configBlanking > 16)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for VALUE_NAME between 1 and 16!",
|
|
inst, "configBlanking");
|
|
}
|
|
}
|
|
if (["F28P65x","F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
if (inst.samplePrescaleHigh < 0 || inst.samplePrescaleHigh > 16777215)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Prescale between 0 and 16,777,215!",
|
|
inst, "samplePrescaleHigh");
|
|
}
|
|
}
|
|
else if (["F28003x","F280013x","F280015x"].includes(Common.getDeviceName()))
|
|
{
|
|
if (inst.samplePrescaleHigh < 0 || inst.samplePrescaleHigh > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Prescale between 0 and 65,535!",
|
|
inst, "samplePrescaleHigh");
|
|
}
|
|
}
|
|
else{
|
|
if (inst.samplePrescaleHigh < 0 || inst.samplePrescaleHigh > 1023)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Prescale between 0 and 1,023!",
|
|
inst, "samplePrescaleHigh");
|
|
}
|
|
}
|
|
if (!Number.isInteger(inst.samplePrescaleHigh))
|
|
{
|
|
validation.logError(
|
|
"Digital Filter Sample Prescale must be an integer",
|
|
inst, "samplePrescaleHigh");
|
|
}
|
|
if (["F28P65x","F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
if (inst.sampleWindowHigh < 1 || inst.sampleWindowHigh > 64)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Window between 1 and 64!",
|
|
inst, "sampleWindowHigh");
|
|
}
|
|
}
|
|
else{
|
|
if (inst.sampleWindowHigh < 1 || inst.sampleWindowHigh > 32)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Window between 1 and 32!",
|
|
inst, "sampleWindowHigh");
|
|
}
|
|
}
|
|
|
|
if (!Number.isInteger(inst.sampleWindowHigh))
|
|
{
|
|
validation.logError(
|
|
"Digital Filter Sample Window must be an integer",
|
|
inst, "sampleWindowHigh");
|
|
}
|
|
|
|
if (!(inst.thresholdHigh > (inst.sampleWindowHigh/2)) || !(inst.thresholdHigh <= inst.sampleWindowHigh))
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Threshold between "+Math.ceil((inst.sampleWindowHigh + 1)/2)+" and "+inst.sampleWindowHigh,
|
|
inst, "thresholdHigh");
|
|
}
|
|
if (!Number.isInteger(inst.thresholdHigh))
|
|
{
|
|
validation.logError(
|
|
"Digital Filter Threshold must be an integer",
|
|
inst, "thresholdHigh");
|
|
}
|
|
|
|
if (["F28P65x","F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
if(inst.samplePrescaleLow < 0 || inst.samplePrescaleLow > 16777215)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Prescale between 0 and 16,777,215!",
|
|
inst, "samplePrescaleLow");
|
|
}
|
|
}
|
|
else if (["F28003x","F280013x","F280015x"].includes(Common.getDeviceName()))
|
|
{
|
|
if (inst.samplePrescaleLow < 0 || inst.samplePrescaleLow > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Prescale between 0 and 65,535!",
|
|
inst, "samplePrescaleLow");
|
|
}
|
|
}
|
|
else if (inst.samplePrescaleLow < 0 || inst.samplePrescaleLow > 1023)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Prescale between 0 and 1,023!",
|
|
inst, "samplePrescaleLow");
|
|
}
|
|
if (!Number.isInteger(inst.samplePrescaleLow))
|
|
{
|
|
validation.logError(
|
|
"Digital Filter Sample Prescale must be an integer",
|
|
inst, "samplePrescaleLow");
|
|
}
|
|
if (["F28P65x","F28P55x"].includes(Common.getDeviceName()))
|
|
{
|
|
if (inst.sampleWindowLow < 1 || inst.sampleWindowLow > 64)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Window between 1 and 64!",
|
|
inst, "sampleWindowLow");
|
|
}
|
|
}
|
|
else{
|
|
if (inst.sampleWindowLow < 1 || inst.sampleWindowLow > 32)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Sample Window between 1 and 32!",
|
|
inst, "sampleWindowLow");
|
|
}
|
|
}
|
|
if (!Number.isInteger(inst.sampleWindowLow))
|
|
{
|
|
validation.logError(
|
|
"Digital Filter Sample Window must be an integer",
|
|
inst, "sampleWindowLow");
|
|
}
|
|
|
|
if (!(inst.thresholdLow > (inst.sampleWindowLow/2)) || (!(inst.thresholdLow <= inst.sampleWindowLow)))
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Digital Filter Threshold between "+Math.ceil((inst.sampleWindowLow + 1)/2)+" and "+inst.sampleWindowLow,
|
|
inst, "thresholdLow");
|
|
}
|
|
if (!Number.isInteger(inst.thresholdLow))
|
|
{
|
|
validation.logError(
|
|
"Digital Filter Threshold must be an integer",
|
|
inst, "thresholdLow");
|
|
}
|
|
|
|
var selectedInterfaces = null;
|
|
var allInterfaces = null;
|
|
if (Common.isContextCPU1()) {
|
|
if (Common.peripheralCount("ANALOG") > 0)
|
|
{
|
|
selectedInterfaces = Pinmux.getPeripheralUseCaseInterfaces(inst.analog, "ANALOG", inst.analog.useCase);
|
|
allInterfaces = Pinmux.getPeripheralUseCaseInterfaces(inst.analog, "ANALOG", "ALL");
|
|
}
|
|
}
|
|
if (["F28002x","F28003x","F28P55x","F280013x","F280015x","F28004x", "F28P65x"].includes(Common.getDeviceName())){
|
|
if ((inst.asysCMPHPMXSELPinInfo == Pinmux.NO_DEVICE_PIN_FOUND) && (inst.asysCMPLPMXSELPinInfo == Pinmux.NO_DEVICE_PIN_FOUND))
|
|
{
|
|
validation.logError(
|
|
"Signal not available for this device, select a valid signal!",
|
|
inst, "asysCMPHPMXSELValue");
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHPMXSELValue].displayName
|
|
var tempPinNameH = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHPMXSELValue].displayName
|
|
var tempPinInfoH = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
|
|
var allPinsMustBeConfigured = true;
|
|
|
|
if ((tempPinName == "B5" || tempPinName == "B11") && Common.getDevicePart() == "F28003x_100PZ")
|
|
{
|
|
validation.logInfo(
|
|
"For 100PZ package on F28003x, only one of the pins can be used and setup for this channel.",
|
|
inst, "asysCMPHPMXSELValue");
|
|
allPinsMustBeConfigured = false;
|
|
}
|
|
|
|
//
|
|
// Check for Pin Usage in analog
|
|
//
|
|
if (Common.isContextCPU1()) {
|
|
if (Common.peripheralCount("ANALOG") > 0)
|
|
{
|
|
|
|
var configurationStatus = [];
|
|
var finalFail = true;
|
|
|
|
for (var apinfo of tempPinInfoH){
|
|
var pinSelected = apinfo.PinDesignSignalName;
|
|
|
|
configurationStatus.push(
|
|
{
|
|
fail: (!selectedInterfaces.includes(pinSelected) && allInterfaces.includes(pinSelected)),
|
|
pinSelected: pinSelected
|
|
}
|
|
)
|
|
}
|
|
for (var cstat of configurationStatus){finalFail &= cstat.fail}
|
|
|
|
|
|
if (allPinsMustBeConfigured)
|
|
{
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPHPMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (finalFail)
|
|
{
|
|
validation.logError(
|
|
"At least one of the following ANALOG PinMux pins must be selected.",
|
|
inst,"asysCMPHPMXSELValue");
|
|
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPHPMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if((inst.highCompNegative != "CMPSS_INSRC_DAC") && (inst.asysCMPHNMXSELPinInfo == Pinmux.NO_DEVICE_PIN_FOUND))
|
|
{
|
|
validation.logError(
|
|
"Signal not available for this device, select a valid signal!",
|
|
inst, "asysCMPHNMXSELValue");
|
|
}
|
|
else
|
|
{
|
|
var tempPinNameN = ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHNMXSELValue].displayName
|
|
var tempPinNameNH = ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPHNMXSELValue].displayName
|
|
var tempPinInfoNH = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinNameN.split("/")[0]))
|
|
|
|
var allPinsMustBeConfigured = true;
|
|
|
|
if ((inst.highCompNegative != "CMPSS_INSRC_DAC") && (tempPinNameN == "B5" || tempPinNameN == "B11") && Common.getDevicePart() == "F28003x_100PZ")
|
|
{
|
|
validation.logInfo(
|
|
"For 100PZ package on F28003x, only one of the pins can be used and setup for this channel.",
|
|
inst, "asysCMPHNMXSELValue");
|
|
allPinsMustBeConfigured = false;
|
|
}
|
|
|
|
//
|
|
// Check for Pin Usage in analog
|
|
//
|
|
if(inst.highCompNegative != "CMPSS_INSRC_DAC")
|
|
{
|
|
if (Common.isContextCPU1()) {
|
|
if (Common.peripheralCount("ANALOG") > 0)
|
|
{
|
|
|
|
var configurationStatus = [];
|
|
var finalFail = true;
|
|
|
|
for (var apinfo of tempPinInfoNH){
|
|
var pinSelected = apinfo.PinDesignSignalName;
|
|
|
|
configurationStatus.push(
|
|
{
|
|
fail: (!selectedInterfaces.includes(pinSelected) && allInterfaces.includes(pinSelected)),
|
|
pinSelected: pinSelected
|
|
}
|
|
)
|
|
}
|
|
for (var cstat of configurationStatus){finalFail &= cstat.fail}
|
|
|
|
if (allPinsMustBeConfigured)
|
|
{
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPHNMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (finalFail)
|
|
{
|
|
validation.logError(
|
|
"At least one of the following ANALOG PinMux pins must be selected.",
|
|
inst,"asysCMPHNMXSELValue");
|
|
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPHNMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (inst.asysCMPLPMXSELPinInfo == Pinmux.NO_DEVICE_PIN_FOUND)
|
|
{
|
|
if((["F28P65x"].includes(Common.getDeviceName())))
|
|
{
|
|
if(ComparatorInputs.CMPSS_comparatorLowPositiveInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue])
|
|
{
|
|
var tempPinNameLowPos = ComparatorInputs.CMPSS_comparatorLowPositiveInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue].displayName
|
|
if(tempPinNameLowPos.includes("VREF"))
|
|
{
|
|
//Do nothing, this is a valid connection for F28P65x
|
|
}
|
|
}
|
|
else
|
|
{
|
|
validation.logError(
|
|
"Signal not available for this device, select a valid signal!",
|
|
inst, "asysCMPLPMXSELValue");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
validation.logError(
|
|
"Signal not available for this device, select a valid signal!",
|
|
inst, "asysCMPLPMXSELValue");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var tempPinName = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue].displayName
|
|
var tempPinNameL = ComparatorInputs.CMPSS_comparatorInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLPMXSELValue].displayName
|
|
var tempPinInfoL = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinName.split("/")[0]))
|
|
|
|
var allPinsMustBeConfigured = true;
|
|
|
|
if ((tempPinName == "B5" || tempPinName == "B11") && Common.getDevicePart() == "F28003x_100PZ")
|
|
{
|
|
validation.logInfo(
|
|
"For 100PZ package on F28003x, only one of the pins can be used and setup for this channel.",
|
|
inst, "asysCMPLPMXSELValue");
|
|
allPinsMustBeConfigured = false;
|
|
}
|
|
|
|
//
|
|
// Check for Pin Usage in analog
|
|
//
|
|
if (Common.isContextCPU1()) {
|
|
if (Common.peripheralCount("ANALOG") > 0)
|
|
{
|
|
|
|
var configurationStatus = [];
|
|
var finalFail = true;
|
|
|
|
for (var apinfo of tempPinInfoL){
|
|
var pinSelected = apinfo.PinDesignSignalName;
|
|
|
|
configurationStatus.push(
|
|
{
|
|
fail: (!selectedInterfaces.includes(pinSelected) && allInterfaces.includes(pinSelected)),
|
|
pinSelected: pinSelected
|
|
}
|
|
)
|
|
}
|
|
for (var cstat of configurationStatus){finalFail &= cstat.fail}
|
|
|
|
|
|
if (allPinsMustBeConfigured)
|
|
{
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPLPMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (finalFail)
|
|
{
|
|
validation.logError(
|
|
"At least one of the following ANALOG PinMux pins must be selected.",
|
|
inst,"asysCMPLPMXSELValue");
|
|
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPLPMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if((inst.lowCompNegative != "CMPSS_INSRC_DAC") && (inst.asysCMPLNMXSELPinInfo == Pinmux.NO_DEVICE_PIN_FOUND))
|
|
{
|
|
validation.logError(
|
|
"Signal not available for this device, select a valid signal!",
|
|
inst, "asysCMPLNMXSELValue");
|
|
}
|
|
else
|
|
{
|
|
var tempPinNameN = ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLNMXSELValue].displayName
|
|
var tempPinNameLN = ComparatorInputs.CMPSS_comparatorNegInputSignals[Common.getDeviceName()][inst.cmpssBase][inst.asysCMPLNMXSELValue].displayName
|
|
var tempPinInfoLN = Pinmux.findAllAnalogPin(Pinmux.getDeviceADCName(tempPinNameN.split("/")[0]))
|
|
|
|
var allPinsMustBeConfigured = true;
|
|
|
|
if ((inst.lowCompNegative != "CMPSS_INSRC_DAC") && (tempPinNameN == "B5" || tempPinNameN == "B11") && Common.getDevicePart() == "F28003x_100PZ")
|
|
{
|
|
validation.logInfo(
|
|
"For 100PZ package on F28003x, only one of the pins can be used and setup for this channel.",
|
|
inst, "asysCMPLNMXSELValue");
|
|
allPinsMustBeConfigured = false;
|
|
}
|
|
|
|
//
|
|
// Check for Pin Usage in analog
|
|
//
|
|
if(inst.lowCompNegative != "CMPSS_INSRC_DAC")
|
|
{
|
|
if (Common.isContextCPU1()) {
|
|
if (Common.peripheralCount("ANALOG") > 0)
|
|
{
|
|
|
|
var configurationStatus = [];
|
|
var finalFail = true;
|
|
|
|
for (var apinfo of tempPinInfoLN){
|
|
var pinSelected = apinfo.PinDesignSignalName;
|
|
|
|
configurationStatus.push(
|
|
{
|
|
fail: (!selectedInterfaces.includes(pinSelected) && allInterfaces.includes(pinSelected)),
|
|
pinSelected: pinSelected
|
|
}
|
|
)
|
|
}
|
|
for (var cstat of configurationStatus){finalFail &= cstat.fail}
|
|
|
|
|
|
if (allPinsMustBeConfigured)
|
|
{
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPLNMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (finalFail)
|
|
{
|
|
validation.logError(
|
|
"At least one of the following ANALOG PinMux pins must be selected.",
|
|
inst,"asysCMPLNMXSELValue");
|
|
|
|
for (var cstat of configurationStatus)
|
|
{
|
|
if (cstat.fail)
|
|
{
|
|
validation.logError(
|
|
"The pin " + cstat.pinSelected + " is not selected in the ANALOG PinMux module." +
|
|
" Add this pin to the 'Pins Used' or change the 'Use Case'",
|
|
inst, "asysCMPLNMXSELValue");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//Add validation for DE support with ePWM
|
|
}
|
|
|
|
/*
|
|
* ======== filterHardware ========
|
|
* Control RX, TX Pin usage by the user specified dataDirection.
|
|
*
|
|
* param component - hardware object describing signals and
|
|
* resources they're attached to
|
|
*
|
|
* returns Boolean indicating whether or not to allow the component to
|
|
* be assigned to an instance's $hardware config
|
|
*/
|
|
function filterHardware(component)
|
|
{
|
|
return (Common.typeMatches(component.type, ["CMPSS"]));
|
|
}
|
|
|
|
|
|
var sharedModuleInstances = undefined;
|
|
if (Common.isContextCPU1()) {
|
|
if (Common.peripheralCount("ANALOG") > 0) {
|
|
sharedModuleInstances = function () {
|
|
return (
|
|
[
|
|
{
|
|
name: "analog",
|
|
displayName: "Analog PinMux",
|
|
moduleName: "/driverlib/analog.js"
|
|
},
|
|
]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
var cmpssModule = {
|
|
peripheralName : "CMPSS",
|
|
displayName : "CMPSS",
|
|
maxInstances : deviceNumberOfInstances,
|
|
defaultInstanceName : "myCMPSS",
|
|
description : "Comparator Subsystem",
|
|
longDescription: (Common.getCollateralFindabilityList("CMPSS")),
|
|
filterHardware : filterHardware,
|
|
config : config,
|
|
sharedModuleInstances : sharedModuleInstances,
|
|
templates: {
|
|
boardc : "/driverlib/cmpss/cmpss.board.c.xdt",
|
|
boardh : "/driverlib/cmpss/cmpss.board.h.xdt"
|
|
},
|
|
validate : onValidate,
|
|
};
|
|
|
|
exports = cmpssModule;
|