FurnaceELK/FrameworkLocal/RTEquipmentLibrary/Unit/IoBoat.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Event;
using MECF.Framework.Common.SubstrateTrackings;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace Aitex.Core.RT.Device.Unit
{
    public class IoBoat : BaseDevice, IDevice
    {
        public enum BoatPosition
        {
            Unknown,
            HomePosition,
            Position1,
            Position2,
            Position3,
            ProcessPosition,
            CapPosition,
            None,
        }
        public enum BoatRotationMode
        {
            None,
            Home,
            Continuously,
            Interval,
            Stop,
        }
        public enum BoatRotationDirection
        {
            Unknown,
            CW,
            CCW,
        }
        public IoBoat(string module, XmlElement node, string ioModule = "")
        {
            base.Module = string.IsNullOrEmpty(node.GetAttribute("module")) ? module : node.GetAttribute("module");
            base.Name = node.GetAttribute("id");
            base.Display = node.GetAttribute("display");
            base.DeviceID = node.GetAttribute("schematicId");

            _diZAxisAtHome = ParseDiNode("diZAxisAtHome", node, ioModule);
            _diZAxisAtProcessPosition = ParseDiNode("diZAxisAtProcessPosition", node, ioModule);
            _diZAxisAtPosition2 = ParseDiNode("diZAxisAtPosition2", node, ioModule);
            _diZAxisAtPosition1 = ParseDiNode("diZAxisAtPosition1", node, ioModule);
            _diHumanInterlockSensor = ParseDiNode("diHumanInterlockSensor", node, ioModule);
            _diZAxisMoving = ParseDiNode("diZAxisMoving", node, ioModule);
            _diRAxisMoving = ParseDiNode("diRAxisMoving", node, ioModule);
            _diRAxisHomed = ParseDiNode("diRAxisHomed", node, ioModule);
            _diError = ParseDiNode("diError", node, ioModule);
            _diServoOn = ParseDiNode("diServoOn", node, ioModule);

            _doZAxisBreak = ParseDoNode("doZAxisBreak", node, ioModule);
            _doZAxisMoveToPosition1 = ParseDoNode("doZAxisMoveToPosition1", node, ioModule);
            _doZAxisMoveToPosition2 = ParseDoNode("doZAxisMoveToPosition2", node, ioModule);
            _doZAxisMoveToProcessPosition = ParseDoNode("doZAxisMoveToProcessPosition", node, ioModule);
            _doZAxisMoveHomePosition = ParseDoNode("doZAxisMoveHomePosition", node, ioModule);
            _doRAxisRotateContinuous = ParseDoNode("doRAxisRotateContinuous", node, ioModule);
            _doRAxisRotateInterval = ParseDoNode("doRAxisRotateInterval", node, ioModule);
            _doRAxisRotateHome = ParseDoNode("doRAxisRotateHome", node, ioModule);
            _doRAxisRotateStop = ParseDoNode("doRAxisRotateStop", node, ioModule);
            _doZAxisStop = ParseDoNode("doZAxisStop", node, ioModule);
            _doRAxisCW = ParseDoNode("doRAxisCW", node, ioModule);
            _doRAxisCCW = ParseDoNode("doRAxisCCW", node, ioModule);
            _doELVPause = ParseDoNode("doELVPause", node, ioModule);
            _doResetError = ParseDoNode("doResetError", node, ioModule);
            _doServoOn = ParseDoNode("doServoOn", node, ioModule);
            _doPowerOn = ParseDoNode("doPowerOn", node, ioModule);

            _aiZAxisSpeed = ParseAiNode("aiZAxisSpeed", node, ioModule);
            _aiRAxisSpeed = ParseAiNode("aiRAxisSpeed", node, ioModule);
            _aiRAxisCurrentPos = ParseAiNode("aiRAxisCurrentPos", node, ioModule);
            _aiZAxisCurrentPos = ParseAiNode("aiZAxisCurrentPos", node, ioModule);
            _aiRAxisCurrentAngle = ParseAiNode("aiRAxisCurrentAngle", node, ioModule);

            _aoZAxisSpeed = ParseAoNode("aoZAxisSpeed", node, ioModule);
            _aoRAxisSpeed = ParseAoNode("aoRAxisSpeed", node, ioModule);
            _aoRAxisIntervalAngle = ParseAoNode("aoRAxisIntervalAngle", node, ioModule);
        }

        #region fields
        private DIAccessor _diHumanInterlockSensor;//1正常
        private DIAccessor _diZAxisAtPosition1;
        private DIAccessor _diZAxisAtPosition2;
        private DIAccessor _diZAxisAtProcessPosition;
        private DIAccessor _diZAxisAtHome;
        private DIAccessor _diZAxisMoving;
        private DIAccessor _diRAxisMoving;
        private DIAccessor _diRAxisHomed;
        private DIAccessor _diError;
        private DIAccessor _diServoOn;

        private DOAccessor _doZAxisBreak;
        private DOAccessor _doZAxisMoveToPosition1;
        private DOAccessor _doZAxisMoveToPosition2;
        private DOAccessor _doZAxisMoveToProcessPosition;
        private DOAccessor _doZAxisMoveHomePosition;
        private DOAccessor _doRAxisRotateContinuous;
        private DOAccessor _doRAxisRotateInterval;
        private DOAccessor _doRAxisRotateHome;
        private DOAccessor _doRAxisRotateStop;
        private DOAccessor _doZAxisStop;
        private DOAccessor _doRAxisCW;
        private DOAccessor _doRAxisCCW;
        private DOAccessor _doELVPause;
        private DOAccessor _doResetError;
        private DOAccessor _doServoOn;
        private DOAccessor _doPowerOn;

        private AIAccessor _aiZAxisSpeed;
        private AIAccessor _aiRAxisSpeed;
        private AIAccessor _aiRAxisCurrentPos;
        private AIAccessor _aiZAxisCurrentPos;
        private AIAccessor _aiRAxisCurrentAngle;

        private AOAccessor _aoZAxisSpeed;
        private AOAccessor _aoRAxisSpeed;
        private AOAccessor _aoRAxisIntervalAngle;

        private RD_TRIG _upLimitTrig = new RD_TRIG();
        private RD_TRIG _downLimitTrig = new RD_TRIG();
        private RD_TRIG _humanInterlockTrig = new RD_TRIG();

        #endregion
        public AlarmEventItem BoatZAxisMoveFailedForInterlock { get; set; }
        public AlarmEventItem BoatZAxisUpLimit { get; set; }
        public AlarmEventItem BoatZAxisDownLimit { get; set; }
        public AlarmEventItem BoatHumanInterlock { get; set; }
        public AlarmEventItem BoatZAxisMoveFailedForAutoShutterNotOpen { get; set; }
        public AlarmEventItem BoatZAxisMoveFailedForAutoShutterNotDown { get; set; }
        public AlarmEventItem BoatZAxisMoveFailedForTiltStatus { get; set; }
        public AlarmEventItem BoatZAxisMoveFailedForHumanInterlock { get; set; }
        public AlarmEventItem BoatZAxisMoveFailedForWaferRobotArmExtend { get; set; }
        public AlarmEventItem BoatZAxisMoveTimeOut { get; set; }
        public AlarmEventItem BoatRAxisMoveTimeOut { get; set; }
        public AlarmEventItem BoatRAxisMoveFailedForInterlock { get; set; }
        public AlarmEventItem BoatZAxisHomeFailed { get; set; }
        public AlarmEventItem BoatZAxisHomeTimeout { get; set; }
        public AlarmEventItem BoatRAxisHomeFailed { get; set; }
        public AlarmEventItem BoatRAxisHomeTimeout { get; set; }
        public bool IsZAxisMoving => _diZAxisMoving.Value;
        public bool IsRAxisRotating => _diRAxisMoving.Value;
        public bool IsRAxisAtHome => _diRAxisHomed.Value;
        public bool IsError => _diError.Value;
        public bool IsServoOn => _diServoOn.Value;
        public bool IsPause => _doELVPause.Value;
        #region properties
        public BoatPosition BoatCurrentPosition
        {
            get
            {
                if(_diZAxisAtHome != null && _diZAxisAtPosition1 != null && _diZAxisAtPosition2 != null && _diZAxisAtProcessPosition != null)
                {
                    if (_diZAxisAtHome.Value && !_diZAxisAtPosition1.Value && !_diZAxisAtPosition2.Value && !_diZAxisAtProcessPosition.Value)
                        return BoatPosition.HomePosition;

                    if (!_diZAxisAtHome.Value && _diZAxisAtPosition1.Value && !_diZAxisAtPosition2.Value && !_diZAxisAtProcessPosition.Value)
                        return BoatPosition.Position1;

                    if (!_diZAxisAtHome.Value && !_diZAxisAtPosition1.Value && _diZAxisAtPosition2.Value && !_diZAxisAtProcessPosition.Value)
                        return BoatPosition.Position2;

                    if (!_diZAxisAtHome.Value && !_diZAxisAtPosition1.Value && !_diZAxisAtPosition2.Value && _diZAxisAtProcessPosition.Value)
                        return BoatPosition.ProcessPosition;
                }
                
                return BoatPosition.Unknown;
            }
        }
        public BoatRotationMode BoatCurrentRotationMode
        {
            get
            {
                if (_diRAxisHomed != null && _diRAxisHomed.Value)
                    return BoatRotationMode.Home;

                if (_doRAxisRotateContinuous != null && _doRAxisRotateContinuous.Value)
                    return BoatRotationMode.Continuously;

                if (_doRAxisRotateInterval != null && _doRAxisRotateInterval.Value)
                    return BoatRotationMode.Interval;

                return BoatRotationMode.Stop;
            }
        }
        #endregion
        public bool Initialize()
        {
            DATA.Subscribe(Name, "BoatPosition", () => BoatCurrentPosition.ToString());
            DATA.Subscribe(Name, "BoatCurrentRotationMode", () => BoatCurrentRotationMode.ToString());
            DATA.Subscribe(Name, "IsBoatRotating", () => _diRAxisMoving != null ?_diRAxisMoving.Value : false);
            DATA.Subscribe(Name, "BoatZAxisSpeed", () => _aiZAxisSpeed != null ? _aiZAxisSpeed.Value : 0);
            DATA.Subscribe(Name, "BoatRAxisSpeed", () => _aiRAxisSpeed != null ? _aiRAxisSpeed.Value : 0);
            DATA.Subscribe(Name, "BoatRAxisAngle", () => _aiRAxisCurrentAngle != null ? _aiRAxisCurrentAngle.Value : 0);
            DATA.Subscribe(Name, "BoatZCurrentPosition", () => _aiZAxisCurrentPos != null ? _aiZAxisCurrentPos.Value : 0);

            BoatZAxisMoveFailedForInterlock = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveFailedForInterlock",
                Description = $"{Name} boat z axis move failed for interlock ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisUpLimit = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisUpLimit",
                Description = $"{Name} boat z axis up limit ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisDownLimit = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisDownLimit",
                Description = $"{Name} boat z axis down limit ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatHumanInterlock = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatHumanInterlock",
                Description = $"{Name} boat human interlock ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisMoveFailedForAutoShutterNotOpen = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveFailedForAutoShutterNotOpen",
                Description = $"{Name} boat z axis move failed for auto shutter not open ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisMoveFailedForAutoShutterNotDown = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveFailedForAutoShutterNotDown",
                Description = $"{Name} boat z axis move failed for auto shutter not down ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisMoveFailedForTiltStatus = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveFailedForTiltStatus",
                Description = $"{Name} boat z axis move failed for tilt status ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisMoveFailedForHumanInterlock = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveFailedForHumanInterlock",
                Description = $"{Name} boat z axis move failed for human interlock ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisMoveFailedForWaferRobotArmExtend = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveFailedForWaferRobotArmExtend",
                Description = $"{Name} boat z axis move failed for wafer robot arm extend ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisMoveTimeOut = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisMoveTimeOut",
                Description = $"{Name} boat z axis move timeout ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatRAxisMoveTimeOut = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatRAxisMoveTimeOut",
                Description = $"{Name} boat r axis move timeout ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatRAxisMoveFailedForInterlock = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatRAxisMoveFailedForInterlock",
                Description = $"{Name} boat r axis move failed for interlock ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.Clear,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisHomeFailed = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisHomeFailed",
                Description = $"{Name} boat Z Axis home failed ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.ClearAndRetry,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatZAxisHomeTimeout = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatZAxisHomeTimeout",
                Description = $"{Name} boat Z Axis home timeout ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.ClearAndRetry,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatRAxisHomeFailed = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatRAxisHomeFailed",
                Description = $"{Name} boat R Axis home failed ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.ClearAndRetry,
                Category = "BoatAlarm",
            }, () => { return true; });

            BoatRAxisHomeTimeout = SubscribeAlarm(new AlarmEventItem()
            {
                EventEnum = $"{Name}.BoatRAxisHomeTimeout",
                Description = $"{Name} boat R Axis home timeout ",
                Solution = "No information available. Press[Clear] to delete alarm message.",
                Explaination = "No information available.",
                AutoRecovery = false,
                Level = EventLevel.Alarm,
                Action = EventAction.ClearAndRetry,
                Category = "BoatAlarm",
            }, () => { return true; });

            return true;
        }

        public void Monitor()
        {
            //if (_doZAxisBreak.Value != _diHumanInterlockSensor.Value)
            //    _doZAxisBreak.SetValue(_diHumanInterlockSensor.Value, out _);

            //_upLimitTrig.CLK = !_diZAxisUpLimit.Value;
            //_downLimitTrig.CLK = !_diZAxisDownLimit.Value;
            //_humanInterlockTrig.CLK = !_diHumanInterlockSensor.Value;

            //if(_upLimitTrig.R)
            //{
            //    SetZAxisStop();
            //    _doZAxisMoveHomePosition.SetValue(false, out _);
            //    _doZAxisMoveToPosition1.SetValue(false, out _);
            //    _doZAxisMoveToPosition2.SetValue(false, out _);
            //    _doZAxisMoveToProcessPosition.SetValue(false, out _);
            //    BoatZAxisUpLimit.Set();
            //}
            //if (_downLimitTrig.R)
            //{
            //    SetZAxisStop();
            //    _doZAxisMoveHomePosition.SetValue(false, out _);
            //    _doZAxisMoveToPosition1.SetValue(false, out _);
            //    _doZAxisMoveToPosition2.SetValue(false, out _);
            //    _doZAxisMoveToProcessPosition.SetValue(false, out _);
            //    BoatZAxisDownLimit.Set();
            //}
            //if (_humanInterlockTrig.R)
            //{
            //    SetZAxisStop();
            //    _doZAxisMoveHomePosition.SetValue(false, out _);
            //    _doZAxisMoveToPosition1.SetValue(false, out _);
            //    _doZAxisMoveToPosition2.SetValue(false, out _);
            //    _doZAxisMoveToProcessPosition.SetValue(false, out _);
            //    BoatHumanInterlock.Set();
            //}
        }

        public void Reset()
        {
        }

        public void Terminate()
        {
        }

        public bool RAxisRotate(string mode, out string reason)
        {
            return RAxisRotate((BoatRotationMode)Enum.Parse(typeof(BoatRotationMode), mode), out reason);
        }

        public bool RAxisRotate(BoatRotationMode mode, out string reason)
        {
            reason = string.Empty;
            switch (mode)
            {
                case BoatRotationMode.None:
                    return true;
                case BoatRotationMode.Home:
                    _doRAxisRotateStop.SetValue(false, out _);
                    _doRAxisRotateInterval.SetValue(false, out _);
                    _doRAxisRotateContinuous.SetValue(false, out _);
                    _doRAxisRotateHome.SetPulseValue(true, 1000);
                    break;
                case BoatRotationMode.Continuously:
                    _doRAxisRotateStop.SetValue(false, out _);
                    _doRAxisRotateHome.SetValue(false, out _);
                    _doRAxisRotateInterval.SetValue(false, out _);
                    _doRAxisRotateContinuous.SetValue(true, out _);
                    break;
                case BoatRotationMode.Interval:
                    _doRAxisRotateStop.SetValue(false, out _);
                    _doRAxisRotateHome.SetValue(false, out _);
                    _doRAxisRotateContinuous.SetValue(false, out _);
                    _doRAxisRotateInterval.SetValue(true, out _);
                    break;
                case BoatRotationMode.Stop:
                    _doRAxisRotateHome.SetValue(false, out _);
                    _doRAxisRotateInterval.SetValue(false, out _);
                    _doRAxisRotateContinuous.SetValue(false, out _);
                    _doRAxisRotateStop.SetPulseValue(true, 1000);
                    break;
            }
            return true;
        }

        public bool ZAxisMoveTo(string position, out string reason)
        {
            return ZAxisMoveTo((BoatPosition)Enum.Parse(typeof(BoatPosition), position), out reason);
        }

        public bool ZAxisMoveTo(BoatPosition position, out string reason)
        {
            reason = string.Empty;
            switch (position)
            {
                case BoatPosition.Unknown:
                    reason = "invalid position";
                    return false;
                case BoatPosition.HomePosition:
                    _doZAxisStop.SetValue(false, out _);
                    _doZAxisMoveToPosition1.SetValue(false, out _);
                    _doZAxisMoveToPosition2.SetValue(false, out _);
                    _doZAxisMoveToProcessPosition.SetValue(false, out _);
                    _doZAxisMoveHomePosition.SetPulseValue(true, 1000);
                    break;
                case BoatPosition.Position1:
                    _doZAxisStop.SetValue(false, out _);
                    _doZAxisMoveHomePosition.SetValue(false, out _);
                    _doZAxisMoveToPosition2.SetValue(false, out _);
                    _doZAxisMoveToProcessPosition.SetValue(false, out _);
                    _doZAxisMoveToPosition1.SetPulseValue(true, 1000);
                    break;
                case BoatPosition.Position2:
                    _doZAxisStop.SetValue(false, out _);
                    _doZAxisMoveHomePosition.SetValue(false, out _);
                    _doZAxisMoveToPosition1.SetValue(false, out _);
                    _doZAxisMoveToProcessPosition.SetValue(false, out _);
                    _doZAxisMoveToPosition2.SetPulseValue(true, 1000);
                    break;
                case BoatPosition.ProcessPosition:
                    _doZAxisStop.SetValue(false, out _);
                    _doZAxisMoveHomePosition.SetValue(false, out _);
                    _doZAxisMoveToPosition1.SetValue(false, out _);
                    _doZAxisMoveToPosition2.SetValue(false, out _);
                    _doZAxisMoveToProcessPosition.SetPulseValue(true, 1000);
                    break;
            }

            return true;
        }

        public void ZAxisMoveReset()
        {
            _doZAxisMoveHomePosition.SetValue(false, out _);
            _doZAxisMoveToPosition1.SetValue(false, out _);
            _doZAxisMoveToPosition2.SetValue(false, out _);
            _doZAxisMoveToProcessPosition.SetValue(false, out _);
        }

        public bool SetRAxisHome(out string reason)
        {
            reason = string.Empty;

            _doRAxisRotateStop.SetValue(false, out _);
            _doRAxisRotateInterval.SetValue(false, out _);
            _doRAxisRotateContinuous.SetValue(false, out _);

            _doRAxisRotateHome.SetPulseValue(true, 1000);

            return true;
        }

        public void SetZAxisSpeed(float speed)
        {
            _aoZAxisSpeed.Value = (short)speed;
        }

        public void SetRAxisSpeed(float speed)
        {
            _aoRAxisSpeed.Value = (short)speed;
        }

        public void SetRAxisIntervalPosition(float position)
        {
            _aoRAxisIntervalAngle.Value = (short)position;
        }

        public bool SetRAxisDirection(string direction, out string reason)
        {
            return SetRAxisDirection((BoatRotationDirection)Enum.Parse(typeof(BoatRotationDirection), direction), out reason);
        }

        public bool SetRAxisDirection(BoatRotationDirection direction, out string reason)
        {
            reason = string.Empty;
            switch (direction)
            {
                case BoatRotationDirection.Unknown:
                    return true;
                case BoatRotationDirection.CW:
                    _doRAxisCCW.SetValue(false, out reason);
                    _doRAxisCW.SetValue(true, out reason);
                    break;
                case BoatRotationDirection.CCW:
                    _doRAxisCW.SetValue(false, out reason);
                    _doRAxisCCW.SetValue(true, out reason);
                    break;
            }
            return true;
        }

        public bool SetRAxisParam(float speed, string mode, string direction, out string reason)
        {
            reason = string.Empty;
            var md = (BoatRotationMode)Enum.Parse(typeof(BoatRotationMode), mode);
            if (md == BoatRotationMode.None)
                return true;

            _aoRAxisSpeed.Value = (short)speed;
            SetRAxisDirection(direction, out reason);
            RAxisRotate(md, out reason);
            return true;
        }

        public void SetZAxisStop()
        {
            _doZAxisMoveToPosition1.SetValue(false, out _);
            _doZAxisMoveToPosition2.SetValue(false, out _);
            _doZAxisMoveToProcessPosition.SetValue(false, out _);
            _doZAxisMoveHomePosition.SetValue(false, out _);
            _doZAxisStop.SetPulseValue(true, 1000);
        }

        public void SetRAxisStop()
        {
            _doRAxisRotateHome.SetValue(false, out _);
            _doRAxisRotateInterval.SetValue(false, out _);
            _doRAxisRotateContinuous.SetValue(false, out _);
            _doRAxisRotateStop.SetPulseValue(true, 1000);
        }

        public void SetReset()
        {
            _doResetError.SetPulseValue(true, 1000);
        }

        public void SetServoOn()
        {
            _doServoOn.SetValue(true, out _);
            _doPowerOn.SetValue(true, out _);
        }

        public void SetPauseResume(bool isPause)
        {
            _doELVPause.SetValue(isPause, out _);
        }
    }
}