Mars200VCE/Metis/EfemDualSchedulerLib/Schedulers/SchedulerTM.cs

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.SubstrateTrackings;
using MECF.Framework.RT.ModuleLibrary.EfemModules;
using MECF.Framework.RT.ModuleLibrary.SystemModules;
using MECF.Framework.RT.ModuleLibrary.TMModules;

namespace EfemDualSchedulerLib.Schedulers
{
    public class SchedulerTM : SchedulerModule
    {
        public override bool IsAvailable
        {
            get { return _tm.IsReady && _tm.IsOnline && CheckTaskDone(); }
        }

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

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

        }

        public bool Blade1Enable
        {
            get => SC.GetValueOrDefault<bool>($"TM.TMRobot.LowerBladeEnable");
        }

        public bool Blade2Enable
        {
            get => SC.GetValueOrDefault<bool>($"TM.TMRobot.UpperBladeEnable");
        }

        private TMModuleBase _tm = null;

        private Hand _hand;


        private Hand _taskSwapPickHand;
        private Hand _taskSwapPlaceHand;
        private int _taskSwapPickSlot;
        private int _taskSwapPlaceSlot;

        public ModuleName PreviousTarget { get; set; }

        public SchedulerTM(TMModuleBase moduleDevice) : base(ModuleName.TM.ToString())
        {
            _tm = moduleDevice;

            PreviousTarget = ModuleName.System;
        }

        public override void ResetTask()
        {
            base.ResetTask();

            PreviousTarget = ModuleName.System;
        }

        public override bool HasWafer(int slot)
        {
            return WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, slot);
        }

        public override bool NoWafer(int slot)
        {
            return WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, slot);
        }

        public bool IsReadyForPick(Hand blade)
        {
            return WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)blade);
        }

        public bool IsReadyForPlace(Hand blade)
        {
            return WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)blade);
        }

        public bool Pick(ModuleName source, int slot, Hand hand, double temp1, double temp2, bool enableCheckTemp)
        {
            _task = TaskType.Pick;
            _hand = hand;
            if (!_tm.Pick(source, hand, slot, temp1, temp2, enableCheckTemp, out string reason))
            {
                LOG.Write(reason);
            }

            PreviousTarget = source;

            LogTaskStart(_task, $"{source}.{slot + 1}=>{Module}.{hand}");
            return true;
        }

        public bool Place(ModuleName destination, int slot, Hand hand, double temp1, double temp2, bool enableCheckTemp)
        {
            _task = TaskType.Place;
            _hand = hand;
            if (!_tm.Place(destination, hand, slot, temp1, temp2, enableCheckTemp, out string reason))
            {
                LOG.Write(reason);
            }

            PreviousTarget = destination;

            LogTaskStart(_task, $"{Module}.{hand}=>{destination}.{slot + 1}");
            return true;
        }

        public bool Map(ModuleName destination)
        {
            _task = TaskType.Map;
            if (!_tm.Map(destination, out string reason))
            {
                LOG.Write(reason);
            }

            PreviousTarget = destination;
            LogTaskStart(_task, $"mapping {Module}");

            return true;
        }

        public bool PickAndPlace(ModuleName target, int pickSlot, int placeSlot, Hand pickHand, Hand placeHand)
        {
            PreviousTarget = target;
            _task = TaskType.PickAndPlace;
            _taskSwapPickHand = pickHand;
            _taskSwapPlaceHand = placeHand;
            _taskSwapPickSlot = pickSlot;
            _taskSwapPlaceSlot = placeSlot;
            LogTaskStart(_task, $" {target}.{pickSlot + 1}=>{Module}.{pickHand} && {Module}.{placeHand}=>{target}.{placeSlot + 1}");
            return _tm.PickAndPlace(target, pickHand, pickSlot, target, placeHand, placeSlot, out _);
        }

        public bool Goto(ModuleName target, int slot, Hand hand)
        {
            PreviousTarget = target;
            _task = TaskType.Goto;
            if (!_tm.Goto(target, hand, slot, out string reason))
            {
                LOG.Write(reason);
            }

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

        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.Pick:
                    if (_hand == Hand.Both)
                    {
                        ret = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)Hand.Blade1)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)Hand.Blade2);
                    }
                    else
                    {
                        ret = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)_hand);
                    }
                    break;
                case TaskType.Place:
                    if (_hand == Hand.Both)
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)Hand.Blade1)
                              && WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)Hand.Blade2);
                    }
                    else
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)_hand);
                    }
                    break;
                case TaskType.Map:
                    ret = _tm.IsReady;
                    break;
                case TaskType.Goto:
                    ret = _tm.IsReady;
                    break;
                case TaskType.PickAndPlace:
                    ret = WaferManager.Instance.CheckHasWafer(ModuleName.TMRobot, (int)_taskSwapPickHand)
                          && WaferManager.Instance.CheckNoWafer(ModuleName.TMRobot, (int)_taskSwapPlaceHand);
                    break;
            }

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

            return ret;
        }
    }
}