ValuesUpdater.cs

Go to the documentation of this file.

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

namespace Seci.Tools
{
    class ValuesUpdater : IDisposable
    {
        private BackgroundWorker _blockUpdater;
        private BackgroundWorker _daeUpdater;
        private Timer _updateTimer;
        private TimerCallback _updateCallBack;
        private int _updateRate = 500;
        private static BlockInfo _statusBlock; //This is for logging the current run status.
        private Boolean _daeUpdating = false;
        private Boolean _timedOut = false;

        public delegate void ValuesUpdatedEventHandler(Boolean timeout);
        public event ValuesUpdatedEventHandler OnValuesUpdated;

        public ValuesUpdater(int updateRate)
        {
            if (updateRate <= 0)
            {
                _updateRate = 500;
            }
            else
            {
                _updateRate = updateRate;
            }

            createStatusBlock();

            if (_blockUpdater == null)
            {
                //Initialise the block background worker
                _blockUpdater = new BackgroundWorker();
                _blockUpdater.DoWork += new DoWorkEventHandler(blockUpdater_DoWork);
                _blockUpdater.RunWorkerCompleted += new RunWorkerCompletedEventHandler(blockUpdater_RunWorkerCompleted);
            }

            if (_daeUpdater == null)
            {
                //Initialise the dae background worker
                _daeUpdater = new BackgroundWorker();
                _daeUpdater.DoWork += new DoWorkEventHandler(_daeUpdater_DoWork);
                _daeUpdater.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_daeUpdater_RunWorkerCompleted);
            }
        }

        private void createStatusBlock()
        {
            _statusBlock = new BlockInfo();
            _statusBlock.BlockName = Status.StatusBlockName;
            _statusBlock.LoggingRate = 5;
            _statusBlock.LogChangesOnly = true;
            _statusBlock.Tolerance = 0;
            _statusBlock.LogValueToFile = true;
            _statusBlock.BlockEnabled = true;
        }

        public void StartUpdater()
        {
            if (_updateCallBack == null && _updateTimer == null)
            {
                _updateCallBack = new TimerCallback(updateTimer_Tick);
                _updateTimer = new Timer(_updateCallBack, null, 0, _updateRate);
            }
        }

        public void PauseUpdater()
        {
            if (_updateTimer != null)
            {
                _updateTimer.Change(System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite);
            }
        }

        public void ResumeUpdater()
        {
            if (_updateTimer != null)
            {
                _updateTimer.Change(0, _updateRate);
            }
        }

        private void updateTimer_Tick(object obj)
        {
            //Only update if not already running background thread
            try
            {
                if (!_blockUpdater.IsBusy)
                {
                    _blockUpdater.RunWorkerAsync();
                }
                if (!_daeUpdater.IsBusy)
                {
                    _daeUpdater.RunWorkerAsync();
                }
            }
            catch
            {
            }
        }

        private void blockUpdater_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
        {
            try
            {
                if (Status.UseDaeMonitorVI)
                {
                    Standard.DaeMonitor.GetRunControlSettings();
                }

                //Get block values for config
                Managers.BlockMgr.UpdateBlockValues();

                //Update block values on DAE monitor
                if (Status.UseDaeMonitorVI)
                {
                    //Standard.DaeMonitor.UpdateBlockValues();
                }

                //Wait for the dae thread to catch up
                //as we want the GUI to update when both are finished.
                DateTime start = DateTime.UtcNow;

                while (_daeUpdating)
                {
                    System.Threading.Thread.Sleep(100);

                    if (DateTime.UtcNow - start >= new TimeSpan(0, 0, 1))
                    {
                        //Timeout: Dae is taking too long so carry on
                        _timedOut = true;
                        break;
                    }
                    _timedOut = false;
                }
            }
            catch (Exception err)
            {
                Helpers.ErrorLogger.LabViewError("blockUpdater_DoWork", err.Message);
            }
        }

        private void blockUpdater_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
        {
            //Raise an event so the GUI can tell when the values have been updated
            if (OnValuesUpdated != null)
            {
                OnValuesUpdated(_timedOut);
            }
        }

        private void _daeUpdater_DoWork(object sender, DoWorkEventArgs e)
        {
            _daeUpdating = true;
            try
            {
                //Update the DAE values
                Standard.Dae.updateRunInformation();
                _daeUpdating = false;
            }
            catch (Exception err)
            {
                Helpers.ErrorLogger.SeciError("daeUpdater_DoWork", err);
            }

            logStatusBlock(false);
        }

        private static void logStatusBlock(Boolean force)
        {
            try
            {
                //Log the dae status
                if (_statusBlock != null)
                {
                    String tempStatus = Seci.Standard.Dae.RunStatus;

                    if (String.IsNullOrEmpty(tempStatus))
                    {
                        tempStatus = "Unknown";
                    }

                    if (force || tempStatus.ToLower() != _statusBlock.CurrentValue.ToLower())
                    {
                        _statusBlock.CurrentValue = tempStatus;

                        _statusBlock.ForceLogForChangesOnly(DateTime.Now, Status.ShortInstrument, Standard.Dae.RunNumber);
                    }
                }
            }
            catch (Exception err)
            {
                Helpers.ErrorLogger.LabViewError("daeUpdater_DoWork problem writing status file", err.Message);
            }
        }

        private void _daeUpdater_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            _daeUpdating = false;
        }

        public static void LogValuesAtStartOrEndRun(DateTime time, string runNumber)
        {
            //Force log of status block
            logStatusBlock(true);

            for (int i = 0; i < Managers.BlockMgr.Blocks.Count; ++i)
            {
                Managers.BlockMgr.Blocks[i].ForceLogForChangesOnly(time, Status.ShortInstrument, runNumber);
            }
        }


        #region IDisposable Members

        public void Dispose()
        {
            try
            {
                Dispose(true);
            }
            finally
            {
                GC.SuppressFinalize(this);
            }
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                // Dispose managed resources.
                if (_blockUpdater != null) _blockUpdater.Dispose();
                if (_updateTimer != null) _updateTimer.Dispose();
            }

            _blockUpdater = null;
            _updateTimer = null;
        }

        #endregion
    }
}