SicMultiplate/SicRT/Equipments/ManualTransfer.cs

using System.Collections.Generic;
using System.Diagnostics;
using Aitex.Core.RT.Routine;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Schedulers;
using SicModules.Aligners.Routines;
using SicRT.Modules.Schedulers;

namespace SicRT.Equipments
{
    public class MoveItemEx : MoveItem
    {
        public int CoolingTime { get; set; }

        public MoveItemEx(ModuleName sourceModule, int sourceSlot, ModuleName destinationModule, int destinationSlot, int coolingTime)
            : base(sourceModule, sourceSlot, destinationModule, destinationSlot, Hand.Blade1)
        {
            CoolingTime = coolingTime;
        }
    }

    public class ManualTransfer : SchedulerModuleFactory
    {
        private Queue<IRoutine> _moveTaskQueue = new Queue<IRoutine>();
        private IRoutine _activeTask;

        public Result Start(object[] objs)
        {
            _moveTaskQueue.Clear();

            ModuleName source = (ModuleName)objs[0];
            int sourceSlot = (int)objs[1];
            ModuleName target = (ModuleName)objs[2];
            int destinationSlot = (int)objs[3];

            //判断传盘路径是否valid
            if (!CheckCanMoveRange(source, target))
            {
                EV.PostWarningLog("System", $"Invalid path,can not transfer from {source} to {target}");
                return Result.DONE;
            }

            //TM范围内传盘
            if (IsTmRobotRange(source) && IsTmRobotRange(target))
            {
                if (!WaferManager.Instance.CheckHasTray(source, sourceSlot))
                {
                    EV.PostWarningLog("System", "source no tray");
                    return Result.FAIL;
                }
                if (!WaferManager.Instance.CheckNoTray(target, destinationSlot))
                {
                    EV.PostWarningLog("System", "destination has tray");
                    return Result.FAIL;
                }

                _moveTaskQueue.Enqueue(new TmRobotMover(new MoveItemEx(source, sourceSlot, target, destinationSlot, 0)));
            }
            else if (IsTrayRobotRange(source) && IsTrayRobotRange(target))
            {
                if (!WaferManager.Instance.CheckHasTray(source, sourceSlot))
                {
                    EV.PostWarningLog("System", "source no tray");
                    return Result.FAIL;
                }
                if (!WaferManager.Instance.CheckNoTray(target, destinationSlot))
                {
                    EV.PostWarningLog("System", "destination has tray");
                    return Result.FAIL;
                }

                _moveTaskQueue.Enqueue(new TrayRobotMover(new MoveItemEx(source, sourceSlot, target, destinationSlot, 0)));
            }
            else if (IsWaferRobotRange(source) && IsWaferRobotRange(target))
            {
                if (!WaferManager.Instance.CheckHasWafer(source, sourceSlot))
                {
                    EV.PostWarningLog("System", "source no wafer");
                    return Result.FAIL;
                }

                if (!WaferManager.Instance.CheckNoWafer(target, destinationSlot))
                {
                    EV.PostWarningLog("System", "destination has wafer");
                    return Result.FAIL;
                }

                if (target == ModuleName.WaferRobot && source != ModuleName.Aligner)
                {
                    _moveTaskQueue.Enqueue(new WaferRobotMover(new MoveItemEx(source, sourceSlot, target, destinationSlot, 0)));
                }
                else if (source == ModuleName.WaferRobot)
                {
                    _moveTaskQueue.Enqueue(new WaferRobotMover(new MoveItemEx(source, sourceSlot, target, destinationSlot, 0)));
                }
                else if (source != ModuleName.Aligner)
                {
                    _moveTaskQueue.Enqueue(new WaferRobotMover(new MoveItemEx(source, sourceSlot, ModuleName.Aligner, 0, 0)));

                    if (target != ModuleName.Aligner)
                    {
                        _moveTaskQueue.Enqueue(new AlignerAlignRoutine());
                        _moveTaskQueue.Enqueue(new WaferRobotMover(new MoveItemEx(ModuleName.Aligner, 0, target, destinationSlot, 0)));
                    } 
                }
                else
                {
                    _moveTaskQueue.Enqueue(new AlignerAlignRoutine());
                    if (target != ModuleName.Aligner)
                    {
                        _moveTaskQueue.Enqueue(new WaferRobotMover(new MoveItemEx(ModuleName.Aligner, 0, target, destinationSlot, 0)));
                    }  
                }
            }

            _activeTask = _moveTaskQueue.Dequeue();

            return _activeTask.Start();
        }


