Metis_xctg/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 object LoadingStageModel
        {
            set
            {
                var m_loadingStageModel = value as PaintDotNet.Base.SettingModel.LoadingStageModel;
                //m_portName = m_loadingStageModel.BaseSetPort;
                //m_baudRate = m_loadingStageModel.BaseSetBps;

                base.LoadingStageModel = value;

                m_workSpeedXY = m_loadingStageModel.items[m_loadingStageModel.WorkSpeedSelect].LSpeed;
                m_workSpeedZ = m_loadingStageModel.items[m_loadingStageModel.WorkSpeedSelect].ZSpeed;
            }
        }

        public override bool NeedSaveResetStageStatus { get => false; }
        public override bool FreeOrLockXYEnabled { get => false; }
        public override bool FreeOrLockZEnabled { get => true; }
        public override string Open()
        {
            axisImply.Open();
            base.Open();
            return axisImply.isOpen ? "已连接" : "未连接";
        }

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

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

        public override void RefreshPosition()
        {
            try
            {
                axisImply.RefreshPosition();
            }
            catch (Exception ex)
            {
                Logs.Write("[HD]Err: Received null or white or space!");
                Console.WriteLine("RefreshPosition Exception:" + ex.Message);
            }
        }
        /// <summary>
        /// 等待平台停稳
        /// </summary>
        public override void WaitMoveDone()
        {
            int waitSum = 0;
            do { System.Threading.Thread.Sleep(20/*200*/);
                if (IsMoving) waitSum = 0;
                else ++waitSum;
            }
            while (IsMoving || waitSum < 5);
            System.Threading.Thread.Sleep(10/*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*10, 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, bool ZMC_Execute_Status = false)
        {
            return axisImply.Command_Execute(g_command, out changps, ZMC_Execute_Status);
        }


        #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
            if (IsMoving)
            {
                Console.WriteLine("XY运动中发送运动指令");
                return;
            }
            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)
        {
            new System.Threading.Tasks.Task(new Action(() =>
            {
                //while (m_cmdQueueM.Count > 0)
                //{
                //    Thread.Sleep(100);
                //}
                StartResetStage(actDone);
            })).Start();
        }

        private void StartResetStage(Action actDone)
        {
            var mf = StartMoveflow();
            mf.Add(() =>
            {
                this.Command_Execute("RUNTASK 1,HOMEX", out _, true); this.Command_Execute("RUNTASK 2,HOMEY", out _, true);// System.Threading.Thread.Sleep(200);
                System.Threading.Thread.Sleep(1000);
                WaitMoveDone();//int movingCount = 0; do {//等待平台停稳 movingCount = IsMoving ? 0 : (movingCount + 1); System.Threading.Thread.Sleep(200); } while (movingCount < 5);
                axisImply.SetSpeed(axisImply.hds_speeds[0], AxisType.X); axisImply.SetSpeed(axisImply.hds_speeds[1], AxisType.Y);
            }, null// () => { return m_AxisX.State == STATE_LOCK && m_AxisY.State == STATE_LOCK; }
                );
            mf.Start(); mf.OnMoveflowDone += actDone; m_currentMoveflow = mf;
        }

        public override void ZScan(double start, double steplen, int times, Action shoot, Action package, Action actDone)
        {
            var mf = StartMoveflow();
            mf.Add(
                () => axisImply.CancelCommand(AxisType.Z),
                null);
            mf.Add(() =>
            {
                axisImply.To(start, AxisType.Z);
            },
                () =>
                {
                    WaitMoveDone();
                    axisImply.RefreshPositionZ();// RefreshPosition();
                    return Math.Abs(axisImply.z_Actual/*m_AxisZ.Actual*/ - start) < 5/*m_AxisZ.Stepping*/;
                });
            mf.Add(shoot, null);
            for (int i = 0; i < times - 1; i++)
            {
                mf.Add(() =>
                {
                    WaitMoveDone();
                    start += steplen;
                    axisImply.To(start, AxisType.Z);
                },
                    () =>
                    {
                        WaitMoveDone();
                        axisImply.RefreshPositionZ();// RefreshPosition();
                        return Math.Abs(axisImply.z_Actual/*m_AxisZ.Actual*/ - start) < 5/*m_AxisZ.Stepping*/;
                    });
                mf.Add(shoot, null);
            }
            mf.Add(package, null);
            mf.Start();
            mf.OnMoveflowDone += actDone;
            m_currentMoveflow = mf;
        }

        /// <summary>
        /// 开始中心移动流程
        /// </summary>
        public override void ToCenter()
        {
            axisImply.To(_centerX, AxisType.X); axisImply.To(_centerY, AxisType.Y);
        }
        //清零
        protected override void ClearPosXY()
        {
            this.Command_Execute("DEFPOS(0) AXIS(0)", out _); this.Command_Execute("DEFPOS(0) AXIS(1)", out _);
        }
        public override void ClearPosZ()
        {
            if (this.Command_Execute("Mpos(2)=0", out _, true) == 0)//DEFPOS(0) AXIS(2)
                axisImply.z_Actual = 0;
        }
        #endregion
        
        int m_workSpeedXY; int m_workSpeedZ;
        public override void SetWorkspeedXY()
        {//# 待完善初始化参数和存储参数
            //m_workSpeedXY = 1000;// m_loadingStageModel.items[m_loadingStageModel.WorkSpeedSelect].LSpeed;
            //m_workSpeedZ = 100;// m_loadingStageModel.items[m_loadingStageModel.WorkSpeedSelect].ZSpeed;
            SetSpeedXY(m_workSpeedXY);
            SetSpeedZ(m_workSpeedZ);
        }

    }
}