init

Common/DTS.CommonCore/Interface/Hardware/AddEditHardware/IAddEditHardwareDASModule.cs

@@ -0,0 +1,24 @@
+using DTS.Common.Enums.Hardware;
+using System.Windows.Media;
+
+namespace DTS.Common.Interface.Hardware.AddEditHardware
+{
+    /// <summary>
+    /// describes interface used in AddEditHardware
+    /// </summary>
+    public interface IAddEditHardwareDASModule
+    {
+        HardwareTypes ModuleType { get; set; }
+        string SerialNumber { get; set; }
+        /// <summary>
+        /// an image representing the das
+        /// </summary>
+        ImageSource DASImage { get; }
+        IAddEditHardwareHardware OwningHardware { get; set; }
+        SLICEBridgeTypes SLICEBridgeType { get; set; }
+        /// <summary>
+        /// returns the prefix for any modules of this moduletype
+        /// </summary>
+        string GetSerialNumberPrefix();
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/AddEditHardware/IAddEditHardwareHardware.cs

@@ -0,0 +1,71 @@
+using DTS.Common.Enums.Hardware;
+using DTS.Common.Interface.DASFactory.Diagnostics;
+using System.Collections.ObjectModel;
+using System.Windows.Media;
+
+namespace DTS.Common.Interface.Hardware.AddEditHardware
+{
+    /// <summary>
+    /// describes interface used in AddEditHardware
+    /// </summary>
+    public interface IAddEditHardwareHardware
+    {
+        /// <summary>
+        /// the das type
+        /// </summary>
+        HardwareTypes HardwareType{ get; set; }
+        /// <summary>
+        /// the serial number for the das
+        /// </summary>
+        string SerialNumber { get; set; }
+        /// <summary>
+        /// the firmware version of the das
+        /// </summary>
+        string FirmwareVersion { get; set; }
+        /// <summary>
+        /// the ipaddress of the das (if supported)
+        /// </summary>
+        string IPAddress { get; set; }
+        /// <summary>
+        /// whether the das supports an ip address
+        /// </summary>
+        bool SupportsIPAddress { get; }
+        /// <summary>
+        /// whether the das supports rack sizes
+        /// </summary>
+        bool SupportsRackSize { get; }
+        /// <summary>
+        /// the configuration of the das (if supported)
+        /// </summary>
+        bool SupportsConfiguration { get; }
+        /// <summary>
+        /// the configuration of the das
+        /// </summary>
+        SLICEConfigurations SLICEConfiguration { get; set; }
+        /// <summary>
+        /// the size of the rack (if supported)
+        /// </summary>
+        RackSizes RackSize { get; set; }
+        /// <summary>
+        /// an image representing the das
+        /// </summary>
+        ImageSource DASImage { get; }
+
+        ObservableCollection<IAddEditHardwareDASModule> Modules { get; set; }
+        void RemoveModule(IAddEditHardwareDASModule module);
+        void AddModule();
+        /// <summary>
+        /// returns a new ISOHardware representation of the hardware
+        /// </summary>
+        IISOHardware ToISOHardware();
+        /// <summary>
+        /// whether this is actual physical hardware or just stand in hardware/not real hardware
+        /// </summary>
+        bool StandIn { get; set; }
+        bool IsModule { get; set; }
+		/// <summary>
+		/// indicates whether this record already exists in the database or is a new entry
+		/// </summary>
+        bool IsAdd { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/AddEditHardware/IAddEditHardwareView.cs

@@ -0,0 +1,16 @@
+using DTS.Common.Base;
+using DTS.Common.Interface.DASFactory.Diagnostics.HardwareList;
+
+namespace DTS.Common.Interface.Hardware.AddEditHardware
+{
+    public interface IAddEditHardwareView : IBaseView
+    {
+	    /// <summary>
+		/// used to notify the view that it has been activated and should handle any
+		/// post activation work
+		/// </summary>
+        void Activated();
+
+        int ViewDbVersion { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/AddEditHardware/IAddEditHardwareViewModel.cs

@@ -0,0 +1,49 @@
+using DTS.Common.Base;
+using DTS.Common.Interface.DASFactory.Diagnostics;
+using DTS.Common.Interface.DASFactory.Diagnostics.HardwareList;
+using DTS.Common.Interface.DataRecorders;
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.Hardware.AddEditHardware
+{
+    public interface IAddEditHardwareViewModel : IBaseViewModel
+    {                
+        IAddEditHardwareView View { get; set; }        
+        void Unset();
+        /// <summary>
+        /// hardware being operated on in viewmodel
+        /// </summary>
+        IAddEditHardwareHardware Hardware { get; set; }
+        int? TestId{ get; set; }
+        /// <summary>
+        /// initializes the viewmodel with the given hardware
+        /// </summary>
+        void SetHardware(IDASHardware hw, IISOHardware isoHW);
+        /// <summary>
+        /// whether to send notifications of changes or not
+        /// this can be used to avoid notifications when initializing things
+        /// <summary>
+        bool NotificationsOn { get; set; }
+        /// <summary>
+        /// returns true if the hardware can be committed, false otherwise
+        /// </summary>
+        bool Validate(IISOHardware isoHW, ref List<string> errors, ref List<string> warnings, bool displayWindow, bool IsAdd);
+        /// <summary>
+        /// commits any changes present
+        /// </summary>
+        void Save();
+        IISOHardware GetISOHardware();
+        /// <summary>
+		/// Whether standin hardware is supported by the current model
+		/// </summary>
+        bool AllowStandin { get; set;  }
+		/// <summary>
+		/// allows access to the SLICE6 treeview module
+		/// </summary>
+        void SetSLICE6TreeView(ISLICE6TreeView treeView, IHardwareListViewModel treeViewModel);
+		/// <summary>
+		/// access to the current SLICE6TreeView
+		/// </summary>
+        ISLICE6TreeView SLICE6TreeView { get; }
+    }    
+}

Common/DTS.CommonCore/Interface/Hardware/HardwareList/IHardware.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics.HardwareList
+{
+    public interface IHardware
+    {
+        int DASId { get; set; }
+        bool Disabled { get; set; }
+        bool Included { get; set; }
+        double TestSampleRate { get; set; }
+        string SerialNumber { get; set; }
+        string HardwareType { get; set; }
+        string ChannelCount { get; set; }
+        string Firmware { get; set; }
+        double? MaxSampleRate{ get; set; }
+        DateTime? CalDate { get; set; }
+        DateTime? CalDueDate { get; set; }
+        object Hardware { get; set; }
+        void SetIncluded(bool bIncluded);
+        void SetMixedRates(bool mixed);
+        bool Filter(string term);
+        string ParentDAS{ get; set; }
+        int PositionOnChain { get; set; }
+        int PositionOnDistributor{ get; set; }
+        int Port{ get; set; }
+        int AnalogChannels { get; set; }
+        int SquibChannels { get; set; }
+        int DigitalInChannels { get; set; }
+        int DigitalOutChannels { get; set; }
+        int UartChannels { get; set; }
+        int StreamOutChannels { get; set; }
+        int StreamInChannels { get; set; }
+        /// <summary>
+        /// determines the ChannelCount text
+        /// </summary>
+        /// <param name="showCompact">whether to show compact or expanded
+        /// compact will not show SLICEPro units connect to ECMs
+        /// </param>
+        void DetermineChannelCount(bool showCompact, IHardware [] allHardware);
+        string IPAddress { get; set; }
+        /// <summary>
+        /// first date of use after calibration
+        /// only valid if IsFirstUseValid is true
+        /// null value indicates hardware has not been used since calibration
+        /// (once again, only if IsFirstUseValid is true)
+        /// 15524 DAS "First Use Date"
+        /// </summary>
+        DateTime? FirstUseDate { get; set; }
+        /// <summary>
+        /// whether hardware supports and is using first use date
+        /// 15524 DAS "First Use Date"
+        /// </summary>
+        bool IsFirstUseValid { get; set; }
+        bool IsTSRAIR { get; }
+        byte PTPDomainID { get; set; }
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/HardwareList/IHardwareListOverdueView.cs

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

Common/DTS.CommonCore/Interface/Hardware/HardwareList/IHardwareListReplaceView.cs

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

Common/DTS.CommonCore/Interface/Hardware/HardwareList/IHardwareListSelectView.cs

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

Common/DTS.CommonCore/Interface/Hardware/HardwareList/IHardwareListView.cs

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

Common/DTS.CommonCore/Interface/Hardware/HardwareList/IHardwareListViewModel.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using DTS.Common.Base;
+using DTS.Common.Classes.Hardware;
+using DTS.Common.Enums;
+using DTS.Common.Interface.Pagination;
+using DTS.Common.Interface.TestSetups.TestSetupsList;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics.HardwareList
+{
+    public interface IHardwareListViewModel : IBaseViewModel, IFilterableListView
+    {
+        /// <summary>
+        /// a user selected slice6
+        /// </summary>
+        ISLICE6TreeNode SelectedSLICE6 { get; set; }
+        /// <summary>
+        /// all slice6 which are not associated with a given S6DB
+        /// </summary>
+        ISLICE6TreeNode[] AvailableSLICE6 { get; set; }
+        /// <summary>
+        /// currently selected SLICE6DB
+        /// </summary>
+        IHardware SelectedSLICE6DB { get; set; }
+        /// <summary>
+        /// all available SLICE6DB
+        /// </summary>
+        IHardware [] AvailableSLICE6DB { get; set; }
+        
+        bool IsEdit { get; set; }
+        int TDASCalPeriod { get; set; }
+        int G5CalPeriod { get; set; }
+        int SLICE1CalPeriod { get; set; }
+        int SLICE1_5CalPeriod { get; set; }
+        int SLICE2_CalPeriod { get; set; }
+        int SLICE6_CalPeriod { get; set; }
+        int POWERPRO_CalPeriod { get; set; }
+        int SLICE6Air_CalPeriod { get; set; }
+        int SLICE6DB_CalPeriod { get; set; }
+        int TSRAir_CalPeriod { get; set; }
+        /// <summary>
+        /// the hardware replacement view
+        /// </summary>
+        IHardwareListReplaceView ReplaceView { get; set; }
+        IHardwareListView View { get; set; }
+        IHardwareListOverdueView OverdueView { get; set; }  
+        IHardwareListSelectView SelectView { get; set; }
+        ISLICE6TreeView SLICE6TreeView { get; set; }
+        IHardware [] Hardware { get; set; }
+        IHardware [] OverdueHardware { get; set; }
+        /// <summary>
+        /// the hardware in the test (replacementview)
+        /// </summary>
+        IHardware [] HardwareInTest { get; set; }
+        /// <summary>
+        /// the hardware to replace
+        /// </summary>
+        IHardware HardwareToReplace { get; set; }
+        /// <summary>
+        /// the hardware that is available to replace with
+        /// </summary>
+        IHardware [] AvailableHardware { get; set; }
+        /// <summary>
+        /// initializes the replacement view given a test id
+        /// </summary>
+        void InitializeReplace(ITestSetup setup, IsoViewMode viewMode);
+        void GetHardware(bool bIncludeModules, bool bIncludeOverdue, bool bIncludeBridges, int? testId, int? groupId);
+        void GetAvailableSampleRates(int[] availableSampleRates);
+        void SetTestSampleRates(Dictionary<string, double> testSampleRates);
+        void SetHasIncludedChildren();
+        void UpdateTestSampleRate(string childSerialNumber, double testSampleRate);
+        int TestAAFRateHzColumnWidth { get; set; }
+        void SetTestAAFRates(Dictionary<string, float> testAAFRates);
+        void UpdateTestAAFilterRate(string childSerialNumber, float testAAFilterRate);
+        Func<SerializableAAF.DAS_TYPE, int, float> GetAAFForHardwareFunc { get; set; }
+        void CheckForMixedDAS(string nonParentSerialNumber, double testSampleRate);
+        void SetParentMixedRates(string parentDAS, bool mixedRates);
+        int TestSampleRateColumnWidth { get; set; }
+        int TestClockMasterColumnWidth { get; set; }
+        int PTPDomainColumnWidth { get; set; }
+        void SetTestClockProfiles(DTS.Common.ClockSyncProfile masterProfile, DTS.Common.ClockSyncProfile slaveProfile);
+        void SetTestClockMasters(Dictionary<string, bool> testClockMasters);
+        void UpdateTestClockMaster(string childSerialNumber, bool testClockMaster);
+        void SetTestPTPDomainIDs(Dictionary<string, byte> testPTPDomainIDs);
+        void UpdateTestPTPDomainID(string childSerialNumber, byte ptpDomainId);
+        void Unset();
+        void Sort(object o, bool columnClick);
+        void SortOverdue(object o, bool columnClick);
+        void SetIncluded(string[] serialNumbers, bool included);
+        void SetIncluded(int[] dasId);
+        void Filter(string term);
+        void MouseDoubleClick(int index);
+
+        void SetCache(IISOHardware[] hardware);
+        /// <summary>
+        /// whether to show a compact view (no rack modules) or
+        /// expanded (show rack modules)
+        /// </summary>
+        bool ShowCompact { get; set; }
+        /// <summary>
+        /// loads tree for given hardware
+        /// </summary>
+        /// <param name="serialNumber"></param>
+        void LoadTreeView(string serialNumber);
+
+        /// <summary>
+        /// all the SLICE6 associated with a S6DB
+        /// (LoadTreeView will set this)
+        /// </summary>
+        ISLICE6TreeNode[] SLICE6TreeNodes{ get; set; }
+
+        /// <summary>
+        /// associates a SLICE6 with a SLICE6DB
+        /// [does not commit]
+        /// </summary>
+        /// <param name="node"></param>
+        void Associate(ISLICE6TreeNode node);
+
+        /// <summary>
+        /// associates units from one SLICE6DB
+        /// with another
+        /// [does not commit]
+        /// </summary>
+        /// <param name="node"></param>
+        void Associate(IHardware node);
+        /// <summary>
+        /// removes the association of a SLICE6 with a SLICE6DB
+        /// [does not commit]
+        /// </summary>
+        /// <param name="node"></param>
+        void UnAssociate(ISLICE6TreeNode node);
+        /// <summary>
+        /// associates or de-associates SLICE6 from a SLICE6DB
+        /// </summary>
+        void SaveSLICE6Associations(string serialNumber);
+
+        IHardware[] GetSelectedItems();
+        /// <summary>
+        /// Replaces HardwareToReplace with ReplacementHardware
+        /// </summary>
+        void Replace();
+        /// <summary>
+        /// the selected hardware to replace with
+        /// </summary>
+        IHardware ReplacementHardware { get; set; }
+        void SetCalPeriods(int g5CalPeriod, int slice1CalPeriod, int slice1_5CalPeriod, int slice2_CalPeriod, int slice6_CalPeriod, int tdasCalPeriod,
+            int powerpro_CalPeriod, int slice6Air_CalPeriod, int slice6DB_CalPeriod, int tsrAir_CalPeriod, int slice6AirBridge_CalPeriod);
+    }    
+}

Common/DTS.CommonCore/Interface/Hardware/HardwareList/ISLICE6TreeNode.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics.HardwareList
+{
+    public interface ISLICE6TreeNode
+    {
+        int DASId { get; set;  }
+        string SerialNumber { get; set; }
+        int Port { get; set;  }
+        string PortString { get; }
+        int Number { get; set; }
+        int PositionOnChain { get; set; }
+        string PositionOnChainString { get; }
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/HardwareList/ISLICE6TreeView.cs

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

Common/DTS.CommonCore/Interface/Hardware/IATDArmStatus.cs

@@ -0,0 +1,121 @@
+using DTS.Common.Converters;
+using DTS.Common.Interface.DASFactory;
+using DTS.Common.Interface.DASFactory.Diagnostics.HardwareList;
+using DTS.Common.Interface.DataRecorders;
+using System;
+using System.ComponentModel;
+using System.Net;
+
+namespace DTS.Common.Interface.Hardware
+{
+    public interface IAllATDStatus
+    {
+        IATDStatus [] ATDs { get; }
+        void AddDevice(IDeviceArmStatus device, string parent);
+        void PopulateFromHardware(IDASHardware[] hardware);
+        AllATDStatuses OverallStatus { get; }
+    }
+
+    public enum AllATDStatuses
+    {
+        NotConnected,
+        Connecting,
+        AllConnected,
+        AllArmed,
+        Errors
+    }
+    public interface IATDStatus
+    {
+        AllATDStatuses Status { get; }
+        IDistributorArmStatus [] Distributors { get; }
+        void AddDistributor(IDistributorArmStatus distributor);
+        IPAddress IP { get; }
+        void SetIP(IPAddress ip);
+        void UpdateAggregateStatus();
+    }
+    public interface IDistributorArmStatus
+    {
+        bool EmptyDistributor { get; }
+        IDeviceArmStatus Distributor { get; }
+        void SetDistributor(IDeviceArmStatus distributor);
+        DistributorStatuses DistributorStatus { get; }
+        void SetDistributorStatus(DistributorStatuses status);
+        AllATDStatuses AggregateStatus { get; }
+        IDeviceArmStatus [] Devices { get; }
+        void AddDevice(IDeviceArmStatus device);
+        string SerialNumber { get; }
+        void SetSerialNumber(string serial);
+        void UpdateAggregateStatus();
+        DateTime? LastSeen { get; }
+        float? InputVoltage { get; }
+        float? BackupVoltage { get; }
+        void UpdateStatusFromQATS(IUDPQATSEntry qats);
+    }
+    [TypeConverter(typeof(EnumDescriptionTypeConverter))]
+    public enum DistributorStatuses
+    {
+        [Description("DistributorStatus_OFFLINE")]
+        NotConnected,
+        [Description("DistributorStatus_ONLINE")]
+        Connected,
+        [Description("DistributorStatus_ARMED")]
+        Armed,
+        [Description("DistributorStatus_IDLE")]
+        NotArmed,
+        [Description("DistributorStatus_ARMEDFAULTED")]
+        Errored
+    }
+    [TypeConverter(typeof(EnumDescriptionTypeConverter))]
+    public enum DASStatuses
+    {
+        [Description("DASStatus_Offline")]
+        MissingNotBooted,
+        [Description("DASStatus_Online")]
+        BootedNotArmedYet,
+        [Description("DASStatus_Online")]
+        BootedNeverArmed,
+        [Description("DASStatus_ARMED")]
+        ArmedReady,
+        [Description("DASStatus_ARMEDFAULTED")]
+        ArmedButFailedDiag,
+        [Description("DASStatus_READYFORDL")]
+        ReadyForDownload
+    }
+    [Flags]
+    public enum DiagStatuses
+    {
+        Passed,
+        NoResults,
+        FailedShunt,
+        FailedOffset,
+        FailedTilt,
+        FailedTemperature
+    }
+    public interface IDeviceArmStatus
+    {
+        bool HasArmed { get; set; }
+        DASStatuses DASStatus { get; }
+        void SetDASStatus(DASStatuses status);
+        DiagStatuses DiagStatus { get; }
+        void SetDiagStatus(DiagStatuses status);        
+        IDistributorArmStatus Distributor { get; }
+        void SetDistributor(IDistributorArmStatus distributor);
+        IDASHardware Hardware { get; }
+        void SetHardware(IDASHardware hardware);
+        IDASCommunication DASCommunication { get; }
+        void SetDASCommunication(IDASCommunication das);
+        string SerialNumber{ get; }
+        void SetSerialNumber(string serial);
+        DateTime? LastSeen { get; }
+        float? InputVoltage { get; }
+        float? BackupVoltage { get; }
+        void UpdateStatusFromQATS(IUDPQATSEntry qats);
+        string ShuntResults { get; }
+        string OffsetResults { get; }
+        double? TiltX { get; }
+        double? TiltY { get; }
+        double? TiltZ { get; }
+        string IPAddress { get; }
+        bool Triggered { get; }
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/IDASMonitorInfo.cs

@@ -0,0 +1,21 @@
+using DTS.Common.Enums.DASFactory;
+
+namespace DTS.Common.Interface.Hardware
+{
+    
+    public interface IDASMonitorInfo
+    {        
+        string SerialNumber { get; }
+        double[] TiltSensorCals { get; }
+        short[] TiltSensorDataPre { get; }
+        DFConstantsAndEnums.TiltAxes TiltAxes { get; }
+        int AxisIgnored { get; }
+        double MountOffsetAxisOne { get; }
+        double MountOffsetAxisTwo { get; }
+        string GetChannelName(int index);
+        double GetOffsetTolerancemVLow(int index);
+        double GetOffsetTolerancemVHigh(int index);
+        void ReadFromFile(string path);
+        void WriteToFile(string path);
+    }
+}

Common/DTS.CommonCore/Interface/Hardware/IDiagnosticResult.cs

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

Common/DTS.CommonCore/Interface/Hardware/IISOHardware.cs

@@ -0,0 +1,27 @@
+using DTS.Common.Enums.Hardware;
+using DTS.Common.Interface.DataRecorders;
+using System;
+using System.Collections.Generic;
+
+namespace DTS.Common.Interface.DASFactory.Diagnostics
+{
+    public interface IISOHardware : IDASDBRecord
+    {
+        void GetChannelsString(out int analog, out int digitalIn, out int digitalOut, out int squib, out int uart, out int streamOut, out int streamIn);
+        HardwareTypes DASTypeEnum { get; set; }       
+        string IPAddress { get; set; }
+        //Pseudo racks are racks are collections of hardware that associated with each 
+        //other but aren't racks, this includes SLICE slabs and SLICE6 with S6DB
+        //this just indicates whether it's capable, not whether it's serving that role
+        bool IsPseudoRackModule();
+        bool IsTSRAIR();
+        bool ValidateSerialNumber(ref List<string> errors);
+        bool ValidateIPAddress(ref List<string> errors);
+        void Insert();
+        void Update();
+        /// <summary>
+        /// remove this hardware from the database
+        /// </summary>
+        void Delete();
+    }
+}