LIBMAS/StageController/HDS/HDSController.cs

using System;

namespace StageController.HDS
{
    public class HDSController : AxisController
    {
        private AxisImply axisImply;
        public string Adrr { set { axisImply.Adrr = value; } }                 //连接的IP地址

        /// <summary>
        /// 平台是否正常开启
        /// </summary>
        public override bool IsOpen
        {
            get => axisImply.isOpen;
        }
        public override string Version { get => axisImply.hds_CONTROL; internal set { } }
        public override bool IsMoving => StateX > 1 || StateY > 1 || StateZ > 1;
        public bool IsMovingXY => StateX > 1 || StateY > 1;

        #region AxisShell List 虚拟轴控制  
        /// <summary>
        /// HDS--> 返回 2，代表运动中，返回 1，代表空闲中
        /// </summary>
        public override int StateX => axisImply.x_State;
        /// <summary>
        /// HDS--> 返回 2，代表运动中，返回 1，代表空闲中
        /// </summary>
        public override int StateY => axisImply.y_State;
        /// <summary>
        /// HDS--> 返回 2，代表运动中，返回 1，代表空闲中
        /// </summary>
        public override int StateZ => axisImply.z_State;

        public override double X => axisImply.x_Actual;
        public override double Y => axisImply.y_Actual;
        public override double Z => axisImply.z_Actual;
        #endregion

        public HDSController() : base()
        {
            axisImply = new AxisImply();
        }
        public override string Open()
        {
            axisImply.Open();
            base.Open();
            return axisImply.isOpen ? "已连接" : "未连接";
        }

        public override void Close()
        {
            axisImply.Close();
            base.Close();
        }

        protected override void Process()
        {
            base.Process();
            RefreshPosition();
        }

        public override void RefreshPosition()
        {
            try
            {
                axisImply.RefreshPosition();
            }
            catch (Exception ex)
            {
                Console.WriteLine("RefreshPosition Exception:" + ex.Message);
            }
        }
        /// <summary>
        /// 等待平台停稳
        /// </summary>
        public override void WaitMoveDone()
        {
            do System.Threading.Thread.Sleep(20/*200*/);
            while (IsMoving);
            //Thread.Sleep(30/*100*/);
        }

        #region Speed
        public override void SetSpeedXY(int speed)
        {//......................................................
            axisImply.SetSpeed(speed, AxisType.X); axisImply.SetSpeed(speed, AxisType.Y);
            //var speed1 = SpeedConvertXY(speed);
            //m_AxisX.Speed = speed1;
            //m_AxisY.Speed = speed1;
            //AxisShellList[AxisType.X].Speed = speed;
            //AxisShellList[AxisType.Y].Speed = speed;
        }

        public override void SetSpeedZ(int speed)
        {//............................................................
            axisImply.SetSpeed(speed, AxisType.Z);
            //m_AxisZ.Speed = SpeedConvertZ(speed);
            //AxisShellList[AxisType.Z].Speed = speed;
        }

        ///// <summary>
        ///// XY速度换算  
        ///// </summary>
        ///// <param name="">微米每秒</param>
        ///// <returns>速度映射值</returns>
        //private int SpeedConvertXY(double umpers)
        //{
        //    var speed = (1000000 * m_AxisX.Stepping / umpers - 33) / 10;
        //    return (int)speed;
        //}

        ///// <summary>
        ///// Z速度换算  
        ///// </summary>
        ///// <param name="">微米每秒</param>
        ///// <returns>速度映射值</returns>
        //private int SpeedConvertZ(double umpers)
        //{
        //    var speed = (1000000 * m_AxisZ.Stepping / umpers - 33) / 40;
        //    return (int)speed;
        //}
        #endregion

        public Int32 Command_Execute(string g_command, out string changps)
        {
            return axisImply.Command_Execute(g_command, out changps);
        }


