Пример #1
0
        /// <summary>
        /// GotoHome(short CardNum[卡号], short Axis[轴号], double homeToLimitFDist[极限到原点距离], double searchHomeDist[原点搜索距离], double offsetPos[感应宽度], double homeoffset[原点偏移距离], double vel[搜索原点速度])
        /// </summary>
        /// <param name="CardNum"></param>
        /// <param name="Axis"></param>
        /// <param name="homeToLimitFDist"></param>
        /// <param name="searchHomeDist"></param>
        /// <param name="offsetPos"></param>
        /// <param name="homeoffset"></param>
        /// <param name="vel"></param>
        public static void GotoHome(short CardNum, short Axis, double homeToLimitFDist, double searchHomeDist, double offsetPos, double homeoffset, double vel)
        {
            uint temp_pClock = 0;

            if (GoHome.Instance.AxisHome[CardNum, Axis].Step != 0)
            {
                GoHome.Instance.AxisHome[CardNum, Axis].State = true;
                switch (GoHome.Instance.AxisHome[CardNum, Axis].Step)
                {
                case 10:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);              //清除报警
                    gts.GT_SetPrfPos(CardNum, Axis, 0);                  //规划器置零
                    gts.GT_SetEncPos(CardNum, Axis, 0);                  //编码器置零
                    gts.GT_SynchAxisPos(CardNum, 1 << (Axis - 1));       //将当前轴进行位置同步
                    GoHome.Instance.AxisHome[CardNum, Axis].Counter = 0; //回原点计数
                    GoHome.Instance.AxisHome[CardNum, Axis].Step    = 20;
                    break;

                case 20:
                    GoHome.Instance.AxisHome[CardNum, Axis].Capture = 0;
                    if (Gg.GetHomeDi(CardNum, Axis) == 0)     //判断是否在原点上
                    {
                        if (GoHome.Instance.AxisHome[CardNum, Axis].Counter > 1)
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].Step = 140;
                        }
                        else
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].Counter = GoHome.Instance.AxisHome[CardNum, Axis].Counter + 1;
                            GoHome.Instance.AxisHome[CardNum, Axis].Step    = 30;  //开始搜索原点
                        }
                    }
                    else
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 200;     //偏离原点,方向与搜索原点方向相反
                    }
                    break;

                case 30:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_SetCaptureMode(CardNum, Axis, gts.CAPTURE_HOME);                                                    //第一次原点搜索
                    GoHome.Instance.AxisHome[CardNum, Axis].TempPos = 0;
                    Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) + searchHomeDist), vel); //启动运动,开始搜索原点
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 40;
                    break;

                case 40:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);
                    gts.GT_GetCaptureStatus(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].Capture, out GoHome.Instance.AxisHome[CardNum, Axis].TempPos, (short)1, out temp_pClock); //获取当前轴原点捕获的状态及捕获的当前位置
                    if (GoHome.Instance.AxisHome[CardNum, Axis].Capture == 1)                                                                                                                    //判断当前轴是否原点捕获触发
                    {
                        Gg.AxisStop(CardNum, Axis);                                                                                                                                              //当前轴停止
                        GoHome.Instance.AxisHome[CardNum, Axis].Capture = 0;
                        GoHome.Instance.AxisHome[CardNum, Axis].Step    = 50;
                    }
                    else if (Gg.GetLimitDi_Z(CardNum, Axis) == 1) //判断当前轴是否触发正极限
                    {
                        Gg.AxisStop(CardNum, Axis);               //当前轴停止
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 170;
                    }
                    else if (Gg.GetLimitDi_F(CardNum, Axis) == 1) //判断当前轴是否触发负极限
                    {
                        Gg.AxisStop(CardNum, Axis);               //当前轴停止
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 150;
                    }
                    else if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)     //判断当前轴规划器是否运动停止(原点搜索距离太小)
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 140;
                    }
                    break;

                case 50:
                    Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(GoHome.Instance.AxisHome[CardNum, Axis].TempPos / Gg.PlusPerUnit(CardNum, Axis)) / Tools.GeerRate[CardNum, Axis] + 1, 2);
                    //Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) + offsetPos), 10); //启动运动,原点反向运动
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 60;
                    break;

                case 60:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock); //获取当前轴的状态
                    if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)               //判断当前轴是否运动停止
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 70;
                    }
                    break;

                case 70:
                    gts.GT_SetCaptureMode(CardNum, Axis, gts.CAPTURE_HOME);                                                 //第二次原点搜索
                    //hRtn = gts.GT_SetCaptureMode(CardNum, Axis,gts. CAPTURE_INDEX);    //启动当前轴的Z相脉冲捕获
                    Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) - offsetPos * 2), 1); //以1mm/s速度找原点
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 80;                                                      //跳转到下一步
                    break;

                case 80:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);                                                                 //获取当前轴的状态
                    gts.GT_GetCaptureStatus(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].Capture, out GoHome.Instance.AxisHome[CardNum, Axis].TempPos, (short)1, out temp_pClock); //获取当前轴Z相脉冲捕获的状态及捕获的当前位置
                    if (GoHome.Instance.AxisHome[CardNum, Axis].Capture == 1)                                                                                                                    //判断当前轴是否Z相脉冲捕获触发
                    {
                        Gg.AxisStop(CardNum, Axis);                                                                                                                                              //当前轴停止
                        GoHome.Instance.AxisHome[CardNum, Axis].Capture = 0;                                                                                                                     //捕获触发标志清零
                        GoHome.Instance.AxisHome[CardNum, Axis].Step    = 90;
                    }
                    else if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 140;     //跳转到第110步(或脉冲未捕获,回原点结束,回原点失败)
                    }
                    break;

                case 90:
                    if (homeoffset < 5)
                    {
                        Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(GoHome.Instance.AxisHome[CardNum, Axis].TempPos / Gg.PlusPerUnit(CardNum, Axis) / Tools.GeerRate[CardNum, Axis]) + homeoffset, 2);
                    }
                    else
                    {
                        Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(GoHome.Instance.AxisHome[CardNum, Axis].TempPos / Gg.PlusPerUnit(CardNum, Axis) / Tools.GeerRate[CardNum, Axis]) + homeoffset, 30);
                    }
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 100;
                    break;

                case 100:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);
                    if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)     //判断当前轴是否运动停止
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].oldtime = API.GetTickCount();
                        GoHome.Instance.AxisHome[CardNum, Axis].Step    = 110;
                    }
                    break;

                case 110:
                    if (API.GetTickCount() - GoHome.Instance.AxisHome[CardNum, Axis].oldtime > 200)
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 120;
                    }
                    break;

                case 120:
                    gts.GT_SetPrfPos(CardNum, Axis, 0);            //将当前轴规划器位置修改为零点
                    gts.GT_SetEncPos(CardNum, Axis, 0);            //将当前轴编码器位置修改为零点
                    gts.GT_SynchAxisPos(CardNum, 1 << (Axis - 1)); //将当前轴进行位置同步
                    GoHome.Instance.AxisHome[CardNum, Axis].oldtime = API.GetTickCount();
                    GoHome.Instance.AxisHome[CardNum, Axis].Step    = 130;
                    break;

                case 130:
                    if (API.GetTickCount() - GoHome.Instance.AxisHome[CardNum, Axis].oldtime > 50)
                    {
                        if (Gg.GetEncPos(CardNum, Axis) == 0 && Gg.GetPrfPos(CardNum, Axis) == 0)
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].Result = true;
                            GoHome.Instance.AxisHome[CardNum, Axis].State  = false;
                            GoHome.Instance.AxisHome[CardNum, Axis].Step   = 0;
                        }
                        else
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].oldtime = API.GetTickCount();
                            GoHome.Instance.AxisHome[CardNum, Axis].Step    = 110;
                        }
                    }
                    break;

                case 140:
                    GoHome.Instance.AxisHome[CardNum, Axis].Result = false;
                    GoHome.Instance.AxisHome[CardNum, Axis].State  = false;
                    GoHome.Instance.AxisHome[CardNum, Axis].Step   = 0;
                    break;

                //*********************************************************************************************************************
                case 150:     //负极限和原点之间距离
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) + homeToLimitFDist), vel * 0.5);
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 160;
                    break;

                case 160:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);
                    if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 20;     //重新搜索原点
                    }
                    break;

                //*********************************************************************************************************************
                case 170:     //offsetPos大于感应片的宽度
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) - offsetPos), vel);
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 180;
                    break;

                case 180:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);
                    if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].Step = 20;     //重新搜索原点
                    }
                    break;

                //*********************************************************************************************************************
                case 200:     //offsetPos大于感应片的宽度
                    Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) + offsetPos), vel);
                    GoHome.Instance.AxisHome[CardNum, Axis].Step = 201;
                    break;

                case 201:
                    if (Gg.GetHomeDi(CardNum, Axis) == 0)     //判断是否在原点上
                    {
                        Gg.AbsMotion(CardNum, Axis, System.Convert.ToDouble(Gg.GetPrfPosmm(CardNum, Axis) + 1), vel);
                        GoHome.Instance.AxisHome[CardNum, Axis].oldtime = API.GetTickCount();
                        GoHome.Instance.AxisHome[CardNum, Axis].Step    = 210;
                    }
                    else
                    {
                        gts.GT_ClrSts(CardNum, Axis, (short)1);
                        gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);
                        if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].oldtime = API.GetTickCount();
                            GoHome.Instance.AxisHome[CardNum, Axis].Step    = 140;
                        }
                    }
                    break;

                case 210:
                    gts.GT_ClrSts(CardNum, Axis, (short)1);
                    gts.GT_GetSts(CardNum, Axis, out GoHome.Instance.AxisHome[CardNum, Axis].status, (short)1, out temp_pClock);
                    if (System.Convert.ToBoolean(GoHome.Instance.AxisHome[CardNum, Axis].status & 0x400) == false)
                    {
                        GoHome.Instance.AxisHome[CardNum, Axis].oldtime = API.GetTickCount();
                        GoHome.Instance.AxisHome[CardNum, Axis].Step    = 220;
                    }
                    break;

                case (short)220:
                    if (API.GetTickCount() - GoHome.Instance.AxisHome[CardNum, Axis].oldtime > 200)
                    {
                        if (Gg.GetHomeDi(CardNum, Axis) == 1)
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].Step = 140;
                        }
                        else
                        {
                            GoHome.Instance.AxisHome[CardNum, Axis].Step = 20;
                        }
                    }
                    break;
                }
            }
        }
