BlockInfo.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml.Serialization;

namespace Seci.Definitions
{
    public enum ControlType
    {
        NUMERIC, BOOLEAN, STRING, UNKNOWN
    };

    public class BlockInfo
    {
        //Members
        private String _blockName;         
        private String _blockUnits;        
        private String _alias;             
        private String _owningComponent;   
        private String _group = "None";             

        private String _nexusName;         
        private String _nexusGroup;        

        private String _parentVi;          
        private String _readControl;       
        private ControlType _readType;     
        private String _writeControl;      
        private String _goButton;          
        private String _waitForControl;    

        private Boolean _underRunControl;  
        private Double _upperLimit;        
        private Double _lowerLimit;        
        private String _runcontrolValue = "";   
        private Boolean _saveSettings;     
        private Boolean _inRange;          
        private Boolean _applyScientificFormatting = true;   
        private Boolean _applyFixedFormatting = false;   
        private int _numDecimalPoints = 3;
        private String _valueFormatting;   

        private Boolean _blockEnabled;     
        private Boolean _visible = true;   

        private Boolean _logValueToFile;   
        private Single _loggingRate;       
        private Boolean _logChangesNow;   
        private Boolean _logChangesTolerance;   
        private Boolean _logToSharedFile;   
        private String _currentValue;      
        private String _previousValue;     
        private String _previousLogValue;  
        private Double _tolerance;         
        private String _setPointValue;     
        private DateTime _lastLogged;      
        private Boolean _prevReadError = false;  

        public static readonly String ErrorString = "Error";

        //Properties
        public String BlockName { get { return _blockName; } set { _blockName = value; } }
        public String BlockUnits { get { return _blockUnits; } set { _blockUnits = value; } }
        public String Alias { get { return _alias; } set { _alias = value; } }
        [XmlIgnore]
        public String OwningComponent { get { return _owningComponent; } set { _owningComponent = value; } }
        public String Group { get { return _group; } set { _group = value; } }
        public String NexusName { get { return _nexusName; } set { _nexusName = value; } }
        public String NexusGroup { get { return _nexusGroup; } set { _nexusGroup = value; } }
        public String ParentVI { get { return _parentVi; } set { _parentVi = value; } }
        public String ReadControl { get { return _readControl; } set { _readControl = value; } }
        public String WriteControl { get { return _writeControl; } set { _writeControl = value; } }
        public String GoButton { get { return _goButton; } set { _goButton = value; } }
        public String WaitForControl { get { return _waitForControl; } set { _waitForControl = value; } }
        public Boolean UnderRunControl { get { return _underRunControl; } set { _underRunControl = value; } }
        public Double UpperLimit { get { return _upperLimit; } set { _upperLimit = value; } }
        public Double LowerLimit { get { return _lowerLimit; } set { _lowerLimit = value; } }
        public String RunControlValue { get { return _runcontrolValue; } set { _runcontrolValue = value; } }
        public Boolean InRange { get { return _inRange; } }
        public Boolean BlockEnabled { get { return _blockEnabled; } set { _blockEnabled = value; } }
        public Boolean Visible { get { return _visible; } set { _visible = value; } }
        public Boolean ApplyFormatting { get { return _applyScientificFormatting; } set { _applyScientificFormatting = value; } }
        public Boolean ApplyFixedFormatting { get { return _applyFixedFormatting; } set { _applyFixedFormatting = value; } }
        public String ValueFormatting { get { return _valueFormatting; } set { _valueFormatting = value; } }
        public int NumberDecimalPlaces { get { return _numDecimalPoints; } set { _numDecimalPoints = value; } }
        public Boolean LogChangesOnly { get { return _logChangesNow; } set { _logChangesNow = value; } }
        public Boolean LogChangesTolerance { get { return _logChangesTolerance; } set { _logChangesTolerance = value; } }
        public Double Tolerance { get { return _tolerance; } set { _tolerance = value; } }
        public Boolean LogValueToFile { get { return _logValueToFile; } set { _logValueToFile = value; } }
        public Boolean SaveSettings { get { return _saveSettings; } set { _saveSettings = value; } }
        public Boolean LogToSharedFile { get { return _logToSharedFile; } set { _logToSharedFile = value; } }
        public Boolean PrevReadError { get { return _prevReadError; } set { _prevReadError = value; } }
        [XmlIgnore]
        public ControlType ReadType { get { return _readType; } set { _readType = value; } }
        public Single LoggingRate
        {
            get
            {
                return _loggingRate;
            }
            set
            {
                if (value >= 5)
                {
                    _loggingRate = value;
                }
                else
                {
                    _loggingRate = 5;
                }
            }
        }

