FurnaceELK/Furnace/FurnaceRT/Equipments/Schedulers/SchedulerWaferRobot.cs

using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using FurnaceRT.Equipments.Systems;
using FurnaceRT.Equipments.WaferRobots;
using FurnaceRT.Equipments.FIMSs;

namespace FurnaceRT.Equipments.Schedulers
{
    public class SchedulerWaferRobot : SchedulerModule
    {
        public override bool IsAvailable
        {
            get { return _waferRobot.IsReady && _waferRobot.IsOnline && CheckTaskDone(); }
        }
 
        public override bool IsOnline
        {
            get { return _waferRobot.IsOnline; }

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

        }
        private WaferRobotModuleBase _waferRobot = null;

        private Hand _hand;


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

        public ModuleName PreviousTarget { get; set; }

        public SchedulerWaferRobot() : base(ModuleName.WaferRobot.ToString())
        {
            _waferRobot = Singleton<EquipmentManager>.Instance.Modules[ModuleName.WaferRobot] as WaferRobotModuleBase;

            PreviousTarget = ModuleName.System;
        }

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

            PreviousTarget = ModuleName.System;
        }

        public bool IsReadyForPick(Hand blade)
        {
            if(blade == Hand.Blade1)
            {
                return WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 0);
            }
            else if (blade == Hand.Blade2)
            {
                return WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 1) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 2) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 3) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 4);
            }
            else
            {
                return WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 0) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 1) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 2) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 3) &&
                    WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 4);
            }
        }

        public bool IsReadyForPlace(Hand blade)
        {
            if (blade == Hand.Blade1)
            {
                return WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 0);
            }
            else if (blade == Hand.Blade2)
            {
                return WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4);
            }
            else
            {
                return WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 0) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3) &&
                    WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4);
            }
        }

        public bool Pick(ModuleName source, int slot, Hand hand)
        {
            _task = TaskType.Pick;
            _hand = hand;
            if (!_waferRobot.Pick(source, hand, slot, 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)
        {
            _task = TaskType.Place;
            _hand = hand;
            if (!_waferRobot.Place(destination, hand, slot, out string reason))
            {
                LOG.Write(reason);
            }

            PreviousTarget = destination;

            LogTaskStart(_task, $"{Module}.{hand}=>{destination}.{slot + 1}");
            return true;
        }
        public bool Map(ModuleName destination, int slotNumber, string slotMap, bool isCompareWithSlotMap, bool isCreateWafer, Hand hand)
        {
            _task = TaskType.Map;
            _hand = hand;
            if (!_waferRobot.Map(destination, hand, slotNumber, slotMap, isCompareWithSlotMap, isCreateWafer, out string reason))
            {
                LOG.Write(reason);
            }

            if (destination == ModuleName.FIMS1 || destination == ModuleName.FIMS2)
                (Singleton<EquipmentManager>.Instance.Modules[destination] as FIMSModule).IsMapping = true;

            PreviousTarget = destination;

            LogTaskStart(_task, $"{Module}.{hand}=> slot number = {slotNumber}");
            return true;
        }
        public bool Goto(ModuleName target, int slot,   Hand hand )
        {
            PreviousTarget = target;
            _task = TaskType.Goto;
            //if (!_waferRobot.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.WaferRobot, 0)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4);
                    }
                    else if(_hand == Hand.Blade1)
                    {
                        ret = WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2);
                    }
                    else
                    {
                        ret = WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 1)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 2)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 3)
                            && WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, 4);
                    }
                    break;
                case TaskType.Place:
                    if (_hand == Hand.Both)
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 0)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 1)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 2)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 3)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 4);
                    }
                    else if (_hand == Hand.Blade1)
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 2);
                    }
                    else
                    {
                        ret = WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 1)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 2)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 3)
                            && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, 4);
                    }
                    break;
                case TaskType.Goto:
                    ret = _waferRobot.IsReady;
                    break;
                case TaskType.PickAndPlace:
                    ret = WaferManager.Instance.CheckHasWafer(ModuleName.WaferRobot, (int)_taskSwapPickHand)
                          && WaferManager.Instance.CheckNoWafer(ModuleName.WaferRobot, (int)_taskSwapPlaceHand);
                    break;
                case TaskType.Map:
                    var carrier = CarrierManager.Instance.GetCarrier(PreviousTarget, 0);
                    if (carrier != null)
                        ret = carrier.IsMapped;
                    else
                        ret = _waferRobot.IsReady;
                    break;
            }

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

            return ret;
        }
    }
}