        public Result Monitor(object[] objs)
        {
            Result ret = _activeTask.Monitor();
            if (ret == Result.FAIL)
                return ret;

            if (ret == Result.DONE)
            {
                if (_moveTaskQueue.Count > 0)
                {
                    _activeTask = _moveTaskQueue.Dequeue();
                    return _activeTask.Start();
                }

                return Result.DONE;
            }

            return Result.RUN;
        }

        public void Clear()
        {
            _moveTaskQueue.Clear();
            _activeTask = null;
        }


        private bool IsWaferRobotRange(ModuleName module)
        {
            return module == ModuleName.CassAL || module == ModuleName.CassAR || module == ModuleName.LoadLock || module == ModuleName.Aligner 
                || module == ModuleName.UnLoad || module == ModuleName.WaferRobot;
        }

        private bool IsTrayRobotRange(ModuleName module)
        {
            return module == ModuleName.CassBL || module == ModuleName.LoadLock || module == ModuleName.TrayRobot;
        }

        private bool IsTmRobotRange(ModuleName module)
        {
            return module == ModuleName.LoadLock || ModuleHelper.IsPm(module) || module == ModuleName.UnLoad || module == ModuleName.Buffer 
                || module == ModuleName.TMRobot;
        }

        private bool CheckCanMoveRange(ModuleName fromModule, ModuleName desModule)
        {
            if (IsTmRobotRange(fromModule) && IsTmRobotRange(desModule))
            {
                return true;
            }

            if (IsTrayRobotRange(fromModule) && IsTrayRobotRange(desModule))
            {
                return true;
            }

            if (IsWaferRobotRange(fromModule) && IsWaferRobotRange(desModule)) 
            {
                return true;
            }

            return false;
        }
    }

    public class TmRobotMover : SchedulerModuleFactory, IRoutine
    {
        private MoveItemEx _moveTask;

        private SchedulerModule _source;
        private SchedulerModule _destination;

        public TmRobotMover(MoveItemEx moveTask)
        {
            _moveTask = moveTask;
        }

        public Result Start()
        {
            _source = GetModule(_moveTask.SourceModule.ToString());
            _destination = GetModule(_moveTask.DestinationModule.ToString());

            System.Diagnostics.Debug.Assert(_source != null, $"{_moveTask.SourceModule} not valid");
            System.Diagnostics.Debug.Assert(_destination != null, $"{_moveTask.DestinationModule} not valid");

            _source.ResetTask();
            _destination.ResetTask();
            _tmRobot.ResetTask();

            if (!WaferManager.Instance.CheckHasTray(_moveTask.SourceModule, _moveTask.SourceSlot))
            {
                EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} slot {_moveTask.SourceSlot + 1} has not tray");
                return Result.FAIL;
            }

            if (WaferManager.Instance.CheckHasTray(_moveTask.DestinationModule, _moveTask.DestinationSlot))
            {
                EV.PostWarningLog("System", $"Failed transfer, destination {_moveTask.DestinationModule} slot {_moveTask.DestinationSlot + 1} has tray");
                return Result.FAIL;
            }
            if (!_tmRobot.IsOnline)
            {
                EV.PostWarningLog("System", $"Failed transfer, TM is not online");
                return Result.FAIL;
            }
            if (!_source.IsAvailable)
            {
                EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} not ready");
                return Result.FAIL;
            }
            if (!_destination.IsAvailable)
            {
                EV.PostWarningLog("System", $"Failed transfer, Destination {_moveTask.DestinationModule} not ready");
                return Result.FAIL;
            }

            if (_moveTask.SourceModule == ModuleName.TMRobot)
                _moveTask.RobotHand = (Hand)_moveTask.SourceSlot;
            if (_moveTask.DestinationModule == ModuleName.TMRobot)
                _moveTask.RobotHand = (Hand)_moveTask.DestinationSlot;