        [XmlIgnore]
        public String CurrentValue
        {
            get
            {
                if (_blockEnabled)
                {
                    return _currentValue;
                }
                else
                {
                    return "Disabled";
                }
            }
            set
            {
                if (_logChangesTolerance)
                {
                    _currentValue = value;

                    //Only change previous value if new value exceeds tolerance
                    if (_previousValue == null || ExceedsTolerance(_currentValue, _previousValue, _tolerance))
                    {
                        _previousValue = _currentValue;
                    }
                }
                else
                {
                    _previousValue = _currentValue;
                    _currentValue = value;
                }
            }
        }

        [XmlIgnore]
        public String FormattedCurrentValue
        {
            get
            {
                if (CurrentValue == null) return "";

                if (!_blockEnabled) return "Disabled";

                if ((_applyScientificFormatting || _applyFixedFormatting) && _readControl.EndsWith("(Numeric)"))
                {
                    Double temp;

                    if (Double.TryParse(_currentValue, out temp))
                    {
                        return formatValue(temp);
                    }
                }

                return _currentValue.Trim();
            }
        }

        [XmlIgnore]
        public String SetPointValue
        {
            get
            {
                if (_writeControl != null)
                {
                    return _setPointValue;
                }
                else
                {
                    return null;
                }
            }
            set
            {
                _setPointValue = value;
            }
        }

        [XmlIgnore]
        public String FormattedSetPointValue
        {
            get
            {
                if (SetPointValue == null) return "";

                if (!_blockEnabled) return "";

                if ((_applyScientificFormatting || _applyFixedFormatting) && _readControl.EndsWith("(Numeric)"))
                {
                    if (SetPointValue == "0")
                    {
                        return SetPointValue.Trim();
                    }

                    Double temp;

                    if (Double.TryParse(SetPointValue, out temp))
                    {
                        return formatValue(temp);
                    }
                }

                return SetPointValue.Trim();
            }
        }

        private String formatValue(Double value)
        {
            if (_applyScientificFormatting)
            {
                string format = "{0:e" + _numDecimalPoints + "}";
                if (Math.Abs(value) > 100000f)
                {
                    return String.Format(format, value);
                }
                else if (Math.Abs(value) < 0.0001f && value != 0)
                {
                    return String.Format(format, value);
                }
                else
                {
                    if (Math.Abs(value) < 1 && value != 0)
                    {
                        //Truncate
                        char[] temp = value.ToString().ToCharArray();
                        string ans = "";
                        int count = 0;
                        for (int i = 0; i < temp.Length; ++i)
                        {
                            if (temp[i] != '0' && temp[i] != '-' && temp[i] != '.')
                            {
                                ++count;
                            }

                            ans += temp[i];

                            if (count >= _numDecimalPoints)
                            {
                                return ans;
                            }                            
                        }

                        return ans;
                    }
                    else
                    {
                        return Math.Round(value, _numDecimalPoints).ToString();
                    }
                }
            }
            else if (_applyFixedFormatting)
            {
                double num = Math.Round(value, _numDecimalPoints);

                return String.Format("{0:0." + "".PadRight(_numDecimalPoints, '0') + "}", num);
            }
            else
            {
                return value.ToString();
            }
        }

        public BlockInfo()
        {
            //Does nothing
        }

