FurnaceELK/Furnace/FurnaceRT/Equipments/Boats/BoatZAxisMoveCycleTest.cs

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.Alarms;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FurnaceRT.Equipments.Systems;
using static Aitex.Core.RT.Device.Unit.IoBoat;
using System.Diagnostics;
using FurnaceRT.Devices;

namespace FurnaceRT.Equipments.Boats
{
    public class BoatZAxisMoveCycleTest : ModuleRoutine, IRoutine
    {
        enum RoutineStep
        {
            SetBoatSpeed,
            AutoShutterOpen,
            CheckPrepareMove,
            MoveToStart,
            MoveToEnd,
            Loop,
            EndLoop,
            Delay1,
            Delay2,
            Delay3,
        }

        private float _speed;
        private float _interval;
        private BoatModule _boatModule;
        private int _timeout = 0;
        private int _shutterTimeout = 0;
        private BoatPosition _positionStart;
        private BoatPosition _positionEnd;
        private int _count;

        public BoatZAxisMoveCycleTest(BoatModule boatModule)
        {
            _boatModule = boatModule;
            Module = boatModule.Module;

            Name = "ZAxisMoveTest";
        }

        public void Init(string positionStart = "HomePosition", string positionEnd = "CapPosition")
        {
            _positionStart = (BoatPosition)Enum.Parse(typeof(BoatPosition), positionStart);
            _positionEnd = (BoatPosition)Enum.Parse(typeof(BoatPosition), positionEnd);
        }

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

            _timeout = SC.GetValue<int>($"Boat.BoatElevatorServo.MotionTimeout");
            _count = SC.GetValue<int>($"Boat.BoatElevatorServo.CycleCount");
            _speed = (float)SC.GetValue<double>($"Boat.BoatElevatorServo.MoveSpeed");
            _interval = (float)SC.GetValue<double>($"Boat.BoatElevatorServo.IntervalTime");
            _shutterTimeout = SC.GetValue<int>($"{Module}.AutoShutter.MotionTimeout");
            string reason = string.Empty;
            if (!_boatModule.CheckPrepareMove(out reason, false))
            {
                _boatModule.BoatZAxisMoveFailedForInterlock.Set(reason);
                return Result.FAIL;
            }
            Notify($"Start");

            return Result.RUN;
        }

        public void Abort()
        {
            _boatModule.ZAxisDevice.ServoStop();
        }

        public override Result Monitor()
        {
            try
            {
                PauseRountine(_boatModule.RAxisDevice.IsPause);
                if (_boatModule.RAxisDevice.IsPause)
                    return Result.RUN;

                if (_boatModule.ZAxisDevice.IsError)
                    return Result.FAIL;

                AutoShutterOpen((int)RoutineStep.AutoShutterOpen, true, _shutterTimeout);

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

                CheckPrepareMove((int)RoutineStep.CheckPrepareMove, 2);

                SetBoatZAxisMove((int)RoutineStep.MoveToStart, _positionStart, (int)_timeout);

                Delay((int)RoutineStep.Delay1, 2);

                Delay((int)RoutineStep.Delay2, _interval);

                SetBoatZAxisMove((int)RoutineStep.MoveToEnd, _positionEnd, (int)_timeout);

                Delay((int)RoutineStep.Delay3, _interval);

                EndLoop((int)RoutineStep.EndLoop);
            }
            catch (RoutineBreakException)
            {
                return Result.RUN;
            }
            catch (RoutineFaildException ex)
            {
                return Result.FAIL;
            }

            Notify("Finished");
            return Result.DONE;
        }
        private void AutoShutterOpen(int id, bool isOpen, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"shutter {(isOpen ? "open" : "close")}");
                string reason;
                if (!_boatModule.ShutterDevice.SetOpen(isOpen, out reason))
                {
                    _boatModule.ShutterDevice.AutoShutterMoveFailedForInterlock.Set();
                    return false;
                }
                return true;
            }, () =>
            {

                return isOpen ? _boatModule.ShutterDevice.OpenCloseStatus == DeviceStatus.Open : _boatModule.ShutterDevice.OpenCloseStatus == DeviceStatus.Close;

            }, timeout * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    if (isOpen)
                    {
                        _boatModule.ShutterDevice.AutoShutterOpenTimeOut.Set($"can not complete in {timeout} seconds");
                    }
                    else
                    {
                        _boatModule.ShutterDevice.AutoShutterCloseTimeOut.Set($"can not complete in {timeout} seconds");
                    }
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }
        private void CheckPrepareMove(int id, int timeout)
        {
            var reason = "";
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Check boat move enable");
                return true;
            }, () =>
            {
                return _boatModule.CheckPrepareMove(out reason);
            }, timeout * 2 * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    _boatModule.BoatZAxisMoveFailedForInterlock.Set($"{reason} is not OK, can not complete in {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }
        private void SetBoatZAxisMove(int id, BoatPosition position, int timeout)
        {
            Tuple<bool, Result> ret = ExecuteAndWait(id, () =>
            {
                Notify($"Boat ZAxis movet to {position}");
                string reason;
                if (!_boatModule.ZAxisDevice.SetServoMoveTo(position.ToString(), out reason))
                {
                    //_boatModule.BoatDevice.BoatRAxisMoveFailedForInterlock.Description = reason;
                    _boatModule.BoatZAxisMoveFailedForInterlock.Set(reason);
                }
                return true;
            }, () =>
            {
                if (_boatModule.ZAxisDevice.IsError)
                    return null;
                return _boatModule.ZAxisDevice.CheckServoAtPosition(position.ToString());
            }, timeout * 2 * 1000);

            if (ret.Item1)
            {
                if (ret.Item2 == Result.FAIL)
                {
                    _boatModule.ZAxisDevice.ServoStop();
                    throw (new RoutineFaildException());
                }
                else if (ret.Item2 == Result.TIMEOUT) //timeout
                {
                    _boatModule.ZAxisDevice.ServoStop();
                    _boatModule.BoatZAxisMoveTimeOut.Set($"can not complete in {timeout} seconds");
                    throw (new RoutineFaildException());
                }
                else
                    throw (new RoutineBreakException());
            }
        }
    }
}