init

Common/DTS.CommonCore/Interface/DASFactory/ARM/IArmStatus.cs

@@ -0,0 +1,48 @@
+namespace DTS.Common.Interface.DASFactory.ARM
+{
+    /// <summary>
+    /// Arm interface for a DAS unit.
+    /// </summary>
+    public interface IArmStatus
+    {
+        /// <summary>
+        /// marks the unit as being in arm        
+        /// <paramref name="WriteToDb">whether to write to db or not</paramref>
+        /// </summary>
+        void SetInArm(bool WriteToDb);
+        /// <summary>
+        /// marks the unit as being in realtime
+        /// <paramref name="WriteToDb">whether to write to db or not</paramref>
+        /// </summary>
+        void SetInRealtime(bool WriteToDb, bool ExitRealtimeIfPossible);
+        /// <summary>
+        /// returns true if the unit is in known to be in Arm
+        /// does not query the hardware, just returns a flag if it has been set
+        /// </summary>
+        /// <returns></returns>
+        bool GetIsInArm();
+        /// <summary>
+        /// returns true if unit is known to be in realtime
+        /// does not query the hardware, just returns a flag if it has been set
+        /// </summary>
+        /// <returns></returns>
+        bool GetIsInRealtime();
+        /// <summary>
+        /// returns true if the unit is known to be streaming
+        /// does not query the hardware, just returns a flag if it has been set
+        /// </summary>
+        /// <returns></returns>
+        bool GetIsStreaming();
+        IArmStatusData DASArmStatus { get; set; }
+        /// <summary>
+        /// sets DASArmStatus and optionally stores in the db
+        /// </summary>
+        /// <param name="status"></param>
+        /// <param name="bSetInDb"></param>
+        void SetDASArmStatus(IArmStatusData status, bool bSetInDb);
+        /// <summary>
+        /// sets to the db (if connected) the current DASArmStatus
+        /// </summary>
+        void SetDASArmStatus();
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/ARM/IArmStatusData.cs

@@ -0,0 +1,126 @@
+namespace DTS.Common.Interface.DASFactory.ARM
+{
+    public interface IArmStatusData
+    {
+        /// <summary>
+        /// returns true if unit received InvalidMode to query commands during initial setup
+        /// 15932 Error when performing test when S6A is streaming
+        /// this is used in some places currently to detect when a unit is streaming
+        /// </summary>
+        bool ReceivedInvalidModeDuringSetup { get; set; }
+        /// <summary>
+        /// clears any flags set or needed for triggercheck
+        /// </summary>
+        void ClearTriggerCheckStatus();
+
+        /// <summary>
+        /// Is the DAS currently armed?
+        /// </summary>
+        bool IsArmed { get; set; }
+        
+        /// <summary>
+        /// Has the DAS sensed a trigger?
+        /// </summary>
+        bool IsTriggered { get; set; }
+
+        /// <summary>
+        /// a little bit distinct from IsTriggered
+        /// in that IsTriggerShorted is only set during TriggerCheck
+        /// while IsTriggered is set in many places
+        /// </summary>
+        bool IsTriggerShorted { get; set; }
+        
+        /// <summary>
+        /// indicates that trigger was shorted
+        /// is only set during triggercheck
+        /// </summary>
+        bool IsStartShorted { get; set; }
+        
+        /// <summary>
+        /// Is the DAS currently recording sample data?
+        /// </summary>
+        bool IsRecording { get; set; }
+
+        /// <summary>
+        /// Has the DAS faulted?
+        /// </summary>
+        bool IsFaulted { get; set; }
+
+        /// <summary>
+        /// Is the DAS in real time mode?
+        /// </summary>
+        bool IsInRealtime { get; set; }
+
+        /// <summary>
+        /// is the DAS in flash write (G5)
+        /// </summary>
+        bool IsInFlashWrite { get; set; }
+
+        /// <summary>
+        /// used for the times when TDAS ARM STAT READ just doesn't return anything
+        /// </summary>
+        bool IsUndefined { get; set; }
+
+        /// <summary>
+        /// Is the DAS in post test diagnostics
+        /// </summary>
+        bool IsInPostTestDiagnostics { get; set; }
+
+        /// <summary>
+        /// How many seconds are left of recording?
+        /// </summary>
+        double TimeRemainingSeconds { get; set; }
+
+        /// <summary>
+        /// what percentage is complete [flashwrite]
+        /// </summary>
+        double PercentComplete { get; set; }
+
+        /// <summary>
+        /// How many samples total will the DAS be recording this test?
+        /// </summary>
+        ulong TotalSamples { get; set; }
+
+        /// <summary>
+        /// What sample are we currently recording?
+        /// </summary>
+        ulong CurrentSample { get; set; }
+
+        /// <summary>
+        /// At what sample rate are we currently recording?
+        /// </summary>
+        uint SampleRate { get; set; }
+
+        /// <summary>
+        /// What's the current input voltage?
+        /// </summary>
+        double? InputMilliVolts { get; set; }        
+
+        /// <summary>
+        /// What's the current battery voltage (null if no battery)?
+        /// </summary>
+        double? BatteryMilliVolts { get; set; }
+        
+        /// <summary>
+        /// Which event number is currently being recorded?
+        /// </summary>
+        int? EventNumber { get; set; }
+        //FB 26817
+        /// <summary>
+        /// The Max number of events supported by a device
+        /// </summary>
+        ushort? MaxEventsPossible { get; set; }
+        int RecordingMode { get; set; }
+        /// <summary>
+        /// optional fault message if there is a fault
+        /// (software will flag some faults and when we do we know what caused it)
+        /// </summary>
+        string FaultMessage { get; set; }
+
+        bool IsRearming { get; set; }
+
+        bool HasBeenRecording { get; set; }
+        
+        double? TimeLeftInArm { get; set; }        
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IConfiguration.cs

@@ -0,0 +1,59 @@
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IConfiguration
+    {
+        /// <summary>
+        /// path on pc the IConfiguration device is storing test information to
+        /// </summary>
+        string TestDirectory { get; set; }
+        /// <summary>
+        /// returns true if the unit supports discovering channel type [bridge/IEPE]
+        /// </summary>
+        bool SupportsAutoDetect{ get; }
+        /// <summary>
+        /// directly query (if possible) if there are any devices connected to this unit
+        /// </summary>
+        void QueryConnectedDevices();
+        /// <summary>
+        /// ConfigData object containing the pre-test setup and configuration
+        /// of all modules and channels in the hardware.  The object is updated
+        /// when <see cref="ConfigurationService">ConfigurationService.Configure(...)</see> is called, and the properties
+        /// of the entire DAS unit can be inspected.
+        /// </summary>
+        IConfigurationData ConfigData { get; set; }
+        /// <summary>
+        /// DASClockSyncProfile object containing the profile for clock sync for the hardware
+        /// The data is updated
+        /// when <see cref="ConfigurationService">ConfigurationService.Configure(...)</see> is called, and is only 
+        /// applied to units that support the value
+        /// </summary>
+        ClockSyncProfile DASClockSyncProfile { get; set; }
+        /// <summary>
+        /// get the display order of this das
+        /// allows a das to be display before or after other das
+        /// default display order is -1
+        /// </summary>
+        /// <returns>display order (-1 default)</returns>
+        int GetDASDisplayOrder();
+        /// <summary>
+        /// gets the display order of channels in this das
+        /// allows channels to have a different order in display UIs
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        int[] GetChannelDisplayOrder();
+
+        /// <summary>
+        /// sets the order of the das to be displayed in UIs
+        /// should only be called really from FWTU
+        /// </summary>
+        /// <param name="order"></param>
+        void SetDASDisplayOrder(int order);
+        /// <summary>
+        /// sets the order of channels to be displayed in UIs
+        /// should only be called really from FWTU
+        /// </summary>
+        /// <param name="order"></param>
+        void SetChannelDisplayOrder(int[] order);
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IConfigurationData.cs

@@ -0,0 +1,67 @@
+using System.Xml;
+using System.Xml.Schema;
+
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IConfigurationData
+    {
+        /// <summary>
+        /// Array of Module objects in the DAS.
+        /// </summary>
+        IDASModule[] Modules { get; set; }
+
+        /// <summary>
+        /// EID's for the whole DAS.
+        /// </summary>
+        IEID[] IDs { get; set; }
+
+        /// <summary>
+        /// The ID of the current test/event.
+        /// </summary>
+        string TestID { get; set; }
+        string TestSetupUniqueId { get; set; }
+
+        /// <summary>
+        /// A description of the current test/event.
+        /// </summary>
+        string Description { get; set; }
+        
+        bool ClearSetup { get; set; }
+
+        /// <summary>
+        /// Counts how many channels are configured.  If a channel's
+        /// 'IsConfigured' property is 'true' it is configured.
+        /// </summary>
+        /// <returns>Number of configured channels</returns>
+        int NumberOfConfiguredChannels();
+
+        /// <summary>
+        /// Count how many channels we have (regardless if they are configured or not).
+        /// </summary>
+        /// <returns>Total number of channels</returns>
+        int NumberOfChannels();
+        /// <summary>
+        /// Count how many downloadable channels (i.e. not UART or StreamOut) we have (regardless if they are configured or not).
+        /// </summary>
+        /// <returns>Total number of downloadable channels</returns>
+        int NumberOfDownloadChannels();
+        int[] DisplayOrder { get; set; }
+        int DasDisplayOrder { get; set; }
+
+        int GetDisplayOrder(uint channelIdx);
+
+        #region Serialization functions        
+
+        void WriteXml(XmlWriter writer);
+
+        void ReadXml(XmlReader reader);
+
+        XmlSchema GetSchema();
+		/// <summary>
+		/// the Address the DAS receives UDP information from
+		/// used to control the OBR-DDR
+		/// </summary>
+        string UDPReceiveAddress { get; set; }
+        #endregion                
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IDASChannel.cs

@@ -0,0 +1,102 @@
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.Enums.Sensors;
+using System;
+using System.Xml;
+using System.Xml.Schema;
+
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IDASChannel
+    {
+        DFConstantsAndEnums.ConfigMode ConfigurationMode { get; set; }
+
+        /// <summary>
+        /// whether the channel should be put in Diagnostics mode or not
+        /// </summary>
+        bool DiagnosticsMode { get; set; }
+
+        /// <summary>
+        /// Channel number with respect to it's containing module <see cref="OwningModule"/>
+        /// </summary>
+        int ModuleChannelNumber { get; set; }
+
+        int AbsoluteDisplayOrder { get; set; }
+
+        double UnitConverision { get; set; }
+
+        bool AtCapacity { get; set; }
+
+        double CapacityOutputIsBasedOn { get; set; }
+        
+        SensorConstants.SensUnits SensitivityUnits { get; set; }
+
+        /// <summary>
+        /// A link back to the Module that contains this channel.
+        /// </summary>
+        //public DASModule OwningModule { get; set; }
+
+        /// <summary>
+        /// The "stack channel number" of this channel with respect to the owning 
+        /// DAS (0 based).
+        /// </summary>
+        byte Number { get; }
+
+        /// <summary>
+        /// Array of (string, byte[]) for EID
+        /// </summary>
+        IEID[] IDs { get; set; }
+
+        /// <summary>
+        /// time stamp of this event
+        /// </summary>
+        DateTime EventStartTime { get; set; }
+
+        /// <summary>
+        /// <see cref="bool"/> value indicating whether or not this channel has registered a level trigger.
+        /// </summary>
+        bool LevelTriggerSeen { get; set; }
+
+        string IsoChannelName { get; set; }
+        string ChannelGroupName { get; set; }
+        string UserCode { get; set; }
+        string UserChannelName { get; set; }
+        string LinearSensorCalibration { get; set; }
+        /// <summary>
+        /// the number of samples to qualify over
+        /// </summary>
+        int QualificationSamples { get; set; }
+
+        ///// <summary>
+        ///// Number of samples that T0 on DASes that did not directly experience the level trigger must be shifted
+        ///// to time align with this channel's directly level triggered T0.  A null value indicates that this channel
+        ///// did not directly receive a level trigger.
+        ///// </summary>
+        int? LevelTriggerT0AdjustmentSamples { get; set; }
+
+        /// <summary>
+        /// Is this channel configured? 'Configured' means a sensor is connected and/or there is 
+        /// information in the containg device's ConfigData object, put there with a call to
+        /// ConfigureService.Configure(...) in the API.
+        /// </summary>
+        /// <returns>True if it is configured, False otherwise.</returns>
+        bool IsConfigured();
+
+        void WriteElementStart(XmlWriter writer);
+
+        void WriteElementEnd(XmlWriter writer);
+
+        void WriteXmlCRC32(XmlWriter writer);
+
+        void WriteXml(XmlWriter writer);
+
+        void ReadXml(XmlReader reader);
+
+        XmlSchema GetSchema();
+        
+        int IdType { get; set; }
+
+        string UserValue1 { get; set; }
+        string UserValue2 { get; set; }
+        string UserValue3 { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IDASModule.cs

@@ -0,0 +1,308 @@
+using DTS.Common.Enums.DASFactory;
+using System;
+using System.Xml;
+using System.Xml.Schema;
+using DTS.Common.Enums;
+
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IDASModule
+    {
+        /// <summary>
+        /// An array of <see cref="DASChannel" /> objects representing the channels attatched to this
+        /// module, indexable by ModuleChannelNumber of the Channel.
+        /// </summary>
+        IDASChannel[] Channels { get; set; }
+
+        /// <summary>
+        /// EID's for the module corresponding to the sensors on each of the channels.
+        /// </summary>
+        IEID[] IDs { get; set; }
+
+        /// <summary>
+        /// Index of this Module in any array of Modules.  The first module in a DAS unit will have a
+        /// ModuleArrayIndex of 0.
+        /// </summary>
+        int ModuleArrayIndex { get; set; }
+
+        /// <summary>
+        /// For use only with Circular-Buffer mode.
+        /// See <see cref="DASModule.RecordingMode" />.
+        /// The number of requested seconds for this Module to sample data before a 'Trigger' event; the number of
+        /// seconds to sample BEFORE time-zero.
+        /// </summary>
+        double RequestedPreTriggerSeconds { get; set; }
+
+        /// <summary>
+        /// For use with all recording modes.
+        /// See <see cref="DASModule.RecordingMode" />.
+        /// The number of requested seconds to sample data from sensors after time-zero, that is after
+        /// a trigger or start event.
+        /// </summary>
+        double RequestedPostTriggerSeconds { get; set; }
+
+        /// <summary>
+        /// For use only with Circular-Buffer mode.
+        /// See <see cref="DASModule.RecordingMode" />.
+        /// The number of seconds for this Module to sample data before a 'Trigger' event; the number of
+        /// seconds to sampel BEFORE time-zero.
+        /// </summary>
+        double PreTriggerSeconds { get; set; }
+
+        /// <summary>
+        /// For use with all recording modes.
+        /// See <see cref="DASModule.RecordingMode" />.
+        /// The number of seconds to sample data from sensors after time-zero, that is after
+        /// a trigger or start event.
+        /// </summary>
+        double PostTriggerSeconds { get; set; }
+
+        /// <summary>
+        /// The number of events to collect before disarming.
+        /// </summary>
+        int NumberOfEvents { get; set; }
+
+        /// <summary>
+        /// The number of seconds of inactivity before going to sleep.
+        /// </summary>
+        int WakeUpMotionTimeout { get; set; }
+
+        /// <summary>
+        /// The version of the firmware on a module.
+        /// </summary>
+        string FirmwareVersion { get; set; }
+
+        /// <summary>
+        /// A string that describes the module, for example, to know if it was created for the
+        /// purposes of adding it to the .dts file during download of Slice6 Distributor attributes.
+        /// </summary>
+        string Description { get; set; }
+
+        /// <summary>
+        /// The maximum storage space for a module.
+        /// </summary>
+        ulong? MaxEventStorageSpaceInBytes { get; set; }
+
+        /// <summary>
+        /// This is set after a recording session and is the total number of samples this Module
+        /// captured during the last data acquisition run.
+        /// </summary>
+        ulong NumberOfSamples { get; set; }
+
+        /// <summary>
+        /// An array of sample numbers where a trigger was activated.
+        /// </summary>
+        ulong[] TriggerSampleNumbers { get; set; }
+
+        int GetLevelTriggerT0AdjustmentSamplesAutoApplied();
+        
+        /// <summary>
+        /// The sample number where recording started.
+        /// </summary>
+        ulong StartRecordSampleNumber { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        uint StartRecordTimestampSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        uint TriggerTimestampSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        uint StartRecordTimestampNanoSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        uint TriggerTimestampNanoSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        bool PTPMasterSync { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TiltSensorAxisXDegreesPre { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TiltSensorAxisYDegreesPre { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TiltSensorAxisZDegreesPre { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TiltSensorAxisXDegreesPost { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TiltSensorAxisYDegreesPost { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        double TiltSensorAxisZDegreesPost { get; set; }
+        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; }
+
+        /// <summary>
+        /// The sample rate in Hz at which the Module will sample sensor data.
+        /// </summary>
+        uint SampleRateHz { get; set; }
+
+        /// <summary>
+        /// FB 25558 Actual sample rate currently is used in realtime for TSR AIR type only in future it might be used for other hardware types
+        /// </summary>
+        uint ActualSampleRateHz { get; set; }
+
+        /// <summary>
+        /// Hardware anti-alias filter rate.
+        /// </summary>
+        float AAFilterRateHz { get; set; }
+
+        /// <summary>
+        /// What type of recording mode is this Module in?
+        /// See <see cref="Test.Module.RecordingMode.RecorderMode" />.
+        /// </summary>
+        DFConstantsAndEnums.RecordingMode RecordingMode { get; set; }
+        DateTime ScheduledStartTime { get; set; }
+        int RecordingInterval { get; set; }
+
+        UDPStreamProfile StreamProfile { get; set; }
+
+        #region Slice 6 Tilt Feature
+
+        /// <summary>
+        /// Defines which 2 axis will be used for the bubble level feature for Slice 6.
+        /// </summary>
+        DFConstantsAndEnums.TiltAxes TiltAxes { get; set; }
+
+        double TargetAxisOne { get; set; }
+
+        double TargetAxisTwo { get; set;}
+
+        /// <summary>
+        /// The target angle threshold in degrees for Axis 1
+        /// </summary>
+        float TargetAngleAxisX { get; set; }
+        /// <summary>
+        /// The target angle threshold in degrees for Axis 2
+        /// </summary>
+        float TargetAngleAxisY { get; set; }
+        /// <summary>
+        /// The target angle threshold in degrees for Axis 3
+        /// </summary>
+        float TargetAngleAxisZ { get; set; }
+
+        double MountOffsetAxisOne { get; set; }
+
+        double MountOffsetAxisTwo { get; set; }
+
+        string SystemLocation { get; set; }
+
+        string SystemID { get; set; }
+
+        int AxisIgnored { get; set; }
+
+        double LevelTolerance { get; set; }
+
+        bool UseForTiltCalculation { get; set; }
+        double InputVoltage { get; set; }
+        double BatteryVoltage { get; set; }
+
+        /// <summary>
+        /// The external tilt enumeration given by the attached DAS
+        /// </summary>
+        byte TiltID { get; set; }
+        /// <summary>
+        /// The serial number of the external tilt
+        /// </summary>
+        string TiltSerialNumber { get; set; }
+        #endregion
+
+        //public IDASCommunication OwningDAS { get; set; }
+
+        /// <summary>
+        /// Count how many channels are configured in this Module.
+        /// See <see cref="AnalogInputDASChannel.IsConfigured" />.
+        /// </summary>
+        /// <returns>Number of configured channels</returns>
+        int NumberOfConfiguredChannels();
+
+        /// <summary>
+        /// Count how many TOM channels are configured in this module
+        /// </summary>
+        /// <returns>Number of configured TOM channels</returns>
+        int NumberOfConfiguredTOMChannels();
+
+        bool IsDummyArmed();
+
+        /// <summary>
+        /// Count how many channels this module has (regardless if they are configured 
+        /// or not).
+        /// </summary>
+        /// <returns>Total number of channels</returns>
+        int NumberOfChannels();
+
+        /// <summary>
+        /// Retrieve the serial number from DASInfo
+        /// </summary>
+        /// <returns>The serial number of this module</returns>
+        string SerialNumber();
+
+        /// <summary>
+        /// Retrieve the module type from DASInfo
+        /// </summary>
+        /// <returns>The type of this module</returns>
+        DFConstantsAndEnums.ModuleType ModuleType();
+        /// <summary>
+        /// Retrieve the module type from DASInfo and return whether or not it's a stream in type
+        /// </summary>
+        /// <returns>Whether the type of this module is a stream in</returns>
+        bool IsStreamIn();
+        /// <summary>
+        /// Retrieve the module type from DASInfo and return whether or not it's a stream out type
+        /// </summary>
+        /// <returns>Whether the type of this module is a stream out</returns>
+        bool IsStreamOut();
+        /// <summary>
+        /// Retrieve the module type from DASInfo and return whether or not it's a uart type
+        /// </summary>
+        /// <returns>Whether the type of this module is a uart</returns>
+        bool IsUart();
+        /// <summary>
+        /// Retrieve the module type from DASInfo and return whether or not it's a clock type
+        /// </summary>
+        /// <returns>Whether the type of this module is a clock</returns>
+        bool IsClock();
+        /// <summary>
+        /// Retrieve the module type from DASInfo and return whether or not it's an embedded type
+        /// </summary>
+        /// <returns>Whether the type of this module is embedded</returns>
+        bool IsEmbedded();
+        void WriteXmlCRC32(XmlWriter writer);
+        void WriteXml(XmlWriter writer);
+        void ReadXml(XmlReader reader);
+        XmlSchema GetSchema();
+
+        ushort GetCRC32();
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IEID.cs

@@ -0,0 +1,10 @@
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IEID
+    {
+        string ID { get; set; }
+        byte[] Blob { get; set; }        
+
+        bool IsValid();
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IInfoResult.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IInfoResult
+    {
+        string MACAddress { get; set; }
+        
+
+        /// <summary>
+        /// An array of the modules in this DAS.
+        /// </summary>
+        IInfoResultModule[] Modules { get; set; }
+
+        List<Common.Classes.Hardware.ExternalTilt> ActiveExternalTilts { get; set; }
+
+        //public IDASCommunication OwningDAS { get; set; }
+
+        uint MaxNumberOfModules { get; set; }
+
+        /// <summary>
+        /// How many bytes of sample storage is available in this DAS? This is null if
+        /// it's specified per module instead.
+        /// </summary>
+        ulong? MaxEventStorageSpaceInBytes { get; set; }
+
+        /// <summary>
+        /// How many bytes are stored for all channels at each sample interval? This is 
+        /// null if it's specified per module instead.
+        /// </summary>
+        uint? NumberOfBytesPerSampleClock { get; set; }
+
+        /// <summary>
+        /// FB15353 Is this device hardware configured for streaming only?
+        /// null if device doesn't support a streaming-only configuration
+        /// </summary>
+        bool? DeviceStreamingOnly { get; set; }
+
+        // temporary constant
+        int NumberOfBridgeChannels { get; set; }
+        
+        IEID BatteryID { get; set; }
+
+        /// <summary>
+        /// TRUE if a battery is present in the hardware unit.
+        /// </summary>
+        bool HasBattery{ get; }
+
+        byte MapDASChannelNumber2RealtimeChannelNumber(int channelNumber);
+
+        /// <summary>
+        /// Convert a DASChannel number (0..29) to a module array index (0..9).
+        /// A DASChannel number is a channel's identifier global within this DAS.
+        /// A Module array index is a Module identifier as it would be indexed in an array.
+        /// </summary>
+        /// <param name="channelNumber">The DAS channel number to convert</param>
+        /// <returns>The module array index</returns>
+        byte MapDASChannelNumber2ModuleArrayIndex(int channelNumber);
+
+        /// <summary>
+        /// Convert a DAS channel number (0..29) to a module device id (1..10)
+        /// A DASChannel number is a channel's identifier global within this DAS.
+        /// A Module deviceID is an identifier for the corresponding channel that starts at 1 for the first Module.
+        /// </summary>
+        /// <param name="channelNumber">The DAS channel number to convert</param>
+        /// <returns>The module device id</returns>
+        byte MapDASChannelNumber2ModuleDeviceID(int channelNumber);
+
+        /// <summary>
+        /// Convert a DAS channel number (0..29) to a module channel number (0..2)
+        /// A DASChannel number is a channel's identifier global within this DAS.
+        /// A moduleChannel number is the channel's identifier relative only to it's parent Module.
+        /// </summary>
+        /// <param name="channelNumber">The DAS channel number to convert</param>
+        /// <returns>The channel number within the module</returns>
+        byte MapDASChannelNumber2ModuleChannelNumber(int channelNumber);
+
+        /// <summary>
+        /// Convert a module array index (0..9) and a module channel number (0..2) to a DAS channel number (0..29)
+        /// A Module array index is a Module identifier as it would be indexed in an array.
+        /// A moduleChannel number is the channel's identifier relative only to it's parent Module.
+        /// A DASChannel number is a channel's identifier global within this DAS.
+        /// </summary>
+        /// <param name="moduleArrayIdx">The module array index (0..9)</param>
+        /// <param name="channelNumber">The module channel number (0..2)</param>
+        /// <returns>The DAS channel number within the DAS (0..29)</returns>
+        byte MapModuleArrayIndexAndChannelNum2DASChannel(int moduleArrayIdx, int channelNumber);
+
+        /// <summary>
+        /// The <see cref="System.DateTime"/> returns the datetime of the DAS (or the oldest module's calibration)
+        /// returns 1970-01-01 is considering invalid/NA
+        /// </summary>        
+        DateTime? CalibrationDate{ get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IInfoResultModule.cs

@@ -0,0 +1,84 @@
+using DTS.Common.Enums.DASFactory;
+using System;
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IInfoResultModule
+    {
+        /// <summary>
+        /// Serial number of this module
+        /// </summary>
+        string SerialNumber { get; set; }
+
+        /// <summary>
+        /// Firmware version in this module
+        /// </summary>
+        string FirmwareVersion { get; set; }
+
+        /// <summary>
+        /// who does this module belong to?
+        /// </summary>
+        //public InfoResult OwningInfoResult { get; set; }
+
+        /// <summary>
+        /// The number of this Module as it would be indexed in an array of Modules.
+        /// </summary>
+        int ModuleArrayIndex { get; set; }
+
+        /// <summary>
+        /// How many channels are connected to this Module.
+        /// </summary>
+        uint NumberOfChannels { get; set; }
+
+        /// <summary>
+        /// What sample rates does it support (in samples per second).
+        /// </summary>
+        uint[] SupportedSampleRates { get; set; }
+
+        /// <summary>
+        /// An associative list (Dictionary) of sample rates and corresponding 
+        /// Anti-Aliasing filter frequencies.
+        /// </summary>
+        Dictionary<uint, float> SampleRate2AAFrequency { get; set; }
+
+        /// <summary>
+        /// How many bytes of sample storage is available in this module? This is null 
+        /// if it's specified per DAS instead.
+        /// </summary>
+        ulong? MaxEventStorageSpaceInBytes { get; set; }
+
+        /// <summary>
+        /// How many bytes are stored for all channels at each sample interval? This is 
+        /// null if it's specified per DAS instead.
+        /// </summary>
+        uint? NumberOfBytesPerSampleClock { get; set; }
+
+        /// <summary>
+        /// How many samples can you record in this module?
+        /// </summary>
+        double MaxRecordingSamples { get; set; }
+
+        /// <summary>
+        /// The <see cref="System.DateTime"/> of this module's last calibration.
+        /// </summary>
+        DateTime? CalibrationDate { get; set; }
+
+        /// <summary>
+        /// True if a TDAS rack is armed and doesn't respond to some queries.
+        /// </summary>
+        bool RackIsUnreadable { get; set; }
+
+        /// <summary>
+        /// What type of module is this?
+        /// </summary>
+        DFConstantsAndEnums.ModuleType TypeOfModule { get; set; }
+
+        /// <summary>
+        /// What recording modes does this Module support.
+        /// </summary>
+        DFConstantsAndEnums.RecordingMode[] SupportedModes { get; set; }
+
+        bool IsProgrammable { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IInformation.cs

@@ -0,0 +1,17 @@
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    /// <summary>
+    /// Information interface for an IDASCommunication object, providing DASInfo object.
+    /// </summary>
+    public interface IInformation
+    {
+        /// <summary>
+        /// DASInfo is populated with values from the hardware.  It provides information
+        /// about the entire DAS as well as the functions necessary to covert between
+        /// Module, ModuleChannel, and DASChannel values.
+        /// </summary>
+        IInfoResult DASInfo { get; set; }
+        void SetDASInfo(IInfoResult dasInfo, bool bSetInDb = true);
+        void SetDASInfo();
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Config/IVoltageInsertionEnabled.cs

@@ -0,0 +1,11 @@
+namespace DTS.Common.Interface.DASFactory.Config
+{
+    public interface IVoltageInsertionEnabled
+    {
+        /// <summary>
+        /// Indicates that Voltage Insertion was detected as being on
+        /// http://manuscript.dts.local/f/cases/34284/Warn-when-VoltageInsertion-switches-are-set
+        /// </summary>
+        bool VoltageInsertionEnabled { get; }
+    }
+}

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

Common/DTS.CommonCore/Interface/DASFactory/Download/IDownload.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IDownload
+    {
+        /// <summary>
+        /// What do you want to download?
+        /// </summary>
+        IDownloadRequest WhatToDownload { get; set; }
+        void SetWhatToDownload(IDownloadRequest request, bool bSetInDb = true);
+        /// <summary>
+        /// The Retrieved information about stored events.
+        /// </summary>
+        IDownloadReport EventInfo { get; set; }
+        void SetEventInfo(IDownloadReport eventInfo, bool bSetInDb = true);
+        /// <summary>
+        /// QueryDownloadedStatus will fill this array (indexed by event number, true if
+        /// HasBeenDownloaded was set for this event, false otherwise)
+        /// </summary>
+        bool[] EventDownloadedStatus { get; set; }
+        void SetEventDownloadStatus(bool[] status, bool storeInDb=true);
+        /// <summary>
+        /// DASFactory will fill this array (indexed by event number).
+        /// </summary>
+        Guid[] EventGuids { get; set; }
+        void SetEventGuids(Guid[] guids, bool storeInDb = true);
+        /// <summary>
+        /// DASFactory will fill this array (indexed by event number).
+        /// </summary>
+        ushort[] FaultFlags { get; set; }
+        void SetEventFaultFlags(ushort[] flags, bool storeInDb = true);
+        /// <summary>
+        /// DASFactory will fill this array (indexed by event number).
+        /// </summary>
+        byte[] ArmAttempts { get; set; }
+        void SetEventArmAttemps(byte[] armAttempts, bool storeInDb = true);
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IDownloadReport.cs

@@ -0,0 +1,16 @@
+using DTS.Common.Interface.DownloadEvent;
+
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IDownloadReport
+    {
+        /// <summary>
+        /// An array of all events stored on this DAS.
+        /// </summary>
+        IEventInfo[] Events { get; set; }
+        /// <summary>
+        /// An array of all UART events stored on this DAS.
+        /// </summary>
+        IUARTEventInfo[] UARTEvents { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IDownloadRequest.cs

@@ -0,0 +1,57 @@
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IDownloadRequest
+    {
+        /// <summary>
+        /// From which event do we want to download data?
+        /// </summary>
+        ushort EventNumber { get; set; }
+
+        /// <summary>
+        /// Which channel? (set to ALL_CHANNELS for all)
+        /// </summary>
+        byte DASChannelNumber { get; set; }
+
+        /// <summary>
+        /// The first sample you want.
+        /// </summary>
+        ulong StartSample { get; set; }
+
+        /// <summary>
+        /// The last sample you want.
+        /// </summary>
+        ulong EndSample { get; set; }
+
+        /// <summary>
+        /// This is used for sub-sampling data, 0 (or 1) means don't sub-sample, 2 means 
+        /// give me every other sample and so on. The number of samples requested 
+        /// (EndSample-StartSample+1) must be an multiple of SamplesToSkip.
+        /// </summary>
+        ulong SamplesToSkip { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double StartRecordTimestampSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TriggerTimestampSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double StartRecordTimestampNanoSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        double TriggerTimestampNanoSec { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        bool PTPMasterSync { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IEventInfo.cs

@@ -0,0 +1,64 @@
+using DTS.Common.Interface.DASFactory.Config;
+using System;
+
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IEventInfo
+    {
+        /// <summary>
+        /// Information about each module that was part of the event.  Addressable by
+        /// ModuleArrayIndex of the corresponding module.
+        /// </summary>
+        IDASModule[] Modules { get; set; }
+
+        /// <summary>
+        /// The event number this information is regarding.
+        /// </summary>
+        int EventNumber { get; set; }
+
+        /// <summary>
+        /// The GUID of the corresponding event.
+        /// </summary>
+        Guid TestGUID { get; set; }
+
+        /// <summary>
+        /// Fault flags (if any)
+        /// </summary>
+        ushort FaultFlags { get; set; }
+        /// <summary>
+        /// Extended Fault flags (if any)
+        /// </summary>
+        ushort FaultFlagsEx { get; set; }
+
+        /// <summary>
+        /// Arm Attempts (if any)
+        /// </summary>
+        byte ArmAttempts { get; set; }
+        /// <summary>
+        /// The timestamp of this event.
+        /// </summary>
+        DateTime TestTime { get; set; }
+
+        /// <summary>
+        /// The ID of this event.
+        /// </summary>
+        string TestID { get; set; }
+
+        /// <summary>
+        /// A text description that was stored.
+        /// </summary>
+        string Description { get; set; }
+
+        /// <summary>
+        /// True if this event has already been downloaded.
+        /// </summary>
+        bool HasBeenDownloaded { get; set; }
+
+        /// <summary>
+        /// True if this event received a trigger.
+        /// </summary>
+        bool WasTriggered { get; set; }
+
+        void ClearFaults();
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IEventInfoAggregate.cs

@@ -0,0 +1,18 @@
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IEventInfoAggregate
+    {
+        string EventId { get; set; }
+        string EventDescription { get; set; }
+        double DurationSeconds { get; set; }
+        string GUID { get; set; }
+        bool HasBeenDownloaded { get; set; }
+        bool WasTriggered { get; set; }
+        int NumberOfChannels { get; set; }
+        ulong NumberOfSamples { get; set; }
+        ulong NumberOfBytes { get; set; }
+        bool Faulted { get; set; }
+        int EventNumber { get; set; }
+        void Add(IEventInfo newEvent);
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IUARTDownload.cs

@@ -0,0 +1,24 @@
+using DTS.Common.Enums;
+using System.IO.Ports;
+
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IUARTDownload
+    {
+        /// <summary>
+        /// FB15335: Move UART and ClockProfile sets to RunTest -> Hardware NavStep, add Reboot
+        /// DASFactory will fill these with the current values.
+        /// </summary>
+        uint BaudRate { get; }
+        uint DataBits { get; }
+        StopBits StopBits { get; }
+        Parity Parity { get; }
+        Handshake FlowControl { get; }
+        UartDataFormat DataFormat { get; }
+        /// <summary>
+        /// What do you want to download?
+        /// </summary>
+        IUARTDownloadRequest WhatUARTToDownload { get; set; }
+        void SetWhatUARTToDownload(IUARTDownloadRequest request, bool bSetInDb = true);
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IUARTDownloadRequest.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IUARTDownloadRequest
+    {
+        /// <summary>
+        /// From which event do we want to download data?
+        /// </summary>
+        ushort EventNumber { get; set; }
+        /// <summary>
+        /// How much data is there?
+        /// </summary>
+        ulong TotalByteCount { get; set; }
+        /// <summary>
+        /// Where in the data did the trigger occur?
+        /// </summary>
+        ulong TriggerByteCount { get; set; }
+        /// <summary>
+        /// Where in the data did the trigger occur?
+        /// </summary>
+        ulong FaultByteCount { get; set; }
+        /// <summary>
+        /// When did the UART stream start?
+        /// </summary>
+        ulong StartTimestamp { get; set; }
+        /// <summary>
+        /// When did the UART stream end?
+        /// </summary>
+        ulong EndTimestamp { get; set; }
+        /// <summary>
+        /// What was the baud rate during recording?
+        /// </summary>
+        int BaudRate { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/Download/IUARTEventInfo.cs

@@ -0,0 +1,43 @@
+namespace DTS.Common.Interface.DASFactory.Download
+{
+    public interface IUARTEventInfo
+    {
+        /// <summary>
+        /// From which event do we want to download data?
+        /// </summary>
+        ushort EventNumber { get; set; }
+        /// <summary>
+        /// Is data present?
+        /// </summary>
+        bool DataPresent { get; set; }
+        /// <summary>
+        /// Has data already been downloaded?
+        /// </summary>
+        bool DataDownloaded { get; set; }
+        /// <summary>
+        /// How much data is there?
+        /// </summary>
+        ulong TotalByteCount { get; set; }
+
+        /// <summary>
+        /// Where in the data did the trigger occur?
+        /// </summary>
+        ulong TriggerByteCount { get; set; }
+        /// <summary>
+        /// Where are the faults?
+        /// </summary>
+        ulong FaultByteCount { get; set; }
+        /// <summary>
+        /// When did the UART stream start?
+        /// </summary>
+        ulong StartTimestamp { get; set; }
+        /// <summary>
+        /// When did the UART stream end?
+        /// </summary>
+        ulong EndTimestamp { get; set; }
+        /// <summary>
+        /// What was the baud rate during UART recording?
+        /// </summary>
+        uint BaudRate { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IAnalogInputDASChannel.cs

@@ -0,0 +1,323 @@
+using DTS.Common.Enums;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.DASFactory.Diagnostics;
+using DTS.Common.Interface.Sensors.SoftwareFilters;
+using System;
+using System.Xml;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IAnalogInputDASChannel
+    {
+        /// <summary>
+        /// Type of Wheatstone Bridge in the sensor; half, full, etc.
+        /// </summary>
+        SensorConstants.BridgeType TypeOfBridge { get; set; }
+
+        /// <summary>
+        /// 14042 Flash Clear turns of excitation for s6
+        /// this allows for ILevelTriggerable channels to store and cache a sample average for checking
+        /// level triggered
+        /// </summary>
+        //double? ILevelTriggerable.SampleAverageADC { get; set; } = null;
+
+        /// <summary>
+        /// used during TDAS diagnostics, it's a throw away value that's computed during configuration
+        /// then compared to during measure shunt.
+        /// </summary>
+        int ShuntTargetADC { get; set; }
+        SensorConstants.BridgeType[] SupportedBridges { get; set; }
+
+        /// <summary>
+        /// the types of digital input modes supported by the channel.
+        /// by default all digital modes are supported, and some hardware restrict the list (notably the g5)
+        /// </summary>
+        DigitalInputModes[] SupportedDigitalInputModes { get; set; }
+
+        /// <summary>
+        /// IEPE Coupling mode (AC, AC/DC)
+        /// correct voltage base on this property.
+        /// </summary>
+        SensorConstants.CouplingModes CouplingMode { get; set; }
+
+        /// <summary>
+        /// Resistance of the Bridge in the sensor.
+        /// </summary>
+        double BridgeResistanceOhms { get; set; }
+
+        /// <summary>
+        /// used to store 2D/3D IR-TRACC ZeroPoint Voltage data
+        /// </summary>    
+        double ZeroPoint { get; set; }
+
+
+        /// <summary>
+        /// Bi-Polar maximum tolerance of sensor in Engineering Units.
+        /// </summary>
+        double SensorCapacityEU { get; set; }
+
+        /// <summary>
+        /// Sensor capacity specified in sensor database.
+        /// </summary>
+        double SensorCapacity { get; set; }
+
+        /// <summary>
+        /// Sensor polarity specified in sensor database.
+        /// </summary>
+        string SensorPolarity { get; set; }
+
+        /// <summary>
+        /// The desired Bi-Polar range of readings (in Engineering Units) 
+        /// from this sensor for this test or event.  This must be
+        /// within the SensorCapacityEU of the sensor.
+        /// </summary>
+        double DesiredRangeWithHeadroomEU { get; set; }
+
+        /// <summary>
+        /// Sensitivity of the sensor in Millivots per Engineering Unit
+        /// as specified by the sensor's manufacturer or hardware settings.
+        /// </summary>
+        double SensitivityMilliVoltsPerEU { get; set; }
+
+        double SensitivityMilliVoltsPerEUNormalized { get; }
+
+        /// <summary>
+        /// Are sensor readings proportional to excitation voltage?
+        /// </summary>
+        bool IsProportionalToExcitation { get; set; }
+
+        bool IsSupported(ExcitationVoltageOptions.ExcitationVoltageOption o);
+
+
+        /// <summary>
+        /// Is this sensor's output inverted?
+        /// </summary>
+        bool IsInverted { get; set; }
+
+        string OriginalChannelName { get; set; }
+        string ChannelName2 { get; set; }
+
+        /// <summary>
+        /// refers to a unique id for a logical channel in the test
+        /// for now this is using TestObjectChannel.GetId()
+        /// which is in the form of TestObjectSerial_ChannelType_ChannelId
+        /// </summary>
+        string ChannelId { get; set; }
+
+        /// <summary>
+        /// refers to the Group for a logical channel in the test
+        /// </summary>
+        string ChannelGroupName { get; set; }
+
+        string HardwareChannelName { get; set; }
+
+        string DIUnits { get; set; }
+        DigitalInputModes DigitalMode { get; set; }
+
+        DTS.Common.Classes.Sensors.LinearizationFormula LinearizationFormula { get; set; }
+        /// <summary>
+        /// The excitation voltage to apply to the sensor.  Firmware will provide the
+        /// correct voltage base on this property.
+        /// </summary>
+        ExcitationVoltageOptions.ExcitationVoltageOption Excitation { get; set; }
+
+        ExcitationVoltageOptions.ExcitationVoltageOption[] SupportedExcitation { get; set; }
+        /// <summary>
+        /// String representation of the Engineering Units this sensor reads, for example
+        /// "g" or "m/s/s" or "meters per second", etc.  Not mathematically relevant, only 
+        /// used for display.
+        /// </summary>
+        string EngineeringUnits { get; set; }
+
+        /// <summary>
+        /// Serial number of the sensor.
+        /// </summary>
+        string SerialNumber { get; set; }
+
+        /// <summary>
+        /// Manufacturer of the sensor.
+        /// </summary>
+        string Manufacturer { get; set; }
+
+        /// <summary>
+        /// Model of the sensor.
+        /// </summary>
+        string Model { get; set; }
+
+        /// <summary>
+        /// A text description of the sensor.
+        /// </summary>
+        string Description { get; set; }
+
+        /// <summary>
+        /// How will this sensor be zeroed?
+        /// </summary>
+        ZeroMethodType ZeroMethod { get; set; }
+
+        /// <summary>
+        /// Start time for the zero window relative to T=0
+        /// used if ZeroMethod is AverageOverTime.
+        /// </summary>
+        double ZeroAverageStartSeconds { get; set; }
+
+        /// <summary>
+        /// Stop time for the zero window relative to T=0
+        /// used if ZeroMethod is AverageOverTime.
+        /// </summary>
+        double ZeroAverageStopSeconds { get; set; }
+
+        /// <summary>
+        /// The initial EU value
+        /// </summary>
+        double InitialEU { get; set; }
+
+        string InitialOffset { get; set; }
+
+        bool Unipolar { get; set; }
+        /// <summary>
+        /// Should the shunt be enabled?
+        /// </summary>
+        bool ShuntIsEnabled { get; set; }
+
+        /// <summary>
+        /// some DAS require holding zeromV in adc in the xml configuration (slice2)
+        /// this is here to hold that information
+        /// </summary>
+        short ZeromVInADC { get; set; }
+
+        /// <summary>
+        /// should voltage insertion (gain) check be enabled?
+        /// </summary>
+        bool VoltageInsertionCheckEnabled { get; set; }
+
+        bool IEPEChannel { get; set; }
+        bool DigitalInputChannel { get; set; }
+        bool CalSignalIsEnabled { get; set; }
+        /// <summary>
+        /// Setting this true will flag the hardware to compensate for the offset of the sensor 
+        /// during a call to DiagnosticsService.Diagnose(...).
+        /// </summary>
+        bool RemoveOffset { get; set; }
+
+        /// <summary>
+        /// Should we verify the measured offset to the limits?
+        /// </summary>
+        bool VerifyOffset { get; set; }
+
+        /// <summary>
+        /// The lower limit on allowed offset for the connected sensor.
+        /// </summary>
+        double OffsetToleranceLowMilliVolts { get; set; }
+
+        /// <summary>
+        /// The upper limit on allowed offset for the connected sensor.
+        /// </summary>
+        double OffsetToleranceHighMilliVolts { get; set; }
+
+        DateTime LastCalibrationDate { get; set; }
+
+        DateTime CalDueDate { get; set; }
+        /// <summary>
+        /// The ISO code for this channel.
+        /// </summary>
+        string ISOCode { get; set; }
+
+        /// <summary>
+        /// Not available on slice or G5.  Remove for now?
+        /// </summary>
+        bool BypassAAFilter { get; set; }
+
+        string SensorID { get; set; }
+        /// <summary>
+        /// Get the channel diagnostics results (if available) for this channel.
+        /// </summary>
+        IDiagnosticResult Diagnostics { get; }
+
+        /// <summary>
+        /// some channels should not be refreshed from the database prior to running configuration, for example sensors that are part of a group
+        /// should not be updated from database
+        /// </summary>
+        bool UpdateChannelFromDatabase { get; set; }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Get/set the "trigger below" threshold.  Set to "null" to deactivate.
+        /// </summary>
+        double? TriggerBelowThresholdEu
+        {
+            get;
+            set;
+        }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Get/set the "trigger above" threshold.  Set to "null" to deactivate.
+        /// </summary>
+        double? TriggerAboveThresholdEu
+        {
+            get;
+            set;
+        }
+
+        bool AlreadyLevelTriggered
+        {
+            get;
+            set;
+        }
+
+
+        double MeasuredEULevelTriggerCheck
+        {
+            get;
+            set;
+        }
+        /// <summary>
+        /// Temporary fix that'll be addressed in 1.1
+        /// </summary>
+        double SoftwareFilterFrequency { get; set; }
+
+        /// <summary>
+        /// Fb 13120 For now continue using SoftwareFilterFrequency needs to be refactored to use SoftwareFilterClass instead 
+        /// </summary>
+        IFilterClass SoftwareFilterClass { get; set; }
+
+        /// <summary>
+        /// Get/set the <see cref="DTS.DASLib.Service.DiagnosticsResult"/> for this channel.
+        /// </summary>
+        IDiagnosticResult DiagnosticInformation { get; }
+
+        /// <summary>
+        /// Get/set the <see cref="double"/> measured excitation voltage.
+        /// </summary>
+        double? MeasuredExcitationVolts { get; }
+
+        /// <summary>
+        /// Get/set the <see cref="double"/> factory excitation voltage.
+        /// </summary>
+        double? FactoryExcitationVolts { get; }
+
+        double ScalefactorMilliVoltsPerADC { get; set; }
+        double ScalefactorEngineeringUnitsPerADC { get; set; }
+
+        double NoiseAsPercentOfFullScale { get; set; }
+
+        /// <summary>
+        /// If this channel is supersampled, what the regular sampling rate is
+        /// </summary>
+        double UnsupersampledSampleRate { get; set; }
+
+        /// <summary>
+        /// If the channel has a serial number in the SerialNumber field, it is "Configured".
+        /// </summary>
+        bool IsConfigured();
+
+        void WriteElementEnd(XmlWriter writer);
+
+        void WriteXml(XmlWriter writer);
+
+        string GetSupportedExcitationSerialized();
+        string GetSupportedDigitalInputModesSerialized();
+        string GetSupportedBridgesSerialized();
+        void WriteXmlCRC32(XmlWriter writer);
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IAutoArmStatus.cs

@@ -0,0 +1,9 @@
+using DTS.Common.Enums.DASFactory;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IAutoArmStatus
+    {
+        DFConstantsAndEnums.CommandStatus AutoArmStatus { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IAutoArmed.cs

@@ -0,0 +1,7 @@
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IAutoArmed
+    {
+        bool AutoArmed { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/ICommunication.cs

@@ -0,0 +1,86 @@
+using DTS.Common.Enums.Communication;
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.Interface.Communication;
+using DTS.Common.Interface.Connection;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface ICommunication: IComparable<ICommunication>, IComparable<string>
+    {
+        IConnection Transport { get; set; }
+        /// <summary>
+        /// setups the receivebuffer and callback, this needs to be done whenever
+        /// the sock is connected
+        /// </summary>
+        void SetupReader();
+        int ReceiveBufferSize { get; set; }
+        
+        string SerialNumber { get; set; }
+
+        string FirmwareVersion { get; set; }
+
+        byte ProtocolVersion { get; set; }
+      
+        ICommunication_DASInfo DASInfo { get; set; }
+
+        Dictionary<DFConstantsAndEnums.ProtocolLimitedCommands, byte> MinimumProtocols { get; set; }
+
+        void InitMinProto();
+
+        bool IsCommandSupported(DFConstantsAndEnums.ProtocolLimitedCommands command);
+
+        byte GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands command);
+
+        event EventHandler OnDisconnected;
+
+        string ConnectString { get; }
+
+        bool Connected { get; }
+
+        void Connect(string ConnectString,
+                     CommunicationConstantsAndEnums.CommunicationCallback Callback,
+                     object CallbackObject,
+                     int CallbackTimeout, string ipAddress);
+
+        void Disconnect(bool reuseSocket,
+            CommunicationConstantsAndEnums.CommunicationCallback Callback,
+                        object CallbackObject,
+                        int CallbackTimeout);
+
+        void Close(int Timeout);
+
+        void Flush(int Timeout);
+
+        bool ExecuteIsBusy { get;  set; }
+
+        void Execute(byte[] byteData,
+            CommunicationConstantsAndEnums.CommunicationCallback Callback,
+                     object CallbackObject,
+                     int CallbackTimeout);
+
+        void PseudoExecute(byte[] byteData,
+            CommunicationConstantsAndEnums.CommunicationCallback Callback,
+                     object CallbackObject,
+                     int CallbackTimeout);
+
+        byte[] SyncExecute(byte[] byteData,
+                           int Timeout);
+
+        void Cancel();
+        void ForceCancel();
+
+        bool IsCanceled();
+
+        void ClearCancel();
+        /// <summary>
+        /// event that will signal if cancel has happened
+        /// prior to this IsCanceled would have to be checked
+        /// or polled
+        /// 17600 Communication class improvements from 3.2
+        /// </summary>
+        ManualResetEvent CancelEvent { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IConnectedEthernetDevice.cs

@@ -0,0 +1,9 @@
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IConnectedEthernetDevice
+    {
+        string MACAddress { get; }
+        int Port { get; }        
+        string SerialNumber { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IDASCommunication.cs

@@ -0,0 +1,262 @@
+using DTS.Common.Enums.Hardware;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.DASFactory.ARM;
+using DTS.Common.Interface.DASFactory.Config;
+using DTS.Common.Interface.DASFactory.Diagnostics;
+using DTS.Common.Interface.DASFactory.Download;
+using System;
+using static DTS.Common.Enums.DASFactory.DFConstantsAndEnums;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    /// <summary>
+    /// Interface to a DAS unit.  The IDASCommunication interface for a DAS unit is the most used
+    /// data structure in the API.  Nearly all services performed on the hardware will take a List 
+    /// of these interfaces (representing a List of hardware units) as a parameter.  Each DAS unit in 
+    /// the real world will have an IDASCommunication interface in the API.  In the case of Configuration, for
+    /// example, the local IDASCommunication corresponding to the hardware configuration target is edited, then
+    /// ConfigurationService.SetConfiguration(...) is called which basically synchronizes the local IDASCommunication
+    /// with the hardware, and vice versa with GetConfiguration(...).
+    /// </summary>
+    public interface IDASCommunication : IConfiguration,
+        IDiagnos,
+        ITriggerCheck,
+        IRealTime,
+        IArmStatus,
+        IDownload,
+        IInformation,
+        IComparable<IDASCommunication>,
+        IDisposable,
+        IAutoArmStatus,
+        IAutoArmed,
+        IRangeBandwidthLimited,
+        ITimeSynchronization
+    {        
+	    /// <summary>
+		/// The Excitation status for DAS
+		/// </summary>
+        ExcitationStatus ExcitationStatus { get; set; }
+        /// <summary>
+        /// populates IsFirstUseDateSupported and FirstUseDate properties
+        /// if unit supports first use date then requires communication with unit
+        /// (to retrieve attribute)
+        /// 15524 DAS "First Use Date"
+        /// this isn't really designed to be called externally, but as part of IDASCommunication initialization
+        /// </summary>
+        void ReadFirstUseDate();
+        /// <summary>
+        /// indicates date of first use
+        /// null indicates the hardware has not been used since calibration
+        /// only valid when IsFirstUseDateSupported is true
+        /// 15524 DAS "First Use Date"
+        /// </summary>
+        DateTime? FirstUseDate { get; set; }
+        /// <summary>
+        /// returns whether the hardware supports first use or not
+        /// for hardware to support first use the hardware must support
+        /// storage for user attributes in firmware and also have been
+        /// calibrated by software support hardware first use
+        /// 15524 DAS "First Use Date"
+        /// </summary>
+        bool IsFirstUseDateSupported { get; set; }
+        /// <summary>
+        /// 
+        /// </summary>
+        void SetIsStreamingSupported(bool supported = false);
+        /// <summary>
+        /// indicates whether or not streaming is supported
+        /// 30429 TSR AIRs can enable/disable streaming via the DISABLE_STREAMING_FEATURE system attribute
+        /// </summary>
+        bool IsStreamingSupported { get; set; }
+        /// <summary>
+        /// performs a quick connection check, returns true if unit can be communicated with
+        /// returns false otherwise
+        /// does not go through units busy service or check that unit is not being communicated with
+        /// this is an emergency check
+        /// </summary>
+        /// <returns></returns>
+        bool ConnectionCheck();
+        HardwareTypes GetHardwareType();
+        int RecordId { get; set; }
+        /// returns the nominal ranges for the das given a bridge type
+        double[] GetNominalRanges(SensorConstants.BridgeType bridge);
+        float InputLowVoltage { get; set; }
+        float InputMediumVoltage { get; set; }
+        float InputHighVoltage { get; set; }
+        float BatteryLowVoltage { get; set; }
+        float BatteryMediumVoltage { get; set; }
+        float BatteryHighVoltage { get; set; }
+        double MinimumValidInputVoltage { get; set; }
+        double MaximumValidInputVoltage { get; set; }
+        double MinimumValidBatteryVoltage { get; set; }
+        double MaximumValidBatteryVoltage { get; set; }
+        /// <summary>
+        /// The serial number of the base unit of this DAS.
+        /// </summary>
+        string SerialNumber { get; set; }
+
+        /// <summary>
+        /// The firmware version currently installed on this DAS.
+        /// </summary>
+        string FirmwareVersion { get; }
+
+        /// <summary>
+        /// This flag is used to tell if arm attributes should be defaulted when arming
+        /// or not. It also serves to let the user know that this DAS has not been 
+        /// diagnosed.
+        /// </summary>
+        bool DiagnosticsHasBeenRun { get; set; }
+
+        /// <summary>
+        /// this flag is used to tell if configure has been run
+        /// this is used prior to when diagnostic results are needed, like the
+        /// diagnostics tab or the acquire tab [when running acquire]
+        /// </summary>
+        bool ConfigureHasBeenRun { get; set; }
+
+        /// <summary>
+        /// Count how many channels are configured.
+        /// </summary>
+        /// <returns>Number of configured channels.</returns>
+        int NumberOfConfiguredChannels();
+
+        /// <summary>
+        /// Count how many channels we have (regardless if they are configured or not).
+        /// </summary>
+        /// <returns>Total number of channels</returns>
+        int NumberOfChannels();
+
+        /// <summary>
+        /// max memory for the das
+        /// </summary>
+        /// <returns></returns>
+        long MaxMemory();
+
+        int MaxModules { get; set; }
+
+        /// <summary>
+        /// min sample rate for the das
+        /// </summary>
+        /// <returns></returns>
+        uint MinSampleRate();
+
+        /// <summary>
+        /// max sample rate for the das
+        /// </summary>
+        /// <returns></returns>
+        uint MaxSampleRate(int numberOfConfiguredChannels);
+        uint MaxAAFilterRate();
+
+        bool SupportsAutoArm();
+
+        bool SupportsLevelTrigger();
+
+        bool SupportsRealtime();
+
+        bool SupportsMultipleEvents();
+
+        /// <summary>
+        /// returns true if the device supports trigger completion inversion or not
+        /// </summary>
+        /// <returns>true if the device supports trigger completion inversion, false otherwise</returns>
+        bool SupportsTriggerInversion();
+        bool InvertTrigger { set; }
+
+        /// <summary>
+        /// returns true if the device supports start completion inversion or not
+        /// </summary>
+        /// <returns>returns true if the device supports start completion inversion, false otherwise</returns>
+        bool SupportsStartInversion();
+        bool InvertStart { get; set; }
+
+        bool IgnoreShortedStart { get; set; }
+        bool IgnoreShortedTrigger { get; set; }
+
+        /// <summary>
+        /// SLICE Base firmware supports checking the trigger and start lines as of protocol 7,
+        /// this function returns whether the hardware supports checking input status or not
+        /// </summary>
+        /// <returns></returns>
+        bool SupportsHardwareInputCheck();
+        /// <summary>
+        /// whether to use multiple sample real time or not
+        /// for sliceware there are times we need to turn off multiple sample realtime
+        /// (like when using a slicedb for instance)
+        /// </summary>
+        /// <returns></returns>
+        bool SupportsMultipleSampleRealtime();
+        /// <summary>
+        /// whether the DASbase actually controls the DAQ for modules
+        /// in the case of TDAS, the modules actually are responsible for the DAQ and the
+        /// rack is just a middleman
+        /// this is relevant because if the DAQ is controlled by the base then the sample numbers
+        /// should match for all modules.
+        /// </summary>
+        /// <returns></returns>
+        bool ControlsDAQ();
+        /// <summary>
+        /// returns if the new AAF rate is acceptible or not
+        /// right now this is only used to handle SLICE2 and it's multiple rate tables
+        /// it does this by comparing the AAF rate that the unit was configured with against the new rate
+        /// </summary>
+        /// <param name="rate">new AAF rate</param>
+        /// <returns></returns>
+        bool CheckAAF(float rate);
+
+        bool RequireDiagnosticRateMatchSampleRate();
+
+        /// <summary>
+        /// returns the phase delay in samples given a module index, a sample rate, and a 
+        /// Hardware AAF
+        /// some DAS may have one phase delay across all modules, some may have separate phase delays for
+        /// individual module types.
+        /// 
+        /// for now most systems will just return 0 for the phase shift samples as the amount of delay
+        /// is only know for a very small number of DAS types
+        /// </summary>
+        /// <param name="ModuleIndex">module to query</param>
+        /// <param name="ActualSampleRate">actual sample rate of data collection</param>
+        /// <param name="HardwareAAF">actual rate of Hardware AAF, this is the sum of
+        /// fixed and variable AAFs
+        /// </param>
+        /// <returns></returns>
+        ulong GetPhaseShiftSamples(uint ModuleIndex, double ActualSampleRate, uint HardwareAAF, ulong originalT0);
+
+        /// <summary>
+        /// returns true if the devices is an ethernet distributor
+        /// for now that is SLICEDb, SLICE ECM, SLICE6DB
+        /// these are devices that we talk through, but not to for device communication
+        /// a rack we communicate with the modules by talking to the rack, so it's not a distributor
+        /// </summary>
+        /// <returns>returns true if the devices is an ethernet distributor</returns>
+        bool IsEthernetDistributor();
+
+        /// <summary>
+        /// returns true if the unit is capable of reading arm status
+        ///	17800 Trigger status is "waiting" but PPRO has indeed triggered
+        /// </summary>
+        /// <returns></returns>
+        bool GetCanCheckArmStatus();
+        /// <summary>
+        /// returns true if the device is a SLICE6DB, originally for the purpose
+        /// of knowing when we should download values from external temperature sensors
+        /// </summary>
+        /// <returns></returns>
+        bool IsSlice6Distributor();
+
+        bool IsBattery();
+
+        bool IsTSRAIR();
+
+        bool IsSlice6Air();
+
+        string MACAddress { get; set; }
+        string[] DownstreamMACAddresses { get; set; }
+        /// <summary>
+        /// Indicates that the unit supports selectable channels for realtime streaming
+        /// this is for 10572 implement SW side for single command streaming realtime
+        /// only SPS supports this currently
+        /// </summary>
+        bool SupportsIndividualChannelRealtimeStreaming { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IDASConfigurationArg.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    /// <summary>
+	/// describes the argument to configuration events
+	/// 17872 Use DASConfig XMLs on disk when performing an emergency download with DAS that have blank filestore(s)
+	/// </summary>
+    public interface IDASConfigurationArg
+    {
+        IDASCommunication DAS { get; }
+        bool BlankConfigurationRead { get; }
+        bool ConfigurationFailedValidation { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IDASFactory.cs

@@ -0,0 +1,53 @@
+using DTS.Common.Interface.StatusAndProgressBar;
+using DTS.Common.Utilities;
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IDASFactory
+    {
+        bool PingAll();
+        string Language { get; set; }
+        void TakeOwnership();
+        bool AllowSDBCommandPort { get; set; }
+        double S6ConnectNewTimeout { get; set; }
+        string [] SliceDBHostNames{ get;set; }
+        string[] GetConnectedDevices();
+        /// <summary>
+        /// TDAS Host Names 
+        /// </summary>
+        string [] TDASHostNames { get; set; }
+
+        string[] TDASSerialPortNames { get; set; }
+
+        string TDASSerialRackSerialNumber { get; set; }
+
+        /// <summary>
+        /// gets a list of all connected DAS devices.
+        /// </summary>
+        /// <returns>List of all connected DAS hardware</returns>
+        List<IDASCommunication> GetDASList();
+
+        List<IDASCommunication> GetSortedDASList();
+        /// <summary>
+        /// Retrieves the ICommunication object of all hardware currently connected.
+        /// </summary>
+        /// <returns>List of ICommunications representing all hardware connected.</returns>
+        List<ICommunication> GetDevList();
+        /// <summary>
+        /// Make DASFactory forget about all devices.
+        /// </summary>
+        void DetachAllDevices(bool detachUSB = false);
+
+        /// <summary>
+        /// Initiate a refresh of the DASFactory (i.e. make sure GetDASList() reflects what's actually connected)
+        /// </summary>
+        /// <param name="action">The action to perform when the refresh is done</param>
+        void Refresh(ActionCompleteDelegate action);
+        /// <summary>
+        /// configures the default timeout in ms for Multicast auto discovery receive functions
+        /// </summary>
+        int MultiCastAutoDiscoveryDefaultTimeoutMS { get; set; }
+        SortableBindingList<IDiscoveredDevice> AutoDiscoverMulticast(bool discoverParents = true);
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IDiscoveredDevice.cs

@@ -0,0 +1,102 @@
+using System.Collections.Generic;
+using static DTS.Common.Enums.DASFactory.DFConstantsAndEnums;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IDiscoveredDevice
+    {
+        /// <summary>
+        /// Device Serial Number
+        /// </summary>
+        string Serial { get; set; }
+        MultiCastDeviceClasses DevClass { get; set; }
+        /// <summary>
+        /// Device Mac
+        /// </summary>
+        string Mac { get; set; }
+
+        IDiscoveredDevice Parent { get; set; }
+        bool IsParent(IDiscoveredDevice possibleChild);
+        int GetPort(IDiscoveredDevice device);
+        int GetSlot(IDiscoveredDevice child, Dictionary<string, IDiscoveredDevice> lookup);
+        int GetSlotOnPort(IDiscoveredDevice child, Dictionary<string, IDiscoveredDevice> lookup);
+        bool IsModule { get; set; }        
+
+        /// <summary>
+        /// if I'm on a SLICE6DB, what port am I on
+        /// </summary>
+        int Port { get; set; }
+        /// <summary>
+        /// starting at the first device in the chain on the first point, up until the last device on the last chain/port, where is this device
+        /// this is used to as we don't show SLICE6 devices when on a SLICE6Db, but we still need to know which devices is where for showing
+        /// the channels in the UI
+        /// </summary>
+        int PositionOnDistributor { get; set; }
+        /// <summary>
+        /// where is this device in a chain of devices, only used for SLICE6 on a SLICE6Db right now
+        /// </summary>
+        int PositionOnChain { get; set; }
+        /// <summary>
+        /// Is DHCP enabled
+        /// </summary>
+        bool Dhcp { get; set; }
+
+        /// <summary>
+        /// Device IP
+        /// </summary>
+        string Ip { get; set; }
+
+        /// <summary>
+        /// Device Subnet
+        /// </summary>
+        string Subnet { get; set; }
+        
+        /// <summary>
+        /// Device Gateway
+        /// </summary>
+        string Gateway { get; set; }
+        
+        /// <summary>
+        ///  Device DNS Sever
+        /// </summary>
+        string Dns { get; set; }
+
+        /// <summary>
+        ///  Is Device connected to another host
+        /// </summary>
+        bool Connected { get; set; }
+
+        /// <summary>
+        /// Host IP that device is connected to
+        /// </summary>
+        string ConnectedIp { get; set; }
+
+        /// <summary>
+        /// Host Name Resolution that device is connected to
+        /// </summary>
+        string ConnectedHost { get; set; }
+
+        /// <summary>
+        /// User entry for Distributor ID that device is connected to
+        /// </summary>
+        ushort SystemId { get; set; }
+
+        /// <summary>
+        /// User entry for location of device
+        /// </summary>
+        string Location { get; set; }
+
+        /// <summary>
+        /// Firmware version string
+        /// [Product Name]-[FW/BL]-[REL/DBG]-[Board #]-[FW Ver Name]
+        /// </summary>
+        string FirmwareVersion { get; set; }
+
+        /// <summary>
+        /// Build Server number for the firmware
+        /// </summary>
+        string BuildId { get; set; }        
+        
+        IConnectedEthernetDevice [] Connections { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IRangeBandwidthLimited.cs

@@ -0,0 +1,7 @@
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IRangeBandwidthLimited
+    {
+        bool RangeBandwidthLimited { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IRealtime.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    /// <summary>
+    /// RealTime Interface for an DAS unit.
+    /// </summary>
+    public interface IRealTime
+    {
+        /// <summary>
+        /// The list of channels from which to recieve Real Time Data.
+        /// </summary>
+        List<int> RealtimeDASChannels { get; set; }
+        
+        /// <summary>
+        /// The Slice6 Axis 1, 2, 3 (X, Y, Z) tilt data in degrees.
+        /// </summary>
+        List<double> TiltAxisData { get; set; }
+        /// <summary>
+        /// The S6/S6A realtime UDP stream address.
+        /// </summary>
+        string UDPStreamAddress { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/ITiltSensorCalAware.cs

@@ -0,0 +1,7 @@
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface ITiltSensorCalAware
+    {
+        double [] TiltSensorCals { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/ITimeSynchronization.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface ITimeSynchronization
+    {
+        bool SupportsTimeSynchronization { get; }
+        DateTime SystemBaseTime { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DASFactory/IUDPQATSEntry.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace DTS.Common.Interface.DASFactory
+{
+    public interface IUDPQATSEntry
+    {
+        string ResponseHostMac { get; }
+        string ResponseClientMacAddress { get; }
+        string SerialNumber { get; }
+        byte ArmState { get; }
+        byte ArmMode { get; }
+        byte Started { get; }
+        byte Triggered { get; }
+        byte FaultFlags { get; }
+        uint SampleRate { get; }
+        ulong TotalSamples { get; }
+        ulong CurrentSample { get; }
+        ushort EventNumber { get; }
+        ulong FaultSampleNumber { get; }
+        ushort LegacyFaultFlags { get; }
+        float InputVoltage { get; }
+        float BackupVoltage { get; }
+        float BatterySOC { get; }
+        ulong EstimateMaxSamples { get; }
+        short TiltSensorCh1 { get; }
+        short TiltSensorCh2 { get; }
+        short TiltSensorCh3 { get; }
+        float SysTempC { get; }
+        byte SyncClockEnable { get; }
+        byte ADCExtClockSyncEnable { get; }
+        byte SyncClockStatus { get; }
+        byte ADCExtClockSyncStatus { get; }
+        ulong EventTriggerSample { get; }
+        float [] ChannelOffsetMV { get; }
+
+        float [] ShuntDeviationPercent { get; }
+        DateTime Timestamp { get; }
+    }
+}