init

DataPRO/SensorDB/IEPESensorDefault.cs

@@ -0,0 +1,198 @@
+using System;
+using DTS.Common.Interface.Sensors;
+using DTS.Common.Settings;
+
+namespace DTS.SensorDB
+{
+    public class IEPESensorDefault : DTS.Common.Base.BasePropertyChanged, IIEPESensorDefaults
+    {
+        #region constants
+        private const string _24V_POWERLOW_KEY = "_24VPowerLow";
+        private const string _24V_POWERHIGH_KEY = "_24VPowerHigh";
+        private const double _24VPOWER_LOW_DEFAULT = 23D;
+        private const double _24VPOWER_HIGH_DEFAULT = 26.5D;
+
+        private const string IEPE_RANGE_LOW_KEY = "IEPERangeLowLimitScalar";
+        private const string IEPE_RANGE_HIGH_KEY = "IEPERangeHighLimitScalar";
+        private const double IEPE_RANGE_HIGH_LIMIT = 100D;
+        private const double IEPE_RANGE_LOW_LIMIT = 1D;
+
+        private const string DISABLE_AUTOSENSE_KEY = "DisableAutoSense";
+        private const bool DISABLE_AUTOSENSE_DEFAULT = false;
+        #endregion constants
+
+        #region properties
+        private bool _disableAutoSense;
+        /// <summary>
+        /// whether AutoSense is allowed or not
+        /// 14634 Implement enable/disable of the "SLICE PRO Auto-sense" feature
+        /// </summary>
+        public bool DisableAutoSense
+        {
+            get => _disableAutoSense;
+            set
+            {
+                SetProperty(ref _disableAutoSense, value, "DisableAutoSense");
+                OnPropertyChanged("DisableAutoSense");
+            }
+        }
+        private double __24VPowerLow;
+        public double _24VPowerLow
+        {
+            get => __24VPowerLow;
+            set
+            {
+                SetProperty(ref __24VPowerLow, value, "_24VPowerLow");
+                OnPropertyChanged("ToleranceValid");
+            }
+        }
+
+        private double __24VPowerHigh;
+        public double _24VPowerHigh
+        {
+            get => __24VPowerHigh;
+            set
+            {
+                SetProperty(ref __24VPowerHigh, value, "_24VPowerHigh");
+                OnPropertyChanged("ToleranceValid");
+            }
+        }
+
+        private double _rangeLowLimitScalar;
+
+        /// <summary>
+        /// the actual range low acceptable value (scalar applied to desired range)
+        /// </summary>
+        public double RangeLowLimitScalar
+        {
+            get => _rangeLowLimitScalar;
+            set
+            {
+                SetProperty(ref _rangeLowLimitScalar, value, "RangeLowLimitScalar");
+                OnPropertyChanged("RangeToleranceValid");
+            }
+        }
+
+        private double _rangeHighLimitScalar;
+
+        /// <summary>
+        /// the actual range high acceptable value (scalar applied to desired range)
+        /// </summary>
+        public double RangeHighLimitScalar
+        {
+            get => _rangeHighLimitScalar;
+            set
+            {
+                SetProperty(ref _rangeHighLimitScalar, value, "RangeHighLimitScalar");
+                OnPropertyChanged("RangeToleranceValid");
+            }
+        }
+
+        public bool ToleranceValid => _24VPowerHigh > _24VPowerLow;
+
+        public bool RangeToleranceValid => RangeLowLimitScalar < RangeHighLimitScalar;
+        #endregion properties
+
+        #region methods
+        public bool Validate()
+        {
+            return ToleranceValid && RangeToleranceValid;
+        }
+        #region static methods
+        public static IIEPESensorDefaults GetIEPESensorDefaults(string user)
+        {
+            var low = SettingsDB.GetGlobalValueDouble(_24V_POWERLOW_KEY, _24VPOWER_LOW_DEFAULT);
+            var high = SettingsDB.GetGlobalValueDouble(_24V_POWERHIGH_KEY, _24VPOWER_HIGH_DEFAULT);
+            var rangeLow = SettingsDB.GetGlobalValueDouble(IEPE_RANGE_LOW_KEY, IEPE_RANGE_LOW_LIMIT);
+            var rangeHigh = SettingsDB.GetGlobalValueDouble(IEPE_RANGE_HIGH_KEY, IEPE_RANGE_HIGH_LIMIT);
+            var disableAutoSense = SettingsDB.GetGlobalValueBool(DISABLE_AUTOSENSE_KEY, DISABLE_AUTOSENSE_DEFAULT);
+            return new IEPESensorDefault()
+            {
+                _24VPowerHigh = high,
+                _24VPowerLow = low,
+                RangeHighLimitScalar = rangeHigh,
+                RangeLowLimitScalar = rangeLow,
+                DisableAutoSense = disableAutoSense
+            };
+        }
+
+        public static void Save(IIEPESensorDefaults defaults)
+        {
+            SettingsDB.SetGlobalValueDouble(_24V_POWERLOW_KEY, defaults._24VPowerLow);
+            SettingsDB.SetGlobalValueDouble(_24V_POWERHIGH_KEY, defaults._24VPowerHigh);
+            SettingsDB.SetGlobalValueDouble(IEPE_RANGE_HIGH_KEY, defaults.RangeHighLimitScalar);
+            SettingsDB.SetGlobalValueDouble(IEPE_RANGE_LOW_KEY, defaults.RangeLowLimitScalar);
+            SettingsDB.SetGlobalValueBoolean(DISABLE_AUTOSENSE_KEY, defaults.DisableAutoSense);
+        }
+
+        public static void RestoreDefaults(IIEPESensorDefaults sensorDefaults)
+        {
+            sensorDefaults._24VPowerHigh = _24VPOWER_HIGH_DEFAULT;
+            sensorDefaults._24VPowerLow = _24VPOWER_LOW_DEFAULT;
+            sensorDefaults.RangeHighLimitScalar = IEPE_RANGE_HIGH_LIMIT;
+            sensorDefaults.RangeLowLimitScalar = IEPE_RANGE_LOW_LIMIT;
+            sensorDefaults.DisableAutoSense = DISABLE_AUTOSENSE_DEFAULT;
+        }
+        #endregion static methods
+
+        public void ReadXML(System.Xml.XmlElement root)
+        {
+            foreach (var node in root.ChildNodes)
+            {
+                if (node is System.Xml.XmlElement) { ProcessXMLElement(node as System.Xml.XmlElement); }
+            }
+        }
+        private void ProcessXMLElement(System.Xml.XmlElement node)
+        {
+            if (Enum.TryParse(node.Name, out IEPEXMLFields field))
+            {
+                switch (field)
+                {
+                    case IEPEXMLFields._24PowerHigh: __24VPowerHigh = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
+                    case IEPEXMLFields._24PowerLow: __24VPowerLow = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
+                    case IEPEXMLFields.RangeHighLimitScalar: RangeHighLimitScalar = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
+                    case IEPEXMLFields.RangeLowLimitScalar: RangeLowLimitScalar = Convert.ToDouble(node.InnerText, System.Globalization.CultureInfo.InvariantCulture); break;
+                    case IEPEXMLFields.DisableAutoSense: DisableAutoSense = Convert.ToBoolean(node.InnerText); break;
+                    default: throw new NotSupportedException("IEPESensorDefault::ProcessXMLElement unsupported field: " + field);
+                }
+            }
+        }
+
+        public void WriteXML(ref System.Xml.XmlWriter writer)
+        {
+            writer.WriteStartElement("IEPESettingDefaults");
+
+            writer.WriteStartElement(IEPEXMLFields._24PowerHigh.ToString());
+            writer.WriteString(_24VPowerHigh.ToString(System.Globalization.CultureInfo.InvariantCulture));
+            writer.WriteEndElement();
+
+            writer.WriteStartElement(IEPEXMLFields._24PowerLow.ToString());
+            writer.WriteString(_24VPowerLow.ToString(System.Globalization.CultureInfo.InvariantCulture));
+            writer.WriteEndElement();
+
+            writer.WriteStartElement(IEPEXMLFields.RangeHighLimitScalar.ToString());
+            writer.WriteString(RangeHighLimitScalar.ToString(System.Globalization.CultureInfo.InvariantCulture));
+            writer.WriteEndElement();
+
+            writer.WriteStartElement(IEPEXMLFields.RangeLowLimitScalar.ToString());
+            writer.WriteString(RangeLowLimitScalar.ToString(System.Globalization.CultureInfo.InvariantCulture));
+            writer.WriteEndElement();
+
+            writer.WriteStartElement(IEPEXMLFields.DisableAutoSense.ToString());
+            writer.WriteString(DisableAutoSense.ToString());
+            writer.WriteEndElement();
+
+            writer.WriteEndElement();
+        }
+        #endregion methods
+    }
+
+    public enum IEPEXMLFields
+    {
+        _24PowerHigh,
+        _24PowerLow,
+        RangeHighLimitScalar,
+        RangeLowLimitScalar,
+        DisableAutoSense
+    }
+}