BlockMgr.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using Seci.Definitions;

namespace Seci.Managers
{
    public static class BlockMgr
    {
        private static BlockDictionary _blocks = new BlockDictionary();
        private static SerialisableList<Definitions.BlockGroup> _groups = new SerialisableList<Definitions.BlockGroup>();
        private static DateTime _timeWentOutOfRange = new DateTime();
        private static Boolean _logValuesEnabled = true;

        public static BlockDictionary Blocks { get { return _blocks; } }
        public static SerialisableList<BlockGroup> Groups { get { return _groups; } internal set { _groups = value; } }

        public delegate void EnableLoggingChangedEventHandler(Boolean enabled);
        public static event EnableLoggingChangedEventHandler OnEnableLoggingUpdated;
        public static Boolean LogValuesEnabled
        {
            get { return _logValuesEnabled; }
            set
            {
                _logValuesEnabled = value;
                if (OnEnableLoggingUpdated != null)
                {
                    OnEnableLoggingUpdated(value);
                }
            }
        }

        #region Public Methods

        public static void SetBlocks(BlockDictionary blocks)
        {
            _blocks = blocks;
            if (Seci.Definitions.Status.LogToDatabase)
            {
                Seci.Helpers.DatabaseLogger.WriteBlockDetails();
            }
        }

        public static BlockDictionary GetBlocksClone()
        {
            BlockDictionary blocks;

            try
            {
                //Get list of all blocks include any in components
                blocks = (BlockDictionary)_blocks.Clone();

                if (blocks == null)
                {
                    //config does not contain any blocks
                    blocks = new BlockDictionary();
                }
            }
            catch (Exception err)
            {
                Helpers.ErrorLogger.SeciError("GetAllBlocks", err);
                blocks = new BlockDictionary();
            }

            return blocks;
        }

        public static List<String> GetAllBlockValues(Boolean visibleOnly, Boolean includeSetpoint, Boolean includeGroup, Boolean includeWaitState)
        {
            List<String> blocks = new List<String>();

            if (_blocks.Count != 0)
            {
                blocks.AddRange(_blocks.GetFormattedBlockValues(visibleOnly, includeSetpoint, includeGroup, includeWaitState));
            }

            if (blocks.Count != 0)
            {
                return blocks;
            }
            else
            {
                return null;
            }
        }

        public static String GetBlockValue(String blockname)
        {
            return _blocks.GetBlockValue(blockname);
        }

        public static String GetFormattedBlockValue(String blockname, Boolean includeSetpoint, Boolean includeGroup, Boolean includeWaiting)
        {
            return _blocks.GetFormattedBlockValue(blockname, includeSetpoint, includeGroup, includeWaiting);
        }

        public static String GetBlockSetpoint(String block)
        {
            return _blocks.GetSetpointValue(block);
        }

        public static Boolean SetBlockRunControl(String blockname, Boolean enabled, Double low, Double high)
        {
            if (_blocks.Contains(blockname.ToLower()))
            {
                _blocks[blockname.ToLower()].SetRunControlLimits(enabled, low, high);
                return true;
            }

            return false;
        }

        public static Boolean ToggleRunContol(String blockname, Boolean enabled)
        {
            if (_blocks.Contains(blockname.ToLower()))
            {
                _blocks[blockname.ToLower()].SetRunControl(enabled);
                return true;
            }

            return false;
        }

        public static bool BlockGroupExists(string name)
        {
            for (int i = 0; i < _groups.Count; ++i)
            {
                if (name.ToLower().Trim() == _groups[i].Name.ToLower().Trim())
                {
                    return true;
                }
            }

            return false;
        }

        public static void ReorderBlockGroups(List<string> neworder)
        {
            SerialisableList<BlockGroup> newList = new SerialisableList<BlockGroup>();
            foreach (string name in neworder)
            {
                newList.Add(new BlockGroup(name));
            }

            _groups = newList;
        }

        #endregion

        internal static void UpdateBlockValues()
        {
            Boolean allInRange = true;

            for (int i = 0; i < Managers.BlockMgr.Blocks.Count; ++i)
            {
                //Check that block is enabled
                if (Managers.BlockMgr.Blocks[i].BlockEnabled)
                {
                    //Update value
                    try
                    {
                        Managers.BlockMgr.Blocks[i].CurrentValue = Seci.LabView.LabViewApp.GetValue(Managers.BlockMgr.Blocks[i].ParentVI, Managers.BlockMgr.Blocks[i].ReadControl)[0];
                        Managers.BlockMgr.Blocks[i].PrevReadError = false;
                        if (Managers.BlockMgr.Blocks[i].WriteControl != null)
                        {
                            try
                            {
                                Managers.BlockMgr.Blocks[i].SetPointValue = Seci.LabView.LabViewApp.GetValue(Managers.BlockMgr.Blocks[i].ParentVI, Managers.BlockMgr.Blocks[i].WriteControl)[0];
                            }
                            catch (Exception err)
                            {
                                Managers.BlockMgr.Blocks[i].SetPointValue = null;
                                //Seci.Helpers.ErrorLogger.SeciError("UpdateBlockValues GetSetpoint (" + Managers.BlockMgr.Blocks[i].BlockName + " ) ", err);
                            }
                        }

                        if (Seci.Definitions.Status.LogToDatabase)
                        {
                            //Push into database
                            Seci.Helpers.DatabaseLogger.AddCurrentValue(Managers.BlockMgr.Blocks[i].BlockName, Managers.BlockMgr.Blocks[i].CurrentValue, Managers.BlockMgr.Blocks[i].SetPointValue);
                        }
                    }
                    catch (Exception err)
                    {
                        Managers.BlockMgr.Blocks[i].CurrentValue = Definitions.BlockInfo.ErrorString;
                        Managers.BlockMgr.Blocks[i].SetPointValue = null;
                        if (!Managers.BlockMgr.Blocks[i].PrevReadError)
                        {
                            //Log it only the first time it throws
                            Managers.BlockMgr.Blocks[i].PrevReadError = true;
                            Seci.Helpers.ErrorLogger.SeciError("UpdateBlockValues (" + Managers.BlockMgr.Blocks[i].BlockName + ")", err);
                        }
                    }
                }

                //Check whether is in range
                if (Managers.BlockMgr.Blocks[i].OutOfRange())
                {
                    //Don't come out of waiting
                    allInRange = false;

                    //Tell DAE to go into waiting state immediately, if not already
                    Standard.Dae.BeginWaiting();
                }

                //Do we need to raise an alert?
                AlertsMgr.CheckBlockInRange(Managers.BlockMgr.Blocks[i]);

                //Then log, if necessary
                if (_logValuesEnabled)
                {
                    Managers.BlockMgr.Blocks[i].LogValue(DateTime.Now, Definitions.Status.ShortInstrument, Standard.Dae.RunNumber);
                }
            }

            //See if should come out of waiting
            if (allInRange)
            {
                //Tell DAE to come out of waiting
                Standard.Dae.EndWaiting();
            }

            if (Standard.Dae.RunStatus == "WAITING")
            {
                AlertsMgr.CheckInWaiting(true);
            }
            else
            {
                AlertsMgr.CheckInWaiting(false);
            }
        }

    }
}