Esempio n. 1
0
        public static void AutoRun(ref PVar.WorkType StaWork)
        {
            try
            {
                switch (StaWork.Step)
                {
                case 10:
                    if (PVar.Stop_Flag == false)
                    {
                        StaWork.IsHaveBezel = false;
                        StaWork.IsHaveSN    = false;
                        StaWork.Result      = false;
                        StaWork.State       = false;
                        TriggerCount        = 0;
                        Line1Time.InitialTime();
                        StaWork.Step = 20;
                    }
                    break;
                //if (PVar.空跑)
                //{

                //}
                //else
                //{

                //}
                case 20:
                    if (PVar.空跑)
                    {
                        if (StaWork.State == false && StaWork.IsHaveFix)
                        {
                            AddList("流水线1开始工作!");
                            StaWork.State      = true;
                            BVar.ProData[1, 1] = "";    //Bezel条码
                            BVar.ProData[1, 2] = "";    //PDCA返回条码
                            BVar.ProData[1, 3] = "";    //载具条码
                            Line1Time.InitialTime();
                            StaWork.Step = 200;
                        }
                        else
                        {
                            if (Line1Time.TimeIsUp(20))
                            {
                                Line1Time.InitialTime();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else
                    {
                        if (StaWork.State == false && StaWork.IsHaveFix && Gg.GetExDi(1, Gg.InPut2.流水线对射感应2) == 1 && Gg.GetExDi(1, Gg.InPut2.流水线对射感应3) == 1)
                        {
                            AddList("流水线1开始工作!");
                            StaWork.State      = true;
                            BVar.ProData[1, 1] = "";    //Bezel条码
                            BVar.ProData[1, 2] = "";    //PDCA返回条码
                            BVar.ProData[1, 3] = "";    //载具条码
                            Line1Time.InitialTime();
                            StaWork.Step = 30;
                        }
                        else
                        {
                            if (Line1Time.TimeIsUp(20))
                            {
                                Line1Time.InitialTime();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    break;

                case 30:

                    if (PVar.ParList.CheckSts[3])     //左右机切换
                    {
                        Frm_Engineering.fEngineering.Lab_Station1.Text = "";
                    }
                    else
                    {
                        Frm_Engineering.fEngineering.Lab_Station3.Text = "";
                    }
                    if (PVar.ParList.CheckSts[8])
                    {
                        StaWork.IsHaveSN    = true;
                        StaWork.IsHaveBezel = true;
                        BVar.ProData[1, 1]  = Frm_Engineering.fEngineering.Txt_BarCode.Text;
                        if (PVar.ParList.CheckSts[3])     //左右机切换
                        {
                            Frm_Engineering.fEngineering.Lab_Station1.Text = BVar.ProData[1, 1];
                        }
                        else
                        {
                            Frm_Engineering.fEngineering.Lab_Station3.Text = BVar.ProData[1, 1];
                        }
                        Line1Time.InitialTime();
                        StaWork.Step = 200;
                    }
                    else
                    {
                        AddList("触发条码枪,获取Bezel条码");
                        TriggerCount += 1;
                        if (Command.TCP_Barcode_Send("||>trigger on") == 1)
                        {
                            Line1Time.InitialTime();
                            StaWork.Step = 50;
                        }
                        else
                        {
                            AddList("条码枪网络异常!");
                            ShowList("条码枪网络异常!");
                            Line1Time.InitialTime();
                            StaWork.Step = 900;    //跳到异常处理
                        }
                    }

                    break;

                case 50:
                    if (BVar.BarCodeData.GetCodeOK)
                    {
                        BVar.BarCodeData.GetCodeOK = false;
                        StaWork.IsHaveSN           = true;
                        StaWork.IsHaveBezel        = true;
                        BVar.ProData[1, 1]         = BVar.BarCodeData.sData.Trim();
                        if (PVar.ParList.CheckSts[3])     //左右机切换
                        {
                            Frm_Engineering.fEngineering.Lab_Station1.Text = BVar.ProData[1, 1];
                        }
                        else
                        {
                            Frm_Engineering.fEngineering.Lab_Station3.Text = BVar.ProData[1, 1];
                        }
                        AddList("Bezel条码:" + BVar.ProData[1, 1]);
                        if (PVar.ParList.CheckSts[20])    //PDCA开启
                        {
                            AddList("等待上传PDCA,检测是否过SFC!");
                        }
                        Line1Time.InitialTime();
                        StaWork.Step = 100;
                    }
                    else if (Line1Time.TimeIsUp(200))
                    {
                        if (TriggerCount < 3)
                        {
                            AddList("重新触发条码枪!");
                            Line1Time.InitialTime();
                            StaWork.Step = 30;    //返回重新触发条码
                        }
                        else
                        {
                            AddList("条码枪获取SN失败!");
                            BVar.RecordErrInfo("HsgSnErr");
                            StaWork.IsHaveSN = false;
                            StaWork.Result   = false;
                            Line1Time.InitialTime();
                            StaWork.Step = 900;    //跳到异常处理
                        }
                    }
                    break;


                //*********************************传PDCA数据,检测是否过路径***********************************
                case 100:
                    if (PVar.ParList.CheckSts[20])    //PDCA开启
                    {
                        if (PDCA.PDCAIsWorking == false)
                        {
                            AddList("开始上传PDCA");
                            PDCA.PDCAIsWorking = true;
                            PDCA.UpLoadStep    = 10;
                            Line1Time.InitialTime();
                            StaWork.Step = 110;
                        }
                    }
                    else
                    {
                        AddList("PDCA关闭,直接跳过SFC!");
                        Line1Time.InitialTime();
                        StaWork.Step = 110;
                    }
                    break;

                case 110:
                    Line1Time.InitialTime();
                    StaWork.Step = 200;
                    break;

                case 200:
                    if (PVar.空跑)
                    {
                        if (PVar.Stop_Flag == false && Gg.GetExDi(1, Gg.InPut2.流水线对射感应4) == 0 &&
                            Gg.GetExDi(1, Gg.InPut2.流水线对射感应5) == 0 && PVar.Sta_Work[(int)BVar.工位.流水线2].State == false)
                        {
                            PVar.Sta_Work[(int)BVar.工位.流水线2].Enable = true;
                            AddList("载具开始放行,等待流水线2接收!");
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸2, 0);
                            Frm_Engineering.fEngineering.Txt_BarCode.Text = "";
                            Linechange.SetMotor1(true, PVar.ParList.Data[43]);
                            Linechange.SetMotor2(true, PVar.ParList.Data[43]);
                            Line1Time.InitialTime();
                            StaWork.Step = 210;
                        }
                        else
                        {
                            if (PVar.Stop_Flag)
                            {
                                StaWork.State = false;
                                Line1Time.InitialTime();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else
                    {
                        //等待放行*****************************
                        if (PVar.Stop_Flag == false && Gg.GetExDi(1, Gg.InPut2.流水线对射感应4) == 0 &&
                            Gg.GetExDi(1, Gg.InPut2.流水线对射感应5) == 0 && PVar.Sta_Work[(int)BVar.工位.流水线2].State == false)
                        {
                            PVar.Sta_Work[(int)BVar.工位.流水线2].Enable = StaWork.IsHaveSN ? true : false;
                            AddList("载具开始放行,等待流水线2接收!");
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸2, 0);
                            Frm_Engineering.fEngineering.Txt_BarCode.Text = "";
                            Linechange.SetMotor1(true, PVar.ParList.Data[43]);
                            Linechange.SetMotor2(true, PVar.ParList.Data[43]);
                            Line1Time.InitialTime();
                            StaWork.Step = 210;
                        }
                    }
                    break;

                case 210:
                    if (PVar.空跑)
                    {
                        if (Line1Time.TimeIsUp(1000))
                        {
                            AddList("载具放行完成!");
                            PVar.Sta_Work[(int)BVar.工位.流水线1].IsHaveFix = false;
                            Linechange.SetMotor1(false, PVar.ParList.Data[43]);
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸2, 1);
                            Line1Time.InitialTime();
                            StaWork.Step = 220;
                        }
                    }
                    else
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应3) == 0)
                        {
                            AddList("载具放行完成!");
                            PVar.Sta_Work[(int)BVar.工位.流水线1].IsHaveFix = false;
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸2, 1);
                            Line1Time.InitialTime();
                            StaWork.Step = 220;
                        }
                        else if (Line1Time.TimeIsUp(5000))
                        {
                            AddList("流水线1放行载具超时!");
                            ShowList("流水线1放行载具超时!");
                            Line1Time.InitialTime();
                            StaWork.Step = 220;
                        }
                    }
                    break;

                case 220:
                    if (PVar.空跑)
                    {
                        if (Line1Time.TimeIsUp(1500))
                        {
                            AddList("载具到达流水线2!");
                            AddList("流水线2开始减速!");
                            Linechange.SetMotor2(true, 10);
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 1);
                            Line1Time.InitialTime();
                            StaWork.Step = 240;
                        }
                    }
                    else
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应4) == 1)
                        {
                            AddList("载具到达流水线2!");
                            Line1Time.InitialTime();
                            StaWork.Step = 230;
                        }
                        else if (Line1Time.TimeIsUp(5000))
                        {
                            AddList("流水线2接收载具超时!");
                            ShowList("流水线2接收载具超时!");
                            Line1Time.InitialTime();
                            StaWork.Step = 230;
                        }
                    }
                    break;

                case 230:
                    if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应5) == 1)
                    {
                        AddList("流水线2收到产品完成!");
                        Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 1);
                        StaWork.IsHaveFix = false;    //本站载具标志复位

                        Linechange.SetMotor1(false, PVar.ParList.Data[43]);
                        if (PVar.ParList.CheckSts[3])     //左右机切换
                        {
                            Frm_Engineering.fEngineering.Lab_Station1.Text = "";
                        }
                        else
                        {
                            Frm_Engineering.fEngineering.Lab_Station3.Text = "";
                        }
                        Line1Time.InitialTime();
                        StaWork.Step = 240;
                    }
                    else if (Line1Time.TimeIsUp(5000))
                    {
                        AddList("流水线2载具到位超时!");
                        ShowList("流水线2载具到位超时!");
                        Line1Time.InitialTime();
                        StaWork.Step = 240;
                    }
                    break;

                case 240:
                    if (Line1Time.TimeIsUp(500))
                    {
                        PVar.Sta_Work[(int)BVar.工位.流水线2].IsHaveFix = true;
                        Linechange.SetMotor2(false, PVar.ParList.Data[43]);
                        Line1Time.InitialTime();
                        StaWork.Step = 250;
                    }
                    break;

                case 250:
                    if (Gg.GetDi(0, Gg.InPut0.阻挡气缸1伸出) == 1)
                    {
                        AddList("阻挡气缸1伸出到位!");
                        Line1Time.InitialTime();
                        StaWork.Step = 800;
                    }
                    else if (Line1Time.TimeIsUp(500))
                    {
                        AddList("阻挡气缸1伸出异常!");
                        ShowList("阻挡气缸1伸出异常!");
                        Line1Time.InitialTime();
                        StaWork.Step = 800;
                    }
                    break;

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

                case 900:
                    //跳转到等待放行
                    StaWork.Result    = false;
                    StaWork.IsHaveFix = true;
                    StaWork.IsHaveSN  = false;
                    Linechange.SetMotor1(false, PVar.ParList.Data[43]);
                    StaWork.Step = 200;
                    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);
            }
        }
