ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemRT/Routines/PickRoutine.cs

using Aitex.Core.Common;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Routine;
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.EquipmentLibrary.HardwareUnits.LoadPorts;
using System;
using System.Threading;

namespace EFEM.RT.Routines
{
    public class PickRoutine : CommonRoutine, IRoutine, IEfemPickRoutine
    {
        enum Pick
        {
            ReserveRobot,
            WaitForPick,
            QueryState,
            OpenLoadLockDoor,
            CoolBufferMoveUP,
            WaitCoolBufferMoveUP,
            CheckBeforePick,
            
            QueryRobotParameter,
            
            RobotServoOff,
            WaitRobotServoOff,
            SetWaferSizeParameter0000,
            SetWaferSizeParameter0114,
            RobotServoOn,
            WaitRobotServoOn,
            PickWafer,
            WaitPick,
            XMove,
            CloseLoadLockDoor,
            CoolBufferMoveDown,
            WaitCoolBufferMoveDown,
            CheckAfterPick,
            PostMessage,

            RobotBusytoSimifOn,
            RobotBusytoSimifOff,
            CheckWaferPrecense,
            WaitCheckWaferPrecense,
            CheckWaferPrecenseAfterPick,
            QuerySignalStatus,
            RobotBladeUnGrip
        }

        protected bool MultiWaferSize = DeviceDefineManager.Instance.GetValue<bool>("MultiWaferSize") ?? false;

        private SCConfigItem _scPickTimeout = null;

        private int _timeout = 0;
        private int _axisTimeout = 0;
        private int _axisSpeed = 0;

        public double WaitForPickTime = 0.00;

        public PickRoutine(string module, string name)
        {
            Module = module;
            Name = name;
            _scPickTimeout = SC.GetConfigItem(SorterCommon.ScPathName.Robot_TimeLimitForPickWafer);
            if (HaveMotionAxis)
            {
                _axisTimeout = SC.GetValue<int>("MotionAxis.MoveTimeout");
                _axisSpeed = SC.GetValue<int>("MotionAxis.AutoSpeed");
            }
        }
        
        public bool Initalize()
        {
            IsStopped = true;


            return true;
        }

        public ModuleName Source { get; set; }
        public int Slot { get; set; }
        public Hand Blade { get; set; }

        private LoadPort _lpDevice;

        private bool _skipWait;

        public Result Start(params object[] objs)
        {
            IsStopped = false;
            Reset();
            _timeout = robot.RobotCommandTimeout;
           
            Reset();

            EV.PostMessage(ModuleName.System.ToString(), EventEnum.PickingWaferFromChamberBegins, string.Format("{0}{1:D2} by {2}", Source.ToString(), Slot + 1, Blade.ToString()));

            //robot.IsBusy = true;

            return Result.RUN;


        }


        public Result Monitor()
        {
            try
            {
                if (IsStopped) return Result.DONE;
                if (WaitForPickTime > 0.0)
                    Wait((int)Pick.WaitForPick, "Wait", WaitForPickTime, Notify, Stop);

                //if (ModuleHelper.IsLoadPort(Source))
                //    QueryLoadportState((int)Pick.QueryState, Source.ToString(), _timeout);

                if (ModuleHelper.IsCoolingBuffer(Source) || ModuleHelper.IsAligner(Source))
                {                    
                    CoolBufferMoveUP((int)Pick.CoolBufferMoveUP, GetCoolBuffer(Source), WaferManager.Instance.GetWaferSize(Source, Slot), _timeout, Notify, Stop);
                    WaitCoolBufferMoveUp((int)Pick.WaitCoolBufferMoveUP, GetCoolBuffer(Source), "Wait CoolingBuffer Move Up...", _timeout, Notify, Stop);
                }
                //RobotSignalStatus((int)Pick.QuerySignalStatus, robot, _timeout);

                CheckBladeWaferIsExist((int)Pick.CheckWaferPrecense, robot, Blade, _timeout);

                WaitRobotMotion((int)Pick.WaitCheckWaferPrecense, robot, "Wait finish check wafer", _timeout, Notify, Stop);

                CheckBeforePick((int)Pick.CheckBeforePick, "Check wafer information", Source, Slot, Blade, Notify, Stop);
               
                if(!ModuleHelper.IsLoadLock(Source))
                {
                    PickWafer((int)Pick.PickWafer, "Pick wafer", Source, Slot, Blade, OffsetX, OffsetY, OffsetZ, Notify, Stop);
                    this.WaitRobotMotion((int)Pick.WaitPick, robot, "Wait picked", _timeout, Notify, Stop);   
                }
                //UnGripRobotBlade((int)Pick.RobotBladeUnGrip, Blade, robot, _timeout);
                //if (ModuleHelper.IsCoolingBuffer(Source) || ModuleHelper.IsAligner(Source))
                //{
                //    CoolBufferMoveDown((int)Pick.CoolBufferMoveDown, GetCoolBuffer(Source), WaferManager.Instance.GetWaferSize(Source, Slot), _timeout, Notify, Stop);
                //    WaitCoolBufferMoveDown((int)Pick.WaitCoolBufferMoveDown, GetCoolBuffer(Source), "Wait CoolingBuffer Move Down...", _timeout, Notify, Stop);
                //}
                PostMessage((int)Pick.PostMessage, string.Format("{0}{1:D2} by {2}.", Source.ToString(), Slot + 1, Blade.ToString()));
                
                //CheckBladeWaferIsExist((int)Pick.CheckWaferPrecenseAfterPick, robot, Blade, _timeout);
                
                CheckAfterPick((int)Pick.CheckAfterPick, "Check wafer information after wafer picked", Source, Slot, Blade, Notify, Stop);
            }
            catch (RoutineBreakException)
            {
                if (!IsActived(TokenId) && !_skipWait)
                {
                    _skipWait = true;

                    return Monitor();
                }

                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                IsStopped = true;
                return Result.FAIL;
            }

            IsStopped = true;
            return Result.DONE;
        }

        