Пример #2
0
        public static void AutoRun(ref PVar.WorkType StaWork)
        {
            try
            {
                switch (StaWork.Step)
                {
                case 10:
                    if (PVar.Stop_Flag == false)
                    {
                        PVar.Sta_Work[1].IsHaveHSG = false;
                        StaWork.Result             = false;
                        StaWork.State = false;
                        StaWork.Step  = 20;
                        //PVar.Sta_Work[1].Step = 20;
                    }
                    break;

                case 20:
                    if (PVar.ParList.CheckSts[17] == false)
                    {
                        if (StaWork.State == false && Gg.GetDi(0, Gg.InPut0.放料光纤感应) == 1 && Gg.GetDi(0, Gg.InPut0.安全光幕) == 0)
                        {
                            AddList("光幕启动开始!");
                            TimeOut      = API.GetTickCount();
                            StaWork.Step = 30;
                        }
                        else
                        {
                            if (API.GetTickCount() - TimeOut > 1000)
                            {
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else
                    {
                        if (StaWork.State == false)
                        {
                            AddList("光幕启动开始!");
                            TimeOut      = API.GetTickCount();
                            StaWork.Step = 30;
                        }
                        else
                        {
                            if (API.GetTickCount() - TimeOut > 1000)
                            {
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    break;


                case 30:
                    if (PVar.ParList.CheckSts[17] == false)
                    {
                        if (Gg.GetDi(0, Gg.InPut0.放料光纤感应) == 1 && Gg.GetDi(0, Gg.InPut0.安全光幕) == 1)
                        {
                            if (BVar.ProductTakeOut)
                            {
                                AddList("启动OK!");

                                //根据载具编号打开相对应的真空吸
                                BVar.OpenedVacumeNo = OpenFixtureVocume();
                                TimeOut             = API.GetTickCount();
                                StaWork.Step        = 40;
                            }
                            else
                            {
                                AddList("请先取出产品!");
                                ShowList("请先取出产品!");
                                //蜂鸣器
                                PVar.Ring_EN = true;
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 1000;
                            }
                        }
                        else
                        {
                            if (Gg.GetDi(0, Gg.InPut0.放料光纤感应) == 0 && Gg.GetDi(0, Gg.InPut0.安全光幕) == 1)
                            {
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else
                    {
                        AddList("启动OK!");
                        //根据载具编号打开相对应的真空吸
                        //BVar.OpenedVacumeNo = OpenFixtureVocume();
                        TimeOut      = API.GetTickCount();
                        StaWork.Step = 50;
                    }
                    break;

                case 40:
                    if (API.GetTickCount() - TimeOut > 1000)    //延时1秒,等待真空吸信号
                    {
                        TimeOut      = API.GetTickCount();
                        StaWork.Step = 50;
                    }
                    break;

                case 50:
                    if (PVar.ParList.CheckSts[17] == false)
                    {
                        if (Gg.GetDi(0, BVar.OpenedVacumeNo + 5) == 1)    //判断真空吸信号
                        {
                            TimeOut      = API.GetTickCount();
                            StaWork.Step = 60;
                        }
                        else
                        {
                            if (API.GetTickCount() - TimeOut > 2000)
                            {
                                AddList("HSG真空吸没达到检测值,请检查产品是否放好!");
                                ShowList("HSG真空吸没达到检测值,请检查产品是否放好!");
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 1000;
                            }
                        }
                    }
                    else
                    {
                        TimeOut      = API.GetTickCount();
                        StaWork.Step = 60;
                    }
                    break;

                case 60:    //等待所有工位结束工作
                    if (PVar.ParList.CheckSts[17] == false)
                    {
                        if (PVar.Stop_Flag == false)
                        {
                            if (Gg.GetDi(0, Gg.InPut0.安全光幕) == 1 && Gg.GetDi(0, BVar.OpenedVacumeNo + 5) == 1 && PVar.Sta_Work[2].State == false && PVar.Sta_Work[3].State == false && PVar.Sta_Work[4].State == false)
                            {
                                StaWork.State = true;
                                CT_Start      = true;
                                PVar.Sta_Work[1].IsHaveHSG = true;
                                Frm_Engineering.fEngineering.OvalShape_Sta0.BackColor = Color.DarkOrange;
                                Frm_Engineering.fEngineering.Chk_StaRound.BackColor   = Color.DarkOrange;
                                if (Gg.GetPrfPos(1, 1) > 300)       //int类型最大值为2^31-1=2147483647
                                {
                                    gts.GT_SetPrfPos(1, 1, 0);      //规划器置零
                                    gts.GT_SetEncPos(1, 1, 0);      //编码器置零
                                    gts.GT_SynchAxisPos(1, 1 << 0); //将当前轴进行位置同步
                                }

                                AddList("转盘开始转动!");
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 70;
                            }
                            else
                            {
                                if (Gg.GetDi(0, BVar.OpenedVacumeNo + 5) == 0)    //判断真空吸信号
                                {
                                    AddList("HSG真空吸力异常,启动失败,请重新启动!");
                                    ShowList("HSG真空吸力异常,启动失败,请重新启动!");
                                    TimeOut      = API.GetTickCount();
                                    StaWork.Step = 1000;
                                }
                            }
                        }
                        else
                        {
                            TimeOut      = API.GetTickCount();
                            StaWork.Step = 1000;
                        }
                    }
                    else
                    {
                        if (PVar.Stop_Flag == false)
                        {
                            if (Gg.GetDi(0, Gg.InPut0.安全光幕) == 1 && PVar.Sta_Work[2].State == false && PVar.Sta_Work[3].State == false && PVar.Sta_Work[4].State == false)
                            {
                                StaWork.State = true;
                                CT_Start      = true;
                                PVar.Sta_Work[1].IsHaveHSG = true;
                                Frm_Engineering.fEngineering.OvalShape_Sta0.BackColor = Color.DarkOrange;
                                Frm_Engineering.fEngineering.Chk_StaRound.BackColor   = Color.DarkOrange;
                                if (Gg.GetPrfPosmm(1, 1) > 300)     //int类型最大值为2^31-1=2147483647
                                {
                                    gts.GT_SetPrfPos(1, 1, 0);      //规划器置零
                                    gts.GT_SetEncPos(1, 1, 0);      //编码器置零
                                    gts.GT_SynchAxisPos(1, 1 << 0); //将当前轴进行位置同步
                                }

                                AddList("转盘开始转动!");
                                TimeOut      = API.GetTickCount();
                                StaWork.Step = 70;
                            }
                        }
                        else
                        {
                            TimeOut      = API.GetTickCount();
                            StaWork.Step = 1000;
                        }
                    }
                    break;

                case 70:
                    StationR_State();
                    Gg.StepMotion(1, 1, PVar.ParAxis.Speed[9], 90, "+");
                    TimeOut      = API.GetTickCount();
                    StaWork.Step = 80;
                    break;

                case 80:
                    if (Gg.ZSPD(1, 1))
                    {
                        Frm_Engineering.fEngineering.OvalShape_Sta0.BackColor = Color.FromArgb(192, 255, 192);
                        Frm_Engineering.fEngineering.Chk_StaRound.BackColor   = Color.FromArgb(192, 255, 192);
                        AddList("转盘转动到位!");
                        TimeOut      = API.GetTickCount();
                        StaWork.Step = 90;
                    }
                    else
                    {
                        if (API.GetTickCount() - TimeOut > 10000)
                        {
                            AddList("转盘转动超时!");
                            ShowList("转盘转动超时!");
                            TimeOut      = API.GetTickCount();
                            StaWork.Step = 10000;
                        }
                    }
                    break;

                case 90:
                    TimeOut      = API.GetTickCount();
                    StaWork.Step = 800;
                    break;

                case 800:
                    StaWork.Result = true;
                    StaWork.State  = false;
                    StaWork.Step   = 10;
                    break;

                case 1000:
                    StaWork.Result = false;
                    StaWork.State  = false;
                    StaWork.Step   = 10;
                    break;

                //严重错误,急停处理
                case 10000:
                    Frm_Engineering.fEngineering.MacStop();
                    break;
                }
            }
            catch (Exception exc)
            {
                string Error_Str  = "";
                string Error_Str1 = "";
                Frm_Engineering.fEngineering.MacStop();
                MessageBox.Show(exc.Message);
                Error_Str  = PVar.BZ_LogPath + DateTime.Now.ToString("yyyyMMdd") + "\\" + DateTime.Now.ToString("yyyyMMdd") + "_代码异常记录" + ".txt";
                Error_Str1 = "\r\n" + "※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※" + "\r\n" +
                             "[" + DateTime.Now.ToString("HH:mm:ss") + "]" + "\r\n" + exc.ToString();
                FileRw.WriteDattxt(Error_Str, Error_Str1);
            }
        }