init

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IArmCheckActions.cs

@@ -0,0 +1,14 @@
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IArmCheckActions
+    {
+        bool PerformBatteryVoltageCheck { get; set; }
+        bool PerformInputVoltageCheck { get; set; }
+        bool PerformSensorIdCheck { get; set; }
+        bool PerformEventLineCheck { get; set; }
+        bool PerformSquibResistanceCheck { get; set; }
+        bool PerformTiltSensorCheck { get; set; }
+        bool PerformTemperatureCheck { get; set; }
+        bool PerformClockSyncCheck { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IArmCheckResults.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IArmCheckResults
+    {
+        Dictionary<int, string[]> SensorIds { get; set; }
+        Dictionary<int, double> SquibResistances { get; set; }
+
+        /// <summary>
+        /// some DAS (TDAS Pro rack) can have multiple battery voltages for modules ...
+        /// </summary>
+        double?[] BatteryVoltage { get; set; }
+        double? InputVoltage { get; set; }
+        bool? StartLineShorted { get; set; }
+        bool? EventLineShorted { get; set; }
+        short[] TiltSensorDataPre { get; set; }
+        double[] TiltDegrees { get; set; }
+        Dictionary<byte, short[]> IndexedTiltSensorDataPre { get; set; }
+        Dictionary<byte, double[]> IndexedTiltDegrees { get; set; }
+        float[] TemperaturesPre { get; set; }
+        double[] Gains { get; set; }
+        double[] ZeroData { get; set; }
+        IDictionary<InputClockSource, bool> InputClockLocks { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IBaseInputValues.cs

@@ -0,0 +1,94 @@
+using DTS.Common.Enums.DASFactory;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IBaseInputValues
+    {
+        /// <summary>
+        /// The current input voltage to the base.
+        /// </summary>
+        double InputMilliVolts { get; set; }
+
+        bool InputMilliVoltsValid { get; }
+
+        /// <summary>
+        /// The current input voltage to the base.
+        /// </summary>
+        double InputVoltage { get; set; }
+        
+        /// <summary>       
+        /// The minimum valid input voltage to the base.
+        /// </summary>
+        double MinimumValidInputVoltage { get; set; }
+        
+        /// <summary>       
+        /// The maximum valid input voltage to the base.
+        /// </summary>
+        double MaximumValidInputVoltage { get; set; }
+
+        bool BatteryMilliVoltsValid { get; }
+
+        /// <summary>
+        /// The current battery voltage.
+        /// </summary>
+        double BatteryMilliVolts { get; set; }
+
+        /// <summary>
+        /// The current battery voltage.
+        /// </summary>
+        double BatteryVoltage { get; set; }
+
+        /// <summary>       
+        /// The minimum valid battery voltage to the base.
+        /// </summary>
+        double MinimumValidBatteryVoltage { get; set; }
+        
+        /// <summary>       
+        /// The maximum valid battery voltage to the base.
+        /// </summary>
+        double MaximumValidBatteryVoltage { get; set; }
+        /// <summary>
+        /// TRUE if the battery is currently charging.
+        /// </summary>
+        bool BatteryIsCharging { get; set; }
+
+        /// <summary>
+        /// Temperature sensed by logic in the hardware, in degrees Celsius.
+        /// </summary>
+        double TemperatureC { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        string BatteryVoltageStatus { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        string InputVoltageStatus { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        string StatusDisplayBattery { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        string StatusDisplayInput { get; set; }
+
+        /// <summary>
+        /// returns color
+        /// </summary>
+        DFConstantsAndEnums.VoltageStatusColor BatteryVoltageStatusColor { get; set; }
+
+        /// <summary>
+        /// returns color
+        /// </summary>
+        DFConstantsAndEnums.VoltageStatusColor InputVoltageStatusColor { get; set; }
+
+        double ChargeCapacity { get; set; }
+
+        bool ChargeCapacityValid { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IDiagnos.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IDiagnos
+    {
+        IDiagnosticActions[] ChannelDiagnostics { get; set; }
+        void SetChannelDiagnosticActions(IDiagnosticActions[] actions, bool setInDb=true);
+        IDiagnosticResult[] ChannelDiagnosticsResults { get; set; }
+        void ClearChannelDiagnosticsResults(bool bClearDb = true);
+        void SetChannelDiagnosticsResults(IDiagnosticResult[] results, bool setInDb);
+        IModuleDiagnosticsResult[] ModuleDiagnosticsResults { get; set; }
+        IBaseInputValues BaseInput { get; set; }
+        IDictionary<InputClockSource, bool> DASClockSyncStatus { get; set; }
+        byte PTPDomainID { get; set; }
+        IArmCheckActions ArmCheckActions { get; set; }
+        IArmCheckResults ArmCheckResults { get; set; }
+        //FB 6416 Keep the optimizations settings used for real-time optimization
+        IOptimizationValues OptimizationValues { get; set; }
+    }    
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IDiagnosticActions.cs

@@ -0,0 +1,65 @@
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IDiagnosticActions
+    {
+        /// <summary>
+        /// Which DAS Channel (CH# WRT entire DAS unit) are these diagnostic test 
+        /// instructions for?
+        /// </summary>
+        int DASChannelNumber { get; set; }
+
+        /// <summary>
+        /// Should we measure the excitation voltage being applied to this sensor?
+        /// </summary>
+        bool MeasureExcitation { get; set; }
+
+        /// <summary>
+        /// Should we measure the sensor's offset from 0?  (If measured, the returned offset can
+        /// be checked against the high and low offset limits that are properties of the 
+        /// AnalogInputDasChannel object corresponding to this sensor.)
+        /// </summary>
+        bool MeasureOffset { get; set; }
+        /// <summary>
+        /// should we check the open/closed/low/high nature of a digital input channel?
+        /// </summary>
+        bool CheckDigitalState { get; set; }
+
+        bool MeasureInternalOffset { get; set; }
+
+        /// <summary>
+        /// Should the firmware compensate for the offset from 0 of this sensor?
+        /// </summary>
+        bool RemoveOffset { get; set; }
+
+        /// <summary>
+        /// Should we measure the noise floor as a percentage of full scale readings?
+        /// </summary>
+        bool MeasureNoise { get; set; }
+
+        /// <summary>
+        /// Should an emulated shunt-check be performed on this sensor.
+        /// </summary>
+        bool PerformShuntCheck { get; set; }
+
+        /// <summary>
+        /// should run a squib fire check on channel
+        /// </summary>
+        bool SquibFireCheck { get; set; }
+
+        /// <summary>
+        /// perform a voltage insertion gain check (SLICE Pro)
+        /// </summary>
+        bool PerformVoltageInsertCheck { get; set; }
+        /// <summary>
+        /// Should a Calibration signal-check be performed on this sensor.
+        /// </summary>
+        bool PerformCalSignalCheck { get; set; }
+
+        /// <summary>
+        /// Should the resistance of the bridge be measured?
+        /// </summary>
+        bool MeasureBridgeResistance { get; set; }
+
+        bool AllActionsDisabled();
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IDiagnosticResult.cs

@@ -0,0 +1,156 @@
+using DTS.Common.Enums.Sensors;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IDiagnosticResult
+    {
+        /// <summary>
+        /// Which DASChannel from which this diagnostics is returning.
+        /// </summary>
+        int DASChannelNumber { get; set; }
+
+        /// <summary>
+        /// The event number that this diagnostics is relevant for.
+        /// </summary>
+        int EventNumber { get; set; }
+
+        /// <summary>
+        /// The firmware calculates a scale factory for the channel's input.  The hardware will
+        /// deliver raw, unprocessed data upon download, but to diagnos this data to  
+        /// reflect real world votages it must be scaled based on the DAS unit's factory  
+        /// diagnostics as well as results from this diagnose.  The samples that 
+        /// will be downloaded will be straight from the A to D Converter so this scale 
+        /// factor is MANDATORY and must be used at the software level to scale the data 
+        /// to the real sensed voltages and engineering units.
+        /// </summary>
+        double ScalefactorMilliVoltsPerADC { get; set; }
+        double ScalefactorEngineeringUnitsPerADC { get; set; }
+
+        /// <summary>
+        /// The factory excitation value (mandatory)
+        /// </summary>
+        double ExpectedExcitationMilliVolts { get; set; }
+
+        /// <summary>
+        /// gets what will probably be the datazerolevel adc for the channel
+        /// </summary>
+        /// <param name="zeroMethod"></param>
+        /// <returns></returns>
+        short GetExpectedDataZeroLevelADC(ZeroMethodType zeroMethod);
+
+
+        /// <summary>
+        /// Excitation voltage provided to sensor as measured by the firmware during 
+        /// calibration. When read from event attributes, a value of 0.0 might actually 
+        /// mean null (i.e. was not measured).
+        /// </summary>
+        double? MeasuredExcitationMilliVolts { get; set; }
+
+        /// <summary>
+        /// flag to indicate whether MeasuredExcitationMilliVolts was negative when it was initially read
+        /// 14233 Negative Excitation Reported by TDAS hardware not showing in Diagnostics
+        /// this was created to relate to legacy TDC/TDAS broken sensor/wire warnings carried through
+        /// the excitation reading
+        /// </summary>
+        bool NegativeExcitation { get; set; }
+
+        /// <summary>
+        /// What is the sensor's offset reading from the 0 level?  This is measured by firmware
+        /// during the calibration. When read from event attributes, a value of 0.0 might actually 
+        /// mean null (i.e. was not measured).
+        /// </summary>        
+        double? MeasuredOffsetMilliVolts{ get; set; }
+
+        double? MeasuredInternalOffsetMilliVolts{ get; set; }
+
+        /// <summary>
+        /// What is the sensor's offset reading from the 0 level?  This is measured by firmware
+        /// during the calibration. When read from event attributes, a value of 0.0 might actually 
+        /// mean null (i.e. was not measured).
+        /// </summary>        
+        double? MeasuredOffsetEngineeringUnits { get; set; }
+
+        /// <summary>
+        /// when a channel is autozero'd (remove offset)
+        /// this is the devation from 0 (from RW Auto zero is checking for +/- 5% from 0 in counts.)
+        /// </summary>        
+        double? AutoZeroPercentDeviation{ get; set; }
+
+        /// <summary>
+        /// If the <see cref="DTS.DASLib.Service.DiagnosticsService" />.Calibrate  method was called with the "RemoveOffset" boolean variable set
+        /// to TRUE then the firmware will attempt to remove the offset of the sensor, moving it's base
+        /// reading back to 0.  This value is how much offset is present after removing the offset.  While the
+        /// offset my not be compeletely removed it may have been reduced to fall within the high and low
+        /// limits for acceptable offsets for the sensor.  See <see cref="AnalogInputDASChannel" /> to find 
+        /// these sensor specific values. When read from event attributes, a value of 0.0 might actually 
+        /// mean null (i.e. was not measured).
+        /// </summary>
+        short? FinalOffsetADC { get; set; }
+
+        int? RemovedOffsetADC { get; set; }
+        
+        int? RemovedInternalOffsetADC { get; set; }
+        /// <summary>
+        /// FullScaleSignal to Noise ratio as a percentage. When read from event attributes, a value of 0.0 might actually 
+        /// mean null (i.e. was not measured).
+        /// </summary>
+        double? NoisePercentFullScale { get; set; }
+
+        bool ShuntDeflectionFailed { get; set; }
+
+        bool CalSignalCheckFailed { get; set; }
+        /// <summary>
+        /// If an emulated shunt test is performed the measured shunt deflection in mV detected
+        /// during the test will be here. 
+        /// <see cref="DTS.DASLib.Service.DiagnosticsActions" />.PerformShuntCheck
+        /// When read from event attributes, a value of 0.0 might actually mean null
+        /// (i.e. was not measured).
+        /// </summary>
+        double? MeasuredShuntDeflectionMv { get; set; }
+
+        double? MeasuredCalSignalMv { get; set; }
+        double? TargetCalSignalMv { get; set; }
+
+        double? MeasuredDurationMS { get; set; }
+
+        double? MeasuredDelayMS { get; set; }
+        bool? SquibFirePassed { get; set; }
+        bool? SquibDurationPassed { get; set; }
+        bool? SquibDelayPassed { get; set; }
+        double[] SquibFireCurrentData { get; set; }
+        double[] SquibFireVoltageData { get; set; }
+        double[] SquibFireTimeAxis { get; set; }
+        double SquibThreshold { get; set; }
+
+        double SquibVoltageScaler { get; set; }
+        double SquibCurrentScaler { get; set; }
+
+        double? TargetGain { get; set; }
+        double? MeasuredGain { get; set; }
+        double? QueriedGain { get; set; }
+
+        /// <summary>
+        /// If an emulated shunt test is performed the target shunt deflection in mV will be here.
+        /// CalibrateActions.PerformShuntCheck When read from event attributes, a value of 0.0 might actually 
+        /// mean null (i.e. was not measured).
+        /// </summary>
+        double? TargetShuntDeflectionMv { get; set; }
+
+        /// <summary>
+        /// If the bridge resistance of the sensor was measured, the measured resistance in
+        /// ohms will be here.  <see cref="DiagnosticsActions.MeasureBridgeResistance" />
+        /// When read from event attributes, a value of 0.0 might actually mean null 
+        /// (i.e. was not measured).
+        /// </summary>
+        double? BridgeResistance { get; set; }
+
+        short ZeroMVInADC { get; set; }
+
+        /// <summary>
+        /// WindowAverageADC is the average ADC over the averaging window specified for the channel
+        /// short.MinValue indicates an unitialized or invalid value
+        /// </summary>
+        short WindowAverageADC { get; set; }
+        bool DigitalInputActiveState { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IModuleDiagnosticsResult.cs

@@ -0,0 +1,14 @@
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IModuleDiagnosticsResult
+    {
+            float TemperatureLocation1Pre { get; set; }
+            float TemperatureLocation2Pre { get; set; }
+            float TemperatureLocation3Pre { get; set; }
+            float TemperatureLocation4Pre { get; set; }
+            float TemperatureLocation1Post { get; set; }
+            float TemperatureLocation2Post { get; set; }
+            float TemperatureLocation3Post { get; set; }
+            float TemperatureLocation4Post { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/IOptimizationValues.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IOptimizationValues
+    {
+        float TransferSpeed { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/ITriggerCheck.cs

@@ -0,0 +1,10 @@
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface ITriggerCheck
+    {
+        /// <summary>
+        /// Here is where the trigger check results are stored
+        /// </summary>
+        ITriggerCheckResult TriggerResult { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Diagnostics/ITriggerCheckResult.cs

@@ -0,0 +1,30 @@
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface ITriggerCheckResult
+    {
+        /// <summary>
+        /// Is the status good on the DAS?
+        /// </summary>
+        bool IsStatusGood { get; set; }
+
+        /// <summary>
+        /// Is the start record line currently active on the DAS?
+        /// </summary>
+        bool IsStartRecordActive { get; set; }
+
+        /// <summary>
+        /// Has the start record line been active at any point after arm?
+        /// </summary>
+        bool HasStartRecordBeenActive { get; set; }
+
+        /// <summary>
+        /// Is the trigger currently active?
+        /// </summary>
+        bool IsTriggered { get; set; }
+
+        /// <summary>
+        /// Has the trigger line been active at any point after arm?
+        /// </summary>
+        bool HasTriggered { get; set; }
+    }
+}