Bridge.cs

Go to the documentation of this file.

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

namespace Seci.Remoting
{
    class Bridge
    {
        #region LabVIEW

        public static Object GetLabViewValue(String vi, String control)
        {
            try
            {
                return LabView.LabViewApp.GetRawValue(vi, control);
            }
            catch
            {
                return null;
            }
        }

        public static Boolean SetLabViewValue(String vi, String control, Object value)
        {
            try
            {
                return LabView.LabViewApp.SetRawValue(vi, control, value);
            }
            catch
            {
                return false;
            }
        }

        public static String[] GetVIsFullpath()
        {
            try
            {
                List<String> vis = LabView.LabViewApp.GetListOfAllVIs(true);
                return vis.ToArray();
            }
            catch
            {
                return null;
            }
        }

        #endregion

        #region Blocks

        public static String GetBlockValue(String blockName)
        {
            try
            {
                return Managers.BlockMgr.GetBlockValue(blockName);
            }
            catch
            {
                return null;
            }
        }

        public static Object GetRawBlockValue(String blockName)
        {
            try
            {
                BlockInfo temp = Managers.BlockMgr.Blocks[blockName.ToLower()];
                return GetLabViewValue(temp.ParentVI, temp.ReadControl);
            }
            catch
            {
                return null;
            }
        }

        public static Object GetRawSetpoint(String blockName)
        {
            try
            {
                BlockInfo temp = Managers.BlockMgr.Blocks[blockName.ToLower()];
                return GetLabViewValue(temp.ParentVI, temp.WriteControl);
            }
            catch
            {
                return null;
            }
        }

        public static Boolean SetRawBlockValue(String blockName, object value)
        {
            try
            {
                BlockInfo temp = Managers.BlockMgr.Blocks[blockName.ToLower()];
                SetLabViewValue(temp.ParentVI, temp.WriteControl, value);

                return true;
            }
            catch
            {
                return false;
            }
        }

        public static String[] GetAllBlockValues(Boolean visibleOnly, Boolean includeSetpoint, Boolean includeGroup, Boolean includeWaitState)
        {
            try
            {
                return Managers.BlockMgr.GetAllBlockValues(visibleOnly, includeSetpoint, includeGroup, includeWaitState).ToArray();
            }
            catch
            {
                return null;
            }
        }

        public static String[] GetBlockNames(Boolean includeHidden)
        {

            return GetBlockNames(includeHidden, false);
        }


        public static String[] GetBlockNames(Boolean includeHidden, Boolean includeAliases)
        {
            try
            {
                String[] keys = Managers.BlockMgr.Blocks.GetKeys();
                List<String> results = new List<string>();

                for (int i = 0; i < keys.GetLength(0); ++i)
                {
                    var temp = Managers.BlockMgr.Blocks[keys[i]];
                    if (!includeHidden && !temp.Visible)
                    {
                        continue;
                    }

                    results.Add(temp.BlockName);

                    if (!String.IsNullOrEmpty(temp.Alias))
                    {
                        results.Add(temp.Alias);
                    }
                }

                return results.ToArray();
            }
            catch
            {
                return null;
            }
        }

        public static String[,] GetBlockAliases()
        {
            try
            {
                String[] keys = Managers.BlockMgr.Blocks.GetKeys();
                String[] aliases = Managers.BlockMgr.Blocks.GetAliases();

                String[,] results = new String[keys.GetLength(0), 2];

                for (int i = 0; i < keys.GetLength(0); ++i)
                {
                    results[i, 0] = keys[i];
                    results[i, 1] = aliases[i];
                }

                return results;
            }
            catch
            {
                return null;
            }
        }

        public static String[,] GetBlocks()
        {
            try
            {
                return Managers.BlockMgr.Blocks.GetLabVIEWInfo();
            }
            catch
            {
                return null;
            }

        }

        public static Boolean SetBlockValue(String blockName, String value)
        {
            try
            {
                //First check that it is not already in motion
                if (!checkForWaitFor(blockName))
                {
                    BlockDictionary blocks = Managers.BlockMgr.Blocks;

                    if (blocks.Count != 0)
                    {
                        if (blocks.Contains(blockName))
                        {
                            //Set value
                            BlockInfo temp = (BlockInfo)blocks[blockName];

                            //Check block enabled
                            if (temp.BlockEnabled)
                            {
                                //Set value
                                if (LabView.LabViewApp.SetValue(temp.ParentVI, temp.WriteControl, value))
                                {

                                    //May need to press button
                                    if (!String.IsNullOrEmpty(temp.GoButton))
                                    {
                                        LabView.LabViewApp.SetValue(temp.ParentVI, temp.GoButton, true);
                                    }

                                    //Pause for a second
                                    System.Threading.Thread.Sleep(1000);

                                    return true;
                                }
                            }
                        }
                    }
                }
                return false;
            }
            catch
            {
                return false;
            }
        }

