FurnaceNTP/Furnace/FurnaceRT/Equipments/Schedulers/SchedulerFIMS.cs

using Aitex.Core.Common;
using Aitex.Core.RT.Fsm;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using FurnaceRT.Equipments.PMs;
using FurnaceRT.Equipments.FIMSs;
using FurnaceRT.Equipments.Systems;

namespace FurnaceRT.Equipments.Schedulers
{
    public class SchedulerFIMS : SchedulerModule
    {
        public override bool IsAvailable
        {
            get { return _pm.IsReady && _pm.IsOnline && CheckTaskDone() && !_pm.IsMapping; }

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

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

        }
        private FIMSModule _pm = null;

        private ModuleName _taskRobot;
        private EnumTransferType _taskTransferType;
        private int _taskSlot;

        private DeviceTimer _timer = new DeviceTimer();

        public SchedulerFIMS(ModuleName chamber) : base(chamber.ToString())
        {
            _pm = Singleton<EquipmentManager>.Instance.Modules[chamber] as FIMSModule;

            System.Diagnostics.Trace.Assert(_pm != null);
        }

        public override bool IsReadyForPick(ModuleName robot, int slot)
        {
            if (robot == ModuleName.CarrierRobot)
                return _pm.CheckReadyForTransfer(robot, Hand.Blade1, slot, EnumTransferType.Pick, out _)
                   && CarrierManager.Instance.CheckHasCarrier(ModuleHelper.Converter(_module), 0);
            if (robot == ModuleName.WaferRobot)
                return _pm.CheckReadyForTransfer(robot, Hand.Blade1, slot, EnumTransferType.Pick, out _)
                       && WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot);

            return false;
        }

        public override bool IsReadyForPlace(ModuleName robot, int slot)
        {
            if (robot == ModuleName.CarrierRobot)
                return _pm.CheckReadyForTransfer(robot, Hand.Blade1, slot, EnumTransferType.Place, out _)
                   && CarrierManager.Instance.CheckNoCarrier(ModuleHelper.Converter(_module), 0);
            if (robot == ModuleName.WaferRobot)
                return _pm.CheckReadyForTransfer(robot, Hand.Blade1, slot, EnumTransferType.Place, out _)
                       && WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);

            return false;
        }

        public override bool PrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            _task = TaskType.PrepareTransfer;
            _taskRobot = robot;
            _taskSlot = slot;
            _taskTransferType = type;
            if (!_pm.PrepareTransfer(robot, Hand.Blade1, slot, type, out string reason))
            {
                LOG.Write(reason);
                return false;
            }

            LogTaskStart(_task, $"{robot} {type} slot {slot + 1}");
            return true;
        }

        public bool IsPrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            return _task == TaskType.PrepareTransfer && _taskRobot == robot && _taskSlot == slot &&
                   _taskTransferType == type;
        }
        public bool Load()
        {
            _task = TaskType.Load;
            _pm.InvokeLoad();

            LogTaskStart(_task, $"{Module} load start");
            return true;
        }
        public bool Unload()
        {
            _task = TaskType.Unload;
            _pm.InvokeUnload();

            LogTaskStart(_task, $"{Module} unload start");
            return true;
        }
        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.PrepareTransfer:
                    ret = _pm.CheckReadyForTransfer(_taskRobot, Hand.Blade1, _taskSlot, _taskTransferType, out _);
                    break;
                case TaskType.Process:
                    ret = _pm.IsReady;
                    break;
                case TaskType.Load:
                    ret = _pm.FIMSDevice.IsLoadCompleted;
                    break;
                case TaskType.Unload:
                    ret = _pm.FIMSDevice.IsUnloadCompleted;
                    break;
            }

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

            return ret;
        }

        public bool Monitor()
        {
            return true;
        }

    }
}