DP44/Common/DTS.CommonCore/.svn/pristine/f3/f384d875a0af28a0e8fa14d43ef503c1e228af22.svn-base

using DTS.Common.Enums.Sensors;

namespace DTS.Common.Interface.Hardware
{
    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; }

        /// <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>
        /// 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; }
    }
}