ELK/Furnace/FurnaceRT/Equipments/WaferRobots/WaferRobotSwap.cs

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.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.LogicUnits;
using System;
using System.Collections.Generic;
using FurnaceRT.Equipments.FIMSs;
using FurnaceRT.Equipments.PMs;
using FurnaceRT.Equipments.Stockers;
using FurnaceRT.Equipments.Systems;

namespace FurnaceRT.Equipments.WaferRobots
{
    public class WaferRobotSwap : ModuleRoutine, IRoutine
    {
        enum RoutineStep
        {
            Loop,
            Pick1,
            Pick2,
            PickInit1,
            PickInit2,
            Place1,
            Place2,
            PlaceInit1,
            PlaceInit2,
            EndLoop,
        }

        private ModuleName _source;
        private ModuleName _dest;
        private int _sourceSlot;
        private int _destSlot;
        private Hand _blade;
        private WaferRobotModule _waferRobotModule;
        private Hand _hand;
        private WaferRobotPick _pick;
        private WaferRobotPlace _place;
        private int _cycleNumber;

        public WaferRobotSwap(WaferRobotModule waferRobotModule)
        {
            _waferRobotModule = waferRobotModule;
            Module = waferRobotModule.Module;
            _pick = new WaferRobotPick(waferRobotModule);
            _place = new WaferRobotPlace(waferRobotModule);

            Name = "Swap";
        }

        public void Init(ModuleName source, ModuleName dest, int sourceSlot, int destSlot, Hand hand)
        {
            _source = source;
            _dest = dest;
            _hand = hand;
            _sourceSlot = sourceSlot;
            _destSlot = destSlot;
        }

        public Result Start(params object[] objs)
        {
            Reset();

            _cycleNumber = SC.GetValue<int>($"{Module}.TransferModeNumber");

            Notify("Start");

            return Result.RUN;
        }

        public void Abort()
        {
            _waferRobotModule.Stop();
        }

        public override Result Monitor()
        {
            try
            {
                PauseRountine(_waferRobotModule.WaferRobotDevice.IsPause);
                if (_waferRobotModule.WaferRobotDevice.IsPause)
                    return Result.RUN;

                Loop((int)RoutineStep.Loop, _cycleNumber);

                PickInit((int)RoutineStep.PickInit1, _source, _sourceSlot, _hand);

                ExecuteRoutine((int)RoutineStep.Pick1, _pick);

                PlaceInit((int)RoutineStep.PlaceInit1, _dest, _destSlot, _hand);

                ExecuteRoutine((int)RoutineStep.Place1, _place);

                PickInit((int)RoutineStep.PickInit2, _dest, _destSlot, _hand);

                ExecuteRoutine((int)RoutineStep.Pick2, _pick);

                PlaceInit((int)RoutineStep.PlaceInit2, _source, _sourceSlot, _hand);

                ExecuteRoutine((int)RoutineStep.Place2, _place);

                EndLoop((int)RoutineStep.EndLoop);
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException ex)
            {
                (Singleton<EquipmentManager>.Instance.Modules[_source] as ITransferTarget)?.NoteTransferStop(ModuleHelper.Converter(_waferRobotModule.Module), _blade, _sourceSlot, EnumTransferType.Pick);
                return Result.FAIL;
            }

            (Singleton<EquipmentManager>.Instance.Modules[_source] as ITransferTarget)?.NoteTransferStop(ModuleHelper.Converter(_waferRobotModule.Module), _blade, _sourceSlot, EnumTransferType.Pick);
            Notify("Finished");
            return Result.DONE;
        }
        private void PickInit(int id, ModuleName source, int slot, Hand blade)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify($"Pick from {source} {slot} init");
                string reason = string.Empty;

                _pick.Init(source, slot, blade, false);

                return true;
            });

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

        private void PlaceInit(int id, ModuleName dest, int slot, Hand blade)
        {
            Tuple<bool, Result> ret = Execute(id, () =>
            {
                Notify($"Place to {dest} {slot} init");
                string reason = string.Empty;

                _place.Init(dest, slot, blade, false);

                return true;
            });

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