        public static Boolean UnderRunControl(String blockName)
        {
            return Managers.BlockMgr.Blocks[blockName].UnderRunControl;
        }

        public static Boolean CheckForWaitingState(String blockName)
        {
            try
            {
                return checkForWaitFor(blockName);
            }
            catch
            {
                return false;
            }

        }

        private static Boolean checkForWaitFor(String blockName)
        {
            if (Managers.BlockMgr.Blocks.Contains(blockName))
            {
                if (!String.IsNullOrEmpty(Managers.BlockMgr.Blocks[blockName].WaitForControl))
                {
                    return Convert.ToBoolean(LabView.LabViewApp.GetValue(Managers.BlockMgr.Blocks[blockName].ParentVI, Managers.BlockMgr.Blocks[blockName].WaitForControl));
                }
            }

            return false;
        }

        public static String[,] GetNexusInfo()
        {
            try
            {
                //Get all blocks including any in a component
                BlockDictionary blocks = Managers.BlockMgr.Blocks;

                String[,] results = new String[blocks.Count, 5];

                int count = 0;

                for (int i = 0; i < blocks.Count; ++i)
                {
                    results[count, 0] = blocks[i].BlockName;
                    results[count, 1] = blocks[i].NexusName;
                    results[count, 2] = blocks[i].NexusGroup;
                    results[count, 3] = blocks[i].ParentVI;
                    results[count, 4] = blocks[i].ReadControl;
                    ++count;
                }

                return results;
            }
            catch
            {
                return null;
            }
        }

        public static Boolean IsInRange(String blockName)
        {
            return !Managers.BlockMgr.Blocks[blockName].OutOfRange();
        }

        public static void EnableBlocksLogging(Boolean enable)
        {
            Managers.BlockMgr.LogValuesEnabled = enable;
        }

        public static Boolean BlocksLoggingStatus()
        {
            return Managers.BlockMgr.LogValuesEnabled;
        }

        #endregion

        #region DAE

        public static Boolean BeginRun()
        {
            try
            {
                Standard.Dae.BeginRun();

                //Should we check that the run has begun?

                return true;
            }
            catch
            {
                return false;
            }
        }

        public static Boolean EndRun()
        {
            try
            {
                Standard.Dae.EndRun();

                //Should we check that this worked?

                return true;
            }
            catch
            {
                return false;
            }
        }


        public static Boolean PauseRun()
        {
            try
            {
                Standard.Dae.PauseRun();

                //Should we check that this worked?

                return true;
            }
            catch
            {
                return false;
            }
        }


        public static Boolean ResumeRun()
        {
            try
            {
                Standard.Dae.ResumeRun();

                //Should we check that this worked?

                return true;
            }
            catch
            {
                return false;
            }
        }


        public static Boolean AbortRun()
        {
            try
            {
                Standard.Dae.AbortRun();

                //Should we check that this worked?

                return true;
            }
            catch
            {
                return false;
            }
        }


        public static Boolean SaveRun()
        {
            try
            {
                Standard.Dae.SaveRun();

                //Should we check that this worked?

                return true;
            }
            catch
            {
                return false;
            }
        }


        public static String GetRunStatus()
        {
            return Standard.Dae.RunStatus;
        }

        public static String[] GetRunInfo()
        {
            return Standard.Dae.GetFormattedValues(true, Definitions.Status.IsMuonInstrument).ToArray();
        }

        #endregion

        #region Configurations

        public static String GetCurrentConfig()
        {
            try
            {
                return Managers.ConfigurationMgr.ConfigName;
            }
            catch
            {
                return null;
            }
        }

        public static String[] GetListOfConfigs()
        {
            try
            {
                System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(Status.ConfigDir);

                System.IO.FileInfo[] files = di.GetFiles("*.conf");

                String[] configs = new String[files.GetLength(0)];

                for (int i = 0; i < files.GetLength(0); ++i)
                {
                    configs[i] = files[i].Name;
                }

                return configs;
            }
            catch
            {
                return null;
            }
        }

        public static int ChangeConfig(String configName)
        {
            try
            {
                if (!String.IsNullOrEmpty(configName))
                {
                    if (configName.EndsWith(".conf") || configName.EndsWith(".comp"))
                    {
                        return Managers.ConfigurationMgr.RemoteConfigurationChange(configName);
                    }
                }

                return 1;
            }
            catch
            {
                return 2;
            }
        }

        public static Boolean IsBusy()
        {
            return Seci.Managers.SeciMgr.IsBusy;
        }

        #endregion

        #region Misc

        public static void ClearGraphs()
        {
            Managers.SeciMgr.ClearGraphs();
        }

        #endregion
    }
}