Update repo
This commit is contained in:
@@ -0,0 +1,457 @@
|
||||
% var module = system.modules['/driverlib/adc.js'];
|
||||
% let Common = system.getScript("/driverlib/Common.js");
|
||||
% var nameOfModule = "adc";
|
||||
% var nameOfPeripheral = module.peripheralName;
|
||||
% var device_driverlib_peripheral = system.getScript("/driverlib/device_driverlib_peripherals/" + Common.getDeviceName().toLowerCase() + "_adc.js");
|
||||
%%{
|
||||
if((["F28002x", "F28003x", "F280013x", "F280015x", "F28004x", "F28P65x", "F28P55x"].includes(Common.getDeviceName()))&&(Common.isContextCPU1())){
|
||||
var staticModule = system.modules['/driverlib/asysctl.js']
|
||||
var stat = staticModule.$static
|
||||
}
|
||||
var varDelay = 500
|
||||
var refMode = ""
|
||||
var refVoltage = ""
|
||||
%%}
|
||||
//*****************************************************************************
|
||||
//
|
||||
// ADC Configurations
|
||||
//
|
||||
//*****************************************************************************
|
||||
void `nameOfPeripheral`_init(){
|
||||
%if (module != null)
|
||||
%{
|
||||
% for(var i = 0; i < module.$instances.length; i++) {
|
||||
% var instance = module.$instances[i];
|
||||
% var baseName = instance.$name + "_BASE";
|
||||
`instance.$name`_init();
|
||||
% }
|
||||
%}
|
||||
}
|
||||
|
||||
% for(var i = 0; i < module.$instances.length; i++)
|
||||
% {
|
||||
% var instance = module.$instances[i];
|
||||
% var baseName = instance.$name + "_BASE";
|
||||
% let instancePinmux = instance[nameOfModule];
|
||||
void `instance.$name`_init(){
|
||||
% // delay depends on analog reference
|
||||
% if((["F28002x", "F28003x", "F280013x", "F280015x", "F28004x", "F28P65x", "F28P55x"].includes(Common.getDeviceName()))&&(Common.isContextCPU1())){
|
||||
% if(stat.analogReference == "EXTERNAL"){
|
||||
% refMode = "ADC_REFERENCE_EXTERNAL"
|
||||
% }
|
||||
% else{
|
||||
% refMode = "ADC_REFERENCE_INTERNAL"
|
||||
% }
|
||||
% if(stat.analogReferenceVoltage == "2P5"){
|
||||
% refVoltage = "ADC_REFERENCE_2_5V"
|
||||
% }
|
||||
% else{
|
||||
% refVoltage = "ADC_REFERENCE_3_3V"
|
||||
% }
|
||||
//
|
||||
// ADC Initialization: Write ADC configurations and power up the ADC
|
||||
//
|
||||
// Set the analog voltage reference selection and ADC module's offset trims.
|
||||
// This function sets the analog voltage reference to internal (with the reference voltage of 1.65V or 2.5V) or external for ADC
|
||||
// which is same as ASysCtl APIs.
|
||||
//
|
||||
ADC_setVREF(`baseName`, `refMode`, `refVoltage`);
|
||||
% }
|
||||
//
|
||||
// Configures the analog-to-digital converter module prescaler.
|
||||
//
|
||||
ADC_setPrescaler(`baseName`, `instance.adcClockPrescaler`);
|
||||
% if( ["F2837xD", "F2837xS","F2838x","F28P65x"].includes(system.deviceData.deviceId)){
|
||||
//
|
||||
// Configures the analog-to-digital converter resolution and signal mode.
|
||||
//
|
||||
ADC_setMode(`baseName`, `instance.adcResolutionMode`, `instance.adcSignalMode`);
|
||||
% }
|
||||
//
|
||||
// Sets the timing of the end-of-conversion pulse
|
||||
//
|
||||
ADC_setInterruptPulseMode(`baseName`, `instance.interruptPulseMode`);
|
||||
% if(!["F2807x","F2837xS", "F2837xD"].includes(system.deviceData.deviceId)){
|
||||
% if (instance.interruptPulseMode == "ADC_PULSE_END_OF_ACQ_WIN"){
|
||||
//
|
||||
// Sets the timing of early interrupt generation.
|
||||
//
|
||||
ADC_setInterruptCycleOffset(`baseName`, `instance.interruptCycleOffset`U);
|
||||
% }
|
||||
% }
|
||||
% if(instance.enableConverter){
|
||||
//
|
||||
// Powers up the analog-to-digital converter core.
|
||||
//
|
||||
ADC_enableConverter(`baseName`);
|
||||
% }
|
||||
% else{
|
||||
//
|
||||
// Powers down the analog-to-digital converter module.
|
||||
//
|
||||
ADC_disableConverter(`baseName`);
|
||||
% }
|
||||
%%{
|
||||
//
|
||||
// delay depends on analog reference
|
||||
//
|
||||
if((["F28002x", "F28003x", "F280013x", "F280015x", "F28004x", "F28P65x", "F28P55x"].includes(Common.getDeviceName()))&&(Common.isContextCPU1())){
|
||||
if(stat.analogReference == "EXTERNAL"){
|
||||
varDelay = 500
|
||||
}
|
||||
else{
|
||||
varDelay = 5000
|
||||
}
|
||||
}
|
||||
%%}
|
||||
//
|
||||
// Delay for 1ms to allow ADC time to power up
|
||||
//
|
||||
DEVICE_DELAY_US(`varDelay`);
|
||||
%if(["F28P65x", "F28P55x"].includes(Common.getDeviceName())){
|
||||
% if(instance.enableTDMA){
|
||||
//
|
||||
// Enable alternate timings for DMA trigger
|
||||
//
|
||||
ADC_enableAltDMATiming(`baseName`);
|
||||
% }
|
||||
% else{
|
||||
//
|
||||
// Disables alternate timings for DMA trigger
|
||||
//
|
||||
ADC_disableAltDMATiming(`baseName`);
|
||||
% }
|
||||
% if(instance.enableEXTMUX){
|
||||
% if (instance.extTiming == "Preselection"){
|
||||
//
|
||||
//! Enables external channel mux preselection
|
||||
//
|
||||
ADC_enableExtMuxPreselect(`baseName`);
|
||||
% }
|
||||
% else{
|
||||
//
|
||||
//! Disables external mux preselection
|
||||
//
|
||||
ADC_disableExtMuxPreselect(`baseName`);
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
//
|
||||
// SOC Configuration: Setup ADC EPWM channel and trigger settings
|
||||
% if(instance.enableBurstMode){
|
||||
//
|
||||
// Enables SOC burst mode.
|
||||
//
|
||||
ADC_enableBurstMode(`baseName`);
|
||||
//
|
||||
// Set SOC burst mode.
|
||||
//
|
||||
ADC_setBurstModeConfig(`baseName`, `instance.burstTrigger`, `(instance.burstSize+1)`);
|
||||
% }
|
||||
% else{
|
||||
//
|
||||
// Disables SOC burst mode.
|
||||
//
|
||||
ADC_disableBurstMode(`baseName`);
|
||||
% }
|
||||
//
|
||||
// Sets the priority mode of the SOCs.
|
||||
//
|
||||
ADC_setSOCPriority(`baseName`, `instance.socHighPriorityMode`);
|
||||
% for(var socIndex in device_driverlib_peripheral.ADC_SOCNumber){
|
||||
% var currentSOC = device_driverlib_peripheral.ADC_SOCNumber[socIndex].name
|
||||
% var socNumber = (currentSOC).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledSOCs).includes(currentSOC)){
|
||||
//
|
||||
// Start of Conversion `socNumber` Configuration
|
||||
//
|
||||
% if(["F28P65x", "F28P55x"].includes(Common.getDeviceName())){
|
||||
% if((instance.enableEXTMUX) && ((instance.adcNumExtPins)!="0")){
|
||||
//
|
||||
// Configures the external channel mux for an ADC SOC.
|
||||
// base: `baseName`
|
||||
// SOC number : `socNumber`
|
||||
// extChannel : `instance["soc"+socNumber+"ExtChannel"]`
|
||||
//
|
||||
ADC_selectSOCExtChannel(`baseName`, ADC_SOC_NUMBER`socNumber`,`instance["soc"+socNumber+"ExtChannel"]`);
|
||||
% }
|
||||
% if(instance["soc" + socNumber.toString() + "Triggermode"]=="repeatermode"){
|
||||
//
|
||||
// Configures Repeater Modules
|
||||
//
|
||||
% for(var rptrIndex in device_driverlib_peripheral.ADC_RepInstance){
|
||||
% var currentRPTR = device_driverlib_peripheral.ADC_RepInstance[rptrIndex].name
|
||||
% var rptriNumber = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
% if((instance["soc" + socNumber.toString() + "Trigger"].replace(/[^0-9]/g,'')==rptriNumber )){
|
||||
//
|
||||
// Repeater module `rptriNumber` parameters
|
||||
// base: `baseName`
|
||||
// RepInstance: `instance["soc" + socNumber.toString() + "Trigger"]`
|
||||
// ADC_RepeaterConfig :
|
||||
// mode : `instance["repeater"+rptriNumber+" Mode"]`
|
||||
// Trigger : `instance["repeater"+rptriNumber+" Trigger"]`
|
||||
// SyncInput : `instance["repeater"+rptriNumber+" SyncInput"]`
|
||||
// Count : `instance["repeater"+rptriNumber+" Count"]`
|
||||
// phase : `instance["repeater"+rptriNumber+" Phase"]`
|
||||
// spread : `instance["repeater"+rptriNumber+" Spread"]`
|
||||
//
|
||||
ADC_triggerRepeaterSelect(`baseName`, ADC_REPINST`rptriNumber`, `instance["repeater"+rptriNumber+" Trigger"]`);
|
||||
ADC_triggerRepeaterMode(`baseName`, ADC_REPINST`rptriNumber`, `instance["repeater"+rptriNumber+" Mode"]`);
|
||||
ADC_triggerRepeaterSyncIn(`baseName`, ADC_REPINST`rptriNumber`, `instance["repeater"+rptriNumber+" SyncInput"]`);
|
||||
ADC_triggerRepeaterCount(`baseName`, ADC_REPINST`rptriNumber`, `instance["repeater"+rptriNumber+" Count"]`);
|
||||
ADC_triggerRepeaterPhase(`baseName`, ADC_REPINST`rptriNumber`, `instance["repeater"+rptriNumber+" Phase"]`);
|
||||
ADC_triggerRepeaterSpread(`baseName`, ADC_REPINST`rptriNumber`, `instance["repeater"+rptriNumber+" Spread"]`);
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
//
|
||||
// Configures a start-of-conversion (SOC) in the ADC and its interrupt SOC trigger.
|
||||
// SOC number : `socNumber`
|
||||
// Trigger : `instance["soc"+socNumber+"Trigger"]`
|
||||
// Channel : `instance["soc"+socNumber+"Channel"]`
|
||||
% if (instance["soc" + socNumber.toString() + "UseCalculatedSampleTime"] &&
|
||||
% instance["soc" + socNumber.toString() + "UseSampleTimeCalculator"]){
|
||||
// Sample Window : `instance["soc"+socNumber+"SampleWindowCalculated"]` SYSCLK cycles
|
||||
% }
|
||||
% else{
|
||||
// Sample Window : `instance["soc"+socNumber+"SampleWindow"]` SYSCLK cycles
|
||||
% }
|
||||
// Interrupt Trigger: `instance["soc"+socNumber+"InterruptTrigger"]`
|
||||
//
|
||||
% if (instance["soc" + socNumber.toString() + "UseCalculatedSampleTime"] &&
|
||||
% instance["soc" + socNumber.toString() + "UseSampleTimeCalculator"]){
|
||||
ADC_setupSOC(`baseName`, ADC_SOC_NUMBER`socNumber`, `instance["soc"+socNumber+"Trigger"]`, `instance["soc"+socNumber+"Channel"]`, `instance["soc"+socNumber+"SampleWindowCalculated"]`U);
|
||||
% }
|
||||
% else{
|
||||
ADC_setupSOC(`baseName`, ADC_SOC_NUMBER`socNumber`, `instance["soc"+socNumber+"Trigger"]`, `instance["soc"+socNumber+"Channel"]`, `instance["soc"+socNumber+"SampleWindow"]`U);
|
||||
% }
|
||||
ADC_setInterruptSOCTrigger(`baseName`, ADC_SOC_NUMBER`socNumber`, `instance["soc"+socNumber+"InterruptTrigger"]`);
|
||||
% }
|
||||
% }
|
||||
% for(var intIndex in device_driverlib_peripheral.ADC_IntNumber){
|
||||
% var currentINT = device_driverlib_peripheral.ADC_IntNumber[intIndex].name
|
||||
% var intNumber = (currentINT).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledInts).includes(currentINT)){
|
||||
//
|
||||
// ADC Interrupt `intNumber` Configuration
|
||||
// Source : `(instance["interrupt"+intNumber+"SOCSource"])`
|
||||
% if(instance["enableInterrupt"+intNumber]){
|
||||
// Interrupt Source: enabled
|
||||
% }
|
||||
% else{
|
||||
// Interrupt Source: disabled
|
||||
% }
|
||||
% if(instance["enableInterrupt"+intNumber+"ContinuousMode"]){
|
||||
// Continuous Mode : enabled
|
||||
% }
|
||||
% else{
|
||||
// Continuous Mode : disabled
|
||||
% }
|
||||
//
|
||||
% for(var ppbIndex in device_driverlib_peripheral.ADC_PPBNumber){
|
||||
% var currentPPB = device_driverlib_peripheral.ADC_PPBNumber[ppbIndex].name
|
||||
% var ppbNumber = (currentPPB).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledPPBs).includes(currentPPB) && (instance.enabledInts).includes(currentINT)&&((instance["interrupt"+intNumber+"SOCSource"]) == "ADC_INT_TRIGGER_OSINT"+ppbNumber)) {
|
||||
// Configures PPB interrupt source
|
||||
// osIntSrc : `(instance["ppb"+ppbNumber+"SelectOSINTSource"])`
|
||||
% }
|
||||
% }
|
||||
//
|
||||
% for(var ppbIndex in device_driverlib_peripheral.ADC_PPBNumber){
|
||||
% var currentPPB = device_driverlib_peripheral.ADC_PPBNumber[ppbIndex].name
|
||||
% var ppbNumber = (currentPPB).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledPPBs).includes(currentPPB) && (instance.enabledInts).includes(currentINT)&&((instance["interrupt"+intNumber+"SOCSource"]) == "ADC_INT_TRIGGER_OSINT"+ppbNumber)) {
|
||||
ADC_selectPPBOSINTSource (`baseName`,ADC_PPB_NUMBER`ppbNumber`,`instance["ppb"+ppbNumber+"SelectOSINTSource"]`);
|
||||
% }
|
||||
% }
|
||||
ADC_setInterruptSource(`baseName`, ADC_INT_NUMBER`intNumber`, `instance["interrupt"+intNumber+"SOCSource"]`);
|
||||
% if(instance["enableInterrupt"+intNumber]){
|
||||
ADC_clearInterruptStatus(`baseName`, ADC_INT_NUMBER`intNumber`);
|
||||
% }
|
||||
% if(instance["enableInterrupt"+intNumber+"ContinuousMode"]){
|
||||
ADC_enableContinuousMode(`baseName`, ADC_INT_NUMBER`intNumber`);
|
||||
% }
|
||||
% else{
|
||||
ADC_disableContinuousMode(`baseName`, ADC_INT_NUMBER`intNumber`);
|
||||
% }
|
||||
% if(instance["enableInterrupt"+intNumber]){
|
||||
ADC_enableInterrupt(`baseName`, ADC_INT_NUMBER`intNumber`);
|
||||
% }
|
||||
% else{
|
||||
ADC_disableInterrupt(`baseName`, ADC_INT_NUMBER`intNumber`);
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% if ((instance.enabledPPBs).length>0){
|
||||
|
||||
//
|
||||
// PPB Configuration: Configure high and low limits detection for ADCPPB
|
||||
% }
|
||||
% var ppbiTotal = 4
|
||||
% for(var ppbIndex in device_driverlib_peripheral.ADC_PPBNumber){
|
||||
% var currentPPB = device_driverlib_peripheral.ADC_PPBNumber[ppbIndex].name
|
||||
% var ppbNumber = (currentPPB).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledPPBs).includes(currentPPB)){
|
||||
//
|
||||
// Post Processing Block `ppbNumber` Configuration
|
||||
// Configures a post-processing block (PPB) in the ADC.
|
||||
// PPB Number : `ppbNumber`
|
||||
// SOC/EOC number : `((instance["ppb"+ppbNumber+"SOCNumber"]).toString()).replace("ADC_SOC_NUMBER", "")`
|
||||
% if(instance["ppb"+ppbNumber+"EventEnable"].length>0){
|
||||
// Events Sources Enabled : `(instance["ppb"+ppbNumber+"EventEnable"])`
|
||||
% }
|
||||
% if(instance["ppb"+ppbNumber+"EventInterruptEnable"].length>0){
|
||||
// Interrupt Sources Enabled: `instance["ppb"+ppbNumber+"EventInterruptEnable"]`
|
||||
% }
|
||||
// Calibration Offset : `instance["ppb"+ppbNumber+"CalibrationOffset"]`
|
||||
// Reference Offset : `instance["ppb"+ppbNumber+"ReferenceOffset"]`
|
||||
% if(instance["ppb"+ppbNumber+"EnableTwosComplement"]){
|
||||
// Two's Complement : Enabled
|
||||
% }
|
||||
% else{
|
||||
// Two's Complement : Disabled
|
||||
% }
|
||||
// Trip High Limit : `instance["ppb"+ppbNumber+"HighTripLimit"]`
|
||||
// Trip Low Limit : `instance["ppb"+ppbNumber+"LowTripLimit"]`
|
||||
% if(!["F2807x","F2837xS", "F2837xD"].includes(system.deviceData.deviceId)){
|
||||
% if(instance["ppb"+ppbNumber+"EnablePPBEventCBCClear"]){
|
||||
// Clear PPB Event Flags : Enabled
|
||||
% }
|
||||
% else{
|
||||
// Clear PPB Event Flags : Disabled
|
||||
% }
|
||||
% }
|
||||
% if(["F28P65x", "F28P55x"].includes(system.deviceData.deviceId)){
|
||||
// Accumulation Limit : `instance["ppb"+ppbNumber+"AccumulationLimit"]`
|
||||
// SyncInput Source : `instance["ppb"+ppbNumber+"SyncInput"]`
|
||||
// Comparator Source : `instance["ppb"+ppbNumber+"CompSource"]`
|
||||
// Right Shift : `instance["ppb"+ppbNumber+"Rightshift"]`
|
||||
// Absolute value : `instance["ppb"+ppbNumber+"AbsValue"]`
|
||||
% }
|
||||
//
|
||||
ADC_setupPPB(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `instance["ppb"+ppbNumber+"SOCNumber"]`);
|
||||
%%{
|
||||
var eventOptions = ["ADC_EVT_TRIPHI","ADC_EVT_TRIPLO","ADC_EVT_ZERO"]
|
||||
var currentEvent = ""
|
||||
var enableEventCount = 0
|
||||
var eventsToEnableOR = "("
|
||||
for (var eventToEnable in instance["ppb"+ppbNumber+"EventEnable"])
|
||||
{
|
||||
currentEvent = instance["ppb"+ppbNumber+"EventEnable"][enableEventCount]
|
||||
if (enableEventCount == 0)
|
||||
{
|
||||
eventsToEnableOR += currentEvent
|
||||
}
|
||||
else
|
||||
{
|
||||
eventsToEnableOR += " | " + currentEvent
|
||||
}
|
||||
var disableIndex = eventOptions.indexOf(currentEvent)
|
||||
if(disableIndex>-1){
|
||||
eventOptions.splice(disableIndex,1)
|
||||
}
|
||||
enableEventCount++
|
||||
}
|
||||
eventsToEnableOR += ")"
|
||||
var eventsToDisableOR = "("
|
||||
var disableEventCount = 0
|
||||
for(var eventToDisable in eventOptions){
|
||||
currentEvent = eventOptions[disableEventCount]
|
||||
if (disableEventCount == 0)
|
||||
{
|
||||
eventsToDisableOR += currentEvent
|
||||
}
|
||||
else
|
||||
{
|
||||
eventsToDisableOR += " | " + currentEvent
|
||||
}
|
||||
disableEventCount++
|
||||
}
|
||||
eventsToDisableOR += ")"
|
||||
%%}
|
||||
% if(enableEventCount > 0){
|
||||
ADC_enablePPBEvent(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `eventsToEnableOR`);
|
||||
% }
|
||||
% if(disableEventCount > 0){
|
||||
ADC_disablePPBEvent(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `eventsToDisableOR`);
|
||||
% }
|
||||
%%{
|
||||
var eventInterruptOptions = ["ADC_EVT_TRIPHI","ADC_EVT_TRIPLO","ADC_EVT_ZERO"]
|
||||
var currentEventInterrupt = ""
|
||||
var enableEventInterruptCount = 0
|
||||
var eventInterruptsToEnableOR = "("
|
||||
for (var eventInterruptToEnable in instance["ppb"+ppbNumber+"EventInterruptEnable"])
|
||||
{
|
||||
currentEventInterrupt = instance["ppb"+ppbNumber+"EventInterruptEnable"][enableEventInterruptCount]
|
||||
if (enableEventInterruptCount == 0)
|
||||
{
|
||||
eventInterruptsToEnableOR += currentEventInterrupt
|
||||
}
|
||||
else
|
||||
{
|
||||
eventInterruptsToEnableOR += " | " + currentEventInterrupt
|
||||
}
|
||||
var disableIndex = eventInterruptOptions.indexOf(currentEventInterrupt)
|
||||
if(disableIndex>-1){
|
||||
eventInterruptOptions.splice(disableIndex,1)
|
||||
}
|
||||
enableEventInterruptCount++
|
||||
}
|
||||
eventInterruptsToEnableOR += ")"
|
||||
var eventInterruptsToDisableOR = "("
|
||||
var disableEventInterruptCount = 0
|
||||
for(var eventInterruptToDisable in eventInterruptOptions){
|
||||
currentEventInterrupt = eventInterruptOptions[disableEventInterruptCount]
|
||||
if (disableEventInterruptCount == 0)
|
||||
{
|
||||
eventInterruptsToDisableOR += currentEventInterrupt
|
||||
}
|
||||
else
|
||||
{
|
||||
eventInterruptsToDisableOR += " | " + currentEventInterrupt
|
||||
}
|
||||
disableEventInterruptCount++
|
||||
}
|
||||
eventInterruptsToDisableOR += ")"
|
||||
%%}
|
||||
% if(enableEventInterruptCount > 0){
|
||||
ADC_enablePPBEventInterrupt(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `eventInterruptsToEnableOR`);
|
||||
% }
|
||||
% if(disableEventInterruptCount > 0){
|
||||
ADC_disablePPBEventInterrupt(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `eventInterruptsToDisableOR`);
|
||||
% }
|
||||
ADC_setPPBCalibrationOffset(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `instance["ppb"+ppbNumber+"CalibrationOffset"]`);
|
||||
ADC_setPPBReferenceOffset(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `instance["ppb"+ppbNumber+"ReferenceOffset"]`);
|
||||
% if(instance["ppb"+ppbNumber+"EnableTwosComplement"]){
|
||||
ADC_enablePPBTwosComplement(`baseName`, ADC_PPB_NUMBER`ppbNumber`);
|
||||
% }
|
||||
% else {
|
||||
ADC_disablePPBTwosComplement(`baseName`, ADC_PPB_NUMBER`ppbNumber`);
|
||||
% }
|
||||
ADC_setPPBTripLimits(`baseName`, ADC_PPB_NUMBER`ppbNumber`, `instance["ppb"+ppbNumber+"HighTripLimit"]`, `instance["ppb"+ppbNumber+"LowTripLimit"]`);
|
||||
% if(!["F2807x","F2837xS", "F2837xD"].includes(system.deviceData.deviceId)){
|
||||
% if (instance["ppb"+ppbNumber+"EnablePPBEventCBCClear"]){
|
||||
ADC_enablePPBEventCBCClear(`baseName`, ADC_PPB_NUMBER`ppbNumber`);
|
||||
% }
|
||||
% else{
|
||||
ADC_disablePPBEventCBCClear(`baseName`, ADC_PPB_NUMBER`ppbNumber`);
|
||||
% }
|
||||
% }
|
||||
% if(["F28P65x", "F28P55x"].includes(Common.getDeviceName())){
|
||||
ADC_setPPBCountLimit(`baseName`, ADC_PPB_NUMBER`ppbNumber`,`instance["ppb"+ppbNumber+"AccumulationLimit"]`);
|
||||
ADC_selectPPBSyncInput(`baseName`, ADC_PPB_NUMBER`ppbNumber`,`instance["ppb"+ppbNumber+"SyncInput"]`);
|
||||
ADC_selectPPBCompareSource(`baseName`, ADC_PPB_NUMBER`ppbNumber`,`instance["ppb"+ppbNumber+"CompSource"]`);
|
||||
ADC_setPPBShiftValue(`baseName`, ADC_PPB_NUMBER`ppbNumber`,`instance["ppb"+ppbNumber+"Rightshift"]`);
|
||||
% if(instance["ppb"+ppbNumber+"AbsValue"]){
|
||||
ADC_enablePPBAbsoluteValue(`baseName`, ADC_PPB_NUMBER`ppbNumber`);
|
||||
% }
|
||||
% else {
|
||||
ADC_disablePPBAbsoluteValue(`baseName`, ADC_PPB_NUMBER`ppbNumber`);
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
}
|
||||
|
||||
% }
|
||||
@@ -0,0 +1,75 @@
|
||||
% var moduleName = "adc"
|
||||
% var module = system.modules['/driverlib/' + moduleName + '.js'];
|
||||
% let Common = system.getScript("/driverlib/Common.js");
|
||||
% var device_driverlib_peripheral = system.getScript("/driverlib/device_driverlib_peripherals/" + Common.getDeviceName().toLowerCase() + "_adc.js");
|
||||
%if (module != null)
|
||||
%{
|
||||
//*****************************************************************************
|
||||
//
|
||||
// ADC Configurations
|
||||
//
|
||||
//*****************************************************************************
|
||||
% for(var i = 0; i < module.$instances.length; i++) {
|
||||
% var instance = module.$instances[i];
|
||||
#define `instance.$name`_BASE `instance.adcBase`
|
||||
#define `instance.$name`_RESULT_BASE `instance.adcBase.replace("_BASE", "RESULT_BASE")`
|
||||
% for(var socIndex in device_driverlib_peripheral.ADC_SOCNumber){
|
||||
% var currentSOC = device_driverlib_peripheral.ADC_SOCNumber[socIndex].name
|
||||
% var socNumber = (currentSOC).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledSOCs).includes(currentSOC)){
|
||||
% var soc_name = instance["soc" + socIndex.toString() + "Name"].replace(/\s/g, '')
|
||||
% if (soc_name != "")
|
||||
% {
|
||||
% if (!instance["soc" + socIndex.toString() + "IndependentNameMode"])
|
||||
% {
|
||||
#define `instance.$name`_`soc_name` ADC_SOC_NUMBER`socNumber`
|
||||
#define `instance.$name`_FORCE_`soc_name` ADC_FORCE_SOC`socNumber`
|
||||
#define `instance.$name`_SAMPLE_WINDOW_`soc_name` `instance["soc" + socIndex.toString() + "SampleTime"]`
|
||||
#define `instance.$name`_TRIGGER_SOURCE_`soc_name` `instance["soc" + socIndex.toString() + "Trigger"]`
|
||||
#define `instance.$name`_CHANNEL_`soc_name` `instance["soc" + socIndex.toString() + "Channel"]`
|
||||
% if(instance["soc" + socNumber.toString() + "Triggermode"]=="repeatermode"){
|
||||
% for(var rptrIndex in device_driverlib_peripheral.ADC_RepInstance){
|
||||
% var currentRPTR = device_driverlib_peripheral.ADC_RepInstance[rptrIndex].name
|
||||
% var rptriNumber = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
%}
|
||||
%}
|
||||
% } else {
|
||||
#define `soc_name` ADC_SOC_NUMBER`socNumber`
|
||||
#define `soc_name`_FORCE ADC_FORCE_SOC`socNumber`
|
||||
#define `soc_name`_ADC_BASE `instance.adcBase`
|
||||
#define `soc_name`_RESULT_BASE `instance.adcBase.replace("_BASE", "RESULT_BASE")`
|
||||
#define `soc_name`_SAMPLE_WINDOW `instance["soc" + socIndex.toString() + "SampleTime"]`
|
||||
#define `soc_name`_TRIGGER_SOURCE `instance["soc" + socIndex.toString() + "Trigger"]`
|
||||
#define `soc_name`_CHANNEL `instance["soc" + socIndex.toString() + "Channel"]`
|
||||
% if(instance["soc" + socNumber.toString() + "Triggermode"]=="repeatermode"){
|
||||
% for(var rptrIndex in device_driverlib_peripheral.ADC_RepInstance){
|
||||
% var currentRPTR = device_driverlib_peripheral.ADC_RepInstance[rptrIndex].name
|
||||
% var rptriNumber = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
%}
|
||||
%}
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% for(var ppbIndex in device_driverlib_peripheral.ADC_PPBNumber){
|
||||
% var currentPPB = device_driverlib_peripheral.ADC_PPBNumber[ppbIndex].name
|
||||
% var ppbNumber = (currentPPB).replace(/[^0-9]/g,'')
|
||||
% if((instance.enabledPPBs).includes(currentPPB)){
|
||||
% var ppb_name = instance["ppb" + ppbNumber.toString() + "Name"].replace(/\s/g, '')
|
||||
% if (ppb_name != "")
|
||||
% {
|
||||
% if (!instance["ppb" + ppbNumber.toString() + "IndependentNameMode"])
|
||||
% {
|
||||
#define `instance.$name`_`ppb_name` ADC_PPB_NUMBER`ppbNumber`
|
||||
#define `instance.$name`_SOC_`ppb_name` `instance["ppb" + ppbNumber.toString() + "SOCNumber"]`
|
||||
% } else {
|
||||
#define `ppb_name` ADC_PPB_NUMBER`ppbNumber`
|
||||
#define `ppb_name`_SOC `instance["ppb" + ppbNumber.toString() + "SOCNumber"]`
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
void `instance.$name`_init();
|
||||
|
||||
% }
|
||||
%}
|
||||
@@ -0,0 +1,514 @@
|
||||
var tEOC_12bit_SYSCLK = {
|
||||
ADC_CLK_DIV_1_0 : 11,
|
||||
ADC_CLK_DIV_2_0 : 21,
|
||||
ADC_CLK_DIV_2_5 : 26,
|
||||
ADC_CLK_DIV_3_0 : 31,
|
||||
ADC_CLK_DIV_3_5 : 36,
|
||||
ADC_CLK_DIV_4_0 : 41,
|
||||
ADC_CLK_DIV_4_5 : 46,
|
||||
ADC_CLK_DIV_5_0 : 51,
|
||||
ADC_CLK_DIV_5_5 : 56,
|
||||
ADC_CLK_DIV_6_0 : 61,
|
||||
ADC_CLK_DIV_6_5 : 66,
|
||||
ADC_CLK_DIV_7_0 : 71,
|
||||
ADC_CLK_DIV_7_5 : 76,
|
||||
ADC_CLK_DIV_8_0 : 81,
|
||||
ADC_CLK_DIV_8_5 : 86,
|
||||
}
|
||||
|
||||
var tEOC_16bit_SYSCLK = {
|
||||
ADC_CLK_DIV_1_0 : 31,
|
||||
ADC_CLK_DIV_2_0 : 60,
|
||||
ADC_CLK_DIV_2_5 : 75,
|
||||
ADC_CLK_DIV_3_0 : 90,
|
||||
ADC_CLK_DIV_3_5 : 104,
|
||||
ADC_CLK_DIV_4_0 : 119,
|
||||
ADC_CLK_DIV_4_5 : 134,
|
||||
ADC_CLK_DIV_5_0 : 149,
|
||||
ADC_CLK_DIV_5_5 : 163,
|
||||
ADC_CLK_DIV_6_0 : 178,
|
||||
ADC_CLK_DIV_6_5 : 193,
|
||||
ADC_CLK_DIV_7_0 : 208,
|
||||
ADC_CLK_DIV_7_5 : 222,
|
||||
ADC_CLK_DIV_8_0 : 237,
|
||||
ADC_CLK_DIV_8_5 : 252,
|
||||
}
|
||||
|
||||
var Cp_F28004x = {
|
||||
ADCINA0 : { CMP_DIS: 12.7 , CMP_EN: 15.2 },
|
||||
ADCINA1 : { CMP_DIS: 13.7 , CMP_EN: 16.2 },
|
||||
ADCINA2 : { CMP_DIS: 9.2 , CMP_EN: 11.7 },
|
||||
ADCINA3 : { CMP_DIS: 6.9 , CMP_EN: 9.4 },
|
||||
ADCINA4 : { CMP_DIS: 9.2 , CMP_EN: 11.7 },
|
||||
ADCINA5 : { CMP_DIS: 7.5 , CMP_EN: 10 },
|
||||
ADCINA6 : { CMP_DIS: 8.0 , CMP_EN: 10.5 },
|
||||
ADCINA7 : { CMP_DIS: 7.0 , CMP_EN: 9.5 },
|
||||
ADCINA8 : { CMP_DIS: 10.0 , CMP_EN: 12.5 },
|
||||
ADCINA9 : { CMP_DIS: 8.1 , CMP_EN: 10.6 },
|
||||
ADCINA10 : { CMP_DIS: 9.3 , CMP_EN: 11.8 },
|
||||
ADCINB0 : { CMP_DIS: 7.1 , CMP_EN: 9.6 },
|
||||
ADCINB1 : { CMP_DIS: 9.3 , CMP_EN: 11.8 },
|
||||
ADCINB2 : { CMP_DIS: 9.6 , CMP_EN: 12.1 },
|
||||
ADCINB3 : { CMP_DIS: 125.6 , CMP_EN: 128.1 },
|
||||
ADCINB4 : { CMP_DIS: 8.8 , CMP_EN: 11.3 },
|
||||
ADCINB5 : { CMP_DIS: 7.1 , CMP_EN: 9.6 },
|
||||
ADCINB6 : { CMP_DIS: 9.2 , CMP_EN: 11.7 },
|
||||
ADCINB8 : { CMP_DIS: 9.2 , CMP_EN: 11.7 },
|
||||
ADCINB15 : { CMP_DIS: 12.7 , CMP_EN: 15.2 },
|
||||
ADCINC0 : { CMP_DIS: 6.4 , CMP_EN: 8.9 },
|
||||
ADCINC1 : { CMP_DIS: 6.1 , CMP_EN: 8.6 },
|
||||
ADCINC2 : { CMP_DIS: 5.24 , CMP_EN: 7.74 },
|
||||
ADCINC3 : { CMP_DIS: 5.5 , CMP_EN: 8 },
|
||||
ADCINC4 : { CMP_DIS: 6.2 , CMP_EN: 8.7 },
|
||||
ADCINC5 : { CMP_DIS: 5.6 , CMP_EN: 8.1 },
|
||||
ADCINC6 : { CMP_DIS: 9.6 , CMP_EN: 12.1 },
|
||||
ADCINC8 : { CMP_DIS: 8.8 , CMP_EN: 11.3 },
|
||||
ADCINC10 : { CMP_DIS: 9.3 , CMP_EN: 11.8 },
|
||||
ADCINC12 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINC14 : { CMP_DIS: 4.5 , CMP_EN: 7 },
|
||||
ADCINC15 : { CMP_DIS: 12.7 , CMP_EN: 15.2 },
|
||||
}
|
||||
|
||||
var Cp_F2837xD = {
|
||||
ADCINA0 : { CMP_DIS: 12.9 , CMP_EN: 12.9 },
|
||||
ADCINA1 : { CMP_DIS: 10.3 , CMP_EN: 10.3 },
|
||||
ADCINA2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA3 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINA4 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA5 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINB0 : { CMP_DIS: 117.0 , CMP_EN: 117.0 },
|
||||
ADCINB1 : { CMP_DIS: 10.6 , CMP_EN: 10.6 },
|
||||
ADCINB2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINB3 : { CMP_DIS: 6.2 , CMP_EN: 8.7 },
|
||||
ADCINB4 : { CMP_DIS: 5.2 , CMP_EN: 5.2 },
|
||||
ADCINB5 : { CMP_DIS: 5.1 , CMP_EN: 5.1 },
|
||||
ADCINC2 : { CMP_DIS: 5.5 , CMP_EN: 6.9 },
|
||||
ADCINC3 : { CMP_DIS: 5.8 , CMP_EN: 8.3 },
|
||||
ADCINC4 : { CMP_DIS: 5.0 , CMP_EN: 6.4 },
|
||||
ADCINC5 : { CMP_DIS: 5.3 , CMP_EN: 7.8 },
|
||||
ADCIND0 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND1 : { CMP_DIS: 5.7 , CMP_EN: 8.2 },
|
||||
ADCIND2 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND3 : { CMP_DIS: 5.6 , CMP_EN: 8.1 },
|
||||
ADCIND4 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCIND5 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCINA14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINA15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINB14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINB15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINC14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINC15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCIND14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCIND15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
}
|
||||
|
||||
var Cp_F2837xS = {
|
||||
ADCINA0 : { CMP_DIS: 12.9 , CMP_EN: 12.9 },
|
||||
ADCINA1 : { CMP_DIS: 10.3 , CMP_EN: 10.3 },
|
||||
ADCINA2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA3 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINA4 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA5 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINB0 : { CMP_DIS: 117.0 , CMP_EN: 117.0 },
|
||||
ADCINB1 : { CMP_DIS: 10.6 , CMP_EN: 10.6 },
|
||||
ADCINB2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINB3 : { CMP_DIS: 6.2 , CMP_EN: 8.7 },
|
||||
ADCINB4 : { CMP_DIS: 5.2 , CMP_EN: 5.2 },
|
||||
ADCINB5 : { CMP_DIS: 5.1 , CMP_EN: 5.1 },
|
||||
ADCINC2 : { CMP_DIS: 5.5 , CMP_EN: 6.9 },
|
||||
ADCINC3 : { CMP_DIS: 5.8 , CMP_EN: 8.3 },
|
||||
ADCINC4 : { CMP_DIS: 5.0 , CMP_EN: 6.4 },
|
||||
ADCINC5 : { CMP_DIS: 5.3 , CMP_EN: 7.8 },
|
||||
ADCIND0 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND1 : { CMP_DIS: 5.7 , CMP_EN: 8.2 },
|
||||
ADCIND2 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND3 : { CMP_DIS: 5.6 , CMP_EN: 8.1 },
|
||||
ADCIND4 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCIND5 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCINA14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINA15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINB14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINB15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINC14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINC15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCIND14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCIND15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
}
|
||||
|
||||
var Cp_F2838x = {
|
||||
ADCINA0 : { CMP_DIS: 12.9 , CMP_EN: 12.9 },
|
||||
ADCINA1 : { CMP_DIS: 10.3 , CMP_EN: 10.3 },
|
||||
ADCINA2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA3 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINA4 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA5 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINB0 : { CMP_DIS: 117.0 , CMP_EN: 117.0 },
|
||||
ADCINB1 : { CMP_DIS: 10.6 , CMP_EN: 10.6 },
|
||||
ADCINB2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINB3 : { CMP_DIS: 6.2 , CMP_EN: 8.7 },
|
||||
ADCINB4 : { CMP_DIS: 5.2 , CMP_EN: 5.2 },
|
||||
ADCINB5 : { CMP_DIS: 5.1 , CMP_EN: 5.1 },
|
||||
ADCINC2 : { CMP_DIS: 5.5 , CMP_EN: 6.9 },
|
||||
ADCINC3 : { CMP_DIS: 5.8 , CMP_EN: 8.3 },
|
||||
ADCINC4 : { CMP_DIS: 5.0 , CMP_EN: 6.4 },
|
||||
ADCINC5 : { CMP_DIS: 5.3 , CMP_EN: 7.8 },
|
||||
ADCIND0 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND1 : { CMP_DIS: 5.7 , CMP_EN: 8.2 },
|
||||
ADCIND2 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND3 : { CMP_DIS: 5.6 , CMP_EN: 8.1 },
|
||||
ADCIND4 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCIND5 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCINA14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINA15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINB14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINB15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINC14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINC15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCIND14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCIND15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
}
|
||||
|
||||
var Cp_F2807x = {
|
||||
ADCINA0 : { CMP_DIS: 12.9 , CMP_EN: 12.9 },
|
||||
ADCINA1 : { CMP_DIS: 10.3 , CMP_EN: 10.3 },
|
||||
ADCINA2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA3 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINA4 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINA5 : { CMP_DIS: 6.3 , CMP_EN: 8.8 },
|
||||
ADCINB0 : { CMP_DIS: 117.0 , CMP_EN: 117.0 },
|
||||
ADCINB1 : { CMP_DIS: 10.6 , CMP_EN: 10.6 },
|
||||
ADCINB2 : { CMP_DIS: 5.9 , CMP_EN: 7.3 },
|
||||
ADCINB3 : { CMP_DIS: 6.2 , CMP_EN: 8.7 },
|
||||
ADCINB4 : { CMP_DIS: 5.2 , CMP_EN: 5.2 },
|
||||
ADCINB5 : { CMP_DIS: 5.1 , CMP_EN: 5.1 },
|
||||
ADCIND0 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND1 : { CMP_DIS: 5.7 , CMP_EN: 8.2 },
|
||||
ADCIND2 : { CMP_DIS: 5.3 , CMP_EN: 6.7 },
|
||||
ADCIND3 : { CMP_DIS: 5.6 , CMP_EN: 8.1 },
|
||||
ADCIND4 : { CMP_DIS: 4.3 , CMP_EN: 4.3 },
|
||||
ADCINA14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINA15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCINB14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCINB15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
ADCIND14 : { CMP_DIS: 8.6 , CMP_EN: 10.0 },
|
||||
ADCIND15 : { CMP_DIS: 9.0 , CMP_EN: 11.5 },
|
||||
}
|
||||
|
||||
var Cp_F28002x = {
|
||||
ADCINA0 : { CMP_DIS: 3.3 , CMP_EN: 15.8 },
|
||||
ADCINC15 : { CMP_DIS: 3.3 , CMP_EN: 15.8 },
|
||||
ADCINA1 : { CMP_DIS: 2.4 , CMP_EN: 4.9 },
|
||||
ADCINA2 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
ADCINC9 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
ADCINA3 : { CMP_DIS: 71.4 , CMP_EN: 73.9 },
|
||||
ADCINC5 : { CMP_DIS: 71.4 , CMP_EN: 73.9 },
|
||||
ADCINA4 : { CMP_DIS: 4.5 , CMP_EN: 7 },
|
||||
ADCINC14 : { CMP_DIS: 4.5 , CMP_EN: 7 },
|
||||
ADCINA5 : { CMP_DIS: 2.7 , CMP_EN: 5.2 },
|
||||
ADCINC2 : { CMP_DIS: 2.7 , CMP_EN: 5.2 },
|
||||
ADCINA6 : { CMP_DIS: 2.6 , CMP_EN: 5.1 },
|
||||
ADCINA7 : { CMP_DIS: 4.2 , CMP_EN: 6.7 },
|
||||
ADCINC3 : { CMP_DIS: 4.2 , CMP_EN: 6.7 },
|
||||
ADCINA8 : { CMP_DIS: 4.5 , CMP_EN: 7 },
|
||||
ADCINC11 : { CMP_DIS: 4.5 , CMP_EN: 7 },
|
||||
ADCINA9 : { CMP_DIS: 3.4 , CMP_EN: 5.9 },
|
||||
ADCINC8 : { CMP_DIS: 3.4 , CMP_EN: 5.9 },
|
||||
ADCINA10 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
ADCINC10 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
ADCINA11 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
ADCINC0 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
ADCINA12 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINC1 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINA14 : { CMP_DIS: 2.5 , CMP_EN: 5 },
|
||||
ADCINC4 : { CMP_DIS: 2.5 , CMP_EN: 5 },
|
||||
ADCINA15 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINC7 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINC6 : { CMP_DIS: 2.9 , CMP_EN: 5.4 },
|
||||
}
|
||||
|
||||
var Cp_F28003x = {
|
||||
ADCINA0 : { CMP_DIS: 9.1 , CMP_EN: 11.6 },
|
||||
ADCINA1 : { CMP_DIS: 7.4 , CMP_EN: 9.9 },
|
||||
ADCINA2 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINA3 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINA4 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINA5 : { CMP_DIS: 3.5 , CMP_EN: 6 },
|
||||
ADCINA6 : { CMP_DIS: 3.2 , CMP_EN: 5.7 },
|
||||
ADCINA7 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINA8 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINA9 : { CMP_DIS: 3.1 , CMP_EN: 5.6 },
|
||||
ADCINA10 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINA11 : { CMP_DIS: 4 , CMP_EN: 6.5 },
|
||||
ADCINA12 : { CMP_DIS: 3.4 , CMP_EN: 5.9 },
|
||||
ADCINA14 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINA15 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC0 : { CMP_DIS: 4 , CMP_EN: 6.5 },
|
||||
ADCINC1 : { CMP_DIS: 3 , CMP_EN: 5.5 },
|
||||
ADCINC2 : { CMP_DIS: 3.6 , CMP_EN: 6.1 },
|
||||
ADCINC3 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC4 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC5 : { CMP_DIS: 3.6 , CMP_EN: 6.1 },
|
||||
ADCINC6 : { CMP_DIS: 3.9 , CMP_EN: 6.4 },
|
||||
ADCINC7 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINC8 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC9 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINC10 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINC11 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINC14 : { CMP_DIS: 4.2 , CMP_EN: 6.7 },
|
||||
ADCINC15 : { CMP_DIS: 9.1 , CMP_EN: 11.6 },
|
||||
ADCINB0 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINB1 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINB2 : { CMP_DIS: 3.9 , CMP_EN: 6.4 },
|
||||
ADCINB3 : { CMP_DIS: 75 , CMP_EN: 77.5 },
|
||||
ADCINB4 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINB5 : { CMP_DIS: 3.5 , CMP_EN: 6 },
|
||||
ADCINB6 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINB7 : { CMP_DIS: 7.4 , CMP_EN: 9.9 },
|
||||
ADCINB8 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINB9 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINB11 : { CMP_DIS: 4 , CMP_EN: 6.5 },
|
||||
ADCINB12 : { CMP_DIS: 3.6 , CMP_EN: 6.1 },
|
||||
ADCINB14 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINB15 : { CMP_DIS: 9.1 , CMP_EN: 11.6 },
|
||||
AGPIO_B5 : { CMP_DIS: 3.2 , CMP_EN: 5.7 },
|
||||
AGPIO_B11 : { CMP_DIS: 3.1 , CMP_EN: 5.6 },
|
||||
}
|
||||
|
||||
var Cp_F280013x = {
|
||||
ADCINA0 : { CMP_DIS: 9.3, CMP_EN: 14.3 },
|
||||
ADCINA1 : { CMP_DIS: 9.3, CMP_EN: 14.3 },
|
||||
ADCINA2 : { CMP_DIS: 1.5, CMP_EN: 4.0 },
|
||||
ADCINA3 : { CMP_DIS: 1.8, CMP_EN: 4.3 },
|
||||
ADCINA4 : { CMP_DIS: 2.4, CMP_EN: 4.9 },
|
||||
ADCINA5 : { CMP_DIS: 4.4, CMP_EN: 9.4 },
|
||||
ADCINA6 : { CMP_DIS: 3.1, CMP_EN: 8.1 },
|
||||
ADCINA7 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINA8 : { CMP_DIS: 2.2, CMP_EN: 4.7 },
|
||||
ADCINA9 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINA10 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINA11 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINA12 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINA14 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINA15 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINA16 : { CMP_DIS: 2.4 , CMP_EN: 4.9},
|
||||
ADCINA17 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA18 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA19 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA20 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC0 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINC1 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINC2 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINC3 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINC4 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINC5 : { CMP_DIS: 1.8 , CMP_EN: 4.3 },
|
||||
ADCINC6 : { CMP_DIS: 3.1 , CMP_EN: 8.1 },
|
||||
ADCINC7 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINC8 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINC9 : { CMP_DIS: 1.5 , CMP_EN: 4.0 },
|
||||
ADCINC10 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINC11 : { CMP_DIS: 2.2, CMP_EN: 4.7 },
|
||||
ADCINC14 : { CMP_DIS: 2.4 , CMP_EN: 4.9 },
|
||||
ADCINC15 : { CMP_DIS: 9.3 , CMP_EN: 14.3},
|
||||
ADCINC16 : { CMP_DIS: 2.4 , CMP_EN: 4.9},
|
||||
ADCINC17 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC18 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC19 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC20 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINB3 : { CMP_DIS: 63 , CMP_EN: 65.5 },
|
||||
ADCINB5 : { CMP_DIS: 2.1 , CMP_EN: 4.6 },
|
||||
ADCINB11 : { CMP_DIS: 1.6 , CMP_EN: 4.1 },
|
||||
AGPIO_B5 : { CMP_DIS: 1 , CMP_EN: 3.5 },
|
||||
AGPIO_B11 : { CMP_DIS: 1 , CMP_EN: 3.5 },
|
||||
}
|
||||
|
||||
var Cp_F280015x = {
|
||||
ADCINA0 : { CMP_DIS: 9.3, CMP_EN: 14.3 },
|
||||
ADCINA1 : { CMP_DIS: 9.3, CMP_EN: 14.3 },
|
||||
ADCINA2 : { CMP_DIS: 1.5, CMP_EN: 4.0 },
|
||||
ADCINA3 : { CMP_DIS: 1.8, CMP_EN: 4.3 },
|
||||
ADCINA4 : { CMP_DIS: 2.4, CMP_EN: 4.9 },
|
||||
ADCINA5 : { CMP_DIS: 4.4, CMP_EN: 9.4 },
|
||||
ADCINA6 : { CMP_DIS: 3.1, CMP_EN: 8.1 },
|
||||
ADCINA7 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINA8 : { CMP_DIS: 2.2, CMP_EN: 4.7 },
|
||||
ADCINA9 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINA10 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINA11 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINA12 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINA14 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINA15 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINA16 : { CMP_DIS: 2.4 , CMP_EN: 4.9},
|
||||
ADCINA17 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA18 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA19 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA20 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC0 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINC1 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINC2 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINC3 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINC4 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINC5 : { CMP_DIS: 1.8 , CMP_EN: 4.3 },
|
||||
ADCINC6 : { CMP_DIS: 3.1 , CMP_EN: 8.1 },
|
||||
ADCINC7 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINC8 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINC9 : { CMP_DIS: 1.5 , CMP_EN: 4.0 },
|
||||
ADCINC10 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINC11 : { CMP_DIS: 2.2, CMP_EN: 4.7 },
|
||||
ADCINC14 : { CMP_DIS: 2.4 , CMP_EN: 4.9 },
|
||||
ADCINC15 : { CMP_DIS: 9.3 , CMP_EN: 14.3},
|
||||
ADCINC16 : { CMP_DIS: 2.4 , CMP_EN: 4.9},
|
||||
ADCINC17 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC18 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC19 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC20 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINB3 : { CMP_DIS: 63 , CMP_EN: 65.5 },
|
||||
ADCINB5 : { CMP_DIS: 2.1 , CMP_EN: 4.6 },
|
||||
ADCINB11 : { CMP_DIS: 1.6 , CMP_EN: 4.1 },
|
||||
AGPIO_B5 : { CMP_DIS: 1 , CMP_EN: 3.5 },
|
||||
AGPIO_B11 : { CMP_DIS: 1 , CMP_EN: 3.5 },
|
||||
}
|
||||
|
||||
var Cp_F28P55x = {
|
||||
ADCINA0 : { CMP_DIS: 9.1 , CMP_EN: 11.6 },
|
||||
ADCINA1 : { CMP_DIS: 7.4 , CMP_EN: 9.9 },
|
||||
ADCINA2 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINA3 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINA4 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINA5 : { CMP_DIS: 3.5 , CMP_EN: 6 },
|
||||
ADCINA6 : { CMP_DIS: 3.2 , CMP_EN: 5.7 },
|
||||
ADCINA7 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINA8 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINA9 : { CMP_DIS: 3.1 , CMP_EN: 5.6 },
|
||||
ADCINA10 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINA11 : { CMP_DIS: 4 , CMP_EN: 6.5 },
|
||||
ADCINA12 : { CMP_DIS: 3.4 , CMP_EN: 5.9 },
|
||||
ADCINA14 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINA15 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC0 : { CMP_DIS: 4 , CMP_EN: 6.5 },
|
||||
ADCINC1 : { CMP_DIS: 3 , CMP_EN: 5.5 },
|
||||
ADCINC2 : { CMP_DIS: 3.6 , CMP_EN: 6.1 },
|
||||
ADCINC3 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC4 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC5 : { CMP_DIS: 3.6 , CMP_EN: 6.1 },
|
||||
ADCINC6 : { CMP_DIS: 3.9 , CMP_EN: 6.4 },
|
||||
ADCINC7 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINC8 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINC9 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINC10 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINC11 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINC14 : { CMP_DIS: 4.2 , CMP_EN: 6.7 },
|
||||
ADCINC15 : { CMP_DIS: 9.1 , CMP_EN: 11.6 },
|
||||
ADCINB0 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINB1 : { CMP_DIS: 4.7 , CMP_EN: 7.2 },
|
||||
ADCINB2 : { CMP_DIS: 3.9 , CMP_EN: 6.4 },
|
||||
ADCINB3 : { CMP_DIS: 75 , CMP_EN: 77.5 },
|
||||
ADCINB4 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINB5 : { CMP_DIS: 3.5 , CMP_EN: 6 },
|
||||
ADCINB6 : { CMP_DIS: 4.1 , CMP_EN: 6.6 },
|
||||
ADCINB7 : { CMP_DIS: 7.4 , CMP_EN: 9.9 },
|
||||
ADCINB8 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINB9 : { CMP_DIS: 3.3 , CMP_EN: 5.8 },
|
||||
ADCINB11 : { CMP_DIS: 4 , CMP_EN: 6.5 },
|
||||
ADCINB12 : { CMP_DIS: 3.6 , CMP_EN: 6.1 },
|
||||
ADCINB14 : { CMP_DIS: 3.8 , CMP_EN: 6.3 },
|
||||
ADCINB15 : { CMP_DIS: 9.1 , CMP_EN: 11.6 },
|
||||
AGPIO_B5 : { CMP_DIS: 3.2 , CMP_EN: 5.7 },
|
||||
AGPIO_B11 : { CMP_DIS: 3.1 , CMP_EN: 5.6 },
|
||||
}
|
||||
|
||||
var Cp_F28P65x = {
|
||||
ADCINA0 : { CMP_DIS: 9.3, CMP_EN: 14.3 },
|
||||
ADCINA1 : { CMP_DIS: 9.3, CMP_EN: 14.3 },
|
||||
ADCINA2 : { CMP_DIS: 1.5, CMP_EN: 4.0 },
|
||||
ADCINA3 : { CMP_DIS: 1.8, CMP_EN: 4.3 },
|
||||
ADCINA4 : { CMP_DIS: 2.4, CMP_EN: 4.9 },
|
||||
ADCINA5 : { CMP_DIS: 4.4, CMP_EN: 9.4 },
|
||||
ADCINA6 : { CMP_DIS: 3.1, CMP_EN: 8.1 },
|
||||
ADCINA7 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINA8 : { CMP_DIS: 2.2, CMP_EN: 4.7 },
|
||||
ADCINA9 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINA10 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINA11 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINA12 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINA14 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINA15 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINA16 : { CMP_DIS: 2.4 , CMP_EN: 4.9},
|
||||
ADCINA17 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA18 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA19 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINA20 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC0 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINC1 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINC2 : { CMP_DIS: 4.4 , CMP_EN: 9.4 },
|
||||
ADCINC3 : { CMP_DIS: 5.1, CMP_EN: 10.1 },
|
||||
ADCINC4 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINC5 : { CMP_DIS: 1.8 , CMP_EN: 4.3 },
|
||||
ADCINC6 : { CMP_DIS: 3.1 , CMP_EN: 8.1 },
|
||||
ADCINC7 : { CMP_DIS: 5.4 , CMP_EN: 10.4 },
|
||||
ADCINC8 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINC9 : { CMP_DIS: 1.5 , CMP_EN: 4.0 },
|
||||
ADCINC10 : { CMP_DIS: 4.3, CMP_EN: 9.3 },
|
||||
ADCINC11 : { CMP_DIS: 2.2, CMP_EN: 4.7 },
|
||||
ADCINC14 : { CMP_DIS: 2.4 , CMP_EN: 4.9 },
|
||||
ADCINC15 : { CMP_DIS: 9.3 , CMP_EN: 14.3},
|
||||
ADCINC16 : { CMP_DIS: 2.4 , CMP_EN: 4.9},
|
||||
ADCINC17 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC18 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC19 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINC20 : { CMP_DIS: 2.7 , CMP_EN: 5.2},
|
||||
ADCINB3 : { CMP_DIS: 63 , CMP_EN: 65.5 },
|
||||
ADCINB5 : { CMP_DIS: 2.1 , CMP_EN: 4.6 },
|
||||
ADCINB11 : { CMP_DIS: 1.6 , CMP_EN: 4.1 },
|
||||
AGPIO_B5 : { CMP_DIS: 1 , CMP_EN: 3.5 },
|
||||
AGPIO_B11 : { CMP_DIS: 1 , CMP_EN: 3.5 },
|
||||
}
|
||||
|
||||
var Cp = {
|
||||
F28P65x: Cp_F28P65x,
|
||||
F28P55x: Cp_F28P55x,
|
||||
F280015x: Cp_F280015x,
|
||||
F280013x: Cp_F280013x,
|
||||
F28003x: Cp_F28003x,
|
||||
F28002x: Cp_F28002x,
|
||||
F2838x : Cp_F2838x,
|
||||
F28004x: Cp_F28004x,
|
||||
F2837xD: Cp_F2837xD,
|
||||
F2837xS: Cp_F2837xS,
|
||||
F2807x: Cp_F2807x
|
||||
}
|
||||
|
||||
var Ron = {
|
||||
F28P65x:{ REF_3V3: 860, REF: 500},
|
||||
F28P55x:{ REF_3V3: 860, REF: 500},
|
||||
F280015x:{ REF_3V3: 860, REF: 500},
|
||||
F280013x:{ REF_3V3: 860, REF: 500},
|
||||
F28003x: { REF_3V3: 860, REF: 500},
|
||||
F28002x: { REF_3V3: 860, REF: 500},
|
||||
F2838x : { REF_3V3: 700, REF: 700},
|
||||
F28004x: { REF_3V3: 860, REF: 500},
|
||||
F2837xD: { REF_3V3: 425, REF: 425},
|
||||
F2837xS: { REF_3V3: 425, REF: 425},
|
||||
F2807x: { REF_3V3: 600, REF: 600},
|
||||
}
|
||||
|
||||
var Ch = {
|
||||
F28P65x:{ REF_3V3: 7.5, REF: 12.5},
|
||||
F28P55x:{ REF_3V3: 7.5, REF: 12.5},
|
||||
F280015x:{ REF_3V3: 7.5, REF: 12.5},
|
||||
F280013x:{ REF_3V3: 7.5, REF: 12.5},
|
||||
F28003x: { REF_3V3: 7.5, REF: 12.5},
|
||||
F28002x: { REF_3V3: 7.5, REF: 12.5},
|
||||
F2838x : { REF_3V3: 16.5, REF: 16.5},
|
||||
F28004x: { REF_3V3: 7.5, REF: 12.5},
|
||||
F2837xD: { REF_3V3: 14.5, REF: 14.5},
|
||||
F2837xS: { REF_3V3: 14.5, REF: 14.5},
|
||||
F2807x: { REF_3V3: 16.5, REF: 16.5},
|
||||
}
|
||||
|
||||
exports = {
|
||||
Ch: Ch,
|
||||
Ron: Ron,
|
||||
Cp: Cp,
|
||||
tEOC_12bit_SYSCLK,
|
||||
tEOC_16bit_SYSCLK
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
/* Stucture for ADC Internal Connections with VREFLO*/
|
||||
// TODO: Verify if need to add individual package support
|
||||
let ADC_internalSignals = {
|
||||
F28002x: {
|
||||
A13: "VREFLO",
|
||||
C12: "TempSensor",
|
||||
C13: "VREFLO",
|
||||
},
|
||||
F28003x: {
|
||||
A13: "VREFLO",
|
||||
B13: "VREFLO",
|
||||
C12: "TempSensor",
|
||||
C13: "VREFLO",
|
||||
},
|
||||
F280013x: {
|
||||
A13: "VREFLO",
|
||||
C12: "TempSensor",
|
||||
C13: "VREFLO",
|
||||
},
|
||||
F280015x: {
|
||||
A13: "VREFLO",
|
||||
C12: "TempSensor",
|
||||
C13: "VREFLO",
|
||||
},
|
||||
F28004x: {
|
||||
A13: "VREFLOA",
|
||||
B13: "VREFLOB",
|
||||
B14: "TempSensor",
|
||||
C13: "VREFLOC",
|
||||
},
|
||||
F2838x: {
|
||||
A8: "VREFLOA",
|
||||
A9: "VREFLOA",
|
||||
A13: "TempSensor",
|
||||
B8: "VREFLOB",
|
||||
B9: "VREFLOB",
|
||||
C8: "VREFLOC",
|
||||
C9: "VREFLOC",
|
||||
D8: "VREFLOD",
|
||||
D9: "VREFLOD",
|
||||
},
|
||||
F2837xD: {
|
||||
A8: "VREFLOA",
|
||||
A9: "VREFLOA",
|
||||
A13: "TempSensor",
|
||||
B8: "VREFLOB",
|
||||
B9: "VREFLOB",
|
||||
C8: "VREFLOC",
|
||||
C9: "VREFLOC",
|
||||
D8: "VREFLOD",
|
||||
D9: "VREFLOD",
|
||||
},
|
||||
F2837xS: {
|
||||
A8: "VREFLOA",
|
||||
A9: "VREFLOA",
|
||||
A13: "TempSensor",
|
||||
B8: "VREFLOB",
|
||||
B9: "VREFLOB",
|
||||
C8: "VREFLOC",
|
||||
C9: "VREFLOC",
|
||||
D8: "VREFLOD",
|
||||
D9: "VREFLOD",
|
||||
},
|
||||
F2807x: {
|
||||
A8: "VREFLOA",
|
||||
A9: "VREFLOA",
|
||||
A13: "TempSensor",
|
||||
B8: "VREFLOB",
|
||||
B9: "VREFLOB",
|
||||
D8: "VREFLOD",
|
||||
D9: "VREFLOD",
|
||||
},
|
||||
F28P65x: {
|
||||
A18: "VREFLOA",
|
||||
C18: "VREFLOA",
|
||||
A13: "TempSensor",
|
||||
A19: "VREFLOB",
|
||||
C19: "VREFLOB",
|
||||
A20: "VREFLOC",
|
||||
C20: "VREFLOC",
|
||||
},
|
||||
F28P55x: {
|
||||
A13: "VREFLO",
|
||||
B13: "VREFLO",
|
||||
C12: "TempSensor",
|
||||
C13: "VREFLO",
|
||||
D13: "VREFLO",
|
||||
E13: "VREFLO",
|
||||
}
|
||||
}
|
||||
|
||||
exports = {
|
||||
ADC_internalSignals: ADC_internalSignals,
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
% var nameOfModule = "adcsafetychecker";
|
||||
% var module = system.modules['/driverlib/' + nameOfModule + '.js'];
|
||||
% let Common = system.getScript("/driverlib/Common.js");
|
||||
% var nameOfPeripheral = module.peripheralName;
|
||||
%
|
||||
% let tileModule = system.modules['/driverlib/adc/modules/adcsafetycheckertile.js'];
|
||||
% let aggrModule = system.modules['/driverlib/adc/modules/adcsafetycheckeraggr.js'];
|
||||
%
|
||||
% let device_driverlib_peripheral = system.getScript("/driverlib/device_driverlib_peripherals/" + Common.getDeviceName().toLowerCase() + "_adc.js");
|
||||
% let device_driverlib_memmap =system.getScript("/driverlib/device_driverlib_peripherals/" + Common.getDeviceName().toLowerCase() + "_memmap.js");
|
||||
void `nameOfPeripheral`_init(){
|
||||
%if (tileModule != null)
|
||||
%{
|
||||
% for(var i = 0; i < tileModule.$instances.length; i++) {
|
||||
% var instance = tileModule.$instances[i];
|
||||
% var baseName = instance.$name + "_BASE";
|
||||
`instance.$name`_init();
|
||||
% }
|
||||
%}
|
||||
|
||||
%if (aggrModule != null)
|
||||
%{
|
||||
% for(var i = 0; i < aggrModule.$instances.length; i++) {
|
||||
% var instance = aggrModule.$instances[i];
|
||||
% var baseName = instance.$name + "_BASE";
|
||||
`instance.$name`_init();
|
||||
% }
|
||||
% }
|
||||
}
|
||||
|
||||
%if (tileModule != null)
|
||||
%{
|
||||
% for(var i = 0; i < tileModule.$instances.length; i++) {
|
||||
% var instance = tileModule.$instances[i];
|
||||
% var baseName = instance.$name + "_BASE";
|
||||
|
||||
void `instance.$name`_init(){
|
||||
% for(var rptrIndex in device_driverlib_peripheral.ADC_SafetyCheckInst){
|
||||
% var currentRPTR = device_driverlib_peripheral.ADC_SafetyCheckInst[rptrIndex].name
|
||||
% var rptrNumber = (currentRPTR).replace(/[^0-9]/g,'');
|
||||
% var socName = "ADC_SOC_NUMBER"+(instance["safetycheck"+rptrNumber+"usedSOC"]).replace(/[^0-9]/g,'') ;
|
||||
//
|
||||
// Configures the safety checker result for a selected SOC.
|
||||
// adcBase : `instance["safetycheck"+rptrNumber+"ADC"].replace("_","")`_BASE
|
||||
// socNumber : `instance["safetycheck"+rptrNumber+"usedSOC"]`
|
||||
// scInput : `instance["safetycheck"+rptrNumber+"inputSource"]`
|
||||
ADC_configSOCSafetyCheckerInput(`instance["safetycheck"+rptrNumber+"ADC"].replace("_","")`_BASE,`instance["safetycheck"+rptrNumber+"ResultSelect"].replace("ADC_RESULT","ADC_SOC_NUMBER")`,`instance["safetycheck"+rptrNumber+"inputSource"]`);
|
||||
//
|
||||
// Configures the safety checker module.
|
||||
// scBase : `baseName`
|
||||
// SafetyCheckerInstant : `rptrNumber`
|
||||
// ADCInstant : `instance["safetycheck"+rptrNumber+"ADC"]`
|
||||
// adcResultInst : `instance["safetycheck"+rptrNumber+"ResultSelect"]`
|
||||
ADC_configureSafetyChecker(`baseName`, ADC_SAFETY_CHECK`rptrNumber`,`instance["safetycheck"+rptrNumber+"ADC"]`,`instance["safetycheck"+rptrNumber+"ResultSelect"]`);
|
||||
% }
|
||||
//
|
||||
// Configures the tolerance allowed between safety check results.
|
||||
// scBase : `baseName`
|
||||
// tolerance : `instance["safetyCheckTolerance"]`
|
||||
ADC_setSafetyCheckerTolerance(`baseName`,`instance["safetyCheckTolerance"]`);
|
||||
% if(instance.enableSafetychecker){
|
||||
//
|
||||
// Enables the ADC result safety checker module.
|
||||
//
|
||||
ADC_enableSafetyChecker(`baseName`);
|
||||
% }
|
||||
% else{
|
||||
//
|
||||
// Disables the ADC result safety checker module.
|
||||
//
|
||||
ADC_disableSafetyChecker(`baseName`);
|
||||
% }
|
||||
}
|
||||
% }
|
||||
% }
|
||||
|
||||
%if (aggrModule != null)
|
||||
%{
|
||||
% for(var i = 0; i < aggrModule.$instances.length; i++) {
|
||||
% var instance = aggrModule.$instances[i];
|
||||
% var baseName = instance.$name + "_BASE";
|
||||
void `instance.$name`_init(){
|
||||
% for (var sftychkr in device_driverlib_memmap.ADCSAFETYCHKMemoryMap) {
|
||||
% for (var chkrslt in device_driverlib_peripheral.ADC_SafetyCheckResult){
|
||||
% var currentchkrslt= device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name.replace("_BASE","").replace("ADC","");
|
||||
% var currentsftychkr = device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name.replace("ADC_SAFETY_CHECK_","");
|
||||
% var chkrNumber = currentchkrslt.replace(/[^0-9]/g,'');
|
||||
% var chkrResult = device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name;
|
||||
% if (instance.enableInterrupt) {
|
||||
% if((instance.eventInterruptSource).includes(currentchkrslt + currentsftychkr)){
|
||||
//
|
||||
// Enable Safety Checker `chkrNumber` `currentsftychkr` interrupt
|
||||
//
|
||||
ADC_enableSafetyCheckInt(`baseName`, ADC_SAFETY_CHECKER`chkrNumber`, `chkrResult`);
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
|
||||
|
||||
% for(var evntIndex in device_driverlib_peripheral.ADC_SafetyCheckEvent){
|
||||
% var currentEvnt = device_driverlib_peripheral.ADC_SafetyCheckEvent[evntIndex].name
|
||||
% var evntNumber = (currentEvnt).replace(/[^0-9]/g,'')
|
||||
% if((instance.enableEvent).includes(currentEvnt)){
|
||||
% for (var sftychkr in device_driverlib_memmap.ADCSAFETYCHKMemoryMap) {
|
||||
% for (var chkrslt in device_driverlib_peripheral.ADC_SafetyCheckResult){
|
||||
% var currentchkrslt= device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name.replace("_BASE","").replace("ADC","");
|
||||
% var currentsftychkr = device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name.replace("ADC_SAFETY_CHECK_","");
|
||||
% var chkrNumber = currentchkrslt.replace(/[^0-9]/g,'');
|
||||
% var chkrResult = device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name;
|
||||
% if((instance["chkEvent" + evntNumber + "Source"]).includes(currentchkrslt + currentsftychkr)){
|
||||
//
|
||||
// Enable Safety Checker `chkrNumber` `currentsftychkr` event `evntNumber`
|
||||
//
|
||||
ADC_enableSafetyCheckEvt(`baseName`, ADC_SAFETY_CHECKER`chkrNumber`, ADC_SAFETY_CHECK_EVENT`evntNumber`, `chkrResult`);
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
% }
|
||||
|
||||
}
|
||||
% }
|
||||
% }
|
||||
@@ -0,0 +1,26 @@
|
||||
% var nameOfModule = "adcsafetychecker";
|
||||
% var module = system.modules['/driverlib/' + nameOfModule + '.js'];
|
||||
% let Common = system.getScript("/driverlib/Common.js");
|
||||
% let tileModule = system.modules['/driverlib/adc/modules/adcsafetycheckertile.js'];
|
||||
% let aggrModule = system.modules['/driverlib/adc/modules/adcsafetycheckeraggr.js'];
|
||||
%if (tileModule != null)
|
||||
%{
|
||||
//*****************************************************************************
|
||||
//
|
||||
// ADC Safety Checker Configurations
|
||||
//
|
||||
//*****************************************************************************
|
||||
% for(var i = 0; i < tileModule.$instances.length; i++) {
|
||||
% var instance = tileModule.$instances[i];
|
||||
#define `instance.$name`_BASE `instance.adcscBase`
|
||||
void `instance.$name`_init();
|
||||
% }
|
||||
%}
|
||||
%if (aggrModule != null)
|
||||
%{
|
||||
% for(var i = 0; i < aggrModule.$instances.length; i++) {
|
||||
% var instance = aggrModule.$instances[i];
|
||||
#define `instance.$name`_BASE `instance.adcIntEvtBase`
|
||||
void `instance.$name`_init();
|
||||
% }
|
||||
%}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 4.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 35 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 50 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 49 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 8.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.9 KiB |
@@ -0,0 +1,219 @@
|
||||
let Common = system.getScript("/driverlib/Common.js");
|
||||
let device_driverlib_peripheral =
|
||||
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
||||
Common.getDeviceName().toLowerCase() + "_adc.js");
|
||||
|
||||
let device_driverlib_memmap =
|
||||
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
||||
Common.getDeviceName().toLowerCase() + "_memmap.js");
|
||||
|
||||
var ADC_SFTYCH_SOURCE =[];
|
||||
|
||||
var ADCINTEVT_INSTANCE =[];
|
||||
|
||||
if (["F28P65x"].includes(Common.getDeviceName()))
|
||||
{
|
||||
for (var sftychkr in device_driverlib_memmap.ADCSAFETYINTEVTAGGMemoryMap)
|
||||
{
|
||||
ADCINTEVT_INSTANCE.push(
|
||||
{ name: device_driverlib_memmap.ADCSAFETYINTEVTAGGMemoryMap[sftychkr].name,
|
||||
displayName: device_driverlib_memmap.ADCSAFETYINTEVTAGGMemoryMap[sftychkr].name.replace("_BASE","")
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
var maxInstances = ADCINTEVT_INSTANCE.length
|
||||
|
||||
if (["F28P65x"].includes(Common.getDeviceName()))
|
||||
{
|
||||
for (var sftychkr in device_driverlib_memmap.ADCSAFETYCHKMemoryMap)
|
||||
{
|
||||
for (var chkrslt in device_driverlib_peripheral.ADC_SafetyCheckResult)
|
||||
{
|
||||
var currentchkrslt= device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name.replace("_BASE","").replace("ADC","")
|
||||
var currentsftychkr = device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name.replace("ADC_SAFETY_CHECK_","")
|
||||
|
||||
ADC_SFTYCH_SOURCE.push(
|
||||
{ name: device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name.replace("_BASE","").replace("ADC","") + device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name.replace("ADC_SAFETY_CHECK_",""),
|
||||
displayName: device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name.replace("_BASE","").replace("ADCSAFETYCHK","SAFETY_CHECK") + " "+ device_driverlib_peripheral.ADC_SafetyCheckResult[chkrslt].name.replace("ADC_SAFETY_CHECK_","")
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
function onChangeSafetyCheckerEVNTs(inst, ui){
|
||||
for(var evntIndex in device_driverlib_peripheral.ADC_SafetyCheckEvent)
|
||||
{
|
||||
var currentEvnt = device_driverlib_peripheral.ADC_SafetyCheckEvent[evntIndex].name
|
||||
var evnti = (currentEvnt).replace(/[^0-9]/g,'')
|
||||
var sftyEVNTConfigs =
|
||||
[
|
||||
"chkEvent" + evnti.toString() + "Source",
|
||||
]
|
||||
|
||||
if (ui)
|
||||
{
|
||||
for (var sftyConfig of sftyEVNTConfigs)
|
||||
{
|
||||
if(inst["enableEvent"].includes(currentEvnt))
|
||||
{
|
||||
ui[sftyConfig].hidden = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
ui[sftyConfig].hidden = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
function onChangeSafetyCheckerINTs(inst, ui) {
|
||||
if (ui) {
|
||||
if((inst.enableInterrupt)) {
|
||||
ui["eventInterruptSource"].hidden = false;
|
||||
}
|
||||
else {
|
||||
ui["eventInterruptSource"].hidden = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var config = [
|
||||
{
|
||||
name : "adcIntEvtBase",
|
||||
displayName : "ADC INTEVT Instance",
|
||||
description : 'Instance of the ADC used.',
|
||||
hidden : false,
|
||||
default : ADCINTEVT_INSTANCE[0].name,
|
||||
options : ADCINTEVT_INSTANCE,
|
||||
},
|
||||
{
|
||||
name : "enableInterrupt",
|
||||
displayName : "Enable Interrupt",
|
||||
description : 'Each ADC result safety checker tile can generate an interrupt signal from out-of-tolerance (OOT) flag and result overflow flags OVF1 and OVF2',
|
||||
longDescription : 'Each ADC result safety checker tile generates an interrupt pulse when an enabled out-of-tolerance (OOT) or overflow OVF1 or OVF2 event occurs. No further interrupt pulses will be generated until the interrupt flag is cleared.',
|
||||
hidden : false,
|
||||
default : false,
|
||||
onChange : onChangeSafetyCheckerINTs,
|
||||
},
|
||||
{
|
||||
name : "eventInterruptSource",
|
||||
displayName : "Select source for interrupt",
|
||||
description : 'Each ADC result safety checker tile can generate an interrupt signal from out-of-tolerance (OOT) flag and result overflow flags OVF1 and OVF2',
|
||||
hidden : true,
|
||||
minSelections : 0,
|
||||
default : [],
|
||||
options : ADC_SFTYCH_SOURCE,
|
||||
onChange : onChangeSafetyCheckerINTs,
|
||||
},
|
||||
{
|
||||
name : "enableEvent",
|
||||
displayName : "Enable Event",
|
||||
description : 'safety checker tiles can generate events that can be sent to the X-BAR, so that automatic hardware actions such as an ePWM trip can be generated',
|
||||
longDescription : '',
|
||||
hidden : false,
|
||||
minSelections : 0,
|
||||
default : [],
|
||||
options :device_driverlib_peripheral.ADC_SafetyCheckEvent,
|
||||
onChange : onChangeSafetyCheckerEVNTs,
|
||||
},
|
||||
|
||||
];
|
||||
|
||||
for(var evntIndex in device_driverlib_peripheral.ADC_SafetyCheckEvent)
|
||||
{
|
||||
var currentEvnt = device_driverlib_peripheral.ADC_SafetyCheckEvent[evntIndex].name
|
||||
var evnti = (currentEvnt).replace(/[^0-9]/g,'')
|
||||
var sfty_Configs = [
|
||||
{
|
||||
name: "chkEvent" + evnti.toString() + "Source",
|
||||
displayName : "Select Source",
|
||||
description : 'Select Source for this event',
|
||||
hidden : true,
|
||||
minSelections : 0,
|
||||
default : [],
|
||||
options : ADC_SFTYCH_SOURCE,
|
||||
},
|
||||
|
||||
]
|
||||
config = config.concat ([{
|
||||
name: "GROUP_EVENT" +evnti.toString(),
|
||||
displayName: "Safety Check Event " + evnti.toString(),
|
||||
description: "",
|
||||
longDescription: "",
|
||||
config: sfty_Configs
|
||||
}])
|
||||
}
|
||||
|
||||
function onValidate(inst, validation) {
|
||||
//
|
||||
// Check duplicate sources
|
||||
//
|
||||
var usedADCSCInsts = [];
|
||||
for (var instance_index in inst.$module.$instances)
|
||||
{
|
||||
var instance_obj = inst.$module.$instances[instance_index];
|
||||
usedADCSCInsts.push(instance_obj.adcIntEvtBase);
|
||||
}
|
||||
|
||||
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];
|
||||
usedADCSCInsts.push(instance_obj.adcIntEvtBase);
|
||||
}
|
||||
}
|
||||
}
|
||||
var duplicatesResult = Common.findDuplicates(usedADCSCInsts)
|
||||
|
||||
if (duplicatesResult.duplicates.length != 0)
|
||||
{
|
||||
var allDuplicates = "";
|
||||
for (var duplicateNamesIndex in duplicatesResult.duplicates)
|
||||
{
|
||||
allDuplicates = allDuplicates + Common.stringOrEmpty(allDuplicates, ", ")
|
||||
+ duplicatesResult.duplicates[duplicateNamesIndex];
|
||||
}
|
||||
validation.logError(
|
||||
"The ADC Safety Checker Aggregator Instance used. Duplicates: " + allDuplicates,
|
||||
inst, "adcIntEvtBase");
|
||||
}
|
||||
|
||||
if (Common.isContextCPU1()) {
|
||||
if (inst["adcIntEvtBase"] == "ADCSAFETYINTEVTAGG2_BASE"){
|
||||
validation.logError(
|
||||
"ADC Safety INTEVT Aggregator 2 instance can not be used for CPU1", inst, "adcIntEvtBase");
|
||||
}
|
||||
}
|
||||
if (Common.isContextCPU2()) {
|
||||
if (inst["adcIntEvtBase"] == "ADCSAFETYINTEVTAGG1_BASE"){
|
||||
validation.logError(
|
||||
"ADC Safety INTEVT Aggregator 1 instance can not be used for CPU2", inst, "adcIntEvtBase");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var adcSCSubmodule = {
|
||||
//peripheralName: "ADCSafetyCheckerINTEVT",
|
||||
displayName: "ADC SAFETY CHECKER INTEVT",
|
||||
defaultInstanceName: "myADCSAFETYCHECKERAGGR",
|
||||
description: "ADC Safety Checker Interrupt Event Aggregator",
|
||||
maxInstances: maxInstances,
|
||||
config: config,
|
||||
validate: onValidate,
|
||||
templates: {
|
||||
// boardc : "",
|
||||
// boardh : ""
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
exports = adcSCSubmodule;
|
||||
@@ -0,0 +1,758 @@
|
||||
let Common = system.getScript("/driverlib/Common.js");
|
||||
let device_driverlib_peripheral =
|
||||
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
||||
Common.getDeviceName().toLowerCase() + "_adc.js");
|
||||
let device_driverlib_memmap =
|
||||
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
||||
Common.getDeviceName().toLowerCase() + "_memmap.js");
|
||||
|
||||
|
||||
var ADCSC_INSTANCE =[];
|
||||
|
||||
if (["F28P65x"].includes(Common.getDeviceName()))
|
||||
{
|
||||
for (var sftychkr in device_driverlib_memmap.ADCSAFETYCHKMemoryMap)
|
||||
{
|
||||
ADCSC_INSTANCE.push(
|
||||
{ name: device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name,
|
||||
displayName: device_driverlib_memmap.ADCSAFETYCHKMemoryMap[sftychkr].name.replace("_BASE","")
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
var maxInstances = ADCSC_INSTANCE.length
|
||||
|
||||
|
||||
|
||||
var longDescriptionsafetychecker = `
|
||||
For safety-critical applications, this device provides the ability to automatically compare ADC conversion results from multiple ADC modules against each other for consistency.
|
||||
Each ADC checker tile captures conversion results from the associated ADCs
|
||||
as soon as the conversions are complete, and compares the absolute value of the difference to the configured
|
||||
tolerance. If the computed delta is out of range, the checker can generate a trip event signal that is sent to
|
||||
an ePWM or output crossbar, and can also trigger an CPU interrupt. The structure and
|
||||
operation of an ADC result safety checker tile are demonstrated in the figure:
|
||||
|
||||
|
||||
To configure an ADC result safety checker tile:
|
||||
1) Select the first ADC instance to test. Then, in the Input field, select the source of the result, which can be any one of the SOCs, PPB modules or PPB sums. The result value should be given in the Selected Result field.
|
||||
2) Select the second ADC instance to test. Then, in the Input field, select the source of the result, which can be any one of the SOCs, PPB modules or PPB sums. The result value should be given in the Selected Result field.
|
||||
3) Configure the checker tolerance by assigning the value to Tolerance field.
|
||||
4) Enable the checker tile by selecting Enable Safety Checker
|
||||
`
|
||||
var longDescriptionsafetycheckertolerance = `
|
||||
Each ADC result safety checker tile can be configured to automatically compare two ADC conversion results
|
||||
against a set tolerance value, and generate an interrupt if an out-of-tolerance (OOT) event occurs. The selected
|
||||
results can be from the same ADC instance, or from different ADCs.
|
||||
`
|
||||
/* Array of ADC configurables that are common across device families */
|
||||
let config = [
|
||||
{
|
||||
name : "adcscBase",
|
||||
displayName : "ADC Safety Checker Instance",
|
||||
longDescription : longDescriptionsafetychecker,
|
||||
hidden : false,
|
||||
default : ADCSC_INSTANCE[0].name,
|
||||
options : ADCSC_INSTANCE,
|
||||
|
||||
},
|
||||
{
|
||||
name : "safetyCheckTolerance",
|
||||
displayName : "Tolerance [LSB]",
|
||||
description : 'Select tolerance in LSB for the difference between check result instancese',
|
||||
longDescription : longDescriptionsafetycheckertolerance,
|
||||
hidden : false,
|
||||
default : 0,
|
||||
},
|
||||
];
|
||||
|
||||
|
||||
|
||||
|
||||
function onChangesafetychecker(inst, ui)
|
||||
{
|
||||
for(var rptrIndex in device_driverlib_peripheral.ADC_SafetyCheckInst)
|
||||
{
|
||||
var currentRPTR = device_driverlib_peripheral.ADC_SafetyCheckInst[rptrIndex].name
|
||||
var rptri = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
var selectedsources=
|
||||
[
|
||||
"safetycheck"+ rptri.toString()+"usedSOC",
|
||||
// "safetycheck"+ rptri.toString()+"usedPPB",
|
||||
// "safetycheck"+ rptri.toString()+"usedPPBSUM",
|
||||
];
|
||||
if (ui)
|
||||
{
|
||||
for (var selectedsource of selectedsources)
|
||||
{
|
||||
if ((inst["safetycheck"+ rptri.toString()+"inputSource"] != "ADC_SAFETY_CHECKER_INPUT_DISABLE"))
|
||||
{
|
||||
ui["safetycheck"+ rptri.toString()+"usedSOC"].hidden = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
ui["safetycheck"+ rptri.toString()+"usedSOC"].hidden = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (["F28P65x"].includes(Common.getDeviceName())) {
|
||||
for (var rptrIndex in device_driverlib_peripheral.ADC_SafetyCheckInst) {
|
||||
var currentRPTR = device_driverlib_peripheral.ADC_SafetyCheckInst[rptrIndex].name
|
||||
let rptri = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
config= config.concat ([
|
||||
{
|
||||
name:"safetychecker"+ rptri.toString(),
|
||||
displayName: "Selector "+ rptri.toString() + " Configurations",
|
||||
longDescription: "",
|
||||
collapsed: true,
|
||||
config:
|
||||
[
|
||||
|
||||
{
|
||||
name: "safetycheck"+ rptri.toString()+"ADC",
|
||||
displayName : "ADC Instance",
|
||||
description : 'Select the ADC for this safety checker module',
|
||||
default : device_driverlib_peripheral.ADC_Select[0].name,
|
||||
options : device_driverlib_peripheral.ADC_Select,
|
||||
},
|
||||
{
|
||||
name: "safetycheck"+ rptri.toString()+"inputSource",
|
||||
displayName: "Input Source",
|
||||
hidden : false,
|
||||
default : device_driverlib_peripheral.ADC_SafetyCheckerInput[0].name,
|
||||
options : device_driverlib_peripheral.ADC_SafetyCheckerInput,
|
||||
onChange : onChangesafetychecker,
|
||||
},
|
||||
{
|
||||
name: "safetycheck"+ rptri.toString()+"ResultSelect",
|
||||
displayName : "Result to Compare",
|
||||
description : 'Select the result for the safety checker module',
|
||||
default : device_driverlib_peripheral.ADC_ResultSelect[0].name,
|
||||
options : device_driverlib_peripheral.ADC_ResultSelect
|
||||
},
|
||||
{
|
||||
name: "safetycheck"+ rptri.toString()+"usedSOC",
|
||||
displayName : "Selected Source",
|
||||
description : 'Selected SOCs for Selector '+ rptri.toString(),
|
||||
hidden : true,
|
||||
default :"",
|
||||
getValue : (inst) =>{
|
||||
let adc = system.modules["/driverlib/adc.js"];
|
||||
var selectedsource= "";
|
||||
if (adc!=null)
|
||||
{
|
||||
for ( var adc_inst of adc.$instances)
|
||||
{
|
||||
if (adc_inst.adcBase.replace("_BASE","").replace("ADC","") ==
|
||||
inst["safetycheck"+ rptri.toString()+"ADC"].replace("ADC_","") )
|
||||
for(var socIndex in device_driverlib_peripheral.ADC_SOCNumber)
|
||||
{
|
||||
var currentSOC = device_driverlib_peripheral.ADC_SOCNumber[socIndex].name
|
||||
var soci = (currentSOC).replace(/[^0-9]/g,'')
|
||||
var resi= inst["safetycheck"+ rptri.toString()+"ResultSelect"].replace(/[^0-9]/g,'')
|
||||
//return adc_inst.enabledSOCs.toString().replace("ADC_","").replace("_NUMBER"," number ").replace("SOC","SOC/EOC")
|
||||
// if((adc_inst.enabledPPBs).includes(currentPPB)){
|
||||
if((adc_inst.enabledSOCs).includes(currentSOC) && (inst["safetycheck"+ rptri.toString()+"inputSource"]=="ADC_SAFETY_CHECKER_INPUT_SOCx"))
|
||||
{
|
||||
if (resi==soci)
|
||||
{
|
||||
selectedsource= "SOC"+soci.toString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(var ppbIndex in device_driverlib_peripheral.ADC_PPBNumber)
|
||||
{
|
||||
var currentPPB = device_driverlib_peripheral.ADC_PPBNumber[ppbIndex].name
|
||||
var ppbi = (currentPPB).replace(/[^0-9]/g,'')
|
||||
var resi= inst["safetycheck"+ rptri.toString()+"ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var highPPB = "";
|
||||
if((adc_inst.enabledPPBs).includes(currentPPB) && ((inst["safetycheck"+ rptri.toString()+"inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBx")||(inst["safetycheck"+ rptri.toString()+"inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBSUMx")))
|
||||
{
|
||||
if (resi == adc_inst["ppb" + ppbi.toString() + "SOCNumber"].replace(/[^0-9]/g,''))
|
||||
{
|
||||
// highPPB+=adc_inst["ppb" + ppbi.toString() + "Name"];
|
||||
highPPB+=adc_inst["ppb" + ppbi.toString() + "SOCNumber"]
|
||||
selectedsource = adc_inst["ppb" + ppbi.toString() + "SOCNumber"].replace("ADC_","").replace("_NUMBER","")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return selectedsource;
|
||||
}
|
||||
},
|
||||
]
|
||||
},
|
||||
])
|
||||
}
|
||||
}
|
||||
config = config.concat([
|
||||
{
|
||||
name: "enableSafetychecker",
|
||||
displayName : "Enable Safety Checker During Initilization",
|
||||
description : 'Enable Safety Checker during initilization',
|
||||
hidden : false,
|
||||
default : false,
|
||||
// onChange :onChangesafetychecker,
|
||||
},
|
||||
])
|
||||
|
||||
|
||||
function onValidateStatic(mod, stat)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
function filterHardware(component)
|
||||
{
|
||||
return (Common.typeMatches(component.type, ["ADC"]));
|
||||
}
|
||||
|
||||
function modules(inst)
|
||||
{
|
||||
if (inst) {
|
||||
return [
|
||||
{
|
||||
name: "adcPullInTemplateDot",
|
||||
moduleName: "/driverlib/adc/templates/adc.dot.dynamic.js",
|
||||
}
|
||||
];
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
|
||||
|
||||
function onValidate(inst, validation) {
|
||||
|
||||
//
|
||||
// Check copy safety Checker Instances
|
||||
//
|
||||
var usedADCSCInsts = [];
|
||||
for (var instance_index in inst.$module.$instances)
|
||||
{
|
||||
var instance_obj = inst.$module.$instances[instance_index];
|
||||
usedADCSCInsts.push(instance_obj.adcscBase);
|
||||
}
|
||||
|
||||
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];
|
||||
usedADCSCInsts.push(instance_obj.adcscBase);
|
||||
}
|
||||
}
|
||||
}
|
||||
var duplicatesResult = Common.findDuplicates(usedADCSCInsts)
|
||||
|
||||
if (duplicatesResult.duplicates.length != 0)
|
||||
{
|
||||
var allDuplicates = "";
|
||||
for (var duplicateNamesIndex in duplicatesResult.duplicates)
|
||||
{
|
||||
allDuplicates = allDuplicates + Common.stringOrEmpty(allDuplicates, ", ")
|
||||
+ duplicatesResult.duplicates[duplicateNamesIndex];
|
||||
}
|
||||
validation.logError(
|
||||
"The ADC Safety Checker Tile Instance used. Duplicates: " + allDuplicates,
|
||||
inst, "adcscBase");
|
||||
}
|
||||
//
|
||||
// Check duplicate ADC sources
|
||||
//
|
||||
let adc = system.modules["/driverlib/adc.js"];
|
||||
|
||||
if (adc!=null)
|
||||
{
|
||||
var usedADCInsts = [];
|
||||
for (var instance_index in adc.$instances)
|
||||
{
|
||||
var instance_obj = adc.$instances[instance_index];
|
||||
usedADCInsts.push(instance_obj.adcBase);
|
||||
}
|
||||
for(var rptrIndex in device_driverlib_peripheral.ADC_SafetyCheckInst) {
|
||||
var currentRPTR = device_driverlib_peripheral.ADC_SafetyCheckInst[rptrIndex].name
|
||||
let rptri = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
if(!(usedADCInsts.includes(inst["safetycheck"+ rptri.toString()+"ADC"].replace("ADC_","ADC")+"_BASE"))){
|
||||
validation.logError(
|
||||
"This ADC Instance has not been configured. If you want to use this ADC, you can set it up via ADC module.",
|
||||
inst, "safetycheck"+ rptri.toString()+"ADC");
|
||||
}
|
||||
}
|
||||
for ( var adc_inst of adc.$instances)
|
||||
{
|
||||
if ((inst["safetycheck1usedSOC"]!=null)&&(inst["safetycheck2usedSOC"]!=null)) {
|
||||
var usedSOC1 =inst["safetycheck1ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var usedSOC2 =inst["safetycheck2ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var selectedSOC1 = inst["safetycheck1ResultSelect"].replace("RESULT","SOC_NUMBER")
|
||||
var selectedSOC2 = inst["safetycheck2ResultSelect"].replace("RESULT","SOC_NUMBER")
|
||||
//
|
||||
// Check the source for SOC
|
||||
//
|
||||
if ((adc_inst.enabledSOCs).includes(selectedSOC1)&&(adc_inst.enabledSOCs).includes(selectedSOC2)&&(inst["safetycheck1inputSource"]=="ADC_SAFETY_CHECKER_INPUT_SOCx")&&
|
||||
(inst["safetycheck2inputSource"]=="ADC_SAFETY_CHECKER_INPUT_SOCx")) {
|
||||
//channel
|
||||
if (adc_inst["soc"+ usedSOC1.toString()+"Channel"]==adc_inst["soc"+ usedSOC2.toString()+"Channel"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Same channel has been selected for SOC of Selector 1 and Selector 2. For safety checking, you need to have different channels.",
|
||||
inst, "safetycheck2usedSOC");
|
||||
}
|
||||
//trigger
|
||||
if (!(adc_inst.enableBurstMode)) {
|
||||
if ((adc_inst["soc"+ usedSOC1.toString()+"Triggermode"]=="singlemode")&&(adc_inst["soc"+ usedSOC2.toString()+"Triggermode"]=="singlemode"))
|
||||
{
|
||||
if (adc_inst["soc"+ usedSOC1.toString()+"Trigger"]!=adc_inst["soc"+ usedSOC2.toString()+"Trigger"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"To get the accurate performance of Safety Checker, same SOC Trigger should be selected for Selector 1 and Selector 2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (!((adc_inst["soc"+ usedSOC1.toString()+"Triggermode"]=="singlemode")^(adc_inst["soc"+ usedSOC2.toString()+"Triggermode"]=="repeatermode")) )
|
||||
{
|
||||
validation.logWarning(
|
||||
"To get the accurate performance of Safety Checker, same Trigger Mode should be selected for SOC of Selector 1 and Selector 2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if ((adc_inst["soc"+ usedSOC1.toString()+"Triggermode"]=="repeatermode")&&(adc_inst["soc"+ usedSOC2.toString()+"Triggermode"]=="repeatermode")) {
|
||||
if (((adc_inst["soc"+ usedSOC1.toString()+"Trigger"]=="ADC_TRIGGER_REPEATER1" )&&(adc_inst["soc"+ usedSOC2.toString()+"Trigger"]=="ADC_TRIGGER_REPEATER2"))||
|
||||
((adc_inst["soc"+ usedSOC1.toString()+"Trigger"]=="ADC_TRIGGER_REPEATER2" )&&(adc_inst["soc"+ usedSOC2.toString()+"Trigger"]=="ADC_TRIGGER_REPEATER1"))) {
|
||||
if (adc_inst["repeater1 Trigger"]!=adc_inst["repeater2 Trigger"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"To get the accurate performance of Safety Checker, you need to make sure same Triger is selected for repeater modules 1 and 2 associated with SOCs of Selector 1 and Selector 2.",
|
||||
inst, "safetycheck2usedSOC");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//sampling time
|
||||
if (adc_inst["soc"+ usedSOC1.toString()+"CalculatedSampleTime"]!=adc_inst["soc"+ usedSOC2.toString()+"CalculatedSampleTime"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"To get the accurate performance of Safety Checker, the sample time should be identical for Selected SOC in Selector 1 and Selector 2.",
|
||||
inst, "safetycheck2usedSOC");
|
||||
}
|
||||
if (adc_inst["soc"+ usedSOC1.toString()+"SampleTime"]!=adc_inst["soc"+ usedSOC2.toString()+"SampleTime"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"To get the accurate performance of Safety Checker, the sample time should be identical for Selected SOC in Selector 1 and Selector 2.",
|
||||
inst, "safetycheck2usedSOC");
|
||||
}
|
||||
}
|
||||
}
|
||||
//
|
||||
// Check the source for PPB
|
||||
//
|
||||
if ((inst["safetycheck1inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBx")&&(inst["safetycheck2inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBx")) {
|
||||
var res1= inst["safetycheck1ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var res2= inst["safetycheck2ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc4= adc_inst["ppb4SOCNumber"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc3= adc_inst["ppb3SOCNumber"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc2= adc_inst["ppb2SOCNumber"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc1= adc_inst["ppb1SOCNumber"].replace(/[^0-9]/g,'')
|
||||
if ((inst.safetycheck1usedSOC)&&(inst.safetycheck2usedSOC)) {
|
||||
if (res1!=res2) {
|
||||
//
|
||||
// To do: make a function to handle this section
|
||||
//
|
||||
// for (let xbari=1; xbari< 5; xbari++){
|
||||
// if ((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER"+xbari)){
|
||||
|
||||
// }
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER1")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER2"))&&(((res1==ppbsoc1)&&(res2==ppbsoc2))||(res1==ppbsoc2)&&(res2==ppbsoc1))) {
|
||||
if (adc_inst["ppb1ReferenceOffset"]!=adc_inst["ppb2ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB1 and PPB2. For safety checking, you need to make sure this setting is identical for PPB1 and PPB2",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb1EnableTwosComplement"]!=adc_inst["ppb2EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB1 and PPB2. For safety checking, you need to make sure this setting is identical for PPB1 and PPB2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER1")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER3"))&&(ppbsoc3!=ppbsoc2)&&(((res1==ppbsoc1)&&(res2==ppbsoc3))||(res1==ppbsoc3)&&(res2==ppbsoc1))) {
|
||||
if (adc_inst["ppb3ReferenceOffset"]!=adc_inst["ppb1ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB1 and PPB3. For safety checking, you need to make sure this setting is identical for PPB1 and PPB3",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3EnableTwosComplement"]!=adc_inst["ppb1EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB1 and PPB3. For safety checking, you need to make sure this setting is identical for PPB1 and PPB3.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER1")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER4"))&&(ppbsoc2!=ppbsoc4)&&(ppbsoc3!=ppbsoc4)&&(((res1==ppbsoc1)&&(res2==ppbsoc4))||(res1==ppbsoc4)&&(res2==ppbsoc1))) {
|
||||
if (adc_inst["ppb1ReferenceOffset"]!=adc_inst["ppb4ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB1 and PPB4. For safety checking, you need to make sure this setting is identical for PPB1 and PPB4",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb1EnableTwosComplement"]!=adc_inst["ppb4EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB1 and PPB4. For safety checking, you need to make sure this setting is identical for PPB1 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER3")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER2"))&&(res1!=ppbsoc1)&&(res2!=ppbsoc1)&&(((res1==ppbsoc2)&&(res2==ppbsoc3))||(res1==ppbsoc3)&&(res2==ppbsoc2))) {
|
||||
if (adc_inst["ppb3ReferenceOffset"]!=adc_inst["ppb2ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB3 and PPB2. For safety checking, you need to make sure this setting is identical for PPB3 and PPB2",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3EnableTwosComplement"]!=adc_inst["ppb2EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB3 and PPB2. For safety checking, you need to make sure this setting is identical for PPB3 and PPB2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER2")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER4"))&&(res1!=ppbsoc1)&&(res2!=ppbsoc1)&&(res1!=ppbsoc3)
|
||||
&&(res2!=ppbsoc3)&&(((res1==ppbsoc4)&&(res2==ppbsoc2))||(res1==ppbsoc2)&&(res2==ppbsoc4))) {
|
||||
if (adc_inst["ppb2ReferenceOffset"]!=adc_inst["ppb4ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB2 and PPB4. For safety checking, you need to make sure this setting is identical for PPB2 and PPB4",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb2EnableTwosComplement"]!=adc_inst["ppb4EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB2 and PPB4. For safety checking, you need to make sure this setting is identical for PPB2 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER3")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER4"))&&(res1!=ppbsoc1)&&(res2!=ppbsoc1)&&(res1!=ppbsoc2)&&
|
||||
(res2!=ppbsoc2)&&(((res1==ppbsoc4)&&(res2==ppbsoc3))||(res1==ppbsoc3)&&(res2==ppbsoc4)))
|
||||
{
|
||||
if (adc_inst["ppb3ReferenceOffset"]!=adc_inst["ppb4ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB3 and PPB4. For safety checking, you need to make sure this setting is identical for PPB3 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3EnableTwosComplement"]!=adc_inst["ppb4EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB3 and PPB4. For safety checking, you need to make sure this setting is identical for PPB3 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//
|
||||
// Check the source for PPBSum
|
||||
//
|
||||
if ((inst["safetycheck1inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBSUMx")&&(inst["safetycheck2inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBSUMx")) {
|
||||
var res1= inst["safetycheck1ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var res2= inst["safetycheck2ResultSelect"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc4= adc_inst["ppb4SOCNumber"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc3= adc_inst["ppb3SOCNumber"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc2= adc_inst["ppb2SOCNumber"].replace(/[^0-9]/g,'')
|
||||
var ppbsoc1= adc_inst["ppb1SOCNumber"].replace(/[^0-9]/g,'')
|
||||
if ((inst.safetycheck1usedSOC)&&(inst.safetycheck2usedSOC)) {
|
||||
if (res1!=res2) {
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER1")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER2"))&&(((res1==ppbsoc1)&&(res2==ppbsoc2))||(res1==ppbsoc2)&&(res2==ppbsoc1))) {
|
||||
if (adc_inst["ppb1ReferenceOffset"]!=adc_inst["ppb2ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB1 and PPB2. For safety checking, you need to make sure this setting is identical for PPB1 and PPB2",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb1EnableTwosComplement"]!=adc_inst["ppb2EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB1 and PPB2. For safety checking, you need to make sure this setting is identical for PPB1 and PPB2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb1Rightshift"]!=adc_inst["ppb2Rightshift"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Number of Bits to Right Shift PSUM have been selected for PPB1 and PPB2.For safety checking, you need to make sure this setting is identical for PPB1 and PPB2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER1")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER3"))&&(ppbsoc3!=ppbsoc2)&&(((res1==ppbsoc1)&&(res2==ppbsoc3))||(res1==ppbsoc3)&&(res2==ppbsoc1))) {
|
||||
if (adc_inst["ppb3ReferenceOffset"]!=adc_inst["ppb1ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB1 and PPB3. For safety checking, you need to make sure this setting is identical for PPB1 and PPB3",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3EnableTwosComplement"]!=adc_inst["ppb1EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB1 and PPB3. For safety checking, you need to make sure this setting is identical for PPB1 and PPB3.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3Rightshift"]!=adc_inst["ppb1Rightshift"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Number of Bits to Right Shift PSUM have been selected for PPB1 and PPB3.For safety checking, you need to make sure this setting is identical for PPB1 and PPB3.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER1")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER4"))&&(ppbsoc2!=ppbsoc4)&&(ppbsoc3!=ppbsoc4)&&(((res1==ppbsoc1)&&(res2==ppbsoc4))||(res1==ppbsoc4)&&(res2==ppbsoc1))) {
|
||||
if (adc_inst["ppb1ReferenceOffset"]!=adc_inst["ppb4ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB1 and PPB4. For safety checking, you need to make sure this setting is identical for PPB1 and PPB4",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb1EnableTwosComplement"]!=adc_inst["ppb4EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB1 and PPB4. For safety checking, you need to make sure this setting is identical for PPB1 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb1Rightshift"]!=adc_inst["ppb4Rightshift"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Number of Bits to Right Shift PSUM have been selected for PPB1 and PPB4.For safety checking, you need to make sure this setting is identical for PPB1 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER3")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER2"))&&(res1!=ppbsoc1)&&(res2!=ppbsoc1)&&(((res1==ppbsoc2)&&(res2==ppbsoc3))||(res1==ppbsoc3)&&(res2==ppbsoc2))) {
|
||||
if (adc_inst["ppb3ReferenceOffset"]!=adc_inst["ppb2ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB3 and PPB2. For safety checking, you need to make sure this setting is identical for PPB3 and PPB2",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3EnableTwosComplement"]!=adc_inst["ppb2EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB3 and PPB2. For safety checking, you need to make sure this setting is identical for PPB3 and PPB2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3Rightshift"]!=adc_inst["ppb2Rightshift"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Number of Bits to Right Shift PSUM have been selected for PPB3 and PPB2.For safety checking, you need to make sure this setting is identical for PPB3 and PPB2.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER2")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER4"))&&(res1!=ppbsoc1)&&(res2!=ppbsoc1)&&(res1!=ppbsoc3)&&(res2!=ppbsoc3)&&(((res1==ppbsoc4)&&(res2==ppbsoc2))||(res1==ppbsoc2)&&(res2==ppbsoc4))) {
|
||||
if (adc_inst["ppb2ReferenceOffset"]!=adc_inst["ppb4ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB2 and PPB4. For safety checking, you need to make sure this setting is identical for PPB2 and PPB4",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb2EnableTwosComplement"]!=adc_inst["ppb4EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB2 and PPB4. For safety checking, you need to make sure this setting is identical for PPB2 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb2Rightshift"]!=adc_inst["ppb4Rightshift"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Number of Bits to Right Shift PSUM have been selected for PPB2 and PPB4.For safety checking, you need to make sure this setting is identical for PPB2 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
if (((adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER3")&&(adc_inst.enabledPPBs).includes("ADC_PPB_NUMBER4"))&&(res1!=ppbsoc1)&&(res2!=ppbsoc1)&&(res1!=ppbsoc2)&&(res2!=ppbsoc2)&&(((res1==ppbsoc4)&&(res2==ppbsoc3))||(res1==ppbsoc3)&&(res2==ppbsoc4)))
|
||||
{
|
||||
if (adc_inst["ppb3ReferenceOffset"]!=adc_inst["ppb4ReferenceOffset"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Reference Offset values have been selected for PPB3 and PPB4. For safety checking, you need to make sure this setting is identical for PPB3 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3EnableTwosComplement"]!=adc_inst["ppb4EnableTwosComplement"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different settings related to Invert Output have been selected for PPB3 and PPB4. For safety checking, you need to make sure this setting is identical for PPB3 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
if (adc_inst["ppb3Rightshift"]!=adc_inst["ppb4Rightshift"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Number of Bits to Right Shift PSUM have been selected for PPB3 and PPB4.For safety checking, you need to make sure this setting is identical for PPB3 and PPB4.",
|
||||
inst, "safetycheck1usedSOC");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for(var rptrIndex in device_driverlib_peripheral.ADC_SafetyCheckInst) {
|
||||
var currentRPTR = device_driverlib_peripheral.ADC_SafetyCheckInst[rptrIndex].name
|
||||
let rptri = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
if ((inst["safetycheck"+ rptri.toString()+"usedSOC"]!="")&&(adc_inst.adcBase.replace("_BASE", "")==inst["safetycheck"+ rptri.toString()+"ADC"].replace("ADC_","ADC"))) {
|
||||
if (inst["safetycheck"+ rptri.toString()+"inputSource"]=="ADC_SAFETY_CHECKER_INPUT_SOCx")
|
||||
{
|
||||
var selectedSOC = inst ["safetycheck"+rptri.toString()+"usedSOC"].replace(/[^0-9]/g,'')
|
||||
validation.logInfo(
|
||||
"You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,"soc"+selectedSOC.toString()+"Name"),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC");
|
||||
}
|
||||
if ((inst["safetycheck"+ rptri.toString()+"inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBx")||(inst["safetycheck"+ rptri.toString()+"inputSource"]=="ADC_SAFETY_CHECKER_INPUT_PPBSUMx")) {
|
||||
for(var ppbIndex in device_driverlib_peripheral.ADC_PPBNumber) {
|
||||
var currentPPB = device_driverlib_peripheral.ADC_PPBNumber[ppbIndex].name
|
||||
var ppbi = (currentPPB).replace(/[^0-9]/g,'')
|
||||
var resi= inst["safetycheck"+ rptri.toString()+"ResultSelect"].replace(/[^0-9]/g,'')
|
||||
let higherPPB="";
|
||||
if (resi==adc_inst["ppb" + ppbi.toString() + "SOCNumber"].replace(/[^0-9]/g,'')){
|
||||
if (adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER1")) {
|
||||
if ((currentPPB=="ADC_PPB_NUMBER4")&&(adc_inst["ppb4SOCNumber"]!=adc_inst["ppb3SOCNumber"])&&(adc_inst["ppb4SOCNumber"]!=adc_inst["ppb2SOCNumber"])&&(adc_inst["ppb4SOCNumber"]!=adc_inst["ppb1SOCNumber"])) {
|
||||
higherPPB= "ppb4Name";
|
||||
validation.logInfo(
|
||||
"SOC"+resi.toString()+" is used in PPB4. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
if ((currentPPB=="ADC_PPB_NUMBER3")&&(adc_inst["ppb3SOCNumber"]!=adc_inst["ppb2SOCNumber"])&&(adc_inst["ppb3SOCNumber"]!=adc_inst["ppb1SOCNumber"])) {
|
||||
higherPPB= "ppb3Name";
|
||||
validation.logInfo(
|
||||
"SOC"+resi.toString()+" is used in PPB3. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
if ((currentPPB=="ADC_PPB_NUMBER2")&&(adc_inst["ppb1SOCNumber"]!=adc_inst["ppb2SOCNumber"])) {
|
||||
higherPPB= "ppb2Name";
|
||||
validation.logInfo(
|
||||
"SOC"+resi.toString()+" is used in PPB2. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
if ((currentPPB=="ADC_PPB_NUMBER1")) {
|
||||
higherPPB= "ppb1Name";
|
||||
validation.logInfo(
|
||||
"SOC"+resi.toString()+" is used in PPB1. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
}
|
||||
if (!(adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER1"))) {
|
||||
if (adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER2")) {
|
||||
if (currentPPB=="ADC_PPB_NUMBER2") {
|
||||
higherPPB= "ppb2Name";
|
||||
validation.logInfo(
|
||||
"SOC"+resi.toString()+" is used in PPB2. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!(adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER1"))) {
|
||||
if (!(adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER2"))||(resi!=adc_inst["ppb2" + "SOCNumber"].replace(/[^0-9]/g,''))) {
|
||||
if (adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER3")){
|
||||
if (currentPPB=="ADC_PPB_NUMBER3")
|
||||
{
|
||||
higherPPB= "ppb3Name";
|
||||
validation.logInfo(
|
||||
"SOC "+resi.toString()+" is used in PPB3. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!(adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER1"))) {
|
||||
if (!(adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER3"))) {
|
||||
if (adc_inst.enabledPPBs.includes("ADC_PPB_NUMBER4")) {
|
||||
if (currentPPB=="ADC_PPB_NUMBER4") {
|
||||
higherPPB= "ppb4Name";
|
||||
validation.logInfo(
|
||||
"SOC"+resi.toString()+" is used in PPB4. You can change settings of Input Source for Selector "+ rptri.toString()+ " via"+ ": " + system.getReference(adc_inst,higherPPB),
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC" );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for(var rptrIndex in device_driverlib_peripheral.ADC_SafetyCheckInst) {
|
||||
var currentRPTR = device_driverlib_peripheral.ADC_SafetyCheckInst[rptrIndex].name
|
||||
let rptri = (currentRPTR).replace(/[^0-9]/g,'')
|
||||
if ((inst["safetycheck"+ rptri.toString()+"usedSOC"]=="") && (inst["safetycheck"+ rptri.toString()+"inputSource"] != "ADC_SAFETY_CHECKER_INPUT_DISABLE")) {
|
||||
validation.logWarning(
|
||||
"There is no Input Source configured for this Result",
|
||||
inst, "safetycheck"+ rptri.toString()+"usedSOC");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
if ((inst["safetycheck1inputSource"] != "ADC_SAFETY_CHECKER_INPUT_DISABLE")||(inst["safetycheck2inputSource"] != "ADC_SAFETY_CHECKER_INPUT_DISABLE")){
|
||||
if (inst["safetycheck1inputSource"] != inst["safetycheck2inputSource"])
|
||||
{
|
||||
validation.logWarning(
|
||||
"Same Input Source should be selected for Selector 1 and Selector 2",
|
||||
inst, "safetycheck2inputSource");
|
||||
}
|
||||
if ((inst["safetycheck1ResultSelect"] == inst["safetycheck2ResultSelect"]) &&
|
||||
(inst["safetycheck1ADC"] == inst["safetycheck2ADC"]))
|
||||
{
|
||||
validation.logWarning(
|
||||
"Different Result should be selected for Selector 1 and Selector 2 when the same ADC instance is used for both",
|
||||
inst, "safetycheck1ResultSelect");
|
||||
}
|
||||
}
|
||||
if (inst["safetyCheckTolerance"] > 16777215)
|
||||
{
|
||||
validation.logError(
|
||||
"The max limit for Tolerance is 16777215",
|
||||
inst, "safetyCheckTolerance");
|
||||
}
|
||||
if (inst["safetyCheckTolerance"] < 0)
|
||||
{
|
||||
validation.logError(
|
||||
"Tolerance must be larger than 0",
|
||||
inst, "safetyCheckTolerance");
|
||||
}
|
||||
if (!Number.isInteger(inst["safetyCheckTolerance"]))
|
||||
{
|
||||
validation.logError(
|
||||
"Tolerance must be an integer value",
|
||||
inst, "safetyCheckTolerance");
|
||||
}
|
||||
}
|
||||
|
||||
var adcscModule = {
|
||||
//peripheralName: "ADCSafetyCheckerTile",
|
||||
displayName: "ADC SAFETY CHECKER",
|
||||
maxInstances: maxInstances,
|
||||
defaultInstanceName: "myADCSAFETYCHECKER",
|
||||
description: "ADC Safety Checker Module",
|
||||
longDescription: (Common.getCollateralFindabilityList("ADC")),
|
||||
filterHardware : filterHardware,
|
||||
config: config,
|
||||
templates: {
|
||||
//boardc : "/driverlib/adc/adcsc.board.c.xdt",
|
||||
//boardh : "/driverlib/adc/adcsc.board.h.xdt"
|
||||
},
|
||||
|
||||
modules : modules,
|
||||
validate : onValidate,
|
||||
};
|
||||
|
||||
exports = adcscModule;
|
||||
@@ -0,0 +1,6 @@
|
||||
exports = {
|
||||
moduleStatic: {},
|
||||
templates: {
|
||||
"/driverlib/adc/templates/adc.dot.xdt" : ""
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,197 @@
|
||||
%%{
|
||||
var module = system.modules['/driverlib/adc.js'];
|
||||
let device_adc_char =
|
||||
system.getScript("/driverlib/adc/adc_char.js");
|
||||
let Common = system.getScript("/driverlib/Common.js");
|
||||
let device_driverlib_peripheral =
|
||||
system.getScript("/driverlib/device_driverlib_peripherals/" +
|
||||
Common.getDeviceName().toLowerCase() + "_adc.js");
|
||||
var nameOfModule = "adc";
|
||||
var nameOfPeripheral = module.peripheralName;
|
||||
var width = 3;
|
||||
var total_number_socs = 16;
|
||||
var high_priority_x_offset = 6;
|
||||
var timing_x_offset = 8;
|
||||
var sysclk_width = 0.5;
|
||||
var instance_x_offset = 0;
|
||||
var instance_y_offset = 0;
|
||||
var colors = [
|
||||
'#FFA0A0',
|
||||
'#A0FFA0',
|
||||
'#A0A0FF',
|
||||
'#FFFFA0',
|
||||
'#A0FFFF',
|
||||
'#FFA0FF',
|
||||
'#5EE0BE'
|
||||
]
|
||||
|
||||
if (module != null)
|
||||
{
|
||||
%%}
|
||||
digraph {
|
||||
graph [fontname = "helvetica"];
|
||||
node [fontname = "helvetica"];
|
||||
edge [fontname = "helvetica"];
|
||||
graph [mclimit=50 nodesep=0.5 rankdir=LR ranksep=1.25]
|
||||
|
||||
node [shape = circle style=filled];
|
||||
|
||||
%%{
|
||||
for(var instanceIndex = 0; instanceIndex < module.$instances.length; instanceIndex++) {
|
||||
var instance = module.$instances[instanceIndex];
|
||||
var instanceName = instance.adcBase.replace("_BASE", "");
|
||||
var instanceNamePrepend = instanceName.toLowerCase() + "_"
|
||||
var highPri = instance.socHighPriorityMode;
|
||||
var number_highpri_socs = device_driverlib_peripheral.ADC_PriorityMode.findIndex(x => x.name == highPri);
|
||||
var number_roundrobin_socs = total_number_socs - number_highpri_socs
|
||||
var alpha = Math.PI*2/number_roundrobin_socs
|
||||
var r = width/2/Math.sin(alpha/2)
|
||||
if (number_roundrobin_socs < 2)
|
||||
{
|
||||
r = width;
|
||||
angle = 0;
|
||||
}
|
||||
var angle = 0;
|
||||
var x = 0;
|
||||
var y = 0;
|
||||
%%}
|
||||
%%{
|
||||
for (var i = number_highpri_socs; i < total_number_socs; i++) {
|
||||
x = r*Math.sin(angle) + instance_x_offset;
|
||||
y = r*Math.cos(angle) + instance_y_offset;
|
||||
angle = angle + alpha
|
||||
%%}
|
||||
`instanceNamePrepend`SOC`i.toString()` [label="`instanceName + " SOC" + i.toString()`" fillcolor="`colors[instanceIndex]`" pos="`x.toFixed(3)`,`y.toFixed(3)`!"]
|
||||
%%{
|
||||
}
|
||||
|
||||
y = r
|
||||
for (var i = 0; i < number_highpri_socs; i++)
|
||||
{
|
||||
|
||||
%%}
|
||||
`instanceNamePrepend`SOC`i.toString()` [fillcolor="`colors[instanceIndex]`" pos="`(high_priority_x_offset*width + instance_x_offset).toFixed(3)`, `(y + instance_y_offset).toFixed(3)`!"]
|
||||
%%{
|
||||
y = y - width
|
||||
}
|
||||
|
||||
for (var i = number_highpri_socs; i < total_number_socs; i++) {
|
||||
if (i < total_number_socs - 1){
|
||||
%%}
|
||||
`instanceNamePrepend`SOC`(i).toString()` -> `instanceNamePrepend`SOC`(i+1).toString()`
|
||||
%%{
|
||||
}
|
||||
else {
|
||||
%%}
|
||||
`instanceNamePrepend`SOC`(i).toString()` -> `instanceNamePrepend`SOC`number_highpri_socs.toString()`
|
||||
%%{
|
||||
}
|
||||
}
|
||||
%%}
|
||||
%%{
|
||||
instance_x_offset = 0;
|
||||
instance_y_offset = instance_y_offset - ((total_number_socs + 1)*width);
|
||||
}
|
||||
%%}
|
||||
node [shape=rect style=filled];
|
||||
%%{
|
||||
instance_y_offset = 0;
|
||||
instance_x_offset = 0;
|
||||
for (var adcTrigger of device_driverlib_peripheral.ADC_Trigger)
|
||||
{
|
||||
var adcTriggerDisplayName = adcTrigger.displayName;
|
||||
var adcTriggerName = adcTrigger.name;
|
||||
var triggerNameInserted = false;
|
||||
|
||||
instance_x_offset = 0;
|
||||
|
||||
for (var instanceIndex = 0; instanceIndex < module.$instances.length; instanceIndex++) {
|
||||
var instance = module.$instances[instanceIndex];
|
||||
var instanceName = instance.adcBase.replace("_BASE", "");
|
||||
var instanceNamePrepend = instanceName.toLowerCase() + "_"
|
||||
var instanceClockDiv = parseFloat(instance.adcClockPrescaler.replace("ADC_CLK_DIV_", "").replace("_", "."))
|
||||
var instanceAdcClockPrescaler = instance.adcClockPrescaler
|
||||
var highPri = instance.socHighPriorityMode;
|
||||
var number_highpri_socs = device_driverlib_peripheral.ADC_PriorityMode.findIndex(x => x.name == highPri);
|
||||
|
||||
var conversion_time = device_adc_char.tEOC_12bit_SYSCLK[instanceAdcClockPrescaler];
|
||||
if (["F2837xD", "F2837xS", "F2838x"].includes(Common.getDeviceName()))
|
||||
{
|
||||
if (instance.adcResolutionMode == "ADC_RESOLUTION_16BIT")
|
||||
{
|
||||
conversion_time = device_adc_char.tEOC_16bit_SYSCLK[instanceAdcClockPrescaler];
|
||||
}
|
||||
}
|
||||
var adc_socs_with_trigger_rr = [];
|
||||
var adc_socs_with_trigger_hp = [];
|
||||
for (var socIndex = 0; socIndex < 16; socIndex++) {
|
||||
if (instance["enableBurstMode"])
|
||||
{
|
||||
if (socIndex >= number_highpri_socs)
|
||||
{
|
||||
if (instance["burstTrigger"] == adcTriggerName)
|
||||
{
|
||||
adc_socs_with_trigger_rr.push(
|
||||
{
|
||||
soc: "soc" + socIndex,
|
||||
window: instance["soc" + socIndex.toString() + "SampleWindow"]
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (instance["soc" + socIndex.toString() + "Trigger"] == adcTriggerName)
|
||||
{
|
||||
if (socIndex < number_highpri_socs)
|
||||
{
|
||||
adc_socs_with_trigger_hp.push(
|
||||
{
|
||||
soc: "soc" + socIndex,
|
||||
window: instance["soc" + socIndex.toString() + "SampleWindow"]
|
||||
}
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!instance["enableBurstMode"])
|
||||
{
|
||||
adc_socs_with_trigger_rr.push(
|
||||
{
|
||||
soc: "soc" + socIndex,
|
||||
window: instance["soc" + socIndex.toString() + "SampleWindow"]
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
if (adc_socs_with_trigger_rr.length > 0) {
|
||||
instance_x_offset = 0;
|
||||
if (!triggerNameInserted) {
|
||||
instance_y_offset = instance_y_offset - width
|
||||
%%}
|
||||
`adcTriggerName`[label="`adcTriggerDisplayName`" fillcolor="yellow" fontsize="40" color="white" pos="`(timing_x_offset*width + instance_x_offset).toFixed(3)`,`instance_y_offset.toFixed(3)`!"]
|
||||
%%{
|
||||
instance_y_offset = instance_y_offset - width
|
||||
triggerNameInserted = true;
|
||||
}
|
||||
instance_y_offset = instance_y_offset - width
|
||||
%%}
|
||||
`instanceNamePrepend + adcTriggerName`[label="`instanceName`" fontsize="40" fillcolor="white" color="white" pos="`(timing_x_offset*width + instance_x_offset).toFixed(3)`,`instance_y_offset.toFixed(3)`!"]
|
||||
%%{
|
||||
instance_x_offset = instance_x_offset + width
|
||||
for (var adc_soc_info of adc_socs_with_trigger_rr){
|
||||
var adc_soc = adc_soc_info.soc;
|
||||
var soc_width = conversion_time*sysclk_width + adc_soc_info.window*sysclk_width
|
||||
var soc_pos = timing_x_offset*width + soc_width/2 + instance_x_offset
|
||||
%%}
|
||||
`instanceNamePrepend + adcTriggerName + "_" + adc_soc`[label="`adc_soc` (S+H[SYSCLK]: `adc_soc_info.window.toString()`, Conv[SYSCLK]: `conversion_time.toString()`)" fillcolor="`colors[instanceIndex]`" width="`(soc_width).toFixed(3)`" pos="`(soc_pos).toFixed(3)`,`instance_y_offset.toFixed(3)`!"]
|
||||
%%{
|
||||
instance_x_offset = instance_x_offset + soc_width
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
%%}
|
||||
}
|
||||
Reference in New Issue
Block a user