Virgo_Mask/VirgoRT/Modules/Schedulers/SchedulerAligner.cs

using System.Diagnostics;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Fsm;
using Aitex.Core.Util;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using VirgoRT.Scheduler;

namespace VirgoRT.Modules.Schedulers
{
    public class SchedulerAligner : SchedulerModule
    {
        public override bool IsAvailable
        {
            get { return /*_entity.IsIdle &&*//* _entity.IsOnline && */CheckTaskDone(); }

        }
        public override bool IsOnline
        {
            get { return _entity.IsOnline; }

        }
        public override bool IsError
        {
            get { return _entity.IsError; }

        }
        private EfemEntity _entity = null;
        private bool _isCooling;

        private DeviceTimer _timerCooling = new DeviceTimer();
        private float _paramCoolingTime = 0;
        private int _token;
        private int _coolingDelayTime;
        private Stopwatch _timerDelay = new Stopwatch();

        private DeviceTimer _timerAligning = new DeviceTimer();

        public SchedulerAligner(ModuleName chamber) : base(chamber.ToString())
        {
            _entity = Singleton<RouteManager>.Instance.EFEM;

            _isCooling = chamber == ModuleName.Cooling1 || chamber == ModuleName.Cooling2;
        }

        public override bool IsReadyForPick(ModuleName robot, int slot, Hand blade)
        {
            return WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot);
        }

        public override bool IsReadyForPlace(ModuleName robot, int slot, Hand blade)
        {
            return WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);
        }

        public override bool Cooling(int coolingTime)
        {
            _task = TaskType.Cooling;

            LogTaskStart(_task, $"Cooling {coolingTime} seconds");

            _coolingDelayTime = SC.GetValue<int>("EFEM.DelayTimeBeforeLiftDown");

            _paramCoolingTime = coolingTime;

            _timerDelay.Restart();

            //_token = _efemEntity.InvokeCooling(Module.ToString(), time);

            return true;//_token != (int)FSM_MSG.NONE;
        }

        public bool Monitor()
        {

            return true;
        }

        public override bool Align(float time) 
        {
            _task = TaskType.Align;
 
            LogTaskStart(_task, _isCooling ? $"Cooling {time} seconds": $"Aligning");

            _paramCoolingTime = time;
            _timerCooling.Start(_paramCoolingTime * 1000);

            _timerDelay.Restart();
            if (_entity.EFEMType == EfemEntity.EfemType.BrooksEFEM || _entity.EFEMType == EfemEntity.EfemType.BeamSUNWAY)
            {
                _token = _entity.InvokeAlign(Module.ToString(), time);
            }
            else
            {
                Singleton<RouteManager>.Instance.EFEM.EfemDevice.SetPinDown(Module);
            }

            return true;// _token != (int)FSM_MSG.NONE;
        }

        public override bool PostTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            StopWaitTransfer(robot);

            if (type == EnumTransferType.Place)
            {
                _task = TaskType.Align;
                LogTaskStart(_task, $"Waiting {_paramCoolingTime} seconds");

                _timerCooling.Start(_paramCoolingTime*1000);
            }


            return true;
        }

        public override bool PostTransfer(ModuleName robot)
        {
            StopWaitTransfer(robot);

            return true;
        }

        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.Align:
                    if (_timerDelay.IsRunning && _timerDelay.ElapsedMilliseconds > 1 * 1000)
                    {
                        _timerDelay.Stop();
                    }

                    ret = !_timerDelay.IsRunning && _timerCooling.IsTimeout() && _entity.IsIdle && IsAligned();
                    break;
                case TaskType.Cooling:
                    if (_timerDelay.IsRunning && _timerDelay.ElapsedMilliseconds > _coolingDelayTime * 1000)
                    {
                        _timerDelay.Stop();

                        //_token = _efemEntity.InvokeLiftDown(Module.ToString());

                        Singleton<RouteManager>.Instance.EFEM.EfemDevice.SetPinDown(Module);

                        //lift pin down time = 2seconds
                        _timerCooling.Start(_paramCoolingTime * 1000 + 2 * 1000);

                        break;
                    }

                    ret = !_timerDelay.IsRunning && _timerCooling.IsTimeout() && _entity.IsIdle;
                    break;
            }

            if (ret && _task != TaskType.None)
            {
                LogTaskDone(_task, "");
                _task = TaskType.None;
            }

            return ret;
        }

        private bool IsAligned()
        {
            if(_entity.EFEMType == EfemEntity.EfemType.BrooksEFEM || _entity.EFEMType == EfemEntity.EfemType.BeamSUNWAY)
                return _entity.CheckAcked(_token);
            else
                return !_entity.EfemDevice.IsBufferPinUp[Module];
        }
    }
}