        public void CheckBeforePick(int id, string name, ModuleName chamber, int slot, Hand blade, Action<string> notify, Action<string> error)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                notify(name);
                string reason = string.Empty;

                if (!CheckRobotMotionInterlock(chamber, slot, out reason))
                {
                    EV.PostMessage(ModuleName.System.ToString(), EventEnum.TransferPrepareFailed, String.Format("target {0}{1:D2},{2}", chamber.ToString(), slot + 1, reason));
                    return false;
                }

                notify(String.Format("Check {0}{1:D2} wafer information", chamber.ToString(), slot));

                if (blade == Hand.Blade1)
                {
                    if (ModuleHelper.IsLoadLock(chamber) && Singleton<EfemEntity>.Instance.IsOnlineMode)
                    {
                        //online mode, CreateWafer in LoadLock
                        WaferManager.Instance.CreateWafer(chamber, slot, WaferStatus.Normal);
                    }
                    else if (ModuleHelper.IsBuffer(chamber) && Singleton<EfemEntity>.Instance.IsOnlineMode)
                    {
                        //online mode, CreateWafer in LoadLock
                        WaferManager.Instance.CreateWafer(chamber, slot, WaferStatus.Normal);
                        if(chamber.ToString()=="Buffer1")
                            WaferManager.Instance.UpdateWaferSize(chamber, slot, bf1.Size);
                        if (chamber.ToString() == "Buffer2")
                            WaferManager.Instance.UpdateWaferSize(chamber, slot, bf2.Size);
                    }
                    else
                    {
                        bool bHasWafer = WaferManager.Instance.CheckWafer(chamber, slot, WaferStatus.Normal);
                        if (!bHasWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferAbsentWithoutRecord, String.Format("target {0}{1:D2}", chamber.ToString(), slot + 1));
                            return false;
                        }
                    }