Esempio n. 2
0
        public static void AutoRun(ref PVar.WorkType StaWork)
        {
            try
            {
                switch (StaWork.Step)
                {
                case 10:
                    if (PVar.Stop_Flag == false)
                    {
                        StaWork.State = false;
                        Line3Time.InitialTime();
                        StaWork.Step = 20;
                    }
                    break;

                case 20:
                    if (StaWork.State == false && StaWork.IsHaveFix)
                    {
                        AddList("组装开始!");
                        StaWork.State = true;

                        BVar.ProData[3, 1] = BVar.ProData[2, 1];    //Bezel条码
                        BVar.ProData[3, 3] = BVar.ProData[2, 3];    //载具条码
                        Line3Time.InitialTime();
                        StaWork.Step = 30;
                    }
                    else if (Line3Time.TimeIsUp(50))
                    {
                        StaWork.Step = 10;
                    }
                    break;

                case 30:
                    if (PVar.空跑)
                    {
                        if (Line3Time.TimeIsUp(2000))
                        {
                            AddList("载具流出感应到!");
                            Linechange.SetMotor3(true, 10);
                            Line3Time.InitialTime();
                            StaWork.Step = 40;
                        }
                    }
                    else
                    {
                        if (Linechange.LineOut() == 1)
                        {
                            AddList("载具流出感应到!");
                            Line3Time.InitialTime();
                            StaWork.Step = 40;
                            Linechange.SetMotor3(false, PVar.ParList.Data[43]);
                        }
                        else if (Line3Time.TimeIsUp(5000))
                        {
                            Line3Time.InitialTime();
                            StaWork.Step = 40;
                        }
                    }

                    break;

                case 40:
                    if (Line3Time.TimeIsUp(1000))
                    {
                        AddList("流水线3马达停止!");
                        Linechange.SetMotor3(false, PVar.ParList.Data[43]);
                        Line3Time.InitialTime();
                        StaWork.Step = 50;
                    }
                    break;

                case 50:
                    if (Linechange.LineOut() == 0)
                    {
                        AddList("载具已经取走!");
                        StaWork.IsHaveFix = false;
                        Line3Time.InitialTime();
                        StaWork.Step = 800;
                    }
                    break;

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

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

                //遇到异常,设备先暂停,确定后处理************************
                case 8000:
                    if (Manual.AutoMotionFlag[3])
                    {
                        if (Manual.HoldFlag[3])
                        {
                            Manual.HoldFlag[3] = false;
                            Frm_Engineering.fEngineering.CmdHoldPress.Text      = "暂停";
                            Frm_Engineering.fEngineering.CmdHoldPress.BackColor = Color.BurlyWood;
                            ShowList("运动已继续");
                        }
                        else
                        {
                            Manual.HoldFlag[3] = true;
                            Frm_Engineering.fEngineering.CmdHoldPress.Text      = "继续";
                            Frm_Engineering.fEngineering.CmdHoldPress.BackColor = Color.Red;
                            ShowList("运动已暂停");
                        }
                    }
                    else
                    {
                        PVar.IsSystemOnPauseMode                        = true;
                        PVar.MacHold                                    = true;
                        StaWork.StaHold                                 = true;
                        PVar.Stop_Flag                                  = false;
                        Frm_Main.fMain.Btn_Start.Enabled                = false;
                        Frm_Main.fMain.Btn_Pause.Enabled                = true;
                        Frm_Main.fMain.Btn_Stop.Enabled                 = false;
                        Frm_Main.fMain.Btn_Start.BZ_BackColor           = PVar.BZColor_UnselectedBtn;
                        Frm_Main.fMain.Btn_Pause.BZ_BackColor           = PVar.BZColor_SelectedEndBtn;
                        Frm_Main.fMain.Btn_Stop.BZ_BackColor            = PVar.BZColor_UnselectedBtn;
                        Frm_Engineering.fEngineering.Auto_Timer.Enabled = false;
                    }

                    PVar.LampStatus = 20;
                    StaWork.Step    = BufferStep;
                    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);
            }
        }
