init

DataPRO/IService/Classes/BaseInput/BaseInputValues.cs

@@ -0,0 +1,135 @@
+using DTS.Common.Enums.DASFactory;
+using DTS.Common.Interface.DASFactory.Diagnostics;
+using DTS.DASLib.Command.TDAS;
+
+namespace DTS.DASLib.Service
+{
+    /// <summary>
+    /// Each time <see cref="DTS.DASLib.Service.DiagnosticsService" />.Diagnose is called these values 
+    /// are populated.  Each IDASCommunication will have one of these objects.  It 
+    /// provides information about input voltage to the base unit, like power input, 
+    /// presence of a battery and battery output voltage.
+    /// </summary>
+    public class BaseInputValues : IBaseInputValues
+    {
+        /// <summary>
+        /// The current input voltage to the base.
+        /// </summary>
+        public double InputMilliVolts { get; set; }
+
+
+        //18740 DataPRO system settings Power setting values for TDAS rack do not change actual power values on device
+        // added Min/Max valid and tied Valid bool to those values
+        public virtual bool InputMilliVoltsValid => InputMilliVolts > 1000D * MinimumValidInputVoltage && InputMilliVolts < 1000D * MaximumValidInputVoltage;
+
+        /// <summary>
+        /// The current input voltage to the base.
+        /// </summary>
+        public double InputVoltage { get; set; }
+
+        /// <summary>       
+        /// The minimum valid input voltage to the base.
+        /// </summary>
+        public double MinimumValidInputVoltage { get; set; } = 6D;
+
+        /// <summary>       
+        /// The maximum valid input voltage to the base.
+        /// </summary>
+        public double MaximumValidInputVoltage { get; set; } = 16D;
+
+        public virtual bool BatteryMilliVoltsValid => BatteryMilliVolts > 1000D * MinimumValidBatteryVoltage && BatteryMilliVolts < 1000D * MaximumValidBatteryVoltage;
+
+        /// <summary>
+        /// The current battery voltage.
+        /// </summary>
+        public double BatteryMilliVolts { get; set; }
+
+        /// <summary>
+        /// The current battery voltage.
+        /// </summary>
+        public double BatteryVoltage { get; set; }
+
+        /// <summary>
+        /// battery state of charge -  null if not queried
+        /// can be 0 if not available
+        /// this is a percentage
+        /// </summary>
+        public double? BatterySoC { get; set; } = null;
+
+        /// <summary>       
+        /// The minimum valid battery voltage to the base.
+        /// </summary>
+        public double MinimumValidBatteryVoltage { get; set; } = 6D;
+
+        /// <summary>       
+        /// The maximum valid battery voltage to the base.
+        /// </summary>
+        public double MaximumValidBatteryVoltage { get; set; } = 16D;
+
+        /// <summary>
+        /// TRUE if the battery is currently charging.
+        /// </summary>
+        public bool BatteryIsCharging { get; set; }
+
+        /// <summary>
+        /// Temperature sensed by logic in the hardware, in degrees Celsius.
+        /// </summary>
+        public double TemperatureC { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        public virtual string BatteryVoltageStatus { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        public virtual string InputVoltageStatus { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        public virtual string StatusDisplayBattery { get; set; }
+
+        /// <summary>
+        /// returns status
+        /// </summary>
+        public virtual string StatusDisplayInput { get; set; }
+
+        /// <summary>
+        /// returns color
+        /// </summary>
+        public virtual DFConstantsAndEnums.VoltageStatusColor BatteryVoltageStatusColor { get; set; }
+
+        /// <summary>
+        /// returns color
+        /// </summary>
+        public virtual DFConstantsAndEnums.VoltageStatusColor InputVoltageStatusColor { get; set; }
+
+        public double ChargeCapacity { get; set; } = double.NaN;
+
+        public bool ChargeCapacityValid => !double.IsNaN(ChargeCapacity) && ChargeCapacity > 0 && ChargeCapacity < 100;
+        public BaseInputValues() { }
+        public BaseInputValues(IBaseInputValues copy)
+        {
+            InputMilliVolts = copy.InputMilliVolts;            
+            InputVoltage = copy.InputVoltage;
+            MinimumValidInputVoltage = copy.MinimumValidInputVoltage;
+            MaximumValidInputVoltage = copy.MaximumValidInputVoltage;
+            BatteryMilliVolts = copy.BatteryMilliVolts;
+            BatteryVoltage = copy.BatteryVoltage;
+            BatterySoC = copy.BatterySoC;
+            MinimumValidBatteryVoltage = copy.MinimumValidBatteryVoltage;
+            MaximumValidBatteryVoltage = copy.MaximumValidBatteryVoltage;
+            BatteryIsCharging = copy.BatteryIsCharging;
+            TemperatureC = copy.TemperatureC;
+            BatteryVoltageStatus = copy.BatteryVoltageStatus;
+            InputVoltageStatus = copy.InputVoltageStatus;
+            StatusDisplayBattery = copy.StatusDisplayBattery;
+            StatusDisplayInput = copy.StatusDisplayInput;
+            BatteryVoltageStatusColor = copy.BatteryVoltageStatusColor;
+            InputVoltageStatusColor = copy.InputVoltageStatusColor;
+            ChargeCapacity = copy.ChargeCapacity;            
+        }
+    }
+}

DataPRO/IService/Classes/BaseInput/SLICE.Base.Input.Reader.cs

@@ -0,0 +1,155 @@
+using System.Threading;
+using DTS.Common.Interface.DASFactory;
+using DTS.DASLib.Command.SLICE;
+
+namespace DTS.DASLib.Service
+{
+    public class SLICEBaseInputReader
+    {
+        private readonly ICommunication _comm;
+
+        public SLICEBaseInputReader(DTS.Common.Interface.DASFactory.ICommunication comm)
+        {
+            _comm = comm;
+        }
+
+        public virtual double InputMilliVolts
+        {
+            get
+            {
+                var measure = new MeasureBaseDiagnosticChannel(_comm);
+                measure.Channel = MeasureBaseDiagnosticChannel.BaseDiagnosticChannelList.InputVoltage;
+                measure.DeviceGroup = 0;
+                measure.DeviceID = 0;
+                measure.SyncExecute();
+                return measure.Measurement * 1000.0;
+            }
+        }
+
+        public virtual double TemperatureC
+        {
+            get
+            {
+                var measure = new MeasureBaseDiagnosticChannel(_comm);
+                measure.Channel = MeasureBaseDiagnosticChannel.BaseDiagnosticChannelList.TemperatureC;
+                measure.DeviceGroup = 0;
+                measure.DeviceID = 0;
+                measure.SyncExecute();
+                return measure.Measurement;
+            }
+        }
+
+        public bool BatteryIsCharging
+        {
+            get
+            {
+                var setSwitch = new QuerySwitchImmediate(_comm);
+                setSwitch.Switch = (byte)Switches.BaseSwitches.ChargeStatus;
+                setSwitch.SwitchText = Switches.BaseSwitches.ChargeStatus.ToString();
+                setSwitch.SyncExecute();
+                return setSwitch.Setting == 1;
+            }
+        }
+
+        public virtual double DirectBackupMilliVolts
+        {
+            get
+            {
+                if (!ShouldMeasureBackupPower())
+                {
+                    return 0D;
+                }
+                var measure = new MeasureBaseDiagnosticChannel(_comm);
+                measure.Channel = MeasureBaseDiagnosticChannel.BaseDiagnosticChannelList.BackupVoltage;
+                measure.DeviceGroup = 0;
+                measure.DeviceID = 0;
+                measure.SyncExecute();
+                return measure.Measurement * 1000.0;
+            }
+        }
+        /// <summary>
+        /// returns true if the unit should check/enable/disable backup power
+        /// originally part of the S6 performance improvements
+        /// note that S6 should not have battery power
+        /// </summary>
+        /// <returns></returns>
+        private bool ShouldEnableBackupPower()
+        {
+            switch (_comm)
+            {
+                case EthernetSlice6 _:
+                case EthernetSlice2 _:
+                case EthernetSlice6Air _:
+                case EthernetSlice6AirBridge _:
+                case EthernetTsrAir _:
+                case WinUSBSlice6 _:
+                case CDCUSBSlice _:
+                    return false;
+            }
+            return true;
+        }
+        /// <summary>
+        /// previously there was no ShouldMeasureBackupPower
+        /// and only ShouldEnableBackupPower existed, however
+        /// TSR AIR SHOULD measure backup power and SHOULD NOT
+        /// enable backup power ...
+        /// </summary>
+        /// <returns></returns>
+        public bool ShouldMeasureBackupPower()
+        {
+            switch (_comm)
+            {
+                case EthernetSlice6 _:
+                case EthernetSlice6Air _:
+                case EthernetSlice6AirBridge _:
+                case WinUSBSlice6 _:
+                case CDCUSBSlice _:
+                    return false;
+                case EthernetSlice2 _:
+                case EthernetTsrAir _:
+                    return true;
+            }
+            return true;
+        }
+        public double BackupMilliVolts
+        {
+            get
+            {
+                try
+                {
+                    if (ShouldEnableBackupPower())
+                    {
+                        EnableBackupPower();
+                        // wait for a second
+                        Thread.Sleep(1500);
+                    }
+                    return DirectBackupMilliVolts;
+                }
+                finally
+                {
+                    DisableBackupPower();
+                }
+            }
+        }
+
+        private void EnableBackupPower()
+        {
+            if (!ShouldEnableBackupPower()) { return; }
+            var setSwitch = new SetSwitchImmediate(_comm);
+            setSwitch.Switch = (byte)Switches.BaseSwitches.BackupPower;
+            setSwitch.SwitchText = Switches.BaseSwitches.BackupPower.ToString();
+            setSwitch.Setting = 1;
+            setSwitch.SyncExecute();
+        }
+
+        private void DisableBackupPower()
+        {
+            if (!ShouldEnableBackupPower()) { return; }
+            var setSwitch = new SetSwitchImmediate(_comm);
+            setSwitch.Switch = (byte)Switches.BaseSwitches.BackupPower;
+            setSwitch.SwitchText = Switches.BaseSwitches.BackupPower.ToString();
+            setSwitch.Setting = 0;
+            setSwitch.SyncExecute();
+        }
+    }
+}

DataPRO/IService/Classes/BaseInput/SLICEBaseInputValues.cs

@@ -0,0 +1,72 @@
+
+
+namespace DTS.DASLib.Service
+{
+    public class SLICEBaseInputValues : BaseInputValues
+    {
+        public enum PossibleVoltageStatus
+        {
+            GREEN,
+            YELLOW,
+            RED,
+            OFF
+        }
+
+        public enum PossibleBatteryStatus
+        {
+            GREEN,
+            YELLOW,
+            RED,
+            NOBATTERY,
+            OFF
+        }
+        public override string BatteryVoltageStatus
+        {
+            get
+            {
+                if (BatteryMilliVoltsValid)
+                {
+                    if (ChargeCapacityValid)
+                    {
+                        if (ChargeCapacity > 70)
+                        {
+                            return PossibleBatteryStatus.GREEN.ToString();
+                        }
+                        return ChargeCapacity > 40 ? PossibleBatteryStatus.YELLOW.ToString() : PossibleBatteryStatus.RED.ToString();
+                    }
+                    if (InputMilliVoltsValid)
+                    {
+                        if (InputMilliVolts > 11000)
+                        {
+                            if (BatteryMilliVolts > 7.6)
+                            {
+                                return PossibleBatteryStatus.GREEN.ToString();
+                            }
+                            return BatteryMilliVolts > 7.6 ? PossibleBatteryStatus.YELLOW.ToString() : PossibleBatteryStatus.RED.ToString();
+                        }
+                        if (InputMilliVolts > 9000)
+                        {
+                            if (BatteryMilliVolts > 7.8)
+                            {
+                                return PossibleBatteryStatus.GREEN.ToString();
+                            }
+                            return BatteryMilliVolts > 7.4 ? PossibleBatteryStatus.YELLOW.ToString() : PossibleBatteryStatus.RED.ToString();
+                        }
+                        if (InputMilliVolts < 9)
+                        {
+                            if (BatteryMilliVolts > 7.8)
+                            {
+                                return PossibleBatteryStatus.GREEN.ToString();
+                            }
+                            return BatteryMilliVolts > 7.4 ? PossibleBatteryStatus.YELLOW.ToString() : PossibleBatteryStatus.RED.ToString();
+                        }
+                        return PossibleBatteryStatus.RED.ToString();
+                    }
+                    return PossibleBatteryStatus.RED.ToString();
+                }
+                return PossibleBatteryStatus.NOBATTERY.ToString();
+            }
+            set {; }//ignore, always generate as needed
+        }
+    }
+}