        public static Boolean OkayToLog(DateTime timeNow, DateTime lastLogged, Double loggingRate, String currVal, String prevVal, Double tolerance, Boolean onAnyChange, Boolean onToleranceExceeded)
        {
            //Log at intervals of x seconds
            if (!onAnyChange)
            {
                //Check that it is time to log; if it is first time then _LastLogged is 01:01:0001, so it will log by default
                if (timeNow.ToUniversalTime() >= lastLogged.AddSeconds(loggingRate).ToUniversalTime())
                {
                    if (onToleranceExceeded)
                    {
                        //Has value changed (by more than tolerance)?
                        if (ExceedsTolerance(currVal, prevVal, tolerance))
                        {
                            return true;
                        }
                    }
                    else
                    {
                        return true;
                    }
                }
            }
            //Log changes
            // if tolerance is exceeded. Tolerance may be zero
            else if (onToleranceExceeded || onAnyChange)
            {
                //Has value changed (by more than tolerance)?
                if (ExceedsTolerance(currVal, prevVal, tolerance))
                {
                    return true;
                }
            }

            return false;
        }

        public void LogValue(DateTime time, String shortName, String runNumber)
        {
            //Note: use UTC for time comparisions as it ignores BST etc.
            //but the values going into the log files should be BST adjusted

            //If the block is not enabled do nothing.
            if (!_blockEnabled || !_logValueToFile) return;

            if (String.IsNullOrEmpty(runNumber))
            {
                //Probably means the DAE is off, so use dummy run number
                runNumber = "00000000";
            }

            if (OkayToLog(time, _lastLogged, _loggingRate, _currentValue, _previousLogValue, _tolerance, _logChangesNow, _logChangesTolerance))
            {
                logValue(time, shortName, runNumber);
                _lastLogged = time;
                _previousLogValue = _currentValue;
            }
        }

        internal void ForceLogForChangesOnly(DateTime time, String shortName, String runNumber)
        {
            if (_logChangesNow || _logChangesTolerance)
            {
                logValue(time, shortName, runNumber);
            }
        }

        private void logValue(DateTime time, String shortName, String runNumber)
        {
            writeToFile(time, shortName, runNumber);

            if (Seci.Definitions.Status.LogToDatabase)
            {
                //Push into database
                Seci.Helpers.DatabaseLogger.AddLogValue(convertTimeToString(ref time), _blockName, _currentValue);
            }
        }

        private void writeToFile(DateTime time, String shortName, String runNumber)
        {
            String updateTime = convertTimeToString(ref time);

            //Actually format of filename not implemented yet. Should be ShortnameRunnumber_blockname.txt
            String fileName = shortName + runNumber + "_" + _blockName + ".txt";

            if (_blockName != Status.StatusBlockName && (_logToSharedFile || Status.LogAllBlocksToSingleFile))
            {
                fileName = shortName + runNumber + ".log";
            }

            StreamWriter SW = new StreamWriter("C:\\data\\" + fileName, true);

            try
            {
                if (_blockName != Status.StatusBlockName && (_logToSharedFile || Seci.Definitions.Status.LogAllBlocksToSingleFile))
                {
                    SW.WriteLine(updateTime + "\t" + _blockName + "\t" + _currentValue);
                }
                else
                {
                    SW.WriteLine(updateTime + "\t" + _currentValue);
                }
            }
            catch (Exception e)
            {
                //Throw the error up the chain
                throw new ArgumentException(e.Message);
            }
            finally
            {
                SW.Close();
            }
        }

        private static String convertTimeToString(ref DateTime time)
        {
            //Convert time to format used in previous versions of SECI
            System.Globalization.DateTimeFormatInfo myDTFI = new System.Globalization.CultureInfo("en-US", false).DateTimeFormat;
            String updateTime = time.ToString(myDTFI.SortableDateTimePattern);
            return updateTime;
        }

