Ejemplo n.º 1
0
        private void waitCurrentRunFinish()
        {
            Thread.Sleep(2);
            //读取输入信息
            ReadInput();
            //int es = GetDi(Define.DiEmergencyStop);
            //if (es == 1)
            //{
            //    EmgStop();
            //    CancleCommPause();
            //    source.Cancel();
            //    source.Token.ThrowIfCancellationRequested();
            //}
            lock (cardActLock)
            {
                short  rtn;
                ushort axisSts;
                rtn = GT400.GT_GetSts(out axisSts);
                runningError("当前轴状态状态查询", rtn);
                bool showTmp = true;
                //判断是否在运动中
                while (0 != (axisSts & 0x400))
                {
                    rtn = GT400.GT_GetSts(out axisSts);
                    runningError("当前轴状态状态查询", rtn);
                    if (showTmp)
                    {
                        showTmp = false;
                    }

                    Thread.Sleep(10);
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// 指定轴运动到指定位置
        /// </summary>
        /// <param name="axisIndex">轴编号</param>
        /// <param name="pos">位移量</param>
        /// <param name="isAbsolute">绝对运动</param>
        public void AxisPosMove(int axisIndex, int pos, bool isAbsolute)
        {
            ushort testAxis = (ushort)axisIndex;

            if (homeFinish == false)
            {
                Util.Notify("控制卡未回原点");
                return;
            }
            lock (cardActLock)
            {
                short rtn;
                int   prfPos = 0;

                rtn = GT400.GT_Axis(testAxis);

                ushort axisSts;
                rtn = GT400.GT_GetSts(out axisSts);//如果测试轴正在运动则退出

                runningError("当前轴状态状态查询", rtn);
                if (0 != (axisSts & 0x400))
                {
                    Util.Notify("轴动作中");
                    //return;
                }

                rtn = GT400.GT_ClrSts();           //清除不正常状态
                runningError("当前轴状态异常状态清除", rtn);
                if (0 != rtn)
                {
                    return;
                }

                if (isAbsolute)
                {
                    prfPos = pos;
                }
                else
                {
                    rtn = GT400.GT_GetPrfPos(out prfPos);
                    runningError("当前轴位置读取", rtn);
                    prfPos += pos;
                }
                //Thread.Sleep(2);

                //Thread.Sleep(2);
                rtn = GT400.GT_SetMAcc(accRun);
                //rtn = GT400.GT_SetAcc(accRun);
                runningError("当前轴加速度设置", rtn);
                //Thread.Sleep(2);
                rtn = GT400.GT_SetVel(speedRun);
                runningError("当前轴目标速度设置", rtn);
                //Thread.Sleep(2);
                rtn = GT400.GT_SetPos(prfPos);
                runningError("当前轴目标位置设置", rtn);

                rtn = GT400.GT_SetJerk(0.087);
                runningError("当前轴加加速度设置", rtn);
                //Thread.Sleep(2);
                rtn = GT400.GT_Update();                 //参数更新后,就可以开始运行了。
                runningError("当前轴参数更新", rtn);
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// 指定轴回原点
        /// </summary>
        /// <param name="axisIndex"></param>
        public void Homing(int axisIndex, int pos, double acc, double speed)
        {
            short  rtn;
            ushort axisSts;

            int prfPos;

            if (isLink == false)
            {
                Util.Notify("控制卡未连接");
                return;
            }
            lock (cardActLock)
            {
                Util.Notify(axisIndex + "开始回原点");
                rtn = GT400.GT_Axis((ushort)axisIndex); //该命令一般不用检测是否正确执行

                rtn = GT400.GT_GetSts(out axisSts);

                runningError("当前轴状态状态查询", rtn);
                if (0 != (axisSts & 0x400))
                {
                    Util.Notify("轴动作中");
                    return;
                }

                rtn = GT400.GT_ClrSts();           //清除当前轴异常状态
                runningError("当前轴状态异常状态清除", rtn);
                if (0 != rtn)
                {
                    return;
                }
                //在当前位置基础上,以S曲线向前运动指定个脉冲

                rtn = GT400.GT_SetMAcc(acc);
                //rtn = GT400.GT_SetAcc(acc);
                runningError("当前轴加速度设置", rtn);
                rtn = GT400.GT_SetVel(speed);
                runningError("当前轴目标速度设置", rtn);
                rtn = GT400.GT_SetPos(pos);
                runningError("当前轴目标位置设置", rtn);
                rtn = GT400.GT_SetJerk(0.087);
                runningError("当前轴加加速度设置", rtn);
                rtn = GT400.GT_Update();
                runningError("当前轴参数更新", rtn);

                Thread.Sleep(10);

                waitCurrentRunFinish();

                rtn = GT400.GT_GetPrfPos(out prfPos);
                runningError("当前轴位置读取", rtn);

                //通过判断 pos正负来确定返回位置
                if (pos >= 0)
                {
                    prfPos -= 100;
                }
                else
                {
                    prfPos += 100;
                }

                rtn = GT400.GT_ClrSts();           //清除不正常状态
                runningError("当前轴状态异常状态清除", rtn);

                rtn = GT400.GT_SetPos(prfPos);
                runningError("当前轴目标位置设置", rtn);
                rtn = GT400.GT_Update();
                runningError("当前轴参数更新", rtn);

                //MyNotify.Notify("轴小段后退中");
                waitCurrentRunFinish();
                //MyNotify.Notify("轴小段后退完成");
                Thread.Sleep(10);

                rtn = GT400.GT_ClrSts();           //清除不正常状态
                runningError("当前轴状态异常状态清除", rtn);


                rtn = GT400.GT_SetVel(speedHomeY / 10.0);
                runningError("当前轴目标速度设置", rtn);
                rtn = GT400.GT_SetPos(pos);     //继续执行回原点:靠-200000这个值自动判断是不是回原点。
                runningError("当前轴目标位置设置", rtn);
                rtn = GT400.GT_Update();
                runningError("当前轴参数更新", rtn);

                waitCurrentRunFinish();

                rtn = GT400.GT_ZeroPos();
                runningError("轴位置状态清零", rtn);
                Util.Notify(axisIndex + "轴原点回归完成");
            }
        }
Ejemplo n.º 4
0
        protected override void ProcDataDeal()
        {
            while (isLink)
            {
                // 状态读取
                try
                {
                    commWaitResetEvent.WaitOne();

                    #region INT读取
                    short rtn;
                    int   ofst;
                    ReadInput();

                    #endregion
                    Thread.Sleep(3);

                    #region OUT写入
                    //// 锁定,从共享存储器获取要写入plc的数据
                    //mutexShMem.WaitOne();
                    //short data = new short();
                    //ofst = DMO_OFST;

                    //data = Marshal.ReadInt16(mapAddrPtr, ofst);
                    //// 解除
                    //mutexShMem.ReleaseMutex();
                    ////状态取反后输出
                    //ushort ioOutput = (ushort)(~data);
                    //lock (cardActLock)
                    //{
                    //    GT400.GT_ExOpt(ioOutput);
                    //}
                    #endregion

                    commWaitResetEvent.WaitOne();

                    #region 轴状态获取

                    ushort[] status = new ushort[axisNum];
                    int[]    pos    = new int[axisNum];
                    for (int i = 0; i < axisNum; i++)
                    {
                        lock (cardActLock)
                        {
                            rtn = GT400.GT_Axis((ushort)(i + 1));
                            runningError("当前轴设置", rtn);

                            rtn = GT400.GT_GetSts(out status[i]);
                            runningError("当前轴状态读取", rtn);

                            rtn = GT400.GT_GetPos(out pos[i]);
                            runningError("当前轴位置信息读取", rtn);
                        }
                        Thread.Sleep(3);
                    }

                    int count = 0;
                    for (int i = 0; i < axisNum; i++)
                    {
                        mutexShMem.WaitOne();

                        // 共有存储在存储器
                        ofst = DMI_OFST + (1 + i) * Marshal.SizeOf(typeof(short));
                        //将读取到的PLC数据写入到相应的内存区域
                        Marshal.WriteInt16(mapAddrPtr, ofst, (short)status[i]);


                        //位置信息
                        ofst = DMI_OFST + (DMO_A_START + count) * Marshal.SizeOf(typeof(int));

                        count++;
                        Marshal.WriteInt32(mapAddrPtr, ofst, pos[i]);
                        ofst = DMI_OFST + (DMO_A_START + count) * Marshal.SizeOf(typeof(int));
                        count++;
                        // 解除
                        mutexShMem.ReleaseMutex();
                    }
                    #endregion
                    Thread.Sleep(3);

                    commWaitResetEvent.WaitOne();
                    ////Measurement.MeasurementManager measureManger = Measurement.MeasurementManager.Instance;
                    ////int left = GetDi(Define.DiLeftButton);
                    ////int es = GetDi(Define.DiEmergencyStop);

                    //if (left == 1 && leftButtonBefore == 0 &&
                    //    measureManger.InMeasurement == false&&
                    //    es==0)
                    //{

                    //    try
                    //    {
                    //        source = new CancellationTokenSource();
                    //        Task.Run(() =>
                    //        {
                    //            measureManger.RunMeasurementLeft();
                    //        }, source.Token);
                    //    }
                    //    catch (AggregateException)//捕获紧急停止按钮
                    //    {
                    //        //MessageBox.Show("停止按钮被按下", "异常", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //    }
                    //}
                    //leftButtonBefore = left;

                    //int right = GetDi(Define.DiRightButton);
                    //if (right == 1 &&
                    //    rightButtonBefore == 0 &&
                    //    measureManger.InMeasurement == false&&
                    //    es==0)
                    //{

                    //    try
                    //    {
                    //        source = new CancellationTokenSource();
                    //        Task.Run(() =>
                    //        {
                    //            measureManger.RunMeasurementRight();
                    //        }, source.Token);
                    //    }
                    //    catch (AggregateException)//捕获紧急停止按钮
                    //    {
                    //        //MessageBox.Show("停止按钮被按下", "异常", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //    }

                    //}
                    //rightButtonBefore = right;

                    //if (es==1&&esButtonBefore==0)
                    //{
                    //    measureManger.InMeasurement = false;
                    //    //MessageBox.Show("停止按钮被按下", "异常", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //}
                    //esButtonBefore = es;
                }
                catch (Exception)
                {
                }
                Thread.Sleep(3);
            }
            CloseCom();
        }