815 lines
32 KiB
JavaScript
815 lines
32 KiB
JavaScript
let Common = system.getScript("/driverlib/Common.js");
|
|
let Pinmux = system.getScript("/driverlib/pinmux.js");
|
|
let PinmuxAdditionalUseCases = system.getScript("/driverlib/pinmux/pinmux_additionalUseCases.js");
|
|
|
|
/* Intro splash on GUI */
|
|
let longDescription = `The Enhanced Quadrature Encoder Pulse (eQEP) module is used for direct interface with a linear or rotary
|
|
incremental encoder to get position, direction, and speed information from a rotating machine for use in a
|
|
high-performance motion and position-control system.
|
|
`
|
|
|
|
let device_driverlib_peripheral =
|
|
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
|
Common.getDeviceName().toLowerCase() + "_eqep.js");
|
|
|
|
function onChangeUseInterrupts(inst, ui)
|
|
{
|
|
if (inst.useInterrupts){
|
|
ui.enableInterrupt.hidden = false
|
|
ui.registerInterrupts.hidden = false
|
|
ui.interruptSources.hidden = false
|
|
}
|
|
else{
|
|
ui.enableInterrupt.hidden = true
|
|
ui.registerInterrupts.hidden = true
|
|
ui.interruptSources.hidden = true
|
|
}
|
|
}
|
|
|
|
/* Array of CAN configurables that are common across device families */
|
|
let config = [
|
|
{
|
|
//
|
|
// This is needed for locking some options when a HARDWARE is needed
|
|
// Currently we only have NO STROB connection for EQEP on launchpads
|
|
//
|
|
name: "$hardware",
|
|
onChange: (inst, ui) => {
|
|
if (inst.$hardware)
|
|
{
|
|
var useCaseNames = Pinmux.getPeripheralUseCaseNames("EQEP").map((useCaseOpt) => {
|
|
return useCaseOpt.name
|
|
}
|
|
);
|
|
useCaseNames = useCaseNames.concat(PinmuxAdditionalUseCases.getAdditionalUseCaseNames("EQEP"));
|
|
|
|
if (useCaseNames.includes("NO STROBE"))
|
|
{
|
|
inst.useCase = "NO STROBE"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
];
|
|
let conditionalConfig = [];
|
|
conditionalConfig = conditionalConfig.concat([
|
|
// setInputPolarity
|
|
{
|
|
name : "inputPolarity",
|
|
displayName : "Input Polarity",
|
|
description : "Sets the polarity of the eQEP module's input signals.",
|
|
hidden : false,
|
|
default : [],
|
|
minSelections: 0,
|
|
options :
|
|
[
|
|
{name: "invertQEPA", displayName: "Invert QEPA"},
|
|
{name: "invertQEPB", displayName: "Invert QEPB"},
|
|
{name: "invertIndex", displayName: "Invert Index"},
|
|
{name: "invertStrobe", displayName: "Invert Strobe"},
|
|
]
|
|
},
|
|
// setDecoderConfig
|
|
{
|
|
name : "eqepOperationMode",
|
|
displayName : "Position Counter Source (QSRC)",
|
|
description : `Specify if quadrature signals are being provided on QEPA and QEPB,
|
|
if a direction signal and a clock are being provided, or if the direction
|
|
should be hard-wired for a single direction with QEPA used for input.`,
|
|
hidden : false,
|
|
default : "EQEP_CONFIG_QUADRATURE",
|
|
options :
|
|
[
|
|
{name: "EQEP_CONFIG_QUADRATURE", displayName: "Quadrature-clock mode"},
|
|
{name: "EQEP_CONFIG_CLOCK_DIR", displayName: "Direction-count mode"},
|
|
{name: "EQEP_CONFIG_UP_COUNT", displayName: "Up-count mode, QDIR = 1"},
|
|
{name: "EQEP_CONFIG_DOWN_COUNT", displayName: "Down-count mode, QDIR = 0"},
|
|
]
|
|
},
|
|
{
|
|
name : "eqepResolution",
|
|
displayName : "Resolution",
|
|
description : "Specify if both rising and falling edges should be counted or just rising edges",
|
|
hidden : false,
|
|
default : "EQEP_CONFIG_2X_RESOLUTION",
|
|
options :
|
|
[
|
|
{name: "EQEP_CONFIG_2X_RESOLUTION", displayName: "2X Resolution: Count rising and falling edge"},
|
|
{name: "EQEP_CONFIG_1X_RESOLUTION", displayName: "1X Resolution: Count rising edge only"},
|
|
]
|
|
},
|
|
{
|
|
name : "eqepSwap",
|
|
displayName : "Swap QEPA and QEPB",
|
|
description : `Specify if the signals provided on QEPA and QEPB should be swapped
|
|
before being processed.`,
|
|
hidden : false,
|
|
default : "EQEP_CONFIG_NO_SWAP",
|
|
options :
|
|
[
|
|
{name: "EQEP_CONFIG_NO_SWAP", displayName: "Do not swap QEPA and QEPB"},
|
|
{name: "EQEP_CONFIG_SWAP", displayName: "Swap QEPA and QEPB"},
|
|
]
|
|
},
|
|
{
|
|
name : "eqepIGATE",
|
|
displayName : "Index Pulse Gating",
|
|
description : `Specify if the gating of the index pulse should be enabled or disabled.`,
|
|
hidden : false,
|
|
default : "EQEP_CONFIG_IGATE_DISABLE",
|
|
options :
|
|
[
|
|
{name: "EQEP_CONFIG_IGATE_DISABLE", displayName: "Disable gating of Index pulse"},
|
|
{name: "EQEP_CONFIG_IGATE_ENABLE", displayName: "Gate the index pin with strobe"},
|
|
]
|
|
},
|
|
])
|
|
if (["F28002x","F28003x","F280013x","F280015x","F2838x", "F28P65x"].includes(Common.getDeviceName())){
|
|
conditionalConfig = conditionalConfig.concat([
|
|
// enableDirectionChangeDuringIndex /disableDirectionChangeDuringIndex
|
|
{
|
|
name : "enableDirectionChange",
|
|
displayName : "Enable Direction Change During Index",
|
|
description : 'Enables the index direction enhancement mode of the eQEP module.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
])
|
|
}
|
|
config = config.concat([
|
|
{
|
|
name : "GROUP_DECODER",
|
|
displayName : "Quadrature Decoder Unit",
|
|
description : "",
|
|
longDescription : "",
|
|
config : conditionalConfig
|
|
},
|
|
{
|
|
name : "GROUP_POSITION",
|
|
displayName : "Position Counter and Control Unit",
|
|
description : "",
|
|
longDescription : "",
|
|
config : [
|
|
// setPositionCounterConfig
|
|
{
|
|
name : "positionCounterMode",
|
|
displayName : "Position Counter Mode",
|
|
description : "Configuration for the eQEP module position counter.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_PositionResetMode[0].name,
|
|
options : device_driverlib_peripheral.EQEP_PositionResetMode
|
|
},
|
|
{
|
|
name : "positionCounterMax",
|
|
displayName : "Maximum Position",
|
|
description : "Specifies the maximum position value.",
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
// setPosition
|
|
{
|
|
name : "setPosition",
|
|
displayName : "Position Counter (QPOSCNT)",
|
|
description : "Sets the current encoder position.",
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name: "GROUP_LATCH",
|
|
displayName: "Latch Mode",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: [
|
|
// setLatchMode
|
|
{
|
|
name : "latchPositionCounter",
|
|
displayName : "QEP Capture Latch Mode (QCLM)",
|
|
description : "Specify the event that latches the position counter.",
|
|
hidden : false,
|
|
default : "EQEP_LATCH_CNT_READ_BY_CPU",
|
|
options :
|
|
[
|
|
{name: "EQEP_LATCH_CNT_READ_BY_CPU", displayName: "On position counter read"},
|
|
{name: "EQEP_LATCH_UNIT_TIME_OUT", displayName: "On unit time-out event"},
|
|
]
|
|
},
|
|
{
|
|
name : "latchStrobePosition",
|
|
displayName : "Strobe Event Latch (SEL)",
|
|
description : "Specify which strobe event will latch the position counter into the strobe position latch register. ",
|
|
hidden : false,
|
|
default : "EQEP_LATCH_RISING_STROBE",
|
|
options :
|
|
[
|
|
{name: "EQEP_LATCH_RISING_STROBE", displayName: "On rising edge of strobe"},
|
|
{name: "EQEP_LATCH_EDGE_DIR_STROBE", displayName: "On rising edge when clockwise, on falling when counter clockwise"},
|
|
]
|
|
},
|
|
{
|
|
name : "latchIndexPosition",
|
|
displayName : "Index Event Latch (IEL)",
|
|
description : "Specify which index event will latch the position counter into the index position latch register.",
|
|
hidden : false,
|
|
default : "EQEP_LATCH_RISING_INDEX",
|
|
options :
|
|
[
|
|
{name: "EQEP_LATCH_RISING_INDEX", displayName: "On rising edge of index"},
|
|
{name: "EQEP_LATCH_FALLING_INDEX", displayName: "On falling edge of index"},
|
|
{name: "EQEP_LATCH_SW_INDEX_MARKER", displayName: "On software index marker"},
|
|
]
|
|
},
|
|
]
|
|
},
|
|
// setPositionInitMode
|
|
{
|
|
name : "positionStrobeEvents",
|
|
displayName : "Position Strobe Events (SEI)",
|
|
description : "Specify which strobe event will initialize the position counter.",
|
|
hidden : false,
|
|
default : "EQEP_INIT_DO_NOTHING",
|
|
options :
|
|
[
|
|
{name: "EQEP_INIT_DO_NOTHING", displayName: "Action is disabled"},
|
|
{name: "EQEP_INIT_RISING_STROBE", displayName: "On rising edge of strobe"},
|
|
{name: "EQEP_INIT_EDGE_DIR_STROBE", displayName: "On rising edge when clockwise, on falling when counter clockwise"},
|
|
]
|
|
},
|
|
{
|
|
name : "positionIndexEvents",
|
|
displayName : "Position Index Events (IEI)",
|
|
description : "Specify which index event will initialize the position counter.",
|
|
hidden : false,
|
|
default : "EQEP_INIT_DO_NOTHING",
|
|
options :
|
|
[
|
|
{name: "EQEP_INIT_DO_NOTHING", displayName: "Action is disabled"},
|
|
{name: "EQEP_INIT_RISING_INDEX", displayName: "On rising edge of index"},
|
|
{name: "EQEP_INIT_FALLING_INDEX", displayName: "On falling edge of index"},
|
|
]
|
|
},
|
|
// setSWPositionInit
|
|
{
|
|
name : "swPositionInit",
|
|
displayName : " Set Software Initialization Position Counter",
|
|
description : 'Sets the software initialization of the encoder position counter.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// setInitialPosition
|
|
{
|
|
name : "initialPosition",
|
|
displayName : "Position Counter Initialization Value",
|
|
description : 'Sets the init value for the encoder position counter.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
// enableModule / disableModule
|
|
{
|
|
name : "enableModule",
|
|
displayName : "Enable Position Counter",
|
|
description : 'Enables the eQEP module.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name: "GROUP_COMPARE",
|
|
displayName: "Compare Configuration",
|
|
description: "",
|
|
longDescription: "",
|
|
collapsed: false,
|
|
config: [
|
|
// setCompareConfig [do we have a boolean to determine if we do this?]
|
|
{
|
|
name : "compareConfig",
|
|
displayName : "Configure Position-Compare Unit",
|
|
description : 'Enables configuration of eQEP module position-compare unit.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "compareSyncPulsePin",
|
|
displayName : "Sync Output Pin Selection (SPSEL)",
|
|
description : "Specify if there is a sync output pulse and which pin should be used.",
|
|
hidden : false,
|
|
default : "EQEP_COMPARE_NO_SYNC_OUT",
|
|
options :
|
|
[
|
|
{name: "EQEP_COMPARE_NO_SYNC_OUT", displayName: "Disable sync output"},
|
|
{name: "EQEP_COMPARE_IDX_SYNC_OUT", displayName: "Sync output on index pin"},
|
|
{name: "EQEP_COMPARE_STROBE_SYNC_OUT", displayName: "Sync output on strobe pin"},
|
|
]
|
|
},
|
|
{
|
|
name : "compareShadowRegisterUse",
|
|
displayName : "Position Compare of Shadow Load (PCLOAD)",
|
|
description : "Specify if a shadow is enabled and when should the load should occur.",
|
|
hidden : false,
|
|
default : "EQEP_COMPARE_NO_SHADOW",
|
|
options :
|
|
[
|
|
{name: "EQEP_COMPARE_NO_SHADOW", displayName: "Disable shadow of QPOSCMP"},
|
|
{name: "EQEP_COMPARE_LOAD_ON_ZERO", displayName: "Load on QPOSCNT = 0"},
|
|
{name: "EQEP_COMPARE_LOAD_ON_MATCH", displayName: "Load on QPOSCNT = QPOSCMP"},
|
|
]
|
|
},
|
|
{
|
|
name : "compareValue",
|
|
displayName : "Compare Value",
|
|
description : 'The value to which the position count value is compared for a position-compare event.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "compareCycles",
|
|
displayName : "Compare Cycles",
|
|
description : 'The width of the pulse that can be generated on a position-compare event. It is in units of 4 SYSCLKOUT cycles.',
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
// enableCompare / disableCompare
|
|
{
|
|
name : "enableCompare",
|
|
displayName : "Enable Position-Compare Unit",
|
|
description : 'Enables the eQEP module position-compare unit.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
]
|
|
},
|
|
]
|
|
},
|
|
{
|
|
name : "GROUP_EDGE_CAPTURE",
|
|
displayName : "Edge Capture Unit",
|
|
description : "",
|
|
longDescription : "",
|
|
config : [
|
|
// setCaptureConfig [do we have a boolean to determine if we do this?]
|
|
{
|
|
name : "captureConfig",
|
|
displayName : "Configure Edge-Capture Unit",
|
|
description : 'Enables configuration of eQEP module edge-capture unit.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "capPrescale",
|
|
displayName : "Capture Prescaler (QC Timer)",
|
|
description : "Prescaler setting of the eQEP capture timer clk.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_CAPCLKPrescale[0].name,
|
|
options : device_driverlib_peripheral.EQEP_CAPCLKPrescale
|
|
},
|
|
{
|
|
name: "qcTimeFreq",
|
|
displayName : "QC Timer Frequency [MHz]",
|
|
getValue : (inst) => {
|
|
if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_1")
|
|
{
|
|
return (Common.getSYSCLK() / 1);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_2")
|
|
{
|
|
return (Common.getSYSCLK() / 2);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_4")
|
|
{
|
|
return (Common.getSYSCLK() / 4);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_8")
|
|
{
|
|
return (Common.getSYSCLK() / 8);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_16")
|
|
{
|
|
return (Common.getSYSCLK() / 16);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_32")
|
|
{
|
|
return (Common.getSYSCLK() / 32);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_64")
|
|
{
|
|
return (Common.getSYSCLK() / 64);
|
|
}
|
|
else if(inst.capPrescale == "EQEP_CAPTURE_CLK_DIV_128")
|
|
{
|
|
return (Common.getSYSCLK() / 128);
|
|
}
|
|
},
|
|
default : Common.getSYSCLK(),
|
|
},
|
|
{
|
|
name : "evntPrescale",
|
|
displayName : "Unit Position Event Prescaler",
|
|
description : "Prescaler setting of the unit position event.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_UPEVNTPrescale[0].name,
|
|
options : device_driverlib_peripheral.EQEP_UPEVNTPrescale
|
|
},
|
|
// enableCapture / disableCapture
|
|
{
|
|
name : "enableCapture",
|
|
displayName : "Enable Edge-Capture Unit",
|
|
description : 'Enables the eQEP module edge-capture unit.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// enableUnitTimer / disableUnitTimer
|
|
{
|
|
name : "enableUnitTimer",
|
|
displayName : "Enable Unit Timer",
|
|
description : 'Enables the eQEP module unit timer.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "unitTimerPeriod",
|
|
displayName : "Unit Timer Period",
|
|
description : "Period value at which a unit time-out interrupt is set.",
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "unitTimerValNS",
|
|
displayName : "Unit Timer Period [ns]",
|
|
description : "Value of Unit Timer in nanoseconds.",
|
|
getValue : (inst) =>
|
|
{
|
|
return ((inst.unitTimerPeriod / Common.getSYSCLK()) * 1000);
|
|
},
|
|
default : 0
|
|
},
|
|
]
|
|
},
|
|
|
|
{
|
|
name : "GROUP_WATCHDOG",
|
|
displayName : "EQEP Watchdog Timer",
|
|
description : "",
|
|
longDescription : "",
|
|
config : [
|
|
// enableWatchDog / disableWatchdog
|
|
{
|
|
name : "enableWatchdog",
|
|
displayName : "Enable EQEP Watchdog",
|
|
description : "Enables the eQEP module watchdog timer.",
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "watchdogTimerPeriod",
|
|
displayName : "EQEP Watchdog Timer Period",
|
|
description : "Watchdog period value at which a time-out will occur if no quadrature-clock event is detected.",
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
// setWatchdogTimerValue
|
|
{
|
|
name : "watchdogTimerValue",
|
|
displayName : "EQEP Watchdog Timer Value",
|
|
description : "Sets the eQEP module watchdog timer value.",
|
|
hidden : false,
|
|
default : 0
|
|
},
|
|
{
|
|
name : "watchdogTimerValueNS",
|
|
displayName : "EQEP Watchdog Timer Value [ns]",
|
|
description : "Value of EQEP Watchdog Timer in nanoseconds.",
|
|
getValue : (inst) =>
|
|
{
|
|
return ((1 / Common.getSYSCLK()) * 1000);
|
|
},
|
|
default : 0
|
|
},
|
|
]
|
|
},
|
|
{
|
|
name : "GROUP_INTERRUPTS",
|
|
displayName : "Interrupts",
|
|
description : "",
|
|
longDescription : "",
|
|
config : [
|
|
// use & register interrupt
|
|
{
|
|
name : "useInterrupts",
|
|
displayName : "Use Interrupt",
|
|
onChange : onChangeUseInterrupts,
|
|
description : 'Whether or not to use Interrupt mode.',
|
|
hidden : false,
|
|
default : true
|
|
},
|
|
{
|
|
name : "registerInterrupts",
|
|
displayName : "Register Interrupt Handler",
|
|
description : 'Whether or not to register interrupt handlers in the interrupt module.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
// enableInterrupt / disableInterrupt
|
|
{
|
|
name : "enableInterrupt",
|
|
displayName : "Enable Interrupt",
|
|
description : 'Enables interrupt source.',
|
|
hidden : false,
|
|
default : false
|
|
},
|
|
{
|
|
name : "interruptSources",
|
|
displayName : "Interrupt Sources",
|
|
description : "The interrupt sources to be enabled.",
|
|
hidden : false,
|
|
default : [],
|
|
minSelections: 0,
|
|
options : device_driverlib_peripheral.EQEP_INT
|
|
},
|
|
]
|
|
},
|
|
|
|
// setEmulationMode
|
|
{
|
|
name : "emulationMode",
|
|
displayName : "Emulation Mode",
|
|
description : "Set the emulation mode of the eQEP module.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_EmulationMode[0].name,
|
|
options : device_driverlib_peripheral.EQEP_EmulationMode
|
|
},
|
|
]);
|
|
if (device_driverlib_peripheral.EQEP_QMAMode){
|
|
//(["F28004x","F28002x","F28003x","F280013x","F280015x","F2838x", "F28P65x"].includes(Common.getDeviceName())){ //Replace to make generic
|
|
config.push(
|
|
// setQMAModuleMode
|
|
{
|
|
name : "qmaModuleMode",
|
|
displayName : "QMA Module Mode",
|
|
description : "Set the quadrature mode adapter (QMA) module mode.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_QMAMode[0].name,
|
|
options : device_driverlib_peripheral.EQEP_QMAMode
|
|
},
|
|
)
|
|
}
|
|
if (device_driverlib_peripheral.EQEP_Source){
|
|
//(["F28002x","F28003x","F280013x","F280015x","F2838x", "F28P65x"].includes(Common.getDeviceName())){
|
|
config.push(
|
|
|
|
// selectSource
|
|
{
|
|
name : "selectSourceA",
|
|
displayName : "QEPA Source",
|
|
description : "Selects the source for QEPA signal.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_Source[0].name,
|
|
options : device_driverlib_peripheral.EQEP_Source
|
|
},
|
|
{
|
|
name : "selectSourceB",
|
|
displayName : "QEPB Source",
|
|
description : "Selects the source for QEPB signal.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_Source[0].name,
|
|
options : device_driverlib_peripheral.EQEP_Source
|
|
},
|
|
{
|
|
name : "selectSourceIndex",
|
|
displayName : "QEPI/Index Source",
|
|
description : "Selects the source for Index signal.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_Source[0].name,
|
|
options : device_driverlib_peripheral.EQEP_Source
|
|
},
|
|
)
|
|
}
|
|
if (device_driverlib_peripheral.EQEP_StrobeSource){
|
|
//(["F28004x","F28002x","F28003x","F280013x","F280015x","F2838x", "F28P65x"].includes(Common.getDeviceName())){
|
|
config.push(
|
|
// setStrobeSource
|
|
{
|
|
name : "strobeSource",
|
|
displayName : "Strobe Source",
|
|
description : "Set the strobe input source of the eQEP module.",
|
|
hidden : false,
|
|
default : device_driverlib_peripheral.EQEP_StrobeSource[0].name,
|
|
options : device_driverlib_peripheral.EQEP_StrobeSource
|
|
},
|
|
)
|
|
}
|
|
|
|
var useCaseConfig = {
|
|
name: "useCase",
|
|
displayName : "Pinmux Use Case",
|
|
description : 'Peripheral use case',
|
|
hidden : false,
|
|
default : 'ALL',
|
|
options : Pinmux.getPeripheralUseCaseNames("EQEP"),
|
|
onChange : Pinmux.useCaseChanged,
|
|
}
|
|
|
|
useCaseConfig.options = useCaseConfig.options.concat(Pinmux.getAdditionalUseCaseNameConfigsNotInDeviceData("EQEP"))
|
|
|
|
config.push(
|
|
useCaseConfig
|
|
)
|
|
|
|
function onValidate(inst, validation) {
|
|
/* Validate Position Counter Max up to 32 bit unsigned int */
|
|
if (inst.positionCounterMax < 0 || inst.positionCounterMax > 4294967295)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Position Counter Maximum between 0 and 4,294,967,295!",
|
|
inst, "positionCounterMax");
|
|
}
|
|
if (!Number.isInteger(inst.positionCounterMax))
|
|
{
|
|
validation.logError(
|
|
"Position Counter Maximum must be an integer",
|
|
inst, "positionCounterMax");
|
|
}
|
|
|
|
/* Validate Position Counter Initialization Value up to 32 bit unsigned int */
|
|
if (inst.initialPosition < 0 || inst.initialPosition > 4294967295)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Position Counter Initialization Value between 0 and 4,294,967,295!",
|
|
inst, "initialPosition");
|
|
}
|
|
if (!Number.isInteger(inst.initialPosition))
|
|
{
|
|
validation.logError(
|
|
"Position Counter Initialization Value must be an integer",
|
|
inst, "initialPosition");
|
|
}
|
|
|
|
/* Validate Unit Timer Period up to 32 bit unsigned int */
|
|
if (inst.unitTimerPeriod < 0 || inst.unitTimerPeriod > 4294967295)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Unit Timer Period between 0 and 4,294,967,295!",
|
|
inst, "unitTimerPeriod");
|
|
}
|
|
if (!Number.isInteger(inst.unitTimerPeriod))
|
|
{
|
|
validation.logError(
|
|
"Unit Timer Period must be an integer",
|
|
inst, "unitTimerPeriod");
|
|
}
|
|
|
|
/* Validate Encoder Position up to 32 bit unsigned int */
|
|
if (inst.setPosition < 0 || inst.setPosition > 4294967295)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Encoder Position between 0 and 4,294,967,295!",
|
|
inst, "setPosition");
|
|
}
|
|
if (!Number.isInteger(inst.setPosition))
|
|
{
|
|
validation.logError(
|
|
"Encoder Position must be an integer",
|
|
inst, "setPosition");
|
|
}
|
|
|
|
/* Validate Watchdog Timer Period up to 16 bit unsigned int */
|
|
if (inst.watchdogTimerPeriod < 0 || inst.watchdogTimerPeriod > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for EQEP Watchdog Timer Period between 0 and 65,535!",
|
|
inst, "watchdogTimerPeriod");
|
|
}
|
|
if (!Number.isInteger(inst.watchdogTimerPeriod))
|
|
{
|
|
validation.logError(
|
|
"EQEP Watchdog Timer Period must be an integer",
|
|
inst, "watchdogTimerPeriod");
|
|
}
|
|
|
|
/* Validate Watchdog Timer Value up to 16 bit unsigned int */
|
|
if (inst.watchdogTimerValue < 0 || inst.watchdogTimerValue > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for EQEP Watchdog Timer Value between 0 and 65,535!",
|
|
inst, "watchdogTimerValue");
|
|
}
|
|
if (!Number.isInteger(inst.watchdogTimerValue))
|
|
{
|
|
validation.logError(
|
|
"EQEP Watchdog Timer Value must be an integer",
|
|
inst, "watchdogTimerValue");
|
|
}
|
|
|
|
/* Validate Compare Value up to 32 bit unsigned int */
|
|
if (inst.compareValue < 0 || inst.compareValue > 4294967295)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Compare Value between 0 and 4,294,967,295!",
|
|
inst, "compareValue");
|
|
}
|
|
if (!Number.isInteger(inst.compareValue))
|
|
{
|
|
validation.logError(
|
|
"Compare Value between must be an integer",
|
|
inst, "compareValue");
|
|
}
|
|
|
|
/* Validate Compare Cycles up to 16 bit unsigned int */
|
|
if (inst.compareCycles < 0 || inst.compareCycles > 65535)
|
|
{
|
|
validation.logError(
|
|
"Enter an integer for Compare Cycles between 0 and 65,535!",
|
|
inst, "compareCycles");
|
|
}
|
|
if (!Number.isInteger(inst.compareCycles))
|
|
{
|
|
validation.logError(
|
|
"Compare Cycles must be an integer",
|
|
inst, "compareCycles");
|
|
}
|
|
|
|
var pinmuxQualMods = Pinmux.getGpioQualificationModInstDefinitions("EQEP", inst)
|
|
for (var pinmuxQualMod of pinmuxQualMods)
|
|
{
|
|
if (inst[pinmuxQualMod.name].qualMode == "GPIO_QUAL_ASYNC")
|
|
{
|
|
validation.logError("The asynchronous mode should not be used for eQEP input pins.", inst);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ======== 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, ["EQEP"]));
|
|
}
|
|
|
|
if (Common.onlyPinmux())
|
|
{
|
|
config = [config[config.length - 1]];
|
|
}
|
|
|
|
var eqepModule = {
|
|
peripheralName: "EQEP",
|
|
displayName: "EQEP",
|
|
maxInstances: Common.peripheralCount("EQEP"),
|
|
defaultInstanceName: "myEQEP",
|
|
description: "Enhanced Quadrature Encoder Peripheral",
|
|
// longDescription: longDescription,
|
|
longDescription: longDescription + "\n" + (Common.getCollateralFindabilityList("EQEP")),
|
|
filterHardware : filterHardware,
|
|
config: config,
|
|
moduleInstances: (inst) => {
|
|
var ownedInstances = []
|
|
var pinmuxQualMods = Pinmux.getGpioQualificationModInstDefinitions("EQEP", inst)
|
|
for (var pinmuxQualMod of pinmuxQualMods)
|
|
{
|
|
pinmuxQualMod.args.qualMode = "GPIO_QUAL_SYNC";
|
|
}
|
|
ownedInstances = ownedInstances.concat(pinmuxQualMods)
|
|
|
|
if (inst.useInterrupts && inst.registerInterrupts)
|
|
{
|
|
ownedInstances = ownedInstances.concat([{
|
|
name: "eqepInt",
|
|
displayName: "EQEP Interrupt",
|
|
moduleName: "/driverlib/interrupt.js",
|
|
collapsed: true,
|
|
args: {
|
|
$name : inst.$name + "_INT",
|
|
int : "INT_" + inst.$name,
|
|
pinmuxPeripheralModule : "eqep",
|
|
driverlibInt: "INT_#"
|
|
}
|
|
}])
|
|
}
|
|
return ownedInstances;
|
|
},
|
|
templates: {
|
|
boardc : "/driverlib/eqep/eqep.board.c.xdt",
|
|
boardh : "/driverlib/eqep/eqep.board.h.xdt"
|
|
},
|
|
validate : onValidate,
|
|
pinmuxRequirements : Pinmux.eqepPinmuxRequirements
|
|
};
|
|
|
|
|
|
if (eqepModule.maxInstances <= 0)
|
|
{
|
|
delete eqepModule.pinmuxRequirements;
|
|
}
|
|
else
|
|
{
|
|
Pinmux.addCustomPinmuxEnumToConfig(eqepModule)
|
|
Pinmux.addPinMuxQualGroupToConfig(eqepModule)
|
|
}
|
|
|
|
|
|
exports = eqepModule; |