Esempio n. 3
0
        public static void HomeSub()
        {
            switch (StepHome)
            {
            case 10:
                GoHome.Reset.State = true;
                AddList("设备初始化开始,请等待!");

                //停止流水线
                Linechange.SetMotor1(false, 0);    //
                Linechange.SetMotor2(false, 0);
                Linechange.SetMotor3(false, 0);
                AddList("关闭传送带电机");
                if (EpsonRobot.IsRobotAlarm)
                {
                    AddList("机械手报警,初始化失败,请检查!");
                    ShowList("机械手报警,初始化失败,请检查!");
                    StepHome = 1000;
                    return;
                }
                Gg.SetDo(0, Gg.OutPut0.启动按钮指示灯, 0);
                Gg.SetDo(0, Gg.OutPut0.日光灯继电器, 0);
                Gg.SetDo(0, Gg.OutPut0.步进电机使能, 0);
                Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 1);
                Gg.SetDo(0, Gg.OutPut0.阻挡气缸2, 1);
                Gg.SetDo(0, Gg.OutPut0.阻挡气缸3, 1);

                Gg.SetExDo(0, 0, Gg.OutPut1.PSA吸嘴升降气缸, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.光源旋转气缸, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.撕膜夹爪气缸, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.机械手滑台气缸, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.机械手撕膜升降气缸, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.机械手撕膜针型气缸, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.载具夹紧气缸, 0);

                Gg.SetExDo(0, 1, Gg.OutPut2.NG指示灯, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.OK指示灯, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.PSA载台破真空, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.PSA载台真空吸, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.搬运PSA破真空, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.搬运PSA真空吸, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.机械手吸嘴破真空, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.机械手吸嘴真空吸, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.机械手夹爪吸膜破真空, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.机械手夹爪吸膜真空吸, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.机械手排线破真空, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.机械手排线真空吸, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.右料盘吸电磁铁, 1);
                Gg.SetExDo(0, 1, Gg.OutPut2.左料盘吸电磁铁, 1);
                Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品破真空, 0);
                Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品真空吸, 0);

                Gg.SetExDo(0, 2, Gg.OutPut3.离子风扇, 0);

                RobotHomeNum = 0;
                ////界面
                Frm_Main.fMain.Btn_Stop.Enabled       = false;
                Frm_Main.fMain.Btn_Pause.Enabled      = false;
                Frm_Main.fMain.Btn_Stop.BZ_BackColor  = PVar.BZColor_UnselectedBtn;
                Frm_Main.fMain.Btn_Pause.BZ_BackColor = PVar.BZColor_UnselectedBtn;
                Frm_ProgressBar.IsShowProgresBar(true);
                InitTime.InitialTime();
                StepHome = 20;
                break;

            //机械手回初始位置
            case 20:
                RobotHomeNum += 1;
                AddList("机械手停止!");
                Gg.SetDo(0, Gg.OutPut0.机械手停止, 1);
                WinAPI.Wait(200);
                Gg.SetDo(0, Gg.OutPut0.机械手停止, 0);
                WinAPI.Wait(100);
                InitTime.InitialTime();
                StepHome = 22;
                break;

            case 22:
                AddList("机械手复位!");
                Gg.SetDo(0, Gg.OutPut0.机械手复位, 1);
                WinAPI.Wait(200);
                Gg.SetDo(0, Gg.OutPut0.机械手复位, 0);
                WinAPI.Wait(100);
                InitTime.InitialTime();
                StepHome = 24;
                break;

            case 24:
                AddList("机械手启动!");
                Gg.SetDo(0, Gg.OutPut0.机械手启动, 1);
                WinAPI.Wait(200);
                Gg.SetDo(0, Gg.OutPut0.机械手启动, 0);
                WinAPI.Wait(100);
                InitTime.InitialTime();
                StepHome = 30;
                break;

            case 30:
                if (Gg.GetDi(0, Gg.InPut0.机械手运动中) == 1)
                {
                    AddList("机械手启动成功!");
                    InitTime.InitialTime();
                    StepHome = 40;
                }
                else if (InitTime.TimeIsUp(2000))
                {
                    if (RobotHomeNum < 3)
                    {
                        InitTime.InitialTime();
                        StepHome = 20;
                    }
                    else
                    {
                        AddList("机械手启动失败!");
                        ShowList("机械手启动失败!");
                        StepHome = 1000;
                        return;
                    }
                }
                break;

            case 40:
                if (Frm_Engineering.fEngineering.Tcp_Robot.IsStart)
                {
                    AddList("机械手网络链接OK!");
                    InitTime.InitialTime();
                    StepHome = 50;
                }
                else if (InitTime.TimeIsUp(5000))
                {
                    if (RobotHomeNum < 3)
                    {
                        InitTime.InitialTime();
                        StepHome = 20;
                    }
                    else
                    {
                        AddList("机械手网络链接失败!");
                        ShowList("机械手网络链接失败!");
                        StepHome = 1000;
                        return;
                    }
                }
                break;

            case 50:
                AddList("获取机械手程序版本!");
                if (Frm_Engineering.fEngineering.Rbt_SendCmd("GetVersion", "0", "0", "0", "0", "0", "0", "0",
                                                             "DAB-SV(1.0.0)_20180505", "0", "0", "0", "0", "0") == false)
                {
                    StepHome = 1000;
                    return;
                }
                InitTime.InitialTime();
                StepHome = 60;
                break;

            case 60:
                if (EpsonRobot.sRobot_Status == "GetVersionOK")
                {
                    AddList("机械手程序版本匹配OK!");
                    InitTime.InitialTime();
                    StepHome = 100;
                }
                else if (EpsonRobot.sRobot_Status == "GetVersionNG")
                {
                    AddList("机械手版本不匹配!");
                    ShowList("机械手版本不匹配!");
                    StepHome = 1000;
                    return;
                }
                else if (InitTime.TimeIsUp(3000))
                {
                    AddList("获取机械手程序版本超时!");
                    ShowList("获取机械手程序版本超时!");
                    StepHome = 1000;
                    return;
                }
                break;

            case 100:
                AddList("机械手回初始位置开始!");
                if (Frm_Engineering.fEngineering.Rbt_SendCmd("Step", RobotPosName.待机位置, "20", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "20") == false)
                {
                    StepHome = 1000;
                    return;
                }
                InitTime.InitialTime();
                StepHome = 110;
                break;

            case 110:
                if (EpsonRobot.sRobot_Status == "Step" + RobotPosName.待机位置)
                {
                    AddList("机械手回待机位置OK!");
                    InitTime.InitialTime();
                    StepHome = 200;
                }
                else if (InitTime.TimeIsUp(10000))
                {
                    AddList("机械手回待机位置超时!");
                    ShowList("机械手回待机位置超时!");
                    StepHome = 1000;
                    return;
                }
                break;

            case 200:
                Frm_ProgressBar.SetValueProgressBar(30);         //初始化进度条的进度更新显示
                if (Gg.GetDi(0, Gg.InPut0.阻挡气缸1伸出) == 1 && Gg.GetDi(0, Gg.InPut0.阻挡气缸2伸出) == 1 && Gg.GetDi(0, Gg.InPut0.阻挡气缸3伸出) == 1 &&
                    Gg.GetExDi(0, Gg.InPut1.光源旋转气缸缩回) == 1 && Gg.GetExDi(0, Gg.InPut1.光源旋转气缸伸出) == 0 &&
                    Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸缩回) == 1 && Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸伸出) == 0 &&
                    Gg.GetExDi(0, Gg.InPut1.机械手撕膜升降气缸缩回) == 1 && Gg.GetExDi(0, Gg.InPut1.机械手撕膜升降气缸伸出) == 0 &&
                    Gg.GetExDi(0, Gg.InPut1.机械手滑台气缸缩回) == 1 && Gg.GetExDi(0, Gg.InPut1.机械手滑台气缸伸出) == 0 &&
                    Gg.GetExDi(0, Gg.InPut1.PSA吸嘴升降气缸上) == 1 && Gg.GetExDi(0, Gg.InPut1.PSA吸嘴升降气缸下) == 0)
                {
                    InitTime.InitialTime();
                    StepHome = 210;
                }

                if (InitTime.TimeIsUp(6000))
                {
                    if (Gg.GetDi(0, Gg.InPut0.阻挡气缸1伸出) == 0)
                    {
                        AddList("阻挡气缸1伸出信号异常,请检查!");
                        ShowList("阻挡气缸1伸出信号异常,请检查!");
                    }

                    if (Gg.GetDi(0, Gg.InPut0.阻挡气缸2伸出) == 0)
                    {
                        AddList("阻挡气缸2伸出信号异常,请检查!");
                        ShowList("阻挡气缸2伸出信号异常,请检查!");
                    }
                    if (Gg.GetDi(0, Gg.InPut0.阻挡气缸3伸出) == 0)
                    {
                        AddList("阻挡气缸3伸出信号异常,请检查!");
                        ShowList("阻挡气缸3伸出信号异常,请检查!");
                    }

                    if (Gg.GetExDi(0, Gg.InPut1.光源旋转气缸缩回) == 0 || Gg.GetExDi(0, Gg.InPut1.光源旋转气缸伸出) == 1)
                    {
                        AddList("光源旋转气缸缩回信号异常,请检查!");
                        ShowList("光源旋转气缸缩回回信号异常,请检查!");
                    }

                    if (Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸缩回) == 0 || Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸伸出) == 1)
                    {
                        AddList("载具夹紧气缸缩回信号异常,请检查!");
                        ShowList("载具夹紧气缸缩回信号异常,请检查!");
                    }

                    if (Gg.GetExDi(0, Gg.InPut1.机械手撕膜升降气缸缩回) == 0 || Gg.GetExDi(0, Gg.InPut1.机械手撕膜升降气缸伸出) == 1)
                    {
                        AddList("机械手撕膜升降气缸缩回信号异常,请检查!");
                        ShowList("机械手撕膜升降气缸缩回信号异常,请检查!");
                    }

                    if (Gg.GetExDi(0, Gg.InPut1.机械手滑台气缸缩回) == 0 || Gg.GetExDi(0, Gg.InPut1.机械手滑台气缸伸出) == 1)
                    {
                        AddList("机械手滑台气缸缩回信号异常,请检查!");
                        ShowList("机械手滑台气缸缩回信号异常,请检查!");
                    }
                    if (Gg.GetExDi(0, Gg.InPut1.PSA吸嘴升降气缸上) == 0 || Gg.GetExDi(0, Gg.InPut1.PSA吸嘴升降气缸下) == 1)
                    {
                        AddList("PSA吸嘴升降气缸上信号异常,请检查!");
                        ShowList("PSA吸嘴升降气缸上信号异常,请检查!");
                    }
                    StepHome = 1000;
                }
                break;

            case 210:
                AddList("料仓左Z轴开始回原点…");
                AddList("料仓右Z轴开始回原点…");
                AddList("PSA供料Z轴开始回原点…");
                AddList("保压Z轴开始回原点…");
                AddList("PSA搬运Y轴开始回原点…");
                GoHome.AxisHome[0, Axis.料仓左Z轴].Result   = false;
                GoHome.AxisHome[0, Axis.料仓右Z轴].Result   = false;
                GoHome.AxisHome[0, Axis.PSA供料Z轴].Result = false;
                GoHome.AxisHome[0, Axis.保压Z轴].Result    = false;
                GoHome.AxisHome[0, Axis.PSA搬运Y轴].Result = false;

                GoHome.AxisHome[0, Axis.料仓左Z轴].Enable   = true;
                GoHome.AxisHome[0, Axis.料仓右Z轴].Enable   = true;
                GoHome.AxisHome[0, Axis.PSA供料Z轴].Enable = true;
                GoHome.AxisHome[0, Axis.保压Z轴].Enable    = true;
                GoHome.AxisHome[0, Axis.PSA搬运Y轴].Enable = true;

                GoHome.AxisHome[0, Axis.料仓左Z轴].Step   = 10;
                GoHome.AxisHome[0, Axis.料仓右Z轴].Step   = 10;
                GoHome.AxisHome[0, Axis.PSA供料Z轴].Step = 10;
                GoHome.AxisHome[0, Axis.保压Z轴].Step    = 10;
                GoHome.AxisHome[0, Axis.PSA搬运Y轴].Step = 10;
                InitTime.InitialTime();
                Frm_ProgressBar.SetValueProgressBar(30);
                StepHome = 220;
                break;

            case 220:
                GotoHome(0, Axis.料仓左Z轴, 30, -1000, 10, 1, 5);
                GotoHome(0, Axis.料仓右Z轴, 30, -1000, 10, 1, 5);
                GotoHome(0, Axis.PSA供料Z轴, 30, -1000, 10, 1, 5);
                GotoHome(0, Axis.保压Z轴, 30, -90, 20, -3, 5);
                GotoHome(0, Axis.PSA搬运Y轴, 30, -1000, 10, 1, 10);

                if (GoHome.AxisHome[0, Axis.PSA搬运Y轴].Step != 0 && Gg.GetExDi(0, Gg.InPut1.PSA吸嘴升降气缸上) == 0)
                {
                    AddList("PSA吸嘴升降气缸上信号异常!");
                    ShowList("PSA吸嘴升降气缸上信号异常!");
                    StepHome = 1000;
                }

                if (GoHome.AxisHome[0, Axis.料仓左Z轴].Step == 0 && GoHome.AxisHome[0, Axis.料仓左Z轴].Enable)
                {
                    GoHome.AxisHome[0, Axis.料仓左Z轴].Enable = false;
                    if (GoHome.AxisHome[0, Axis.料仓左Z轴].Result)
                    {
                        AddList("料仓左Z轴回原点成功!");
                    }
                    else
                    {
                        AddList("料仓左Z轴回原点失败!");
                        ShowList("料仓左Z轴回原点失败!");
                        StepHome = 1000;
                    }
                }

                if (GoHome.AxisHome[0, Axis.料仓右Z轴].Step == 0 && GoHome.AxisHome[0, Axis.料仓右Z轴].Enable)
                {
                    GoHome.AxisHome[0, Axis.料仓右Z轴].Enable = false;
                    if (GoHome.AxisHome[0, Axis.料仓右Z轴].Result)
                    {
                        AddList("料仓右Z轴回原点成功!");
                    }
                    else
                    {
                        AddList("料仓右Z轴回原点失败!");
                        ShowList("料仓右Z轴回原点失败!");
                        StepHome = 1000;
                    }
                }

                if (GoHome.AxisHome[0, Axis.PSA供料Z轴].Step == 0 && GoHome.AxisHome[0, Axis.PSA供料Z轴].Enable)
                {
                    GoHome.AxisHome[0, Axis.PSA供料Z轴].Enable = false;
                    if (GoHome.AxisHome[0, Axis.PSA供料Z轴].Result)
                    {
                        AddList("PSA供料Z轴回原点成功!");
                    }
                    else
                    {
                        AddList("PSA供料Z轴回原点失败!");
                        ShowList("PSA供料Z轴回原点失败!");
                        StepHome = 1000;
                    }
                }

                if (GoHome.AxisHome[0, Axis.保压Z轴].Step == 0 && GoHome.AxisHome[0, Axis.保压Z轴].Enable)
                {
                    GoHome.AxisHome[0, Axis.保压Z轴].Enable = false;
                    if (GoHome.AxisHome[0, Axis.保压Z轴].Result)
                    {
                        AddList("保压Z轴回原点成功!");
                    }
                    else
                    {
                        AddList("保压Z轴回原点失败!");
                        ShowList("保压Z轴回原点失败!");
                        StepHome = 1000;
                    }
                }

                if (GoHome.AxisHome[0, Axis.PSA搬运Y轴].Step == 0 && GoHome.AxisHome[0, Axis.PSA搬运Y轴].Enable)
                {
                    GoHome.AxisHome[0, Axis.PSA搬运Y轴].Enable = false;
                    if (GoHome.AxisHome[0, Axis.PSA搬运Y轴].Result)
                    {
                        AddList("PSA搬运Y轴回原点成功!");
                    }
                    else
                    {
                        AddList("PSA搬运Y轴回原点失败!");
                        ShowList("PSA搬运Y轴回原点失败!");
                        StepHome = 1000;
                    }
                }

                if (GoHome.AxisHome[0, Axis.料仓左Z轴].Result && GoHome.AxisHome[0, Axis.料仓右Z轴].Result &&
                    GoHome.AxisHome[0, Axis.PSA供料Z轴].Result && GoHome.AxisHome[0, Axis.保压Z轴].Result &&
                    GoHome.AxisHome[0, Axis.PSA搬运Y轴].Result)
                {
                    Frm_ProgressBar.SetValueProgressBar(50);
                    InitTime.InitialTime();
                    StepHome = 300;
                }
                break;

            //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

            case 300:
                AddList("各轴开始回待机位置…");
                //料仓
                Gg.AbsMotion(0, Axis.料仓左Z轴, mFunction.Pos.TeachAxis1[Axis.tTag.左料仓, Axis.Point左料仓.初始位置], 20);
                Gg.AbsMotion(0, Axis.料仓右Z轴, mFunction.Pos.TeachAxis1[Axis.tTag.右料仓, Axis.Point右料仓.初始位置], 20);

                //PSA供料
                Gg.AbsMotion(0, Axis.PSA供料Z轴, mFunction.Pos.TeachAxis2[Axis.tTag.PSA供料, Axis.Point供料PSA.PSA_Z轴初始位置], 20);
                Gg.AbsMotion(0, Axis.PSA搬运Y轴, mFunction.Pos.TeachAxis1[Axis.tTag.PSA供料, Axis.Point供料PSA.PSA_Y轴吸料位置], 20);

                //保压站
                Gg.AbsMotion(0, Axis.保压Z轴, mFunction.Pos.TeachAxis1[Axis.tTag.保压, Axis.Point保压.初始位置], 20);

                InitTime.InitialTime();
                StepHome = 310;
                break;

            case 310:
                if (Gg.ZSPD(0, Axis.PSA搬运Y轴) == false && Gg.GetExDi(0, Gg.InPut1.PSA吸嘴升降气缸上) == 0)
                {
                    AddList("PSA吸嘴升降气缸上信号异常!");
                    ShowList("PSA吸嘴升降气缸上信号异常!");
                    StepHome = 1000;
                }

                if (Gg.ZSPD(0, Axis.料仓左Z轴) && Gg.ZSPD(0, Axis.料仓右Z轴) &&
                    Gg.ZSPD(0, Axis.PSA供料Z轴) && Gg.ZSPD(0, Axis.PSA搬运Y轴) &&
                    Gg.ZSPD(0, Axis.保压Z轴))
                {
                    AddList("整机回待机位置完成!");
                    InitTime.InitialTime();
                    StepHome = 350;
                }
                else
                {
                    if (InitTime.TimeIsUp(10000))
                    {
                        if (Gg.ZSPD(0, Axis.料仓左Z轴) == false)
                        {
                            AddList("料仓左Z轴回待机位置失败!");
                            ShowList("料仓左Z轴回待机位置失败!");
                        }
                        if (Gg.ZSPD(0, Axis.料仓右Z轴) == false)
                        {
                            AddList("料仓右Z轴回待机位置失败!");
                            ShowList("料仓右Z轴回待机位置失败!");
                        }
                        if (Gg.ZSPD(0, Axis.PSA供料Z轴) == false)
                        {
                            AddList("PSA供料Z轴回待机位置失败!");
                            ShowList("PSA供料Z轴回待机位置失败!");
                        }
                        if (Gg.ZSPD(0, Axis.PSA搬运Y轴) == false)
                        {
                            AddList("PSA搬运Y轴回待机位置失败!");
                            ShowList("PSA搬运Y轴回待机位置失败!");
                        }
                        if (Gg.ZSPD(0, Axis.保压Z轴) == false)
                        {
                            AddList("保压Z轴回待机位置失败!");
                            ShowList("保压Z轴回待机位置失败!");
                        }
                        StepHome = 1000;
                    }
                }
                break;

            case 350:
                //平移气缸回到左边
                Gg.SetExDo(0, 2, Gg.OutPut3.料盘平移无杆气缸左, 1);
                Gg.SetExDo(0, 2, Gg.OutPut3.料盘平移无杆气缸右, 0);

                //保压无杆气缸向右复位
                Gg.SetExDo(0, 0, Gg.OutPut1.保压无杆气缸左, 0);
                Gg.SetExDo(0, 0, Gg.OutPut1.保压无杆气缸右, 1);
                AddList("料盘平移无杆气缸向左复位!");
                InitTime.InitialTime();
                StepHome = 360;
                break;

            case 360:
                if (Gg.GetExDi(2, Gg.InPut3.料盘平移无杆气缸左) == 1 && Gg.GetExDi(2, Gg.InPut3.料盘平移无杆气缸右) == 0 &&
                    Gg.GetExDi(0, Gg.InPut1.保压无杆气缸右) == 1 && Gg.GetExDi(0, Gg.InPut1.保压无杆气缸左) == 0)
                {
                    AddList("料盘平移无杆气缸向左复位OK!");
                    InitTime.InitialTime();
                    StepHome = 370;
                }
                else
                {
                    if (InitTime.TimeIsUp(6000))
                    {
                        if (Gg.GetExDi(2, Gg.InPut3.料盘平移无杆气缸左) == 0 || Gg.GetExDi(2, Gg.InPut3.料盘平移无杆气缸右) == 1)
                        {
                            AddList("料盘平移无杆气缸左信号异常!");
                            InitTime.InitialTime();
                            StepHome = 1000;
                        }
                    }
                    if (Gg.GetExDi(0, Gg.InPut1.保压无杆气缸左) == 1 || Gg.GetExDi(0, Gg.InPut1.保压无杆气缸右) == 0)
                    {
                        AddList("保压无杆气缸右信号异常!");
                        InitTime.InitialTime();
                        StepHome = 1000;
                    }
                }
                break;

            case 370:
                InitTime.InitialTime();
                StepHome = 800;
                break;

            case 800:
                AddList("初始化完成");
                ShowList("初始化完成");
                PVar.LampStatus    = 20;
                PVar.Stop_Flag     = true;
                PVar.AutoRunFlag   = false;
                PVar.MacHold       = false;
                PVar.CPKDoneCounts = 0;
                PVar.WorkMode      = 0;

                Frm_Main.fMain.Panel_CPK.Visible = false;

                //按钮初始化
                Frm_Main.fMain.Btn_Start.Enabled      = true;
                Frm_Main.fMain.Btn_Pause.Enabled      = false;
                Frm_Main.fMain.Btn_Stop.Enabled       = true;
                Frm_Main.fMain.Btn_Start.BZ_BackColor = PVar.BZColor_SelectedBtn;       //'主页面初始化和自动运行按钮
                Frm_Main.fMain.Btn_Pause.BZ_BackColor = PVar.BZColor_UnselectedBtn;
                Frm_Main.fMain.Btn_Stop.BZ_BackColor  = PVar.BZColor_UnselectedBtn;

                Frm_Engineering.fEngineering.TabPage3.Parent = Frm_Engineering.fEngineering.TabControl1;
                Frm_Engineering.fEngineering.TabPage4.Parent = Frm_Engineering.fEngineering.TabControl1;

                Frm_ProgressBar.IsShowProgresBar(false);         //'初始化进度条显示
                Frm_Engineering.fEngineering.Home_Timer.Enabled = false;
                for (int i = 0; i <= 10; i++)
                {
                    PVar.Sta_Work[i].State     = false;
                    PVar.Sta_Work[i].Result    = false;
                    PVar.Sta_Work[i].IsHaveHSG = false;
                    PVar.Sta_Work[i].Step      = 0;
                }
                Mod_ErrorCode.CheckSystemTimeStep = 0;
                GoHome.Reset.State  = false;
                GoHome.Reset.Result = true;
                StepHome            = 0;
                break;

            case 1000:
                PVar.LampStatus = 10;
                PVar.MacHold    = false;
                PVar.Stop_Flag  = true;
                //按钮初始化
                Frm_Main.fMain.Btn_Start.Enabled      = true;
                Frm_Main.fMain.Btn_Pause.Enabled      = false;
                Frm_Main.fMain.Btn_Stop.Enabled       = false;
                Frm_Main.fMain.Btn_Start.BZ_BackColor = PVar.BZColor_UnselectedBtn;       //主页面初始化和自动运行按钮
                Frm_Main.fMain.Btn_Pause.BZ_BackColor = PVar.BZColor_UnselectedBtn;
                Frm_Main.fMain.Btn_Stop.BZ_BackColor  = PVar.BZColor_SelectedEndBtn;

                PVar.Rtn = gts.GT_Stop(0, 255, 255);     //紧急停止0号卡所有轴
                Frm_Engineering.fEngineering.Home_Timer.Enabled = false;
                Frm_ProgressBar.IsShowProgresBar(false); //初始化进度条显示
                GoHome.Reset.Result = false;
                GoHome.Reset.State  = false;
                StepHome            = 0;
                break;
            }

            //string tempStr = "";
            //if (Gg.GetDi(0, Gg.InPut0.安全门) == 0)
            //    {
            //    tempStr = "安全门";
            //    }

            //if (!string.IsNullOrEmpty(tempStr))
            //    {
            //    AddList("请关闭" + tempStr + "再初始化");
            //    ShowList("请关闭" + tempStr + "再初始化");
            //    StepHome = 1000;
            //    return;
            //    }
        }
