init

Common/DTS.CommonCore/Interface/BuildTestSetup/IBuildTestSetup.cs

@@ -0,0 +1,95 @@
+using System.ComponentModel;
+using System.Collections.Generic;
+using DTS.Common.XMLUtils;
+
+namespace DTS.Common.Interface.BuildTestSetup
+{
+    public interface IBuildTestSetup : INotifyPropertyChanged
+    {
+        string DASSerialNumber { get; set; }
+        string SetupName { get; set; }
+        string SetupDescription { get; set; }
+        string AutomaticMode { get; set; }
+        string AutomaticModeDelay { get; set; }
+        string WarnOnBatteryFail { get; set; }
+        string ViewRealtime { get; set; }
+        string RecordingMode { get; set; }
+        string SamplesPerSecond { get; set; }
+        string PreTriggerSeconds { get; set; }
+        string PostTriggerSeconds { get; set; }
+        string NumberOfEvents { get; set; }
+        string WakeUpMotionTimeout { get; set; }
+        string StrictDiagnostics { get; set; }
+        string RequireConfirmationOnErrors { get; set; }
+        string AllowSensorIdToBlankChannel { get; set; }
+        string ExcitationWarmupTimeMS { get; set; }
+        string PerformArmChecklist { get; set; }
+        string CheckInputVoltage { get; set; }
+        string CheckBatteryVoltage { get; set; }
+        string CheckSquibResistance { get; set; }
+        string CheckSensorIds { get; set; }
+        string CheckStartEventLines { get; set; }
+        string CheckTiltSensor { get; set; }
+        string CheckTemperature { get; set; }
+        string RequireAllUnitsPassArmCheckList { get; set; }
+        string ROIDownload { get; set; }
+        string ViewROIDownload { get; set; }
+        string DownloadAll { get; set; }
+        string RealtimeCharts { get; set; }
+        string ROIStart { get; set; }
+        string ROIEnd { get; set; }
+        string ViewDownloadAll { get; set; }
+        string Export { get; set; }
+        //string ExportFormat { get; set; }
+        string UseLabDetails { get; set; }
+        string UseCustomerDetails { get; set; }
+        string AllowMissingSensors { get; set; }
+        string LastModified { get; set; }
+        string LastModifiedBy { get; set; }
+        string PostTestDiagnostics { get; set; }
+        string UserTags { get; set; }
+        string CalibrationBehavior { get; set; }
+        string SuppressMissingSensorsWarning { get; set; }
+        string NotAllChannelsRealTime { get; set; }
+        string NotAllChannelsViewer { get; set; }
+        string TriggerCheckStep { get; set; }
+        string QuitTestWithoutWarning { get; set; }
+        string ExportFolder { get; set; }
+        string ExportCh10FilteredEUDesired { get; set; }
+        //string ExportCh10UnfilteredEUDesired { get; set; }
+        string ExportChryslerDDASDesired { get; set; }
+        string ExportCSVADCDesired { get; set; }
+        string ExportCSVFilteredDesired { get; set; }
+        string ExportCSVMVDesired { get; set; }
+        string ExportCSVUnfilteredDesired { get; set; }
+        string ExportDiademADCDesired { get; set; }
+        string ExportHDFADCDesired { get; set; }
+        //string ExportHDFFilteredDesired { get; set; }
+        string ExportHDFMVDesired { get; set; }
+        string ExportHDFUnfilteredDesired { get; set; }
+        string ExportISOFilteredDesired { get; set; }
+        string ExportISOUnfilteredDesired { get; set; }
+        string ExportRDFADCDesired { get; set; }
+        //string ExportSomatFilteredDesired { get; set; }
+        //string ExportSomatUnfilteredDesired { get; set; }
+        string ExportTDASADCDesired { get; set; }
+        string ExportTDMSADCDesired { get; set; }
+        //string ExportToyotaFilteredDesired { get; set; }
+        string ExportToyotaUnfilteredDesired { get; set; }
+        string ExportTSVFilteredDesired { get; set; }
+        string ExportTSVUnfilteredDesired { get; set; }
+        string ExportXLSXFilteredDesired { get; set; }
+        string ExportXLSXUnfilteredDesired { get; set; }
+        string ExportASCDesired { get; set; }
+        string DownloadFolder { get; set; }
+        string CommonStatusLine { get; set; }
+        string UploadData { get; set; }
+        string UploadDataFolder { get; set; }
+        string UseTestEngineerDetails { get; set; }
+        string AutoArm { get; set; }
+        string Streaming { get; set; }
+        string MeasureSquibResistances { get; set; }
+
+        List<GroupXMLClass> Groups {get; set;}
+    }
+}

Common/DTS.CommonCore/Interface/Channels/ChannelCodes/IChannelCode.cs