            return Result.RUN;
        }
        public Result Start(params object[] objs)
        {
            return this.Start();
        }

        public Result Monitor()
        {
            if (_source.NoTray(_moveTask.SourceSlot) && _destination.HasTray(_moveTask.DestinationSlot) &&
                _tmRobot.IsAvailable)
            {
                if (_source.IsWaitTransfer(ModuleName.TMRobot))
                    _source.StopWaitTransfer(ModuleName.TMRobot);

                if (_destination.IsWaitTransfer(ModuleName.TMRobot))
                    _destination.StopWaitTransfer(ModuleName.TMRobot);

                return Result.DONE;
            }

            //Pick
            if (_moveTask.SourceModule != ModuleName.TMRobot)
            {
                if (_source.HasTray(_moveTask.SourceSlot))
                {
                    if (!_source.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_source.IsReadyForPick(ModuleName.TMRobot, _moveTask.SourceSlot))
                    {
                        if (!_source.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Pick, _moveTask.SourceSlot))
                            return Result.FAIL;
                    }

                    if (!_source.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_tmRobot.HasTray((int)_moveTask.RobotHand))
                    {
                        if (!_tmRobot.Pick(_moveTask.SourceModule, _moveTask.SourceSlot, _moveTask.RobotHand))
                        {
                            return Result.FAIL;
                        }

                        _source.WaitTransfer(ModuleName.TMRobot);
                    }

                    if (!_tmRobot.IsAvailable)
                        return Result.RUN;
                }
                else
                {
                    if (!_tmRobot.IsAvailable)
                        return Result.RUN;

                    if (_source.IsWaitTransfer(ModuleName.TMRobot))
                        _source.StopWaitTransfer(ModuleName.TMRobot);
                }
            }

            //Place
            if (_moveTask.DestinationModule != ModuleName.TMRobot)
            {
                if (!_destination.IsAvailable)
                    return Result.RUN;

                if (_destination.NoTray(_moveTask.DestinationSlot))
                {
                    if (!_destination.IsReadyForPlace(ModuleName.TMRobot, _moveTask.DestinationSlot))
                    {
                        if (!_destination.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Place,
                            _moveTask.DestinationSlot))
                            return Result.FAIL;
                    }

                    if (!_destination.IsAvailable)
                        return Result.RUN;

                    if (_tmRobot.HasTray((int)_moveTask.RobotHand))
                    {
                        if (!_tmRobot.Place(_moveTask.DestinationModule, _moveTask.DestinationSlot, _moveTask.RobotHand))
                            return Result.FAIL;

                        _destination.WaitTransfer(ModuleName.TMRobot);
                    }

                    if (!_tmRobot.IsAvailable)
                        return Result.RUN;
                }
                else
                {
                    if (!_tmRobot.IsAvailable)
                        return Result.RUN;

                    if (_destination.IsWaitTransfer(ModuleName.TMRobot))
                        _destination.StopWaitTransfer(ModuleName.TMRobot);
                }
            }

            return Result.RUN;
        }
        public void Abort()
        {
            Clear();
        }

        public void Clear()
        {
            _tmRobot.ResetTask();
            _source?.ResetTask();
            _destination?.ResetTask();
        }
    }

    public class WaferRobotMover : SchedulerModuleFactory, IRoutine
    {
        private MoveItemEx _moveTask;

        private SchedulerModule _source;
        private SchedulerModule _destination;

        public WaferRobotMover(MoveItemEx _moveItem)
        {
            _moveTask = _moveItem;
        }

        public Result Start(params object[] objs)
        {
            _source = GetModule(_moveTask.SourceModule.ToString());
            _destination = GetModule(_moveTask.DestinationModule.ToString());

            Debug.Assert(_source != null, $"{_moveTask.SourceModule} not valid");
            Debug.Assert(_destination != null, $"{_moveTask.DestinationModule} not valid");

            _source.ResetTask();
            _destination.ResetTask();
            _waferRobot.ResetTask();

            if (!WaferManager.Instance.CheckHasWafer(_moveTask.SourceModule, _moveTask.SourceSlot))
            {
                EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} slot {_moveTask.SourceSlot + 1}  not has wafer");
                return Result.FAIL;
            }

            if (WaferManager.Instance.CheckHasWafer(_moveTask.DestinationModule, _moveTask.DestinationSlot))
            {
                EV.PostWarningLog("System", $"Failed transfer, destination {_moveTask.DestinationModule} slot {_moveTask.DestinationSlot + 1} has wafer");
                return Result.FAIL;
            }

            if (!_waferRobot.IsOnline)
            {
                EV.PostWarningLog("System", $"Failed transfer, WaferRobot is not online");
                return Result.FAIL;
            }

            if (!_source.IsAvailable)
            {
                EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} not ready");
                return Result.FAIL;
            }

            if (!_destination.IsAvailable)
            {
                EV.PostWarningLog("System", $"Failed transfer, Destination {_moveTask.DestinationModule} not ready");
                return Result.FAIL;
            }

            _moveTask.RobotHand = Hand.Blade1;

            return Result.RUN;
        }

        public Result Monitor()
        {
            if (_source.NoWafer(_moveTask.SourceSlot) && _destination.HasWafer(_moveTask.DestinationSlot) &&
            _waferRobot.IsAvailable)
            {
                if (_source.IsWaitTransfer(ModuleName.WaferRobot))
                {
                    _source.StopWaitTransfer(ModuleName.WaferRobot);
                }
                    
                if (_destination.IsWaitTransfer(ModuleName.WaferRobot))
                {
                    _destination.StopWaitTransfer(ModuleName.WaferRobot);
                }
                    
                return Result.DONE;
            }

            //Pick
            if (_moveTask.SourceModule != ModuleName.WaferRobot)
            {
                if (_source.HasWafer(_moveTask.SourceSlot))
                {
                    if (!_source.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_source.IsReadyForPick(ModuleName.WaferRobot, _moveTask.SourceSlot))
                    {
                        if (!_source.PrepareTransfer(ModuleName.WaferRobot, EnumTransferType.Pick, _moveTask.SourceSlot))
                            return Result.FAIL;
                    }

                    if (!_source.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if(!_waferRobot.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_waferRobot.HasWafer((int)_moveTask.RobotHand))
                    {
                        if (!_waferRobot.Pick(_moveTask.SourceModule, _moveTask.SourceSlot, _moveTask.RobotHand))
                        {
                            return Result.FAIL;
                        }

                        if (_source is SchedulerCassette schCass)
                            schCass.WaitTransfer(ModuleName.WaferRobot, true, _moveTask.SourceSlot);
                        else        
                            _source.WaitTransfer(ModuleName.WaferRobot);
                    }

                    if (!_waferRobot.IsAvailable)
                        return Result.RUN;
                }
                else
                {
                    if (!_waferRobot.IsAvailable)
                        return Result.RUN;

                    if (_source.IsWaitTransfer(ModuleName.WaferRobot))
                        _source.StopWaitTransfer(ModuleName.WaferRobot);
                }
            }

            //Place
            if (_moveTask.DestinationModule != ModuleName.WaferRobot)
            {
                if (!_destination.IsAvailable)
                    return Result.RUN;

                if (_destination.NoWafer(_moveTask.DestinationSlot))
                {
                    if (!_destination.IsReadyForPlace(ModuleName.WaferRobot, _moveTask.DestinationSlot))
                    {
                        if (!_destination.PrepareTransfer(ModuleName.WaferRobot, EnumTransferType.Place,
                            _moveTask.DestinationSlot))
                            return Result.FAIL;
                    }

                    if (!_destination.IsAvailable)
                        return Result.RUN;

                    if (!_waferRobot.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (_waferRobot.HasWafer((int)_moveTask.RobotHand))
                    {
                        if (!_waferRobot.Place(_moveTask.DestinationModule, _moveTask.DestinationSlot, _moveTask.RobotHand))
                            return Result.FAIL;

                        if (_destination is SchedulerCassette schCass)
                            schCass.WaitTransfer(ModuleName.WaferRobot, false, _moveTask.SourceSlot);
                        else
                            _destination.WaitTransfer(ModuleName.WaferRobot);
                    }

                    if (!_waferRobot.IsAvailable)
                        return Result.RUN;
                }
                else
                {
                    if (!_waferRobot.IsAvailable)
                        return Result.RUN;

                    if (_destination.IsWaitTransfer(ModuleName.WaferRobot))
                        _destination.StopWaitTransfer(ModuleName.WaferRobot);
                }
            }


            return Result.RUN;
        }

        public void Abort()
        {
            Clear();
        }

        public void Clear()
        {
            _waferRobot.ResetTask();
            _source?.ResetTask();
            _destination?.ResetTask();
        }
    }

    public class TrayRobotMover : SchedulerModuleFactory, IRoutine
    {
        private MoveItemEx _moveTask;

        private SchedulerModule _source;
        private SchedulerModule _destination;

        public TrayRobotMover(MoveItemEx moveTask)
        {
            _moveTask = moveTask;
        }

        public Result Start(params object[] objs)
        {
            _source = GetModule(_moveTask.SourceModule.ToString());
            _destination = GetModule(_moveTask.DestinationModule.ToString());

            Debug.Assert(_source != null, $"{_moveTask.SourceModule} not valid");
            Debug.Assert(_destination != null, $"{_moveTask.DestinationModule} not valid");

            _source.ResetTask();
            _destination.ResetTask();

            _trayRobot.ResetTask();

            if (!WaferManager.Instance.CheckHasTray(_moveTask.SourceModule, _moveTask.SourceSlot))
            {
                EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} slot {_moveTask.SourceSlot + 1} not has tray");
                return Result.FAIL;
            }

            if (WaferManager.Instance.CheckHasTray(_moveTask.DestinationModule, _moveTask.DestinationSlot))
            {
                EV.PostWarningLog("System", $"Failed transfer, destination {_moveTask.DestinationModule} slot {_moveTask.DestinationSlot + 1} has tray");
                return Result.FAIL;
            }

            if (!_trayRobot.IsOnline)
            {
                EV.PostWarningLog("System", $"Failed transfer, TrayRobot is not online");
                return Result.FAIL;
            }

            if (!_source.IsAvailable)
            {
                EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} not ready");
                return Result.FAIL;
            }

            if (!_destination.IsAvailable)
            {
                EV.PostWarningLog("System", $"Failed transfer, Destination {_moveTask.DestinationModule} not ready");
                return Result.FAIL;
            }

            _moveTask.RobotHand = Hand.Blade1;

            return Result.RUN;
        }

        public Result Monitor()
        {
            if (_source.NoTray(_moveTask.SourceSlot) && _destination.HasTray(_moveTask.DestinationSlot) &&
            _trayRobot.IsAvailable)
            {
                if (_source.IsWaitTransfer(ModuleName.TrayRobot))
                    _source.StopWaitTransfer(ModuleName.TrayRobot);

                if (_destination.IsWaitTransfer(ModuleName.TrayRobot))
                    _destination.StopWaitTransfer(ModuleName.TrayRobot);

                return Result.DONE;
            }

            //Pick
            if (_moveTask.SourceModule != ModuleName.TrayRobot)
            {
                if (_source.HasTray(_moveTask.SourceSlot))
                {
                    if (!_source.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_source.IsReadyForPick(ModuleName.TrayRobot, _moveTask.SourceSlot))
                    {
                        if (!_source.PrepareTransfer(ModuleName.TrayRobot, EnumTransferType.Pick, _moveTask.SourceSlot))
                            return Result.FAIL;
                    }

                    if (!_source.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_trayRobot.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (!_trayRobot.HasTray((int)_moveTask.RobotHand))
                    {
                        if (!_trayRobot.Pick(_moveTask.SourceModule, _moveTask.SourceSlot, _moveTask.RobotHand))
                        {
                            return Result.FAIL;
                        }

                        _source.WaitTransfer(ModuleName.TrayRobot);
                    }

                    if (!_trayRobot.IsAvailable)
                        return Result.RUN;
                }
                else
                {
                    if (!_trayRobot.IsAvailable)
                        return Result.RUN;

                    if (_source.IsWaitTransfer(ModuleName.TrayRobot))
                        _source.StopWaitTransfer(ModuleName.TrayRobot);
                }
            }

            //Place
            if (_moveTask.DestinationModule != ModuleName.TrayRobot)
            {
                if (!_destination.IsAvailable)
                    return Result.RUN;

                if (_destination.NoTray(_moveTask.DestinationSlot))
                {
                    if (!_destination.IsReadyForPlace(ModuleName.TrayRobot, _moveTask.DestinationSlot))
                    {
                        if (!_destination.PrepareTransfer(ModuleName.TrayRobot, EnumTransferType.Place,
                            _moveTask.DestinationSlot))
                            return Result.FAIL;
                    }

                    if (!_destination.IsAvailable)
                        return Result.RUN;

                    if (!_trayRobot.IsAvailable)
                    {
                        return Result.RUN;
                    }

                    if (_trayRobot.HasTray((int)_moveTask.RobotHand))
                    {
                        if (!_trayRobot.Place(_moveTask.DestinationModule, _moveTask.DestinationSlot, _moveTask.RobotHand))
                            return Result.FAIL;

                        _destination.WaitTransfer(ModuleName.TrayRobot);
                    }

                    if (!_trayRobot.IsAvailable)
                        return Result.RUN;
                }
                else
                {
                    if (!_trayRobot.IsAvailable)
                        return Result.RUN;

                    if (_destination.IsWaitTransfer(ModuleName.TrayRobot))
                        _destination.StopWaitTransfer(ModuleName.TrayRobot);
                }
            }

            return Result.RUN;
        }

        public void Abort()
        {
            _trayRobot.ResetTask();
            _source?.ResetTask();
            _destination?.ResetTask();
        }
    }
}