                    bool bNoWafer = WaferManager.Instance.CheckWafer(ModuleName.Robot, 0, WaferStatus.Empty);
                    if (!bNoWafer)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDetectedBeforePick);
                        return false;
                    }

                    bNoWafer = CheckSensorNoWafer(ModuleName.Robot, 0);  //check sensor
                    if (!bNoWafer)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDetectedBeforePick);
                        return false;
                    }

                    if (ModuleHelper.IsBuffer(chamber))
                    {
                        bool bHasWafer = CheckSeneorHasWafer(chamber, slot);  //check sensor
                        if (!bHasWafer)
                        {
                            EV.PostWarningLog(chamber.ToString(), "Can not pick wafer from buffer, Buffer slot has no wafer.");
                            return false;
                        }
                    }
                }
                else if (blade == Hand.Blade2)
                {
                    bool bHasWafer = true;
                    for (int i = 0; i < robot.Blade2Slots; i++)
                    {
                        if (ModuleHelper.IsLoadLock(chamber) && Singleton<EfemEntity>.Instance.IsOnlineMode)
                        {
                            //online mode, CreateWafer in LoadLock
                            WaferManager.Instance.CreateWafer(chamber, slot, WaferStatus.Normal);
                        }
                        else if (ModuleHelper.IsBuffer(chamber) && Singleton<EfemEntity>.Instance.IsOnlineMode)
                        {
                            //online mode, CreateWafer in LoadLock
                            WaferManager.Instance.CreateWafer(chamber, slot, WaferStatus.Normal);
                            if (chamber.ToString() == "Buffer1")
                                WaferManager.Instance.UpdateWaferSize(chamber, slot, bf1.Size);
                            if (chamber.ToString() == "Buffer2")
                                WaferManager.Instance.UpdateWaferSize(chamber, slot, bf2.Size);
                        }
                        else
                            bHasWafer = WaferManager.Instance.CheckWafer(chamber, slot + i, WaferStatus.Normal);


                        bool bNoWafer = WaferManager.Instance.CheckWafer(ModuleName.Robot, (int)blade + i, WaferStatus.Empty);
                        if (!bNoWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDetectedBeforePick);
                            return false;
                        }

                        bNoWafer = CheckSensorNoWafer(ModuleName.Robot, (int)blade + i);  //check sensor
                        if (!bNoWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDetectedBeforePick);
                            return false;
                        }

                        if (ModuleHelper.IsBuffer(chamber))
                        {
                            bHasWafer = CheckSeneorHasWafer(chamber, slot + i);  //check sensor
                            if (!bHasWafer)
                            {
                                EV.PostWarningLog(chamber.ToString(), "Can not pick wafer from buffer, Buffer slot has no wafer.");
                                return false;
                            }
                        }
                    }

                    if (!bHasWafer)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferAbsentWithoutRecord, String.Format("target {0}{1:D2}", chamber.ToString(), slot + 1));
                        return false;
                    }
                }
                else
                {
                    bool bHasWafer = true;
                    for (int i = 0; i < robot.Blade2Slots + 1; i++)
                    {
                        if (ModuleHelper.IsLoadLock(chamber) && Singleton<EfemEntity>.Instance.IsOnlineMode)
                        {
                            //online mode, CreateWafer in LoadLock
                            WaferManager.Instance.CreateWafer(chamber, slot, WaferStatus.Normal);
                        }
                        else if (ModuleHelper.IsBuffer(chamber) && Singleton<EfemEntity>.Instance.IsOnlineMode)
                        {
                            //online mode, CreateWafer in LoadLock
                            WaferManager.Instance.CreateWafer(chamber, slot, WaferStatus.Normal);
                            if (chamber.ToString() == "Buffer1")
                                WaferManager.Instance.UpdateWaferSize(chamber, slot, bf1.Size);
                            if (chamber.ToString() == "Buffer2")
                                WaferManager.Instance.UpdateWaferSize(chamber, slot, bf2.Size);
                        }
                        else
                            bHasWafer = WaferManager.Instance.CheckWafer(chamber, slot, WaferStatus.Normal);


                        bool bNoWafer = WaferManager.Instance.CheckWafer(ModuleName.Robot, (int)Hand.Blade1 + i, WaferStatus.Empty);
                        if (!bNoWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDetectedBeforePick);
                            return false;
                        }
                        bNoWafer = CheckSensorNoWafer(ModuleName.Robot, (int)Hand.Blade1 + i);  //check sensor
                        if (!bNoWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDetectedBeforePick);
                            return false;
                        }

                        if (ModuleHelper.IsBuffer(chamber) && blade == Hand.Both)
                        {
                            bHasWafer &= CheckSeneorHasWafer(chamber, slot + i);  //check sensor
                            if (!bHasWafer)
                            {
                                EV.PostWarningLog(chamber.ToString(), "Can not pick wafer from buffer, Buffer slot has no wafer.");
                                return false;
                            }
                        }
                    }

                    if (!bHasWafer)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferAbsentWithoutRecord, String.Format("target {0}{1:D2}", chamber.ToString(), slot));
                        return false;
                    }
                }



                if (ModuleHelper.IsCoolingBuffer(chamber))
                {
                        IoCoolingBuffer buffer = DEVICE.GetDevice<IoCoolingBuffer>(chamber.ToString());

                        if (!buffer.CheckPinUp())
                        {
                            EV.PostWarningLog(chamber.ToString(), "Can not pick wafer from buffer, buffer isn't pick position.");
                            return false;
                        }
                }


                return true;
            });

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    //error(String.Format("Failed to check wafer information."));
                    throw (new RoutineFaildException());
                }
            }
        }


        public void CheckAfterPick(int id, string name, ModuleName chamber, int slot, Hand blade, Action<string> notify, Action<string> error)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                notify(name);
              
                if (blade == Hand.Blade1)
                {

                    bool bHasWafer = CheckSeneorHasWafer(ModuleName.Robot, (int)blade);

                    if (!bHasWafer)
                    {
                        EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferNotDetectedAfterPick);
                        return false;
                    }
                }
                else if (blade == Hand.Blade2)
                {

                    for (int i = 0; i < robot.Blade2Slots; i++)
                    {
                        bool bHasWafer = CheckSeneorHasWafer(ModuleName.Robot, (int)Hand.Blade2 + i);
                        if (!bHasWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferNotDetectedAfterPick);
                            return false;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < robot.Blade2Slots + 1; i++)
                    {
                        bool bHasWafer = CheckSeneorHasWafer(ModuleName.Robot, (int)Hand.Blade1 + i);
                        if (!bHasWafer)
                        {
                            EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferNotDetectedAfterPick);
                            return false;
                        }

                    }
                }

                return true;
            });

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    //error(String.Format("Failed to check wafer information."));
                    throw (new RoutineFaildException());
                }
            }
        }
    }
}