Mars200/JetMainframe/TMs/TMGotoRoutine.cs

using System;
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.Sorter.Common;
using MECF.Framework.Common.Equipment;

namespace JetMainframe.TMs
{
    public class TMGotoRoutine : ModuleRoutine, IRoutine
    {
        enum RoutineStep
        {
            CheckBeforeGoto,
            RobotGoto,
        }

        private int _gotoTimeout;
        private ModuleName _source;
        private int _sourceSlot;
        private Hand _hand;

        private TMModule _robotModule;

        public TMGotoRoutine(TMModule robotModule)
        {
            Module = "TM";
            Name = "Goto";

            _robotModule = robotModule;
        }

        public Result Start(params object[] objs)
        {
            _gotoTimeout = SC.GetValue<int>("TM.TMRobot.GotoTimeout");

            Reset();

            if (!DEVICE.GetDevice<IoSensor>($"System.SensorTMInSafety").Value)
            {
                EV.PostAlarmLog(Module, $"Can not Goto, Sensor TMInSafety is false");
                return Result.FAIL;
            }

            if (_source == ModuleName.LLA && DEVICE.GetDevice<IoSensor>($"System.SensorBufferABigWaferProtrusion").Value)
            {
                EV.PostAlarmLog(Module, $"Can not Goto, Sensor BufferABigWaferProtrusion is false");
                return Result.FAIL;
            }

            if (_source == ModuleName.LLB && DEVICE.GetDevice<IoSensor>($"System.SensorBufferBBigWaferProtrusion").Value)
            {
                EV.PostAlarmLog(Module, $"Can not Goto, Sensor BufferBBigWaferProtrusion is false");
                return Result.FAIL;
            }

            Notify($"Start, Goto {_source} slot {_sourceSlot + 1}, by {_hand}");

            return Result.RUN;
        }


        public void Init(ModuleName source, int slot, Hand hand)
        {

            _source = source;
            _sourceSlot = slot;
            _hand = hand;

        }

        public void Abort()
        {
            Notify("Abort");
        }


        public Result Monitor()
        {
            try
            {

                CheckBeforeGoto((int)RoutineStep.CheckBeforeGoto, _source, _sourceSlot, _hand);

                RobotGoto((int)RoutineStep.RobotGoto, _source, _sourceSlot, _hand, _gotoTimeout);


            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException)
            {
                return Result.FAIL;
            }

            Notify($"Finish, robot move to {_source} slot {_sourceSlot + 1}, by {_hand}");

            return Result.DONE;
        }


        public void CheckBeforeGoto(int id, ModuleName source, int slot, Hand blade)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify("Check robot goto motion is enabled");

                string reason = string.Empty;

                return true;
            });

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw new RoutineFaildException();
                }
            }
        }


        public void RobotGoto(int id, ModuleName chamber, int slot, Hand hand, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify("robot execute goto command");

                string reason;
                if (!_robotModule.RobotDevice.Goto(chamber, hand, slot, out reason))
                {
                    Stop(reason);
                    return false;
                }
                return true;
            }, () =>
            {
                if (_robotModule.RobotDevice.IsError)
                    return null;
                if (_robotModule.RobotDevice.IsIdle)
                    return true;

                return false;
            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    Stop(string.Format("failed."));
                    throw new RoutineFaildException();
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    Stop(string.Format("timeout, can not complete in {0} seconds", timeout));
                    throw new RoutineFaildException();
                }
                else
                    throw new RoutineBreakException();
            }
        }

    }
}