        #region Motion
        /// <summary>
        /// 平台平移（9、 相对运动 相对运动可以转化为绝对运动来实现，这样接口更简单、可靠。） waitmovedone
        /// </summary>
        /// <param name="x">X轴移动距离(μm)</param>
        /// <param name="y">Y轴移动距离(μm)</param>
        public override void Move(double x, double y)
        {//待调试确认 自测重点 1
            axisImply.Move(x, AxisType.X); axisImply.Move(y, AxisType.Y);
        }
        /// <summary>
        /// 8、 绝对运动
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public override void To(double x, double y)
        {//待调试确认 自测重点 1
            axisImply.To(x, AxisType.X); axisImply.To(y, AxisType.Y);
        }
        public override void Up(double z)//6400/3200/1600
        {
            axisImply.Move(z, AxisType.Z);
        }
        public override void UpTo(double z)
        {
            axisImply.To(z, AxisType.Z);
        }
        public override void Up(int z)
        {
            axisImply.Move(z, AxisType.Z);
        }
        /// <summary>
        /// Z连续
        /// </summary>
        /// <param name="isToTop">true:正向.false:反向</param>
        public override void GoTop(bool isToTop)
        {
            axisImply.VMove(AxisType.Z, isToTop);
        }
        /// <summary>
        /// 平台朝一个水平方向连续运动
        /// </summary>
        /// <param name="direction">0-7 从X周负向逆时针</param>
        public override void Split(int direction)
        {
            switch (direction)
            {
                case 0:
                    axisImply.VMove(AxisType.X, true);
                    break;
                case 1:
                    axisImply.VMove(AxisType.X, true);
                    axisImply.VMove(AxisType.Y,false);
                    break;
                case 2:
                    axisImply.VMove(AxisType.Y, false);
                    break;
                case 3:
                    axisImply.VMove(AxisType.X, false);
                    axisImply.VMove(AxisType.Y, false);
                    break;
                case 4:
                    axisImply.VMove(AxisType.X, false);
                    break;
                case 5:
                    axisImply.VMove(AxisType.X, false);
                    axisImply.VMove(AxisType.Y, true);
                    break;
                case 6:
                    axisImply.VMove(AxisType.Y, true);
                    break;
                case 7:
                    axisImply.VMove(AxisType.X, true);
                    axisImply.VMove(AxisType.Y, true);
                    break;
            }
            if (IsOpen) Console.WriteLine("Split " + direction);
        }
        protected override void ToAction(AxisType axisType, double start)
        {
            base.ToAction(axisType, start);
            axisImply.To(start, axisType);
        }
        protected override void MoveAction(AxisType axisType, double steplen)
        {
            base.MoveAction(axisType, steplen);
            axisImply.Move(steplen, axisType);
        }
        #endregion

        #region Stop
        public override void FreeStage()
        {
            axisImply.CancelCommand(AxisType.X); axisImply.CancelCommand(AxisType.Y);
        }
        public override void LockStage()
        {
            axisImply.CancelCommand(AxisType.X); axisImply.CancelCommand(AxisType.Y);
        }
        public override void FreeZ()
        {
            axisImply.CancelCommand(AxisType.Z);
        }
        public override void LockZ()
        {
            axisImply.CancelCommand(AxisType.Z);
        }
        protected override void Stop(AxisType axis, M3H.HandLock hlock)
        {
            base.Stop(axis, hlock);
            axisImply.CancelCommand(axis);
        }
        #endregion

        #region Moveflow
        //复位
        public override void ResetStage(Action actDone)
        {
            var mf = StartMoveflow();
            mf.Add(() =>
            {
                this.Command_Execute("RUNTASK 1,HOMEX", out _); this.Command_Execute("RUNTASK 2,HOMEY", out _);// System.Threading.Thread.Sleep(200);
                WaitMoveDone();//int movingCount = 0; do {//等待平台停稳 movingCount = IsMoving ? 0 : (movingCount + 1); System.Threading.Thread.Sleep(200); } while (movingCount < 5);
            }, null// () => { return m_AxisX.State == STATE_LOCK && m_AxisY.State == STATE_LOCK; }
                );
            mf.Start(); mf.OnMoveflowDone += actDone; m_currentMoveflow = mf;
        }
        //清零
        protected override void ClearPosXY()
        {
            this.Command_Execute("DEFPOS(0) AXIS(0)", out _); this.Command_Execute("DEFPOS(0) AXIS(1)", out _);
            base.ClearPosXY();
        }
        public override void ClearPosZ()
        {
            this.Command_Execute("DEFPOS(0) AXIS(2)", out _);
            base.ClearPosZ();
        }
        #endregion


        #region Speed
        int m_workSpeedXY;
        int m_workSpeedZ;
        public override void SetWorkspeedXY()
        {//# 待完善初始化参数和存储参数
            m_workSpeedXY = 100;// m_loadingStageModel.items[m_loadingStageModel.WorkSpeedSelect].LSpeed;
            m_workSpeedZ = 100;// m_loadingStageModel.items[m_loadingStageModel.WorkSpeedSelect].ZSpeed;
            SetSpeedXY(m_workSpeedXY);
            SetSpeedZ(m_workSpeedZ);
        }
        #endregion

        /// <summary>
        /// 拼图模式
        /// </summary>
        public override void SetMergeMode(bool isMerge)
        {
            //if (isMerge)
            //    AddCommand(new CommandGlobal(M3H.ControlType.P));
            //else
            //    AddCommand(new CommandGlobal(M3H.ControlType.Q));
        }

        /// <summary>
        /// 启用/禁用摇杆
        /// </summary>
        /// <param name="isAvailable">摇杆可用</param>
        public override void SetRockerEnabel(bool isAvailable)
        {

        }

    }
}