Virgo_Mask/VirgoRT/Modules/Schedulers/SchedulerBuffer.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Threading.Tasks;

using MECF.Framework.Common.Equipment;
using VirgoRT.Scheduler;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;

namespace VirgoRT.Modules.Schedulers
{
    public class SchedulerBuffer :  SchedulerModule
    {
        private readonly int _MAX_SLOT = SC.GetValue<int>("EFEM.Buffer.SlotNumber");

        public override bool IsAvailable
        {
            get
            {
                return CheckTaskDone();
            }
        }
        public SchedulerBuffer(ModuleName buffer) : base(buffer.ToString())
        {
            EventWaferArrived += WaferArrived;
        }

        private void WaferArrived(object sender, EventArgs e)
        {
            var eArgs = e as WaferMoveArgs;
            WaferArriveTicks[eArgs.DstSlot] = DateTime.Now.Ticks;
        }

        private DeviceTimer _timerCooling = new DeviceTimer();
        private float _paramCoolingTime = 0;

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

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

            _timerCooling.Start(_paramCoolingTime * 1000);

            return true;
        }

        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.Cooling:
                    ret = _timerCooling.IsTimeout();
                    break;
            }

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

            return ret;
        }


        public override SlotItem GetReadyOutSlot()
        {
            double maxDelay = 0;
            SlotItem item = new SlotItem(ModuleName.System, -1);

            if (AutoTransfer_T.GetSystemInnerWaferCount() >= AutoTransfer_T.SystemInternalWaferCount)
                return item;

            for (int i = 0; i < _MAX_SLOT; i++)
            {
                var wafer = WaferManager.Instance.GetWafer(Module, i);

                if (wafer.IsEmpty || wafer.NextSequenceStep > wafer.ProcessJob.Sequence.Steps.Count)  // wafer.NextSequenceStep already increased after wafer arrive
                    continue;

                if (!wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep - 1].StepParameter.ContainsKey("CoolingTime")) // parameter name may change
                    continue;

                float stayTime;
                if (!float.TryParse((string)wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep - 1].StepParameter["CoolingTime"], out stayTime))
                    continue;

                long elapsedTicks = DateTime.Now.Ticks - WaferArriveTicks[i];
                TimeSpan elapsedSpan = new TimeSpan(elapsedTicks);
                double delay = elapsedSpan.TotalSeconds - stayTime;
                if (delay > maxDelay)
                {
                    maxDelay = delay;
                    item.Module = Module;
                    item.Slot = i;
                }
            }

            return item;
        }
    }
}