@@ -0,0 +1,40 @@
+using System.Windows.Input;
+using DTS.Common.Enums;
+using DTS.Common.Enums.Channels;
+
+namespace DTS.Common.Interface.Channels.ChannelCodes
+{
+    /// <summary>
+    /// used to describe the behavior of channelcodes for the UI
+    /// </summary>
+    public interface IChannelCode
+    {
+        /// <summary>
+        /// id of the channel code in the database
+        /// </summary>
+        int Id { get; }
+        /// <summary>
+        /// codevalue (either user code or isocode depending on codetype)
+        /// </summary>
+        string Code { get; set; }
+        /// <summary>
+        /// name associated with code (either user channel name or iso channel name)
+        /// </summary>
+        string Name { get; set; }
+        /// <summary>
+        /// the type of code (iso or user)
+        /// </summary>
+        ChannelEnumsAndConstants.ChannelCodeType CodeType { get; }
+        /// <summary>
+        /// handler for paste command
+        /// this is used for when data is pasted into either a channel code or name
+        /// it's needed because you can paste many rows, a CSV for example, into one field
+        /// </summary>
+        ICommand PasteCommand { get; set; }
+        /// <summary>
+        /// the status of the item in the UI
+        /// (failed/success/etc)
+        /// </summary>
+        UIItemStatus ItemStatus { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Channels/ChannelCodes/IChannelCodesListView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.Channels.ChannelCodes
+{
+    public interface IChannelCodesListView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Channels/ChannelCodes/IChannelCodesListViewModel.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using DTS.Common.Base;
+using DTS.Common.Enums;
+
+namespace DTS.Common.Interface.Channels.ChannelCodes
+{
+    public interface IChannelCodesListViewModel : IBaseViewModel
+    {        
+        IChannelCodesListView View { get; set; }
+        void Unset();
+        void SetPage(object page);
+        void OnSetActive();
+        bool Save();
+        ObservableCollection<IChannelCode> ISOChannelCodes { get; set; }
+        ObservableCollection<IChannelCode> UserChannelCodes { get; set; }
+        bool Validate(bool bDisplayWindow);
+        void CopySelected();
+        void DeleteSelected();
+        void Filter(object columnTag, string searchTerm);
+        void Sort(object columnTag, bool bColumnClick);
+        Func<IList<IChannelCode>> ChannelCodesFunc { get; }
+        bool ShowISOStringBuilder { get; set; }
+        bool UniqueISOCodesRequired { get; set; }
+        bool ShowChannelCodeLookupHelper { get; set; }
+        bool IsReadOnly { get; set; }
+        IChannelCode [] SelectedCodes { get; }
+    }    
+}

Common/DTS.CommonCore/Interface/Channels/IChannelCode.cs

@@ -0,0 +1,12 @@
+using DTS.Common.Enums.Channels;
+
+namespace DTS.Common.Interface.Channels
+{
+    public interface IChannelCode
+    {
+        int Id { get; }
+        string Code { get; }
+        string Name { get; }
+        ChannelEnumsAndConstants.ChannelCodeType CodeType { get; }
+    }
+}

Common/DTS.CommonCore/Interface/Channels/IChannelDbRecord.cs

@@ -0,0 +1,60 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System;
+
+namespace DTS.Common.Interface.Channels
+{
+    /// <summary>
+    /// Interface describing a Channel in the Db
+    /// </summary>
+    public interface IChannelDbRecord
+    {
+        [Key]
+        [Column("Id")]
+        /// <summary>
+        /// The id/key of the Channel record in the db
+        /// </summary>
+        long Id { get; set; }
+
+        [Column("GroupId")]
+        int GroupId { get; set; }
+
+        [Column("IsoCode")]
+        string IsoCode { get; set; }
+        
+        [Column("IsoChannelName")]
+        string IsoChannelName { get; set; }
+        
+        [Column("UserCode")]
+        string UserCode { get; set; }
+        
+        [Column("UserChannelName")]
+        string UserChannelName { get; set; }
+        
+        [Column("DASId")]
+        int DASId { get; set; }
+
+        [Column("DASChannelIndex")]
+        /// <summary>
+        /// The physical channel index of the channel among channels on the DAS
+        /// </summary>
+        int DASChannelIndex { get; set; }
+
+        [Column("GroupChannelOrder")]
+        int GroupChannelOrder { get; set; }
+
+        [Column("TestSetupOrder")]
+        int TestSetupOrder { get; set; }
+
+        int SensorId { get; set; }
+
+        [Column("Disabled")]
+        bool Disabled { get; set; }
+
+        [Column("LastModified")]
+        DateTime LastModified { get; set; }
+
+        [Column("LastModifiedBy")]
+        string LastModifiedBy { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Channels/IChannelSetting.cs

@@ -0,0 +1,15 @@
+namespace DTS.Common.Interface.Channels
+{
+    public interface IChannelSetting
+    {
+        long ChannelId { get; set; }
+        int SettingTypeId { get; }
+        string SettingName { get; }
+        string DefaultValue { get; }
+        string Value { get; set; }
+        int IntValue { get; set; }
+        double DoubleValue { get; set; }
+        bool BoolValue { get; set; }
+        IChannelSetting Clone();
+    }
+}

Common/DTS.CommonCore/Interface/Channels/IChannelSettingRecord.cs

@@ -0,0 +1,9 @@
+namespace DTS.Common.Interface.Channels
+{
+    public interface IChannelSettingRecord
+    {
+        int Id { get; set; }
+        string SettingName { get; set; }
+        string DefaultValue { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Channels/IGroupChannel.cs

@@ -0,0 +1,372 @@
+using DTS.Common.Interface.DataRecorders;
+using DTS.Common.Interface.Sensors.SensorsList;
+using System;
+using System.Windows.Input;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Enums;
+using DTS.Common.Interface.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Enums.Sensors.SensorsList;
+using DTS.Common.Classes.ChannelCodes;
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Interface.Sensors.SoftwareFilters;
+using System.IO.Ports;
+
+namespace DTS.Common.Interface.Channels
+{
+    public interface IGroupChannel : IComparable<IGroupChannel>, IChannelDbRecord
+    {
+        SensorConstants.AvailableRangesLowG RangeLowG { get; set; }
+        /// <summary>
+        /// whether the channel has a calibration less voltage measurement channel
+        /// </summary>
+        bool VoltageInsertionSensor { get; }
+        /// <summary>
+        /// Whether the channel has an embedded range modifiable low g sensor
+        /// </summary>
+        bool RangeModifiableSensorLowG { get; }
+        /// <summary>
+        /// whether the channel has an embedded range modifiable ars sensor
+        /// </summary>
+        bool RangeModifiableSensorARS { get; }
+        /// <summary>
+        /// available initial offsets for this channel
+        /// dependent on a sensor w/ a sensor calibration being assigned
+        /// </summary>
+        InitialOffset [] AvailableInitialOffsets { get; set; }
+        /// <summary>
+        /// current support for IEPE by channel
+        /// if there is a sensor assigned, value is depedent on sensor bridge
+        /// if there is no sensor but hardware is assigned, is dependent on hardwarechannel support
+        /// if neither is assigned, IEPE Is available to be assigned to the channel
+        /// </summary>
+        string IEPESupport { get; }
+        /// <summary>
+        /// the group the channel belongs to
+        /// </summary>
+        IGroup Group { get; set; }
+        /// <summary>
+        /// the name of the group (DisplayName) the channel belongs to
+        /// </summary>
+        string GroupName { get; set; }
+        /// <summary>
+        /// whether the group name is valid or not
+        /// </summary>
+        bool GroupNameValid{ get; set; }
+        /// <summary>
+        /// whether the isocode is set or not [does not examine iso code validity]
+        /// </summary>
+        bool IsoCodeValid { get; set; }
+        /// <summary>
+        /// whether the iso channel name is set or not
+        /// </summary>
+        bool IsoChannelNameValid { get; set; }
+        /// <summary>
+        /// whether the user code is set or not
+        /// </summary>
+        bool UserCodeValid { get; set; }
+        /// <summary>
+        /// whether the user channel name is set or not
+        /// </summary>
+        bool UserChannelNameValid { get; set; }
+        /// <summary>
+        /// whether the hardware has been set or not
+        /// </summary>
+        bool HardwareValid { get; }
+        /// <summary>
+        /// this is the old identifier for the hardware channel assigned
+        /// it's something in the form of [das serial]:[channel index]
+        /// I'm not sure why we have two hardware ids around and why this one is still around...
+        /// </summary>
+        string HardwareId { get; set; }
+        /// <summary>
+        /// stores the sample rate of the DAS associated with this channel
+        /// </summary>
+        double TestSampleRate { get; set; }
+        /// <summary>
+        /// whether the sensor has been set or not
+        /// </summary>
+        bool SensorValid { get; }
+        /// <summary>
+        /// whether the channel should be used for collecting data or not
+        /// </summary>
+        bool IsDisabled { get; set; }
+        void SetHardwareChannel(IHardwareChannel hardwareChannel);
+        void SetSensor(IDragAndDropItem sensor, IChannelSetting [] channelDefaults, bool applySensorDataToBlankChannels);
+        bool CompareValue(string property);
+        bool SetDifferent(string property);
+        void SetNotDifferent();
+        void SetRange(CACOption option);
+        bool CanMoveUp { get; set; }
+        bool CanMoveDown { get; set; }
+        bool DeleteShouldBeEnabled { get; set; }
+        System.Windows.Visibility RemoveSensorVisibility { get; set; }
+        /// <summary>
+        /// indicates whether the channel is a new non edited channel
+        /// </summary>
+        /// <returns></returns>
+        bool IsBlank();
+        /// <summary>
+        /// clears hardware and sensor assignments for channel
+        /// </summary>
+        void Clear();
+        /// <summary>
+        /// return true if channel contains the given term
+        /// </summary>
+        /// <param name="term"></param>
+        /// <returns></returns>
+        bool Filter(string term);
+        /// <summary>
+        /// what to do when something is pasted to the channel
+        /// </summary>
+        ICommand PasteCommand { get; set; }
+        /// <summary>
+        /// settings (range/polarity/ etc) for channel
+        /// </summary>
+        IChannelSetting [] ChannelSettings { get; set; }
+
+        /// <summary>
+        /// returns a channel name for channel based on view mode
+        /// </summary>
+        /// <param name="isoViewMode"></param>
+        /// <returns></returns>
+        string GetChannelName(IsoViewMode isoViewMode);
+        /// <summary>
+        /// returns a code for channel based on view mode
+        /// </summary>
+        /// <param name="isoViewMode"></param>
+        /// <returns></returns>
+        string GetChannelCode(IsoViewMode isoViewMode);
+        /// <summary>
+        /// creates a memory copy of channel
+        /// </summary>
+        /// <param name="groupChannel"></param>
+        void Copy(IGroupChannel groupChannel);
+
+        /// <summary>
+        /// string to display in UI for hardware
+        /// </summary>
+        string Hardware { get; set; }
+        /// <summary>
+        /// string to display in UI for sensor
+        /// </summary>
+        string Sensor { get; }
+        ISensorData SensorData{ get; }
+        IHardwareChannel HardwareChannel{ get; }
+        IDragAndDropItem DragAndDropItem { get; }
+        ISensorCalibration SensorCalibration{ get; }
+        void SetSensorCalibration(ISensorCalibration calibration);
+        void SetSensorData(ISensorData sensorData, IDragAndDropItem dragAndDropItem, bool decideSettings=false);
+
+        bool HasEID { get; }
+        /// <summary>
+        /// whether channel has an analog sensor assigned
+        /// if no sensor is assigned but the channel is not blank, returns true
+        /// returns false if channel is blank
+        /// </summary>
+        bool IsAnalog { get; }
+        /// <summary>
+        /// whether the channel has a squib sensor assigned
+        /// if no sensor is assigned but the channel is not blank, returns true
+        /// returns false if channel is blank
+        /// </summary>
+        bool IsSquib { get; }
+        /// <summary>
+        /// whether the channel has a digital input sensor assigned
+        /// if no sensor is assigned but the channel is not blank, returns true
+        /// returns false if channel is blank
+        /// </summary>
+        bool IsDigitalIn { get; }
+        /// <summary>
+        /// whether the channel has a digital output sensor assigned
+        /// if no sensor is assigned but the channel is not blank, returns true
+        /// returns false if channel is blank
+        /// </summary>
+        bool IsDigitalOut { get; }
+        /// <summary>
+        /// whether the channel is from a RTC module
+        /// returns false if channel is a normal phyiscal measurement channel
+        /// </summary>
+        bool IsClock { get; }
+        /// <summary>
+        /// whether the channel is from a UART module
+        /// returns false if channel is a normal phyiscal measurement channel
+        /// </summary>
+        bool IsUart { get; }
+        /// <summary>
+        /// whether the channel is from a stream in module
+        /// returns false if channel is a normal phyiscal measurement channel
+        /// </summary>
+        bool IsStreamIn { get; }
+        /// <summary>
+        /// whether the channel is from a stream out module
+        /// returns false if channel is a normal phyiscal measurement channel
+        /// </summary>
+        bool IsStreamOut { get; }
+        /// <summary>
+        /// range setting value for the channel
+        /// </summary>
+        double Range { get; set; }
+
+        /// <summary>
+        /// the capacity of the sensor on the channel
+        /// </summary>
+        double Capacity { get; }
+        /// <summary>
+        /// FB 13120 filter class setting value for the channel
+        /// </summary>
+        IFilterClass FilterClass { get; set; }
+        /// <summary>
+        /// polarity setting value for the channel
+        /// </summary>
+        string Polarity { get; set; }
+        string Units { get; }
+
+        ZeroMethodType ZeroMethod { get; set; }
+        double ZeroMethodStart { get; set; }
+        double ZeroMethodEnd { get; set; }
+        string Sensitivity { get; }        
+
+        InitialOffset InitialOffset { get; set; }
+
+        bool SquibLimitDuration { get; set; }
+        double SquibDuration { get; set; }
+        //14623 SquibDelay is nullable for UI perpose
+        double? SquibDelay { get; set; }
+
+        double SquibCurrent { get; set; }
+
+        bool DigitalOutLimitDuration { get; set; }
+        double DigitalOutDuration { get; set; }
+        //FB 28107 Define max value allowed for digital out duration
+        double DigitalOutDurationMax { get; set; }
+        double DigitalOutDelay { get; set; }        
+
+        /// <summary>
+        /// output mode setting value for the channel
+        /// </summary>
+        DigitalOutputModes DigitalOutputMode { get; set; }
+        /// <summary>
+        /// fire mode setting value for the channel
+        /// </summary>
+        SquibFireMode SquibFireMode { get; set; }
+        /// <summary>
+        /// digital input mode setting value for the channel
+        /// </summary>
+        DigitalInputModes DigitalInputMode { get; set; }
+        /// <summary>
+        /// active value setting value for the channel
+        /// </summary>
+        string ActiveValue { get; set; }
+        /// <summary>
+        /// default value setting value for the channel
+        /// </summary>
+        string DefaultValue { get; set; }
+        ///<summary>
+        /// baud rate setting value for the channel
+        ///</summary>
+        uint UartBaudRate { get; set; }
+        ///<summary>
+        /// data bits setting value for the channel
+        ///</summary>
+        uint UartDataBits { get; set; }
+        ///<summary>
+        /// stop bits setting value for the channel
+        ///</summary>
+        StopBits UartStopBits { get; set; }
+        ///<summary>
+        /// parity setting value for the channel
+        ///</summary>
+        Parity UartParity { get; set; }
+        ///<summary>
+        /// flow control setting value for the channel FB 30486 removed set, it's always NONE
+        ///</summary>
+        Handshake UartFlowControl { get; } 
+        ///<summary>
+        /// data format setting value for the channel
+        ///</summary>
+        UartDataFormat UartDataFormat { get; set; }
+        ///<summary>
+        /// udp address setting value for the channel
+        ///</summary>
+        string StreamInUDPAddress { get; set; }
+        ///<summary>
+        /// udp profile setting value for the channel
+        ///</summary>
+        UDPStreamProfile StreamOutUDPProfile { get; set; }
+        ///<summary>
+        /// udp address setting value for the channel
+        ///</summary>
+        string StreamOutUDPAddress { get; set; }
+        ///<summary>
+        /// time channel id setting value for the channel
+        ///</summary>
+        ushort StreamOutUDPTimeChannelId { get; set; }
+        ///<summary>
+        /// data channel id setting value for the channel
+        ///</summary>
+        ushort StreamOutUDPDataChannelId { get; set; }
+        ///<summary>
+        /// tmns config setting value for the channel
+        ///</summary>
+        string StreamOutUDPTmNSConfig { get; set; }
+        ///<summary>
+        /// irig data packet interval setting value for the channel
+        ///</summary>
+        ushort StreamOutIRIGTimeDataPacketIntervalMs { get; set; }
+        /// <summary>
+        /// time in ms between sending out TMATS information while streaming
+        /// http://manuscript.dts.local/f/cases/29987/Add-CG-DP-TMATS-interval-UI-support
+        /// </summary>
+        ushort StreamOutTMATSIntervalMs { get; set; }
+    /// <summary>
+    /// FB 15574 FB 13120
+    /// get the current FilterClass from the current isocode
+    /// </summary>
+    /// <param name="filters"></param>
+    /// <param name="isoCode"></param>
+    /// <returns></returns>
+    IFilterClass GetFilterClassFromISOCode(ISoftwareFilter[] filters, string isoCode);
+        /// <summary>
+        /// gets a function that will perform coercion on isocodes if needed
+        /// </summary>
+        CoerceISOCodeDelegate CoerceISOCodeFunc { get; }
+        /// <summary>
+        /// returns the status of the channel considering IsComplete and sensor cal status
+        /// </summary>
+        UIItemStatus ChannelStatus { get; }
+        /// <summary>
+        /// sets the channel settings based on a sensor's settings
+        /// </summary>
+        /// <param name="sd"></param>
+        void SetSettingsFromSensor(ISensorData sd);
+
+        /// <summary>
+        /// returns a list of sensor parameter differences from sensor vs channel
+        /// returns empty string if there aren't any
+        /// </summary>
+        /// <param name="sensor"></param>
+        /// <returns></returns>
+        string GetChangeList(ISensorData sensor);
+        bool IsRangeDifferent { get; set; }
+        bool IsFilterClassDifferent { get; set; }
+        bool IsPolarityDifferent { get; set; }
+        bool IsZeroMethodDifferent { get; set; }
+        bool IsZeroMethodStartDifferent { get; set; }
+        bool IsZeroMethodEndDifferent { get; set; }
+        bool IsInitialOffsetDifferent { get; set; }
+        bool IsSquibFireModeDifferent { get; set; }
+        bool IsSquibDelayDifferent { get; set; }
+        bool IsSquibLimitDurationDifferent { get; set; }
+        bool IsSquibDurationDifferent { get; set; }
+        bool IsSquibCurrentDifferent { get; set; }
+        bool IsDigitalOutputModeDifferent { get; set; }
+        bool IsDigitalOutDelayDifferent { get; set; }
+        bool IsDigitalOutLimitDurationDifferent { get; set; }
+        bool IsDigitalOutDurationDifferent { get; set; }
+        bool IsDigitalInputModeDifferent { get; set; }
+        bool IsDefaultValueDifferent { get; set; }
+        bool IsActiveValueDifferent { get; set; }
+        bool BorderShouldShowOutOfDate { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Channels/IGroupChannelSettingRecord.cs

@@ -0,0 +1,9 @@
+namespace DTS.Common.Interface.Channels
+{
+    public interface IGroupChannelSettingRecord
+    {
+        long ChannelId { get; set; }
+        int SettingId { get; set; }
+        string SettingValue { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/CheckChannels/ICheckChannelsMenuView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.RibbonControl;
+
+namespace DTS.Common.Interface
+{
+    public interface ICheckChannelsMenuView : IRibbonView { }
+}

Common/DTS.CommonCore/Interface/CheckChannels/ICheckChannelsMenuViewModel.cs

@@ -0,0 +1,6 @@
+using DTS.Common.RibbonControl;
+
+namespace DTS.Common.Interface
+{
+    public interface ICheckChannelsMenuViewModel : IRibbonViewModel { }
+}

Common/DTS.CommonCore/Interface/CheckChannels/ICheckChannelsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICheckChannelsView: IBaseView { }
+}

Common/DTS.CommonCore/Interface/CheckChannels/ICheckChannelsViewModel.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICheckChannelsViewModel : IBaseViewModel { }
+}

Common/DTS.CommonCore/Interface/CheckTrigger/ICheckTriggerView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICheckTriggerView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/CheckTrigger/ICheckTriggerViewModel.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICheckTriggerViewModel : IBaseViewModel { }
+}

Common/DTS.CommonCore/Interface/Communication/ICommunicationReport.cs

@@ -0,0 +1,11 @@
+using DTS.Common.Enums.Communication;
+
+namespace DTS.Common.Interface.Communication
+{
+    public interface ICommunicationReport
+    {
+        object UserState { get; set; }
+        CommunicationConstantsAndEnums.CommunicationResult Result { get; set; }
+        byte[] Data { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Communication/ICommunication_DASInfo.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace DTS.Common.Interface.Communication
+{
+    public interface ICommunication_DASInfo
+    {
+        /// <summary>
+        /// these are devices which are connected to the das
+        /// currently only used by SLICE6DB
+        /// </summary>
+        IDASConnectedDevice[] ConnectedDevices { get; }
+
+        /// <summary>
+        /// sets ConnectedDevices
+        /// </summary>
+        /// <param name="devices">devices connected to this das</param>
+        void SetConnectedDevices(IDASConnectedDevice[] devices);
+
+        string[] SerialNumbers { get; set; }
+        string[] FirmwareVersions { get; set; }
+        string StackSerialNumber(int devid); 
+        /// <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>
+        /// 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; }
+    }
+}

Common/DTS.CommonCore/Interface/Communication/IDASConnectedDevice.cs

@@ -0,0 +1,45 @@
+using DTS.Common.Enums.Hardware;
+using System.Net.NetworkInformation;
+
+namespace DTS.Common.Interface.Communication
+{
+    /// <summary>
+    /// part of 10582 Implement auto-discover and monitor DAS status.
+    /// this describes a device connected to a DAS, in particular S6 connected to a S6DB
+    /// </summary>
+    public interface IDASConnectedDevice
+    {
+        /// <summary>
+        /// the device type of the connected device
+        /// </summary>
+        HardwareTypes DeviceType { get; } 
+        /// <summary>
+        /// the port on the DAS which the device is on (0 based)
+        /// </summary>
+        int Port { get; }
+        /// <summary>
+        /// the spot on the chain or port the device is on (0 based)
+        /// </summary>
+        int SpotOnPort { get; }
+        /// <summary>
+        /// MAC Address or physical address
+        /// </summary>
+        PhysicalAddress PhysicalAddress{ get; }
+        /// <summary>
+        /// the IPAddress of the device
+        /// </summary>
+        string IPAddress{ get; }
+        /// <summary>
+        /// the serial number of the device
+        /// </summary>
+        string SerialNumber { get; }
+        /// <summary>
+        /// the location of the device
+        /// </summary>
+        string Location { get; }
+        /// <summary>
+        /// the version of the device
+        /// </summary>
+        string Version { get; }
+    }
+}

Common/DTS.CommonCore/Interface/Components/IAssemblyListView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IAssemblyListView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Components/IAssemblyListViewModel.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IAssemblyListViewModel : IBaseViewModel
+    {
+        IMainViewModel Parent { get; set; }
+        IAssemblyListView View { get; set; }
+        List<IAssemblyView> GroupList { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Components/IAssemblyView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IAssemblyView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Components/IAssemblyViewModel.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IAssemblyViewModel : IBaseViewModel
+    {
+        IAssemblyView View { get; set; }
+
+        string GroupName { get; set; }
+        List<AssemblyNameImage> AssemblyList { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Components/IGroupListView.cs

@@ -0,0 +1,6 @@
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface IGroupListView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Components/IGroupListViewModel.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface IGroupListViewModel : IBaseViewModel
+    {
+        IMainViewModel Parent { get; set; }
+        IGroupListView View { get; set; }
+        List<IGroupView> GroupList { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Components/IGroupView.cs

@@ -0,0 +1,6 @@
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface IGroupView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Components/IGroupViewModel.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface IGroupViewModel : IBaseViewModel
+    {
+        IGroupView View { get; set; }
+
+        string GroupName { get; set; }
+        List<AssemblyNameImage> AssemblyList { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Components/ITileListView.cs

@@ -0,0 +1,6 @@
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface ITileListView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Components/ITileListViewModel.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface ITileListViewModel : IBaseViewModel
+    {
+        IMainViewModel Parent { get; set; }
+        ITileListView View { get; set; }
+        List<ITileView> GroupList { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Components/ITileView.cs

@@ -0,0 +1,6 @@
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface ITileView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/Components/ITileViewModel.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Reflection;
+using DataPro.Common.Base;
+
+namespace DataPro.Common.Interface
+{
+    public interface ITileViewModel : IBaseViewModel
+    {
+        ITileView View { get; set; }
+
+        string GroupName { get; set; }
+        List<AssemblyNameImage> AssemblyList { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Connection/IConnection.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Interface.Connection
+{
+    public interface IConnection: IDisposable
+    {
+        Task<int> SendAsync(byte[] sendBuffer,
+            int bufferStartOffset,
+            int bufferSizeToSend);
+        /// <summary>
+        /// returns true if the unit is soft disconnected
+        /// soft disconnected means we've connected then voluntarily disconnected with the expectation of reconnecting
+        /// </summary>
+        bool IsSoftDisconnected{ get; }
+        /// <summary>
+        /// soft disconnects the unit (voluntarily disconnect with the intention of reconnecting later)
+        /// </summary>
+        void SoftDisconnect();
+        /// <summary>
+        /// reconnects a soft disconnected unit
+        /// </summary>
+        void SoftConnect();
+
+        System.Net.Sockets.SocketFlags Flags { get; set; }
+
+        event EventHandler OnDisconnected;
+		// indicates that the device has not received a timely response to keep-alive
+        void KeepAliveErrorReceived();
+        string ConnectString { get; }
+
+        bool Connected { get; }
+
+        void Create(string connectString);
+        void Create(string connectString, string hostIPAddress);
+
+        string GetConnectionData();
+
+        IAsyncResult BeginConnect(AsyncCallback callback, object callbackObject);
+
+        void EndConnect(IAsyncResult ar);
+
+        IAsyncResult BeginDisconnect(bool reuseSocket, AsyncCallback callback, object state);
+
+        void EndDisconnect(IAsyncResult asyncResult);
+
+        IAsyncResult BeginAccept(AsyncCallback callback,
+                                 object state);
+
+        IConnection EndAccept(IAsyncResult asyncResult);
+
+        void Bind(int port);
+
+        void Listen(int backlog);
+
+        IAsyncResult BeginSend(byte[] sendBuffer,
+                               int bufferStartOffset,
+                               int bufferSizeToSend,
+                               AsyncCallback callback,
+                               object callbackObject);
+
+        int EndSend(IAsyncResult ar);
+
+        IAsyncResult BeginReceive(byte[] receiveBuffer,
+                                  int bufferStartOffset,
+                                  int maxSizeToReceive,
+                                  AsyncCallback callback,
+                                  object callbackObject);
+
+        int EndReceive(IAsyncResult ar);
+
+        ///// <summary>
+        ///// current upload rate in b/s
+        ///// </summary>
+        ///// <returns></returns>
+        //double GetCurrentUploadRate();
+        ///// <summary>
+        ///// current download rate in b/s
+        ///// </summary>
+        ///// <returns></returns>
+        //double GetCurrentDownloadRate();
+    }
+}

Common/DTS.CommonCore/Interface/CustomChannels/ICustomChannelModel.cs

@@ -0,0 +1,8 @@
+namespace DTS.Common.Interface.CustomChannels
+{
+    public interface ICustomChannelModel
+    {
+        string Name { get; }
+        bool Included { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/CustomChannels/ICustomChannelsExportView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.CustomChannels
+{
+    public interface ICustomChannelsExportView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/CustomChannels/ICustomChannelsImportView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.CustomChannels
+{
+    public interface ICustomChannelsImportView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/CustomChannels/ICustomChannelsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICustomChannelsView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/CustomChannels/ICustomChannelsViewModel.cs

@@ -0,0 +1,27 @@
+using System.Collections.ObjectModel;
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface.CustomChannels
+{
+    public interface ICustomChannelsViewModel : IBaseViewModel
+    {
+        ICustomChannelsImportView ImportView { get; set; }
+        ICustomChannelsExportView ExportView { get; set; }
+
+        void Unset();
+
+        void OnSetActive(bool bImport);
+
+        string ExportFileName { get; set; }
+        string ImportFileName { get; set; }
+        void ReadImportFile();
+
+        ObservableCollection<ICustomChannelModel> AllCustomChannels { get; }
+
+        void SelectAll();
+        void ClearSelection();
+
+        void Export();
+        void Import();
+    }
+}

Common/DTS.CommonCore/Interface/CustomerDetails/ICustomerDetailsView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICustomerDetailsView :IBaseView { }
+}

Common/DTS.CommonCore/Interface/CustomerDetails/ICustomerDetailsViewModel.cs

@@ -0,0 +1,8 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICustomerDetailsViewModel : IBaseViewModel
+    {
+    }
+}

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

Common/DTS.CommonCore/Interface/DTS.Common.CPU/IcpuEngine.cs

@@ -0,0 +1,8 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface ICPUEngine : IBaseClass
+    {
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/CalculatedChannel/IAddCalculatedChannelView.cs

@@ -0,0 +1,7 @@
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IAddCalculatedChannelView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/CalculatedChannel/IAddCalculatedChannelViewModel.cs

@@ -0,0 +1,21 @@
+using DTS.Common.Base;
+using System.Windows.Input;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IAddCalculatedChannelViewModel : IBaseViewModel
+    {         
+        /// <summary>
+        /// Gets the Search View.
+        /// </summary>
+        IBaseView View { get; set; }
+        IBaseViewModel Parent { get; set; }
+        void PublishChanges();
+        bool IncludeGroupNameInISOExport { get; set; }
+
+        int DefaultDTSEncoding { get; set; }
+        ICommand AddCalculatedChannelCommand { get; }
+        object ContextSearchRegion { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/ChartOptions/IChartOptionsModel.cs

@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using System.Windows.Input;
+using DTS.Common.Base;
+using DTS.Common.Enums.Viewer;
+using DTS.Common.Interface.Sensors.SoftwareFilters;
+using Microsoft.Practices.Prism.Commands;
+
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IChartOptionsModel : IBaseModel
+    {
+	    /// <summary>
+		/// true if all channels support ADC
+		/// </summary>
+        bool SupportsADC { get; set; }
+		/// <summary>
+		/// true if all channels support mV
+		/// </summary>
+        bool SupportsMV { get; set; }
+        /// <summary>
+        /// indicates if current mV option is for Volts or mV
+        /// </summary>
+        bool DisplayingVolts { get; set; }
+        /// <summary>
+        /// returns mV or V depending on DisplayingVolts value
+        /// </summary>
+        string MVOrV { get; }
+        List<double> FullScaleValues { get; set; }
+        double SelectedFullScaleValue { get; set; }
+        double MinFixedY { get; set; }
+        double MaxFixedY { get; set; }
+        bool LockedT { get; set; }
+        bool LockedY { get; set; }
+        double MinFixedT { get; set; }
+        double MaxFixedT { get; set; }
+        bool ShowCursor { get; set; }
+        string CurrentCursorValues { get; set; }
+        YRangeScaleEnum YRange { get; set; }
+        ChartUnitTypeEnum UnitType { get; set; }
+        TimeUnitTypeEnum TimeUnitType { get; set; }
+        string UnitTypeDescription { get; }
+        FilterOptionEnum Filter { get; set; }
+        //FB 13120 Updated to use IFilterClass 
+        IFilterClass SelectedFilter { get; set; }
+        IChartOptionsViewModel Parent { get; set; }
+        bool IsCursorsAvailable { get; set; }
+        bool CanPublishChanges { get; set; }
+        bool ReadData { get; set; }
+        DelegateCommand ResetZoomCommand { get; }
+        DelegateCommand ResetTCommand { get; }
+        DelegateCommand SaveToPDFCommand { get; }
+        bool IsDigitalChannel { get; set; }
+        bool DecimateData { get; set; }
+        long WidthPoints { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/ChartOptions/IChartOptionsView.cs

@@ -0,0 +1,7 @@
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IChartOptionsView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/ChartOptions/IChartOptionsViewModel.cs

@@ -0,0 +1,22 @@
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IChartOptionsViewModel : IBaseViewModel
+    {         
+        /// <summary>
+        /// Gets the Search View.
+        /// </summary>
+        IBaseView View { get; set; }
+        IBaseViewModel Parent { get; set; }
+        IChartOptionsModel Model { get; set; }
+        void PublishChanges();
+        void ResetZoomMethod();
+        void ResetTMethod();
+        void SaveToPDFMethod();
+        void ShowCusor(bool value);
+        void ShowMinMaxCursor(bool value);
+        object ContextSearchRegion { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Filter/IFilterView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IFilterView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Filter/IFilterViewModel.cs

@@ -0,0 +1,16 @@
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IFilterViewModel : IBaseViewModel
+    {         
+        /// <summary>
+        /// Gets the Search View.
+        /// </summary>
+        IBaseView View { get; set; }
+        IBaseViewModel Parent { get; set; }
+
+        object ContextSearchRegion { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphChannelView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphChannelView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphChannelViewModel.cs

@@ -0,0 +1,18 @@
+using System.Collections.ObjectModel;
+using DTS.Common.Base;
+using DTS.Common.Classes.Viewer.TestMetadata;
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphChannelViewModel : IBaseViewModel
+    {
+        /// <summary>
+        /// Gets the Tab View.
+        /// </summary>
+        IGraphChannelView View { get; }
+        ObservableCollection<ITestChannel> GraphChannelList { get; set; }
+        ObservableCollection<ITestChannel> SelectedGraphChannelList { get; set; }
+        TestChannel SelectedGraphChannel { get; set; }
+
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphMainView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphMainView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphMainViewModel.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphMainViewModel : IBaseViewModel
+    {
+        /// <summary>
+        /// Gets the Graph Main View.
+        /// </summary>
+        IGraphMainView View { get; set; }
+        IBaseViewModel Parent { get; set; }
+        List<ITestChannel> LockedChannelList { get; set; }
+        List<ITestChannel> SelectedChannelList { get; set; }
+        string LockedGroupName { get; set; }
+        void PublishSelectedChannels();
+        void AddSelectedChannel(ITestChannel channel);
+        void AddSelectedGroupChannels(string groupName, List<ITestChannel> channels);
+        void AddLockedChannel(ITestChannel channel, bool isLocked);
+        void AddLockedGroupChannels(string testName, string groupName, List<ITestChannel> channels, bool isLocked);
+        void GraphList_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e);
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphPropertyView.cs

@@ -0,0 +1,6 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphPropertyView : IBaseView { }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphPropertyViewModel.cs

@@ -0,0 +1,12 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphPropertyViewModel : IBaseViewModel
+    {
+        /// <summary>
+        /// Gets the Tab View.
+        /// </summary>
+        IGraphPropertyView View { get; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphView.cs

@@ -0,0 +1,13 @@
+using System.Collections.ObjectModel;
+using DTS.Common.Base;
+using DTS.Common.Interface;
+
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphView : IBaseView
+    {
+        //void SetGraphs(ObservableCollection<ITestDataSeries> graphs);
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/IGraphViewModel.cs

@@ -0,0 +1,13 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IGraphViewModel : IBaseViewModel
+    {
+        /// <summary>
+        /// Gets the Tab View.
+        /// </summary>
+        IGraphView View { get; }
+        ITestDataSeriesView DataSeriesView { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/ITestDataSeries.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Windows.Media;
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface ITestDataSeries : IBaseModel
+    {
+        string TestGroup { get; set; }
+        string TestSetupName { get; set; }
+
+        string TestId { get; set; }
+        string ChannelId { get; set; }
+        double[] Xvalue { get; set; }
+        double[] Yvalue { get; set; }
+        Brush GraphColor { get; set; }
+
+        string HardwareChannel { get; set; }
+        string Bridge { get; set; }
+        string GroupName { get; set; }
+        string SWAAF { get; set; }
+        string HWAAF { get; set; }
+        string SampleRate { get; set; }
+        string ISOCode { get; set; }
+        string ISOChannelName { get; set; }
+        string UserCode { get; set; }
+        string UserChannelName { get; set; }
+        string ChannelName { get; set; }
+        string Description { get; }
+        string SensorSN { get; set; }
+        string SensorSNDisplay { get; }
+        string EngineeringUnits { get; set; }
+        string Excitation { get; set; }
+        string Polarity { get; set; }
+        string MinY { get; }
+        string MaxY { get; }
+        string AvgY { get; }
+        string StdDevY { get; }
+        string T0EUValue { get; }
+        /// <summary>
+        /// represents the peak frequency in series according to
+        /// magnitude
+        /// only populated when FFT is true
+        /// </summary>
+        double PeakFrequency { get; }
+        /// <summary>
+        /// represents the peak magnitude of frequencies in data set
+        /// only populated when FFT is true
+        /// </summary<
+        double PeakMagnitude { get; }
+        string RecordingMode { get; set; }
+        bool HIC { get; }
+        string HICValue { get; }
+        string T1Time { get; }
+        string T2Time { get; }
+        /// <summary>
+        /// is true if the series is an FFT of signal data
+        /// </summary>
+        bool FFT { get; }
+        /// <summary>
+        /// holds the root-mean-squared acceleration
+        /// only calculated in PSD results graphs
+        /// </summary>
+        double GRMS { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/DTS.Viewer/Graphs/ITestDataSeriesView.cs

@@ -0,0 +1,13 @@
+using DTS.Common.Base;
+using DTS.Common.Events;
+
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface ITestDataSeriesView : IBaseView
+    {
+        bool SaveReportToPDF(string directory);
+        bool SaveReportToCSV(string directory);
+    }
+}