        public static Boolean ExceedsTolerance(String currValue, String prevValue, Double tolerance)
        {
            if (currValue == null)
            {
                return false;
            }

            //If no previous value (probably a new block or Seci started) then
            //return true
            if (prevValue == null)
            {
                return true;
            }

            //First check if it is a boolean value
            if (currValue.ToLower() == "true" || currValue.ToLower() == "false")
            {
                //Ignore any tolerances on bools as they are pointless
                if ((currValue.ToLower() == "true" && prevValue.ToLower() == "false") || (currValue.ToLower() == "false" && prevValue.ToLower() == "true"))
                {
                    //Value has changed
                    return true;
                }
                else
                {
                    //Value has not changed
                    return false;
                }
            }

            //If the tolerance is 0.0 and the value has changed return true
            if (tolerance == 0.0)
            {
                if (prevValue != currValue)
                {
                    return true;
                }
                return false;
            }

            //Otherwise, do proper test
            try
            {
                Double curr;
                Double previous;
                if (Double.TryParse(currValue, out curr) && Double.TryParse(prevValue, out previous))
                {
                    //It is a numeric value
                    if (prevValue != null)
                    {
                        if (Math.Abs(curr - previous) >= tolerance)
                        {
                            //Has exceeded tolerance
                            return true;
                        }
                    }
                    else
                    {
                        //Always log the value the first time
                        return true;
                    }
                }
            }
            catch
            {
                //probably means that could not convert a value to double
                //So do nothing as this function will return false by default
            }

            //if it gets this far then by default assume it has not exceeded tolerance
            return false;
        }

        public bool OutOfRange()
        {
            //Checks whether the block is under run-control and if so is it in range
            if (_underRunControl == true)
            {
                //Check it is not NaN
                if (_currentValue == "NaN")
                {
                    _inRange = true;
                    return false;
                }

                //Is under run control
                if (_readType == ControlType.NUMERIC || _readType == ControlType.UNKNOWN)
                {
                    //In case convert to double fails
                    try
                    {
                        Double low = _lowerLimit;
                        Double high = _upperLimit;

                        if (_lowerLimit > _upperLimit)
                        {
                            low = _upperLimit;
                            high = _lowerLimit;
                        }

                        if ((Convert.ToDouble(_currentValue) < low))
                        {
                            _inRange = false;
                            return true;
                        }

                        if ((Convert.ToDouble(_currentValue) > high))
                        {
                            _inRange = false;
                            return true;
                        }

                        _inRange = true;
                        return false;

                        //Check range
                        //if ((Convert.ToDouble(_currentValue) >= _lowerLimit) && (Convert.ToDouble(_currentValue) <= _upperLimit))
                        //{
                        //    //In range
                        //    _inRange = true;
                        //    return false;
                        //}
                        //else
                        //{
                        //    //Out of range
                        //    _inRange = false;
                        //    return true;
                        //}
                    }
                    catch
                    {
                        _inRange = true;
                        return false;
                    }
                }
                else if (_readType == ControlType.STRING || _readType == ControlType.BOOLEAN)
                {
                    if (_currentValue.ToLower().Trim() == _runcontrolValue.ToLower().Trim())
                    {
                        //In range
                        _inRange = true;
                        return false;
                    }
                    else
                    {
                        //Out of range
                        _inRange = false;
                        return true;
                    }
                }

                _inRange = true;
                return false;
            }
            else
            {
                //Not under run control, so return false as it is technically in range
                _inRange = true;
                return false;
            }
        }

        public void SetRunControlLimits(Boolean enabled, Double low, Double high)
        {
            //make sure low is less than high
            if (low > high)
            {
                _lowerLimit = high;
                _upperLimit = low;
            }
            else
            {
                _lowerLimit = low;
                _upperLimit = high;
            }

            SetRunControl(enabled);
        }

        public void SetRunControlLimits(Boolean enabled, String value)
        {
            SetRunControl(enabled);
            _runcontrolValue = value;
        }

        public void SetRunControl(Boolean enabled)
        {
            _underRunControl = enabled;
        }

        public object Clone()
        {
            // Only need a shallow copy of this class
            return MemberwiseClone();
        }
    }
}