Esempio n. 4
0
        public static void AutoRun(ref PVar.WorkType StaWork)
        {
            try
            {
                switch (StaWork.Step)
                {
                case 10:
                    if (PVar.Stop_Flag == false)
                    {
                        StaWork.State  = false;
                        StaWork.Result = false;
                        Line2Time.InitialTime();
                        StaWork.Step = 20;
                    }
                    break;

                case 20:
                    if (PVar.空跑)
                    {
                        if (StaWork.State == false && StaWork.Enable && StaWork.IsHaveFix)
                        {
                            AddList("组装开始!");
                            StaWork.State  = true;
                            StaWork.Enable = false;

                            BVar.ProData[2, 1] = BVar.ProData[1, 1];    //Bezel条码
                            BVar.ProData[2, 3] = BVar.ProData[1, 3];    //载具条码
                            Frm_Engineering.fEngineering.Lab_Station2.Text = BVar.ProData[2, 1];

                            Gg.SetExDo(0, 0, Gg.OutPut1.载具夹紧气缸, 1);
                            Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品真空吸, 1);
                            Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品破真空, 0);
                            Line2Time.InitialTime();
                            StaWork.Step = 30;
                        }
                        else
                        {
                            if (Line2Time.TimeIsUp(20))
                            {
                                Line2Time.InitialTime();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else    //********************************************
                    {
                        if (StaWork.State == false && StaWork.Enable && StaWork.IsHaveFix)
                        {
                            AddList("组装开始!");
                            StaWork.State  = true;
                            StaWork.Enable = false;

                            BVar.ProData[2, 1] = BVar.ProData[1, 1];    //Bezel条码
                            BVar.ProData[2, 3] = BVar.ProData[1, 3];    //载具条码
                            Frm_Engineering.fEngineering.Lab_Station2.Text = BVar.ProData[2, 1];

                            Gg.SetExDo(0, 0, Gg.OutPut1.载具夹紧气缸, 1);
                            Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品真空吸, 1);
                            Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品破真空, 0);
                            Line2Time.InitialTime();
                            StaWork.Step = 30;
                        }
                        else if (StaWork.State == false && StaWork.Enable == false && StaWork.IsHaveFix)
                        {
                            AddList("没有条码,跳过组装!");
                            StaWork.Result = false;
                            Line2Time.InitialTime();
                            StaWork.Step = 5000;     //等待放行
                        }
                        else
                        {
                            StaWork.Step = 10;
                        }
                    }
                    break;

                case 30:
                    AddList("保压Z轴回初始位置!");
                    Gg.AbsMotion(0, Axis.保压Z轴, mFunction.Pos.TeachAxis1[Axis.tTag.保压, Axis.Point保压.初始位置], PVar.ParAxis.Speed[Axis.保压Z轴]);
                    Line2Time.InitialTime();
                    StaWork.Step = 40;
                    break;

                case 40:
                    //保压轴和气缸复位
                    if (Gg.ZSPD(0, Axis.保压Z轴) && Gg.GetHomeDi(0, Axis.保压Z轴) == 1)
                    {
                        //保压站无杆气缸双头电磁阀向右
                        AddList("保压Z轴OK!");
                        Gg.SetExDo(0, 0, Gg.OutPut1.保压无杆气缸左, 0);
                        Gg.SetExDo(0, 0, Gg.OutPut1.保压无杆气缸右, 1);
                        Line2Time.InitialTime();
                        StaWork.Step = 50;
                    }
                    else if (Line2Time.TimeIsUp(8000))
                    {
                        AddList("保压Z轴运动到初始位置超时!");
                        ShowList("保压Z轴运动到初始位置超时!");
                        StaWork.Result = false;
                        Line2Time.InitialTime();
                        StaWork.Step = 10000;
                    }
                    break;

                case 50:
                    if (Gg.GetExDi(0, Gg.InPut1.保压无杆气缸左) == 0 && Gg.GetExDi(0, Gg.InPut1.保压无杆气缸右) == 1)
                    {
                        if (EpsonRobot.RobotLivePos.Y > -150)    //判断机械手是否在流水线外
                        {
                            Gg.SetExDo(0, 0, Gg.OutPut1.光源旋转气缸, 1);
                        }
                        Line2Time.InitialTime();
                        StaWork.Step = 60;
                    }
                    else if (Line2Time.TimeIsUp(5000))
                    {
                        AddList("保压无杆气缸右信号感应异常!");
                        ShowList("保压无杆气缸右信号感应异常!");
                        StaWork.Result = false;
                        Line2Time.InitialTime();
                        StaWork.Step = 5000;      //等待放行
                    }
                    break;

                case 60:
                    if (Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸缩回) == 0 && Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸伸出) == 1)
                    {
                        AddList("载具夹紧气缸伸出信号OK!");
                        AddList("等待光源旋转气缸伸出信号感应!");
                        Line2Time.InitialTime();
                        StaWork.Step = 70;
                    }
                    else if (Line2Time.TimeIsUp(2000) && Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸缩回) == 0)
                    {
                        AddList("保载具夹紧气缸伸出信号感应异常!");
                        Line2Time.InitialTime();
                        StaWork.Step = 70;    //小异常忽略
                    }
                    break;

                case 70:
                    if (Gg.GetExDi(0, Gg.InPut1.光源旋转气缸缩回) == 0 && Gg.GetExDi(0, Gg.InPut1.光源旋转气缸伸出) == 1)
                    {
                        AddList("光源旋转气缸伸出信号感应OK!");
                        Line2Time.InitialTime();
                        StaWork.Step = 200;
                    }
                    else
                    {
                        if (EpsonRobot.RobotLivePos.Y > -200)    //判断机械手是否在流水线外
                        {
                            Gg.SetExDo(0, 0, Gg.OutPut1.光源旋转气缸, 1);
                        }
                    }
                    break;

                //相机拍照
                case 200:
                    CCD_CMD = "T31" + "," + BVar.ProData[2, 1] + "," +
                              EpsonRobot.RobotLivePos.X + "," + EpsonRobot.RobotLivePos.Y + "," + EpsonRobot.RobotLivePos.U;
                    sRtn = Command.TCP_CCD_Send(CCD_CMD);
                    AddList("Bezel定位拍照");
                    if (PVar.空跑)
                    {
                        Line2Time.InitialTime();
                        StaWork.Step = 210;
                    }
                    else
                    {
                        if (sRtn == 1)     //命令发送成功
                        {
                            Line2Time.InitialTime();
                            StaWork.Step = 210;
                        }
                        else
                        {
                            AddList("T31命令发送失败!");
                            ShowList("T31命令发送失败!");
                            Line2Time.InitialTime();
                            StaWork.Step = 1000;
                        }
                    }
                    break;

                case 210:
                    if (PVar.空跑)
                    {
                        if (Line2Time.TimeIsUp(2000))
                        {
                            AddList("<<- Recevied:" + PVar.CCD_StrData);
                            Gg.SetExDo(0, 0, Gg.OutPut1.光源旋转气缸, 0);
                            Line2Time.InitialTime();
                            StaWork.Step = 220;
                        }
                    }
                    else    //****************************************************
                    {
                        if (Command.CCD_Resule && PVar.CCD_Data[0] == "T31")
                        {
                            AddList("<<- Recevied:" + PVar.CCD_StrData);
                            Gg.SetExDo(0, 0, Gg.OutPut1.光源旋转气缸, 0);
                            Line2Time.InitialTime();
                            StaWork.Step = 220;
                        }
                        else
                        {
                            if (Line2Time.TimeIsUp(5000))
                            {
                                AddList("等待CCD T31数据超时!");
                                ShowList("等待CCD T31数据超时!");
                                Line2Time.InitialTime();
                                StaWork.Step = 1000;
                            }
                        }
                    }
                    break;

                case 220:
                    if (PVar.空跑)
                    {
                        AddList("拍照OK,开始等待机械手开始工作结束");
                        Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品真空吸, 0);
                        PVar.Sta_Work[(int)BVar.工位.机械手].Enable = true;    //允许机械手开始工作,目前不考虑CT,后续提前并行
                        Line2Time.InitialTime();
                        StaWork.Step = 230;
                    }
                    else
                    {
                        if (PVar.CCD_Data[1] == "1")
                        {
                            AddList("拍照OK,开始等待机械手开始工作结束");

                            PVar.Sta_Work[(int)BVar.工位.机械手].Enable = true;    //允许机械手开始工作,目前不考虑CT,后续提前并行
                            Line2Time.InitialTime();
                            StaWork.Step = 230;
                        }
                        else
                        {
                            AddList("Bezel拍照NG,异常直接流出");
                            StaWork.Result = false;
                            Line2Time.InitialTime();
                            StaWork.Step = 5000;
                        }
                    }
                    break;

                case 230:
                    if (Gg.GetExDi(0, Gg.InPut1.光源旋转气缸缩回) == 1 && Gg.GetExDi(0, Gg.InPut1.光源旋转气缸伸出) == 0)
                    {
                        AddList("光源旋转气缸缩回信号感应OK!");
                        StaWork.IsReady = true;    //所有准备就绪,等待机械手完成
                        Line2Time.InitialTime();
                        StaWork.Step = 300;
                    }
                    else if (Line2Time.TimeIsUp(5000))
                    {
                        AddList("光源旋转气缸缩回超时!");
                        ShowList("光源旋转气缸缩回超时!");
                        Line2Time.InitialTime();
                        StaWork.Step = 5000;
                    }
                    break;



                //************************************************************************************************
                //等待机械手装配完成
                case 300:
                    if (StaWork.IsReady == false)
                    {
                        AddList("装配完成,开始复检!");
                        Line2Time.InitialTime();
                        StaWork.Step = 310;
                    }
                    break;

                case 310:
                    if (Gg.GetExDi(0, Gg.InPut1.光源旋转气缸缩回) == 0 && Gg.GetExDi(0, Gg.InPut1.光源旋转气缸伸出) == 1)
                    {
                        AddList("光源旋转气缸伸出信号感应OK!");
                        Line2Time.InitialTime();
                        StaWork.Step = 320;
                    }
                    else
                    {
                        if (EpsonRobot.RobotLivePos.Y > -150)    //判断机械手是否在流水线外
                        {
                            Gg.SetExDo(0, 0, Gg.OutPut1.光源旋转气缸, 1);
                        }
                    }
                    break;

                case 320:
                    CCD_CMD = "T33" + "," + BVar.ProData[2, 1] + "," +
                              EpsonRobot.RobotLivePos.X + "," + EpsonRobot.RobotLivePos.Y + "," + EpsonRobot.RobotLivePos.U;
                    sRtn = Command.TCP_CCD_Send(CCD_CMD);
                    AddList("Bezel下相机复检拍照");
                    if (PVar.空跑)
                    {
                        Line2Time.InitialTime();
                        StaWork.Step = 330;
                    }
                    else
                    {
                        if (sRtn == 1)     //命令发送成功
                        {
                            Line2Time.InitialTime();
                            StaWork.Step = 330;
                        }
                        else
                        {
                            AddList("T33命令发送失败!");
                            ShowList("T33命令发送失败!");
                            Line2Time.InitialTime();
                            StaWork.Step = 1000;
                        }
                    }
                    break;

                case 330:
                    if (PVar.空跑)
                    {
                        if (Line2Time.TimeIsUp(1000))
                        {
                            AddList("<<- Recevied:" + PVar.CCD_StrData);
                            Line2Time.InitialTime();
                            StaWork.Step = 340;
                        }
                    }
                    else
                    {
                        if (Command.CCD_Resule && PVar.CCD_Data[0] == "T33")
                        {
                            AddList("<<- Recevied:" + PVar.CCD_StrData);
                            Line2Time.InitialTime();
                            StaWork.Step = 340;
                        }
                        else
                        {
                            if (Line2Time.TimeIsUp(5000))
                            {
                                AddList("等待CCD T33数据超时!");
                                ShowList("等待CCD T33数据超时!");
                                Line2Time.InitialTime();
                                StaWork.Step = 1000;
                            }
                        }
                    }
                    break;

                case 340:
                    if (PVar.空跑)
                    {
                        AddList("拍照OK");
                        Line2Time.InitialTime();
                        StaWork.Step = 350;
                    }
                    else
                    {
                        if (PVar.CCD_Data[1] == "1")
                        {
                            AddList("拍照OK");
                            Line2Time.InitialTime();
                            StaWork.Step = 350;
                        }
                        else
                        {
                            AddList("Bezel拍照NG,异常直接流出");
                            StaWork.Result = false;
                            Line2Time.InitialTime();
                            StaWork.Step = 5000;
                        }
                    }
                    break;

                case 350:
                    CCD_CMD = "T41" + "," + BVar.ProData[2, 1] + "," +
                              EpsonRobot.RobotLivePos.X + "," + EpsonRobot.RobotLivePos.Y + "," + EpsonRobot.RobotLivePos.U;
                    sRtn = Command.TCP_CCD_Send(CCD_CMD);
                    AddList("Bezel上相机复检拍照");
                    if (PVar.空跑)
                    {
                        Line2Time.InitialTime();
                        StaWork.Step = 360;
                    }
                    else
                    {
                        if (sRtn == 1)     //命令发送成功
                        {
                            Line2Time.InitialTime();
                            StaWork.Step = 360;
                        }
                        else
                        {
                            AddList("T41命令发送失败!");
                            ShowList("T41命令发送失败!");
                            Line2Time.InitialTime();
                            StaWork.Step = 1000;
                        }
                    }
                    break;

                case 360:
                    if (PVar.空跑)
                    {
                        if (Line2Time.TimeIsUp(1000))
                        {
                            AddList("<<- Recevied:" + PVar.CCD_StrData);
                            Line2Time.InitialTime();
                            StaWork.Step = 370;
                        }
                    }
                    else
                    {
                        if (Command.CCD_Resule && PVar.CCD_Data[0] == "T41")
                        {
                            AddList("<<- Recevied:" + PVar.CCD_StrData);
                            Line2Time.InitialTime();
                            StaWork.Step = 370;
                        }
                        else
                        {
                            if (Line2Time.TimeIsUp(5000))
                            {
                                AddList("等待CCD T41数据超时!");
                                ShowList("等待CCD T41数据超时!");
                                Line2Time.InitialTime();
                                StaWork.Step = 1000;
                            }
                        }
                    }
                    break;

                case 370:
                    if (PVar.空跑)
                    {
                        AddList("拍照OK,开始上传PDCA");
                        Line2Time.InitialTime();
                        StaWork.Step = 380;
                    }
                    else
                    {
                        if (PVar.CCD_Data[1] == "1")
                        {
                            AddList("拍照OK,开始上传PDCA");
                            Line2Time.InitialTime();
                            StaWork.Step = 380;
                        }
                        else
                        {
                            AddList("Bezel拍照NG,异常直接流出");
                            StaWork.Result = false;
                            Line2Time.InitialTime();
                            StaWork.Step = 5000;
                        }
                    }
                    break;

                case 380:

                    Line2Time.InitialTime();
                    StaWork.Step = 505;
                    break;

                //复检检测输出值
                //***********************************************

                case 505:
                    Gg.SetDo(0, Gg.OutPut0.阻挡气缸3, 0);
                    Gg.SetExDo(0, 0, Gg.OutPut1.载具夹紧气缸, 0);
                    Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品真空吸, 0);
                    Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品破真空, 1);
                    Line2Time.InitialTime();
                    StaWork.Step = 510;
                    break;

                case 510:
                    if (Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸缩回) == 1 && Gg.GetExDi(0, Gg.InPut1.载具夹紧气缸伸出) == 0)
                    {
                        AddList("装配完成,等待放行!");
                        Line2Time.InitialTime();
                        StaWork.Step = 600;
                    }
                    else if (Line2Time.TimeIsUp(3000))
                    {
                        AddList("保载具夹紧气缸伸出信号感应异常!");
                        Line2Time.InitialTime();
                        StaWork.Step = 400;
                    }
                    break;

                case 600:
                    if (PVar.空跑)
                    {
                        if (PVar.Stop_Flag == false && Linechange.LineOut() == 0 && PVar.Sta_Work[(int)BVar.工位.流水线3].State == false)
                        {
                            AddList("载具开始放行,等待流水线3接收!");
                            Gg.SetExDo(0, 1, Gg.OutPut2.载具上产品破真空, 0);
                            Frm_Engineering.fEngineering.Txt_BarCode.Text = "";
                            Linechange.SetMotor2(true, PVar.ParList.Data[43]);
                            Linechange.SetMotor3(true, PVar.ParList.Data[43]);
                            Line2Time.InitialTime();
                            StaWork.Step = 610;
                        }
                        else
                        {
                            if (PVar.Stop_Flag)
                            {
                                StaWork.State = false;
                                Line2Time.InitialTime();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else    //******************************************************
                    {
                        //等待放行*****************************
                        if (PVar.Stop_Flag == false && Linechange.LineOut() == 0 && PVar.Sta_Work[(int)BVar.工位.流水线3].State == false)
                        {
                            AddList("载具开始放行,等待流水线3接收!");
                            Frm_Engineering.fEngineering.Txt_BarCode.Text = "";
                            Linechange.SetMotor2(true, PVar.ParList.Data[43]);
                            Linechange.SetMotor3(true, PVar.ParList.Data[43]);
                            Line2Time.InitialTime();
                            StaWork.Step = 610;
                        }
                    }
                    break;

                case 610:
                    if (PVar.空跑)
                    {
                        if (Line2Time.TimeIsUp(1000))
                        {
                            AddList("载具开始放行!");
                            Line2Time.InitialTime();
                            StaWork.Step = 620;
                        }
                    }
                    else
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应4) == 0)
                        {
                            AddList("载具开始放行!");
                            Line2Time.InitialTime();
                            StaWork.Step = 620;
                        }
                        else if (Line2Time.TimeIsUp(5000))
                        {
                            AddList("流水线2放行载具超时!");
                            ShowList("流水线2放行载具超时!");
                            Line2Time.InitialTime();
                            StaWork.Step = 620;
                        }
                    }
                    break;

                case 620:
                    if (PVar.空跑)
                    {
                        if (Line2Time.TimeIsUp(1000))
                        {
                            AddList("流水线2载具开始放行完成!");
                            //*********************************************************应该可以开始接受上站载具
                            PVar.Sta_Work[(int)BVar.工位.流水线3].IsHaveFix = true;

                            Line2Time.InitialTime();
                            StaWork.Step = 630;
                        }
                    }
                    else
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应5) == 0)
                        {
                            AddList("流水线2载具开始放行完成!");
                            //*********************************************************应该可以开始接受上站载具
                            PVar.Sta_Work[(int)BVar.工位.流水线3].IsHaveFix = true;
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸3, 1);
                            Line2Time.InitialTime();
                            StaWork.Step = 630;
                        }
                        else if (Line2Time.TimeIsUp(5000))
                        {
                            AddList("流水线2放行载具超时!");
                            ShowList("流水线2放行载具超时!");
                            Line2Time.InitialTime();
                            StaWork.Step = 630;
                        }
                    }
                    break;

                case 630:
                    if (Line2Time.TimeIsUp(500))
                    {
                        AddList("流水线2载具放行完成!");
                        Gg.SetDo(0, Gg.OutPut0.阻挡气缸3, 1);
                        PVar.Sta_Work[(int)BVar.工位.流水线2].IsHaveFix = false;
                        PVar.Sta_Work[(int)BVar.工位.流水线3].IsHaveFix = true;
                        Linechange.SetMotor2(false, PVar.ParList.Data[43]);
                        Line2Time.InitialTime();
                        StaWork.Step = 650;
                    }
                    break;

                case 650:
                    if (Line2Time.TimeIsUp(200))
                    {
                        Line2Time.InitialTime();
                        StaWork.Step = 800;
                    }
                    break;

                case 800:
                    StaWork.Enable           = false;
                    StaWork.Result           = true;
                    StaWork.State            = false;
                    Manual.AutoMotionFlag[2] = false;
                    StaWork.Step             = 10;
                    break;

                case 1000:
                    StaWork.Enable           = false;
                    StaWork.Result           = false;
                    StaWork.State            = false;
                    Manual.AutoMotionFlag[2] = false;
                    StaWork.Step             = 10;
                    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);
            }
        }
Esempio n. 5
0
        public static void AutoRun(ref PVar.WorkType StaWork)
        {
            try
            {
                switch (StaWork.Step)
                {
                case 10:
                    if (PVar.Stop_Flag == false)
                    {
                        StaWork.IsHaveFix = false;
                        StaWork.Result    = false;
                        StaWork.State     = false;
                        Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 1);
                        Line0Time.InitialTime();
                        StaWork.Step = 20;
                    }
                    break;

                case 20:
                    if (PVar.空跑)
                    {
                        if (StaWork.State == false && Gg.GetExDi(1, Gg.InPut2.流水线对射感应1) == 0 && Linechange.LineIN() == 0)
                        {
                            //启动触发,载具感应触发,防呆无触发,说明有载具
                            AddList("启动开始!");
                            StaWork.State     = true;
                            StaWork.IsHaveFix = true;    //入口有载具
                            Line0Time.InitialTime();
                            StaWork.Step = 30;
                        }
                    }
                    else    //******************************************************
                    {
                        if (StaWork.State == false && Gg.GetDi(0, Gg.InPut0.启动按钮) == 1 && Gg.GetExDi(1, Gg.InPut2.流水线对射感应1) == 1 && Linechange.LineIN() == 0)
                        {
                            //启动触发,载具感应触发,防呆无触发,说明有载具
                            AddList("启动开始!");
                            StaWork.State     = true;
                            StaWork.IsHaveFix = true;    //入口有载具
                            Line0Time.InitialTime();
                            StaWork.Step = 30;
                        }
                    }
                    break;

                case 30:
                    if (PVar.空跑)
                    {
                        if (PVar.Sta_Work[(int)BVar.工位.流水线1].IsHaveFix == false && PVar.Stop_Flag == false && Gg.GetExDi(1, Gg.InPut2.流水线对射感应2) == 0 &&
                            Gg.GetExDi(1, Gg.InPut2.流水线对射感应3) == 0 && PVar.Sta_Work[(int)BVar.工位.流水线1].State == false)
                        {
                            StaWork.IsHaveFix = false;    //本站载具标志复位
                            AddList("载具开始放行,等待流水线1接收!");
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 0);
                            Linechange.SetMotor1(true, PVar.ParList.Data[43]);
                            Line0Time.InitialTime();
                            StaWork.Step = 40;
                        }
                        else
                        {
                            if (PVar.Stop_Flag)
                            {
                                StaWork.State = false;
                                Line0Time.InitialTime();
                                StaWork.Step = 10;
                            }
                        }
                    }
                    else    //*******************************************
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应1) == 0 || Linechange.LineIN() == 1)
                        {
                            AddList("载具感性信号异常,重新启动");
                            PVar.Sta_Work[0].IsHaveFix = false;
                            Line0Time.InitialTime();
                            StaWork.Step = 10;
                            return;
                        }
                        //等待放行*****************************
                        if (PVar.Stop_Flag == false && Gg.GetExDi(1, Gg.InPut2.流水线对射感应2) == 0 &&
                            Gg.GetExDi(1, Gg.InPut2.流水线对射感应3) == 0 && PVar.Sta_Work[(int)BVar.工位.流水线1].State == false)
                        {
                            StaWork.IsHaveFix = false;    //本站载具标志复位
                            AddList("载具开始放行,等待流水线1接收!");
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 0);
                            Linechange.SetMotor1(true, PVar.ParList.Data[43]);
                            Line0Time.InitialTime();
                            StaWork.Step = 40;
                        }
                    }
                    break;

                case 40:
                    if (PVar.空跑)
                    {
                        if (Line0Time.TimeIsUp(1000))
                        {
                            AddList("载具开始放行完成!");
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 1);
                            Line0Time.InitialTime();
                            StaWork.Step = 50;
                        }
                    }
                    else
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应1) == 0)
                        {
                            AddList("载具开始放行完成!");
                            Gg.SetDo(0, Gg.OutPut0.阻挡气缸1, 1);
                            Line0Time.InitialTime();
                            StaWork.Step = 50;
                        }
                    }
                    break;

                case 50:
                    if (PVar.空跑)
                    {
                        if (Line0Time.TimeIsUp(1000))
                        {
                            AddList("流水线对射感应2触发!");
                            AddList("流水线1开始减速!");
                            Linechange.SetMotor1(true, 10);
                            Line0Time.InitialTime();
                            StaWork.Step = 60;
                        }
                    }
                    else    //********************************************
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应2) == 1)
                        {
                            AddList("流水线对射感应2触发!");
                            Linechange.SetMotor1(true, 10);
                            Line0Time.InitialTime();
                            StaWork.Step = 60;
                        }
                    }
                    break;

                case 60:
                    if (PVar.空跑)
                    {
                        if (Line0Time.TimeIsUp(1000))
                        {
                            AddList("载具到达流水线1!");
                            Linechange.SetMotor1(true, 5);
                            Line0Time.InitialTime();
                            StaWork.Step = 70;
                        }
                    }
                    else
                    {
                        if (Gg.GetExDi(1, Gg.InPut2.流水线对射感应3) == 1)
                        {
                            AddList("载具到达流水线1!");
                            Line0Time.InitialTime();
                            StaWork.Step = 70;
                        }
                    }
                    break;

                case 70:
                    if (Line0Time.TimeIsUp(200))
                    {
                        PVar.Sta_Work[(int)BVar.工位.流水线1].IsHaveFix = true;
                        AddList("流水线1电机关闭!");
                        Linechange.SetMotor1(false, 0);
                        Line0Time.InitialTime();
                        StaWork.Step = 80;
                    }
                    break;

                case 80:
                    AddList("确认按钮是否松开?");
                    Line0Time.InitialTime();
                    StaWork.Step = 100;
                    break;

                case 100:
                    if (Gg.GetDi(0, Gg.InPut0.启动按钮) == 0)
                    {
                        AddList("按钮松开!");
                        Line0Time.InitialTime();
                        StaWork.Step = 800;
                    }
                    break;

                case 800:
                    Manual.AutoMotionFlag[0] = false;
                    StaWork.Enable           = false;
                    StaWork.State            = false;
                    StaWork.Step             = 10;
                    break;

                case 1000:
                    Manual.AutoMotionFlag[0] = false;
                    StaWork.Enable           = false;
                    StaWork.Result           = false;
                    StaWork.State            = false;
                    StaWork.Step             = 10;
                    break;

                //遇到异常,设备先暂停,确定后处理************************
                case 8000:
                    if (Manual.AutoMotionFlag[0])
                    {
                        if (Manual.HoldFlag[0])
                        {
                            Manual.HoldFlag[0] = false;
                            Frm_Engineering.fEngineering.CmdHoldS0.Text      = "暂停";
                            Frm_Engineering.fEngineering.CmdHoldS0.BackColor = Color.BurlyWood;
                            ShowList("运动已继续");
                        }
                        else
                        {
                            Manual.HoldFlag[0] = true;
                            Frm_Engineering.fEngineering.CmdHoldS0.Text      = "继续";
                            Frm_Engineering.fEngineering.CmdHoldS0.BackColor = Color.Red;
                            ShowList("运动已暂停");
                        }
                    }
                    else
                    {
                        PVar.IsSystemOnPauseMode                        = true;
                        PVar.MacHold                                    = true;
                        StaWork.StaHold                                 = true;
                        PVar.Stop_Flag                                  = false;
                        Frm_Main.fMain.Btn_Start.Enabled                = false;
                        Frm_Main.fMain.Btn_Pause.Enabled                = true;
                        Frm_Main.fMain.Btn_Stop.Enabled                 = false;
                        Frm_Main.fMain.Btn_Start.BZ_BackColor           = PVar.BZColor_UnselectedBtn;
                        Frm_Main.fMain.Btn_Pause.BZ_BackColor           = PVar.BZColor_SelectedEndBtn;
                        Frm_Main.fMain.Btn_Stop.BZ_BackColor            = PVar.BZColor_UnselectedBtn;
                        Frm_Engineering.fEngineering.Auto_Timer.Enabled = false;
                    }

                    PVar.LampStatus = 20;
                    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);
            }
        }