using log4net.Core; using NPOI.HSSF.Record.Chart; using Rs.Controls; using Rs.Framework; using Rs.MotionPlat.Commom; using Rs.MotionPlat.Entitys; using Rs.MotionPlat.Entitys.Trays; using Rs.MotionPlat.Flow.Camera; using Rs.MotionPlat.Flow.Common; using Rs.MotionPlat.Flow.SafePosFlow; using Rs.MotionPlat.Flow.SubFlow; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Windows.Forms; using static Rs.MotionPlat.Commom.SchedulingMessageBox; namespace Rs.MotionPlat.Flow { /// /// 周转流程步序 /// enum ETurnoverFlowStep { 等待任务, 到周转盘取料位上方, 等待运动到周转盘取料位上方, 取料异常报警, 到周转盘下方取料位1, 等待运动到周转盘下方取料位1, 到周转盘下方取料位2, 等待运动到周转盘下方取料位2, 到周转盘取料破真空位, 等待到周转盘取料破真空位, 周转盘取料完成抬起, 等待周转盘取料完成抬起, 周转盘取料完成真空检测, 到测试放料位上方, 等待运动到测试放料位上方, 测试位上料丢料检测, 到测试放料位下方1, 等待运动到到测试放料位下方1, 到测试放料位下方2, 等待运动到到测试放料位下方2, 测试位放料完成抬起1, 等待测试位放料完成抬起1, 测试位放料完成抬起2, 等待测试位放料完成抬起2, 测试位放料完成粘料检测, 测试位放料完成真空检测, 到测试保压位上方, 等待到测试保压位上方, 到测试保压位下方1, 等待到测试保压位下方1, 到测试保压位下方2, 等待到测试保压位下方2, 通知中控开始测试, 等待测试完成, 测试完成抬起到高速位, 等待测试完成抬起到高速位, 测试完成抬起安全位, 等待测试完成抬起安全位, 测试完成到治具取料位上方, 等待测试完成到治具取料位上方, /// /// /////////////////////////////////////////////////////////////////// /// 到测试取料位上方, 等待到测试取料位上方, 到测试取料位下方1, 测试治具取料失败报警, 等待到测试取料位下方1, 到测试取料位下方2, 等待到测试取料位下方2, 到测试破关真空位, 等待到测试关破真空位, 测试位取料完成抬起, 等待测试位取料完成抬起, 测试位取料完成后真空检测, 等待排料离开周转盘, 到周转盘放料位上方, 等待到周转盘放料位上方, 周转盘放料前丢料检测, 到周转盘放料位下方1, 等待到周转盘放料位下方1, 到周转盘放料位下方2, 等待到周转盘放料位下方2, 周转盘放料完成粘料检测, 周转盘放料完成后真空检测, 周转盘放料真空异常处理, 周转盘放料完成抬起1, 等待周转盘放料完成抬起1, 周转盘放料完成抬起2, 等待周转盘放料完成抬起2, 到安全位, 等待到安全位, 上报中控任务完成 } /// /// 周转流程 /// public class TurnoverFlow:BaseFlow { /// /// 周转盘取料是否完成 /// bool turnoverTakeFinishe = false; public EFlowStatus FlowStatus { get; set; } = EFlowStatus.Idle; private static TurnoverFlow instance; public static TurnoverFlow Instance { get { if(instance == null) instance = new TurnoverFlow(); return instance; } } private TurnoverFlow(){ } /// /// 保压位上料 /// private bool pressLoad = false; /// /// 保压位下料 /// private bool pressUnload = false; private bool loadOk = false; private bool unloadOk = false; //List slots = new List(); List ngList = new List(); ETurnoverFlowStep Step = ETurnoverFlowStep.等待任务; //double targetPos = 0.0; Motion.ErrorCode errCode = Motion.ErrorCode.Ok; List hasProductNozzles = new List(); /// /// 重取次数 /// private int retakeNum = 0; List slots; /// /// 丢料的吸嘴 /// List loseSlots = new List(); /// /// 粘料的吸嘴 /// List masticSlots = new List(); AlarmEntity alarmEntity= null; bool bTakeFlag = false; bool hasUnloadFlag = false; int turnoverTrayToTestTrayNum = 1; double targetTurnoverY = 0.0; double targetTurnoverZ = 0.0; double targetPressZ = 0.0; /// /// 可以下料到周转盘 /// public void CanMoveFromTestTrayToTurnoverTray() { bTakeFlag = true; } /// /// 不可以下料到周转盘 /// public void CannotMoveFromTestTrayToTurnoverTray() { bTakeFlag = false; } /// /// 获取未执行的任务 /// private List undealTasks = new List(); public override void Run() { switch (Step) { case ETurnoverFlowStep.等待任务: if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskType.TestLoad) > 0) { turnoverTakeFinishe = false; FlowStatus = EFlowStatus.Running; retakeNum = 0; logInfo = GetClassName()+$"接收到测试工位上料任务"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到周转盘取料位上方; } else if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskType.TestUnload) > 0)//测试下料任务一般不会在这里触发，只有上次异常结束打开软件时，中控会发过来下料任务 { FlowStatus = EFlowStatus.Running; retakeNum = 0; logInfo = GetClassName() + $"接收到测试工位下料任务"; MessageQueue.Instance.Insert(logInfo); if(GlobalVar.CleanOut==true && GlobalVar.TurnoverNozzleHasProduct) { Step = ETurnoverFlowStep.到周转盘放料位上方; } else { Step = ETurnoverFlowStep.测试完成抬起到高速位; } //Step = ETurnoverFlowStep.到测试取料位上方; } break; case ETurnoverFlowStep.到周转盘取料位上方: if(CanGoTurnoverTrayPos()) { targetTurnoverY = SysConfigParam.GetValue("TurnoverTakeY"); errCode = AxisControl.TurnoverY.MovePos(targetTurnoverY, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到周转盘取料位上方,ty:{targetTurnoverY}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待运动到周转盘取料位上方; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverY运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { //Msg.ShowError("turnovery axis move is unsafe"); alarmEntity = AlarmCollection.Get(AlarmConstID.运动不安全).Transform($"{AxisAlias.TurnoverY}", $"{AxisAlias.LoadY}"); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待运动到周转盘取料位上方: if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverX, AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { logInfo = GetClassName() + $"已运动到周转盘取料位上方,cy:{Ops.GetCurPosition(AxisControl.TurnoverY)}"; MessageQueue.Instance.Insert(logInfo); if (retakeNum <= GlobalVar.TurnoverRetakeNum) { Step = ETurnoverFlowStep.到周转盘下方取料位1; } else { undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); TurnoverDumpFlow.Instance.Dump(ETrayType.Turnover, undealTasks.Select(t => ((t.FromIndex + 1) > 8 ? (t.FromIndex + 1) - 8 : (t.FromIndex + 1))).ToList()); TurnoverDumpFlow.Instance.Wait(); Step = ETurnoverFlowStep.取料异常报警; } } else { Step = ETurnoverFlowStep.到周转盘取料位上方; } } break; case ETurnoverFlowStep.取料异常报警: //查询周转盘中待测穴位中有料的穴位 List untestSlots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have); if (untestSlots != null && untestSlots.Count > 0) { bool exit = false; while (!exit) { //alarmInfo = GetClassName() + $"周转盘{string.Join(",", untestSlots.Select(s => s.Index))}号穴位产品未取出，请处理"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转吸头在周转盘取料失败报警), untestSlots.Select(s => (s.Index>8?s.Index-8:s.Index)).ToJoinString(), untestSlots.Select(s => s.Index).ToJoinString()); alarmEntity = AlarmCollection.Get(AlarmConstID.周转吸头在周转盘取料失败报警).Transform(untestSlots.Select(s => (s.Index > 8 ? s.Index - 8 : s.Index)).ToJoinString(), untestSlots.Select(s => s.Index).ToJoinString()); //TestCenterMessageBox.Show(AlarmConstID.TurnoverTakeFailAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), //MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //msgBox = MsgBox.ShowDialog(AlarmConstID.周转吸头在周转盘取料失败报警, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(),MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverTakeFailAlarm); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Retry: logInfo = $"选择了重试"; MessageQueue.Instance.Insert(logInfo); retakeNum = 0; exit = true; Step = ETurnoverFlowStep.到周转盘取料位上方; break; case ETipButton.Skip: retakeNum = 0; logInfo = GetClassName() + $"选择了跳过"; MessageQueue.Instance.Insert(logInfo); untestSlots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have); foreach (TurnoverTraySlot slot in untestSlots) { TestHeightResult heightResult = LaserFlow.Instance.HasProduct(ETrayType.Turnover, slot.Index); if (!heightResult.HasProduct) { VacManager.TurnoverTrayVacSuction(EVacOperator.Close, true, slot.Index); slot.ClearProduct(); GlobalTray.TurnoverTray.ChangeStatus(slot.Index, ESlotStatus.NotHave); } } untestSlots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have); if (untestSlots == null || untestSlots.Count == 0) { exit = true; Step = ETurnoverFlowStep.到测试放料位上方; } break; case ETipButton.Yes: logInfo = $"选择了移动到安全位"; MessageQueue.Instance.Insert(logInfo); TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.TurnoverTray); break; default: break; } } } break; case ETurnoverFlowStep.到周转盘下方取料位1: if(GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset; } else { targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ"); } errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { logInfo = GetClassName() + $"到周转盘下方取料位1,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待运动到周转盘下方取料位1; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待运动到周转盘下方取料位1: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到周转盘下方取料位1 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到周转盘下方取料位2; } else { Step = ETurnoverFlowStep.到周转盘下方取料位1; } } else { Step = ETurnoverFlowStep.到周转盘取料位上方; } } break; case ETurnoverFlowStep.到周转盘下方取料位2: targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到周转盘下方取料位2,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待运动到周转盘下方取料位2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待运动到周转盘下方取料位2: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到周转盘下方取料位2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); /*提前打开周转吸嘴真空吸*/ VacManager.TransitNozzleVacSuction(EVacOperator.Open, true, undealTasks.Select(t => t.ToIndex + 1).ToArray()); if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } /*关闭周转盘真空吸*/ //VacManager.TurnoverTrayVacSuction(EVacOperator.Close, true, undealTasks.Select(t => t.FromIndex + 1).ToArray()); /*打开周转盘真空破*/ //VacManager.TurnoverTrayVacBreak(EVacOperator.Open, true, undealTasks.Select(t => t.FromIndex + 1).ToArray()); Step = ETurnoverFlowStep.到周转盘取料破真空位; } else { Step = ETurnoverFlowStep.到周转盘下方取料位2; } } else { Step = ETurnoverFlowStep.到周转盘取料位上方; } } break; case ETurnoverFlowStep.到周转盘取料破真空位: if(GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ") + GlobalVar.CloseVacOffsetHeight; errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); } else { targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); } if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到周转盘取料破真空位,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到周转盘取料破真空位; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待到周转盘取料破真空位: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = $"已到周转盘取料破真空位,cz:{Ops.GetCurPosition(AxisControl.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); /*关闭周转盘真空破*/ VacManager.TurnoverTrayVacBreak(EVacOperator.Close, false, undealTasks.Select(t => t.FromIndex + 1).ToArray()); Step = ETurnoverFlowStep.周转盘取料完成抬起; } else { Step = ETurnoverFlowStep.到周转盘取料破真空位; } } break; case ETurnoverFlowStep.周转盘取料完成抬起: targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"周转盘取料完成抬起,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert (logInfo); Step = ETurnoverFlowStep.等待周转盘取料完成抬起; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待周转盘取料完成抬起: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"周转盘取料完成已抬起,cz:{Ops.GetCurPosition(AxisControl.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.周转盘取料完成真空检测; } else { Step = ETurnoverFlowStep.周转盘取料完成抬起; } } break; case ETurnoverFlowStep.周转盘取料完成真空检测: undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); foreach (TurnoverInfo task in undealTasks) { if (Ops.IsOn($"周转{task.ToIndex + 1}号吸嘴真空吸检测") || GlobalVar.VirtualAxis || GlobalVar.RunSpace) { GlobalTray.TurnoverNozzle.ChangeStatus(task.ToIndex + 1, ESlotStatus.Have); //如果真空检测OK，带料产品已经吸上了 TransitNozzleManager.Instance.Nozzle(task.ToIndex + 1).AddProduct(task); TurnoverTrayManager.Instance.Slot(task.FromIndex + 1).ClearProduct(); //slot.ClearProduct(); GlobalTray.TurnoverTray.ChangeStatus(task.FromIndex + 1, ESlotStatus.NotHave); task.Dealed = true; } else { MessageQueue.Instance.Warn($"周转{task.ToIndex + 1}号吸嘴真空吸检测异常"); } } hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); if (hasProductNozzles.Count > 0) { logInfo = GetClassName()+ $"周转吸头{hasProductNozzles.Select(n => n.NozzleIndex).ToJoinString()}真空检测OK"; MessageQueue.Instance.Insert(logInfo); undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); if(undealTasks.Count > 0 ) { TurnoverDumpFlow.Instance.Dump(ETrayType.Turnover, undealTasks.Select(t => ((t.FromIndex + 1) > 8 ? (t.FromIndex + 1 - 8) : (t.FromIndex + 1))).ToList()); TurnoverDumpFlow.Instance.Wait(); } Step = ETurnoverFlowStep.到测试放料位上方; } else { retakeNum++; Step = ETurnoverFlowStep.到周转盘取料位上方; } break; case ETurnoverFlowStep.到测试放料位上方: targetTurnoverY = SysConfigParam.GetValue("PressDumpY"); errCode = AxisControl.TurnoverY.MovePos(targetTurnoverY, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试放料位上方,ty:{targetTurnoverY}"; MessageQueue.Instance.Insert(logInfo); if (turnoverTrayToTestTrayNum == 1) { TestTrayHasProduct();//异步检测 } Step = ETurnoverFlowStep.等待运动到测试放料位上方; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverY运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待运动到测试放料位上方: if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverX, AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { LogHelper.Debug(GetClassName()+ $"turnoverxy in target ,cury={Ops.GetCurPosition(AxisControl.TurnoverY)},y={targetTurnoverY}"); //if (turnoverTrayToTestTrayNum == 1) //{ // testTrayHasProductCheckEvent.WaitOne(); // if(testTrayHasProductList!=null && testTrayHasProductList.Count>0) // { // while (true) // { // //alarmInfo = $"测试穴位{testTrayHasProductList.ToJoinString()}中有产品，请取出后点击确定"; // //alarmEntity = AlarmCollection.Get(AlarmConstID.测试穴位有产品待取出).Transform(testTrayHasProductList.ToJoinString()); // LogHelper.Debug(alarmEntity.CN); // //MsgBox.ShowDialog(1, alarmInfo, ETipButton.Ok); // AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); // //再次检测 // TestTrayHasProduct(); // testTrayHasProductCheckEvent.WaitOne(); // if (testTrayHasProductList ==null || testTrayHasProductList.Count == 0) // { // break; // } // } // } //} //turnoverTrayToTestTrayNum++; if (turnoverTakeFinishe == false && TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have).Count() == 0) { turnoverTakeFinishe = true; //在这里处理中控发过来的任务 //如果有下料任务，先处理下料任务，再处理上料任务 #region 下料任务 if(hasUnloadFlag) { hasUnloadFlag = false; while (true) { if (LoadAndUnloadTask.Instance.TestUnloadTaskArrived) { LoadAndUnloadTask.Instance.TestUnloadTaskArrived = false; MachineManage.Instance.SetTesterState(new TesterInfo() { State = ETesterState.NotReady, ReadySites = null }); logInfo = GetClassName() + "通知中控产品全部已从治具中取出，状态变成NotReady"; MessageQueue.Instance.Insert(logInfo); unloadOk = true; TestCenter.Instance.LoadTestUnLoadResult(); LoadAndUnloadTask.Instance.Clear(1); MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting); break; } } } #endregion #region 上料任务 while (true) { if (LoadAndUnloadTask.Instance.TestloadTaskArrived) { LoadAndUnloadTask.Instance.TestloadTaskArrived = false; string reportStr = LoadAndUnloadTask.Instance.GetTestLoadString(); TestCenter.Instance.Send(reportStr,Encoding.ASCII); LoadAndUnloadTask.Instance.Clear(1); MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting); MessageQueue.Instance.Insert("通知中控周转载盘产品已取走,可以继续排料"); break; } } #endregion } Step = ETurnoverFlowStep.测试位上料丢料检测; } else { Step = ETurnoverFlowStep.到测试放料位上方; } } break; case ETurnoverFlowStep.测试位上料丢料检测: if(GlobalVar.VirtualAxis || GlobalVar.RunSpace) { Step = ETurnoverFlowStep.到测试放料位下方1; } else { if(TransitNozzleManager.Instance.GetHasProductNozzles().Count>0) { loseSlots.Clear(); //检测是否丢料 foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles()) { if (!nozzle.HasVacSignal()) { loseSlots.Add(nozzle.NozzleIndex); } } if (loseSlots.Count > 0) { bool exit = false; while (!exit) { //alarmInfo = $"周转{loseSlots.ToJoinString()}号吸嘴真空异常丢料，请处理"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转吸头在测试治具放料时丢料报警), loseSlots.ToJoinString()); alarmEntity = AlarmCollection.Get(AlarmConstID.周转吸头在测试治具放料时丢料报警).Transform(loseSlots.ToJoinString()); LogHelper.Debug(GetClassName()+ alarmEntity.CN); //TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); // msgBox = MsgBox.ShowDialog(AlarmConstID.周转吸头在测试治具放料时丢料报警, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch (btnRet) { case ETipButton.Skip: logInfo = GetClassName() + $"点击了跳过按钮"; MessageQueue.Instance.Insert(logInfo); exit = true; List hasProducts = TransitNozzleManager.Instance.GetHasProductNozzles(); //把吸嘴的真空吸关闭 VacManager.TransitNozzleVacSuction(EVacOperator.Close,false, loseSlots.ToArray()); //打开周转吸嘴的真空破 VacManager.TransitNozzleVacBreak(EVacOperator.Open,true, loseSlots.ToArray()); //关闭周转吸嘴的真空破 VacManager.TransitNozzleVacBreak(EVacOperator.Close,false, loseSlots.ToArray()); foreach(int nozzleIndex in loseSlots) { TransitNozzleManager.Instance.Nozzle(nozzleIndex).Clear(); } Step = ETurnoverFlowStep.到测试放料位上方; break; case ETipButton.Yes: logInfo = GetClassName() + $"点击了移动到安全位按钮"; MessageQueue.Instance.Insert(logInfo); TransitModuleSafePosFlow.Instance.GoSafePostion( EExceptionSafePos.TransitNozzle); break; default: break; } } } else { logInfo = GetClassName() + $"已运动到测试放料位上方"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到测试放料位下方1; } } else { if (!turnoverTakeFinishe) { Step = ETurnoverFlowStep.到周转盘取料位上方; retakeNum++; } else { if (TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count > 0) { Step = ETurnoverFlowStep.到测试保压位上方; } else { Step = ETurnoverFlowStep.通知中控开始测试; } } } } break; case ETurnoverFlowStep.到测试放料位下方1: if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if (GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("PressDumpZ") + GlobalVar.PressLowSpeedOffset; } else { targetTurnoverZ = SysConfigParam.GetValue("PressDumpZ"); } errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { //获取需要放料的吸嘴 hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); /*打开测试穴位真空吸*/ VacManager.TestTrayVacSuction(EVacOperator.Open, false, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试放料位下方1,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待运动到到测试放料位下方1; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode);'' alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { Step = ETurnoverFlowStep.到测试放料位上方; } break; case ETurnoverFlowStep.等待运动到到测试放料位下方1: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到到测试放料位下方1 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到测试放料位下方2; } else { Step = ETurnoverFlowStep.到测试放料位下方1; } } else { Step = ETurnoverFlowStep.到测试放料位上方; } } break; case ETurnoverFlowStep.到测试放料位下方2: targetTurnoverZ = SysConfigParam.GetValue("PressDumpZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis ) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo =GetClassName()+ $"到测试放料位下方2,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待运动到到测试放料位下方2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待运动到到测试放料位下方2: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { //获取需要放料的吸嘴 hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); //TrayStatusManager.UpdateMultiSlotAsync("TurnoverNozzle", hasProductNozzles.Select(n => n.NozzleIndex).ToArray(), 0); logInfo = GetClassName() + $"已运动到到测试放料位下方2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); /*打开测试穴位真空吸*/ //VacManager.TestTrayVacSuction(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); /*关闭周转吸头真空吸*/ VacManager.TransitNozzleVacSuction(EVacOperator.Close, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); /*打开周转吸头真空破*/ VacManager.TransitNozzleVacBreak(EVacOperator.Open, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); /*关闭周转吸头真空破*/ VacManager.TransitNozzleVacBreak(EVacOperator.Close, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); //在这里更新产品状态 //TransitNozzleManager.Instance.Transi Step = ETurnoverFlowStep.测试位放料完成抬起1; } else { Step = ETurnoverFlowStep.到测试放料位下方2; } } else { Step = ETurnoverFlowStep.到测试放料位上方; } } break; case ETurnoverFlowStep.测试位放料完成抬起1: if(GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("PressDumpZ") + GlobalVar.PressLowSpeedOffset; } else { targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); } errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName()+$"测试位放料完成抬起1,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待测试位放料完成抬起1; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待测试位放料完成抬起1: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { //获取需要放料的吸嘴 //hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); /*关闭周转吸头真空破*/ //VacManager.TransitNozzleVacBreak(EVacOperator.Close, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); logInfo = GetClassName() + $"测试位放料完成抬起完成1,cz:{Ops.GetCurPosition(AxisControl.TurnoverZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.测试位放料完成抬起2; } else { Step = ETurnoverFlowStep.测试位放料完成抬起1; } } break; case ETurnoverFlowStep.测试位放料完成抬起2: targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"测试位放料完成抬起2,tz:{targetTurnoverZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待测试位放料完成抬起2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待测试位放料完成抬起2: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if (Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { //获取需要放料的吸嘴 //hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); /*关闭周转吸头真空破*/ //VacManager.TransitNozzleVacBreak(EVacOperator.Close, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); //logInfo = GetClassName() + $"测试位放料完成抬起完成2"; //MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.测试位放料完成粘料检测; } else { Step = ETurnoverFlowStep.测试位放料完成抬起2; } } break; case ETurnoverFlowStep.测试位放料完成粘料检测: masticSlots.Clear(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); //打开全部吸嘴的真空吸 VacManager.TransitNozzleVacSuction(EVacOperator.Open,true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles()) { //nozzle.OpenVac(); if (nozzle.HasVacSignal() && !GlobalVar.RunSpace) { logInfo = $"周转{nozzle.NozzleIndex}号吸嘴粘料"; MessageQueue.Instance.Insert(logInfo); masticSlots.Add(nozzle.NozzleIndex); } else { logInfo = $"周转{nozzle.NozzleIndex}号吸嘴无粘料"; MessageQueue.Instance.Insert(logInfo); nozzle.CloseVac(); } } if(masticSlots.Count > 0) { //粘料报警 //alarmInfo = $"周转吸头{masticSlots.ToJoinString()}号吸嘴真空异常粘料，请手工处理"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转头粘料报警), masticSlots.ToJoinString()); alarmEntity = AlarmCollection.Get(AlarmConstID.周转头粘料报警).Transform(masticSlots.ToJoinString()); //TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //msgBox = MsgBox.ShowDialog(AlarmConstID.周转头粘料报警, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Skip: logInfo = GetClassName() + $"点击了跳过按钮"; MessageQueue.Instance.Insert(logInfo); foreach (int nozzleIndex in masticSlots) { TransitNozzle nozzle = TransitNozzleManager.Instance.Nozzle(nozzleIndex); if (!nozzle.HasVacSignal()) { nozzle.CloseVac(); nozzle.OpenBreak(); nozzle.CloseBreak(); nozzle.Clear(); } } break; case ETipButton.Yes: MessageQueue.Instance.Insert(GetClassName() + $"点击了移动到安全位按钮"); TransitModuleSafePosFlow.Instance.GoSafePostion( EExceptionSafePos.TransitNozzle); break; default: break; } } else { Step = ETurnoverFlowStep.测试位放料完成真空检测; } break; case ETurnoverFlowStep.测试位放料完成真空检测: /*检测逻辑（光纤优先原则） 1 先用光纤检测是否叠料，如果光纤跌料，则报警，如果光纤检测没有叠料，再用真空检测 2 真空检测正常则继续，真空检测异常，报真空报警 */ foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles()) { if(nozzle.IsHasProduct) { if (Ops.IsOn($"测试{nozzle.NozzleIndex}号穴位真空吸检测") || GlobalVar.RunSpace || GlobalVar.DisableFixtureVacuumCheck) { GlobalTray.TurnoverNozzle.ChangeStatus(nozzle.NozzleIndex, ESlotStatus.NotHave); GlobalTray.TestTray.ChangeStatus(nozzle.NozzleIndex, ESlotStatus.Have); TestTrayManager.Instance.Slot(nozzle.NozzleIndex).AddProduct(nozzle); nozzle.Clear(); } else { bool exit = false; while (!exit) { // alarmInfo = $"测试治具{nozzle.NozzleIndex}号真空吸异常"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转吸头放料到测试治具后测试治具真空吸报警), nozzle.NozzleIndex); alarmEntity = AlarmCollection.Get(AlarmConstID.周转吸头放料到测试治具后测试治具真空吸报警).Transform(nozzle.NozzleIndex); MessageQueue.Instance.Warn(GetClassName() + alarmEntity.CN); //TestCenterMessageBox.Show(AlarmConstID.周转吸头放料到测试治具后测试治具真空吸报警, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); // msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.周转吸头放料到测试治具后测试治具真空吸报警); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Retry: VacManager.TestTrayVacSuction(EVacOperator.Open,true, nozzle.NozzleIndex); if (Ops.IsOn($"测试{nozzle.NozzleIndex}号穴位真空吸检测")) { GlobalTray.TestTray.ChangeStatus(nozzle.NozzleIndex, ESlotStatus.Have); TestTrayManager.Instance.Slot(nozzle.NozzleIndex).AddProduct(nozzle); nozzle.Clear(); exit = true; } break; case ETipButton.Skip: //镭射头过来复检，有产品则继续报警， TestHeightResult heightResult = LaserFlow.Instance.HasProduct(ETrayType.Test, nozzle.NozzleIndex); if (!heightResult.HasProduct) { nozzle.Clear(); exit = true; } break; case ETipButton.Yes://移动到安全位 VacManager.TestTrayVacSuction(EVacOperator.Close,true, nozzle.NozzleIndex); TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.Socket); break; } } } } } if (!turnoverTakeFinishe) { Step = ETurnoverFlowStep.到周转盘取料位上方; } else { Step = ETurnoverFlowStep.到测试保压位上方; } break; case ETurnoverFlowStep.到测试保压位上方: targetTurnoverY = SysConfigParam.GetValue("PressY"); errCode = AxisControl.TurnoverY.MovePos(targetTurnoverY, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { turnoverTrayToTestTrayNum = 1; if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试保压位上方,ty:{targetTurnoverY}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到测试保压位上方; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverY运动异常).Transform($"{AxisAlias.TurnoverY}", errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待到测试保压位上方: if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverX, AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if (TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count > 0) { logInfo = GetClassName() + $"已运动到测试保压位上方,cy:{Ops.GetCurPosition(AxisControl.TurnoverY)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到测试保压位下方1; } else { logInfo = GetClassName() + $"检测到测试治具中无产品需要测试"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.通知中控开始测试; } } else { Step = ETurnoverFlowStep.到测试保压位上方; } } break; case ETurnoverFlowStep.到测试保压位下方1: if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { targetPressZ = SysConfigParam.GetValue("PressZ"); if (GlobalVar.EnableTwoSpeed) { targetPressZ = targetPressZ + SysConfigParam.GetValue("PressLowSpeedOffset"); } errCode = AxisControl.PressZ.MovePos(targetPressZ, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试保压位下方1,tz:{targetPressZ}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到测试保压位下方1; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.PressZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.PressZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { Step = ETurnoverFlowStep.到测试保压位上方; } break; case ETurnoverFlowStep.等待到测试保压位下方1: if (Ops.IsStop(AxisControl.PressZ) || GlobalVar.VirtualAxis) { if (AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.PressZIsInTargetPos(targetPressZ)) { logInfo = GetClassName() + $"已到测试保压位下方1 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到测试保压位下方2; } else { Step = ETurnoverFlowStep.到测试保压位下方1; } } else { Step = ETurnoverFlowStep.到测试保压位上方; } } break; case ETurnoverFlowStep.到测试保压位下方2: if (AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { targetPressZ = SysConfigParam.GetValue("PressZ"); errCode = AxisControl.PressZ.MovePos(targetPressZ, GlobalVar.PressLowSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试保压位下方2"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到测试保压位下方2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.PressZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.PressZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { Step = ETurnoverFlowStep.到测试保压位上方; } break; case ETurnoverFlowStep.等待到测试保压位下方2: if (Ops.IsStop(AxisControl.PressZ) || GlobalVar.VirtualAxis) { //Thread.Sleep(100); //if(Ops.IsArrived(AxisControl.PressZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.PressZIsInTargetPos(targetPressZ)) { logInfo = GetClassName() + $"已到测试保压位下方2 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; MessageQueue.Instance.Insert(logInfo); /*关闭测试穴位真空吸*/ List willTestSlot = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have); VacManager.TestTrayVacSuction(EVacOperator.Close, false, willTestSlot.Select(s => s.Index).ToArray()); Step = ETurnoverFlowStep.通知中控开始测试; } else { Step = ETurnoverFlowStep.到测试保压位下方2; } } else { Step = ETurnoverFlowStep.到测试保压位上方; } } break; case ETurnoverFlowStep.通知中控开始测试: MachineManage.Instance.TestStatus = ETestStatus.Testing; loadOk = true; HashSet needTestSlot = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Select(s => s.Index-1).ToHashSet(); MachineManage.Instance.SetTesterState(new TesterInfo() { State = ETesterState.Ready, ReadySites = needTestSlot }); logInfo = GetClassName() + $"通知中控测试位就绪，可以开始测试{needTestSlot.ToJoinString()}"; MessageQueue.Instance.Insert(logInfo); //Thread.Sleep(1000 * 30); Step = ETurnoverFlowStep.等待测试完成; break; /*---------------------------------------------准备下料---------------------------------------------------------------------------------*/ case ETurnoverFlowStep.等待测试完成: //if(MachineManage.Instance.tes) if(MachineManage.Instance.TestStatus== ETestStatus.Finished) { hasUnloadFlag = true; //测试完成后，重新打开真空吸 List tested = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have); VacManager.TestTrayVacSuction(EVacOperator.Open, true, tested.Select(s => s.Index).ToArray()); //测试完成后先判断中控的任务有没有下发过来，如果已经过来了就直接用，如果没有过来就自己生成任务 if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskType.TestUnload) <= 0) { LoadAndUnloadTask.Instance.CreateTestUnLoadTask(); } Step = ETurnoverFlowStep.测试完成抬起到高速位; } break; case ETurnoverFlowStep.测试完成抬起到高速位: double curPos = Ops.GetCurPosition(AxisAlias.PressZ); if(Math.Abs(curPos- SysConfigParam.GetValue("PressSafeZ")) <1) { Step = ETurnoverFlowStep.测试完成抬起安全位; } else { if (GlobalVar.EnableTwoSpeed) { targetPressZ = SysConfigParam.GetValue("PressZ") + GlobalVar.PressLowSpeedOffset; errCode = AxisControl.PressZ.MovePos(targetPressZ, GlobalVar.PressLowSpeed); } else { targetPressZ = SysConfigParam.GetValue("PressSafeZ"); errCode = AxisControl.PressZ.MovePos(targetPressZ, GlobalVar.WholeSpeed); } if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName()+$"测试完成准备抬起"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待测试完成抬起到高速位; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.PressZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.PressZ运动异常).Transform($"{AxisAlias.PressZ}", errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } break; case ETurnoverFlowStep.等待测试完成抬起到高速位: if (Ops.IsStop(AxisControl.PressZ) || GlobalVar.VirtualAxis) { if(AxisArrived.PressZIsInTargetPos(targetPressZ)) { logInfo = GetClassName() + $"测试完成已抬起 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.测试完成抬起安全位; } else { Step = ETurnoverFlowStep.测试完成抬起到高速位; } } break; case ETurnoverFlowStep.测试完成抬起安全位: targetPressZ = SysConfigParam.GetValue("PressSafeZ"); errCode = AxisControl.PressZ.MovePos(targetPressZ, GlobalVar.WholeSpeed); if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"测试完成抬起安全位"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待测试完成抬起安全位; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.PressZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.PressZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待测试完成抬起安全位: if (Ops.IsStop(AxisControl.PressZ) || GlobalVar.VirtualAxis) { //AxisControl.PressZ.Get_Target_Position(out double pos); //double tpos = Ops.GetCurPosition(AxisControl.PressZ); //AxisControl.PressZ.IsArrived(out bool isArrived); //Thread.Sleep(100); //if (Ops.IsArrived(AxisAlias.PressZ) || GlobalVar.VirtualAxis) if(AxisArrived.PressZIsInTargetPos(targetPressZ)) { retakeNum = 0; logInfo = GetClassName() + $"测试完成已抬起到安全位 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到测试取料位上方; } else { Step = ETurnoverFlowStep.测试完成抬起安全位; } } break; //case ETurnoverFlowStep.测试完成到治具取料位上方: // targetPos = SysConfigParam.GetValue("PressTakeX"); // errCode = AxisControl.TurnoverX.MovePos(targetPos, GlobalVar.WholeSpeed); // if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) // { // targetPos = SysConfigParam.GetValue("PressTakeY"); // errCode = AxisControl.TurnoverY.MovePos(targetPos, GlobalVar.WholeSpeed); // if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) // { // if (GlobalVar.VirtualAxis) // { // Thread.Sleep(GlobalVar.VirtualAxisMoveTime); // } // logInfo = GetClassName() + $"测试完成到治具取料位上方"; // MessageQueue.Instance.Insert(logInfo); // Step = ETurnoverFlowStep.等待测试完成到治具取料位上方; // } // else // { // MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); // } // } // else // { // MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverX, errCode); // } // break; //case ETurnoverFlowStep.等待测试完成到治具取料位上方: // if (Ops.IsStop(AxisControl.TurnoverX, AxisControl.TurnoverY) || GlobalVar.VirtualAxis) // { // if(Ops.IsArrived(AxisControl.TurnoverX,AxisControl.TurnoverY)) // { // logInfo = GetClassName() + $"已运动到治具取料位上方 TurnoverY at:{Ops.GetCurPosition(AxisAlias.TurnoverY)}"; // MessageQueue.Instance.Insert(logInfo); // Step = ETurnoverFlowStep.等待任务; // } // } // break; //-----------------------------------------------测试位下料--------------------------------------------------------------------------------------------------------- case ETurnoverFlowStep.到测试取料位上方: targetTurnoverY = SysConfigParam.GetValue("PressTakeY"); errCode = AxisControl.TurnoverY.MovePos(targetTurnoverY, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试取料位上方"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到测试取料位上方; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverY运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待到测试取料位上方: if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverX, AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { logInfo = GetClassName() + $"已运动到测试取料位上方 TurnoverY at:{Ops.GetCurPosition(AxisAlias.TurnoverY)}"; MessageQueue.Instance.Insert(logInfo); if (retakeNum < 3) { Step = ETurnoverFlowStep.到测试取料位下方1; } else { LogHelper.Debug(GetClassName()+ $"失败次数已达上限{retakeNum},报警"); // undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); //TurnoverDumpFlow.Instance.Dump(ETrayType.Test, undealTasks.Select(t => t.FromIndex + 1).ToList()); //TurnoverDumpFlow.Instance.Wait(); Step = ETurnoverFlowStep.测试治具取料失败报警; } } else { Step = ETurnoverFlowStep.到测试取料位上方; } } break; case ETurnoverFlowStep.测试治具取料失败报警: //取三次之后还没有取起来的产品，这个时候需要弹框报警提示是否继续还是跳过 //获取还未执行完的任务 List testedSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have); if (testedSlots != null && testedSlots.Count > 0) { undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); if(TurnoverDumpFlow.Instance.Dump(ETrayType.Test, undealTasks.Select(t => t.FromIndex + 1).ToList())) { TurnoverDumpFlow.Instance.Wait(); } bool exit = false; while (!exit) { //alarmInfo = GetClassName() + $"测试治具{testedSlots.Select(s => s.Index).ToJoinString()}号穴位取料失败"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转吸头在测试治具取料失败报警), testedSlots.Select(s => s.Index).ToJoinString()); alarmEntity = AlarmCollection.Get(AlarmConstID.周转吸头在测试治具取料失败报警).Transform(testedSlots.Select(s => s.Index).ToJoinString()); LogHelper.Debug(GetClassName() + alarmEntity.CN); //TestCenterMessageBox.Show(AlarmConstID.周转吸头在测试治具取料失败报警, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.周转吸头在测试治具取料失败报警); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Retry: logInfo = GetClassName() + $"选择了重试按钮"; MessageQueue.Instance.Insert(logInfo); retakeNum = 0; exit = true; Step = ETurnoverFlowStep.到测试取料位上方; break; case ETipButton.Skip: retakeNum = 0; logInfo = GetClassName() + $"选择了跳过按钮"; MessageQueue.Instance.Insert(logInfo); testedSlots = testedSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have); foreach (TestTraySlot slot in testedSlots) { TestHeightResult heightResult = LaserFlow.Instance.HasProduct(ETrayType.Test, slot.Index); if (!heightResult.HasProduct) { logInfo = GetClassName() + $"镭射头检测{slot.Index}号穴位无产品"; MessageQueue.Instance.Insert(logInfo); TurnoverInfo ti = LoadAndUnloadTask.Instance.GetTestUnloadTask(slot.Index); if(ti != null) { ti.Dealed = true; } slot.ClearProduct(); GlobalTray.TestTray.ChangeStatus(slot.Index, ESlotStatus.NotHave); } } testedSlots = testedSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have); if (testedSlots == null || testedSlots.Count == 0) { exit = true; Step = ETurnoverFlowStep.上报中控任务完成; } break; case ETipButton.Yes://移动到安全位 logInfo = GetClassName() + $"选择了移动到安全位按钮"; MessageQueue.Instance.Insert(logInfo); if (testedSlots.Select(ts => (ts.Index >= 9 && ts.Index <= 16)).Count() > 0) { TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.SocketFrom9ToSixteen); } else { TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.Socket); } break; default: break; } } } break; case ETurnoverFlowStep.到测试取料位下方1: if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { targetTurnoverZ = SysConfigParam.GetValue("PressTakeZ"); if (GlobalVar.EnableTwoSpeed) { targetTurnoverZ = targetTurnoverZ + GlobalVar.PressLowSpeedOffset; } errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); /*提前打开周转吸头真空吸*/ VacManager.TransitNozzleVacSuction(EVacOperator.Open, false, undealTasks.Select(t => t.FromIndex + 1).ToArray()); if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试取料位下方1"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到测试取料位下方1; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { Step = ETurnoverFlowStep.到测试取料位上方; } break; case ETurnoverFlowStep.等待到测试取料位下方1: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到到测试取料位下方1"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到测试取料位下方2; } else { Step = ETurnoverFlowStep.到测试取料位下方1; } } else { Step = ETurnoverFlowStep.到测试取料位上方; } } break; case ETurnoverFlowStep.到测试取料位下方2: //if(AxisArrived.TurnoverXYIsInTargetPos(targetTurnoverX,targetTurnoverY)) { targetTurnoverZ = SysConfigParam.GetValue("PressTakeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到测试取料位下方2"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到测试取料位下方2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } //else //{ // Step = ETurnoverFlowStep.到测试取料位上方; //} break; case ETurnoverFlowStep.等待到测试取料位下方2: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到测试取料位下方2 TurnoverZ at:{Ops.GetCurPosition("TurnoverZ")}"; MessageQueue.Instance.Insert(logInfo); //int[] indexes = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Select(s=>s.Index).ToArray(); undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); /*打开周转吸头真空吸*/ //VacManager.TransitNozzleVacSuction(EVacOperator.Open, true, indexes); /*关闭测试穴位真空吸*/ VacManager.TestTrayVacSuction(EVacOperator.Close, true, undealTasks.Select(t => t.FromIndex + 1).ToArray()); /*打开测试穴位真空破*/ VacManager.TestTrayVacBreak(EVacOperator.Open, true, undealTasks.Select(t => t.FromIndex + 1).ToArray()); Step = ETurnoverFlowStep.到测试破关真空位; } else { Step = ETurnoverFlowStep.到测试取料位下方2; } } else { Step = ETurnoverFlowStep.到测试取料位上方; } } break; case ETurnoverFlowStep.到测试破关真空位: if(GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("PressTakeZ") + GlobalVar.PressLowSpeedOffset; errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); } else { targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); } if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { logInfo = GetClassName()+ $"到测试破关真空位"; MessageQueue.Instance.Insert(logInfo); if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } Step = ETurnoverFlowStep.等待到测试关破真空位; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待到测试关破真空位: if(Ops.IsStop(AxisAlias.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到测试关破真空位"; MessageQueue.Instance.Insert(logInfo); undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); /*关闭测试穴位真空破*/ VacManager.TestTrayVacBreak(EVacOperator.Close, false, undealTasks.Select(t => t.FromIndex + 1).ToArray()); Step = ETurnoverFlowStep.测试位取料完成抬起; } else { Step = ETurnoverFlowStep.到测试破关真空位; } } break; case ETurnoverFlowStep.测试位取料完成抬起: targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if(errCode== Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo =GetClassName()+ $"测试位取料完成抬起"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待测试位取料完成抬起; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待测试位取料完成抬起: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"测试位取料完成已抬起"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.测试位取料完成后真空检测; } else { Step = ETurnoverFlowStep.测试位取料完成抬起; } } break; case ETurnoverFlowStep.测试位取料完成后真空检测: /* 测试位取料完成真空检测，只要有吸嘴上有产品，就先把产品放到周转盘中 */ undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); if(undealTasks != null && undealTasks.Count>0) { foreach (TurnoverInfo task in undealTasks) { TestTraySlot testSlot = TestTrayManager.Instance.Slot(task.FromIndex + 1); if (Ops.IsOn($"周转{task.FromIndex + 1}号吸嘴真空吸检测") || GlobalVar.VirtualAxis || GlobalVar.RunSpace) { GlobalTray.TurnoverNozzle.ChangeStatus(task.FromIndex + 1, ESlotStatus.Have); logInfo = $"周转{task.FromIndex + 1}号吸嘴真空吸检测OK"; MessageQueue.Instance.Insert(logInfo); testSlot.ClearProduct(); task.Dealed = true; TransitNozzleManager.Instance.Nozzle(task.FromIndex + 1).AddProduct(task); GlobalTray.TestTray.ChangeStatus(task.FromIndex + 1, ESlotStatus.NotHave); } else { logInfo = $"周转{task.FromIndex + 1}号吸嘴真空吸检测异常"; MessageQueue.Instance.Insert(logInfo); } } } if (TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count == 0) { hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); if (hasProductNozzles.Count > 0 || GlobalVar.RunSpace || GlobalVar.VirtualAxis) { //Step = ETurnoverFlowStep.到周转盘放料位上方; Step = ETurnoverFlowStep.等待排料离开周转盘; } else { Step = ETurnoverFlowStep.上报中控任务完成; } } else { hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); if (hasProductNozzles.Count > 0 || GlobalVar.RunSpace || GlobalVar.VirtualAxis) { undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); if(undealTasks.Count > 0 ) { TurnoverDumpFlow.Instance.Dump(ETrayType.Test, undealTasks.Select(t => t.FromIndex + 1).ToList()); TurnoverDumpFlow.Instance.Wait(); } //Step = ETurnoverFlowStep.到周转盘放料位上方; Step = ETurnoverFlowStep.等待排料离开周转盘; } else { retakeNum++; Step = ETurnoverFlowStep.到测试取料位上方; } } break; case ETurnoverFlowStep.等待排料离开周转盘: if (bTakeFlag|| GlobalVar.CleanOut) { Step = ETurnoverFlowStep.到周转盘放料位上方; } break; case ETurnoverFlowStep.到周转盘放料位上方: if (CanGoTurnoverTrayPos()) { targetTurnoverY = SysConfigParam.GetValue("TurnoverDumpY"); errCode = AxisControl.TurnoverY.MovePos(targetTurnoverY, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到周转盘放料位上方"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到周转盘放料位上方; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverY运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { Msg.ShowError("turnovery axis move is unsafe"); } break; case ETurnoverFlowStep.等待到周转盘放料位上方: if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverX, AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { logInfo = GetClassName() + $"已运动到周转盘放料位上方"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.周转盘放料前丢料检测; } else { Step = ETurnoverFlowStep.到周转盘放料位上方; } } break; case ETurnoverFlowStep.周转盘放料前丢料检测: if(!GlobalVar.RunSpace) { loseSlots.Clear(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); if (hasProductNozzles != null && hasProductNozzles.Count > 0) { foreach (var nozzle in hasProductNozzles.ToArray()) { if (!nozzle.HasVacSignal()) { loseSlots.Add(nozzle.NozzleIndex); } } if (loseSlots.Count > 0) { bool exit = false; while (!exit) { //alarmInfo = $"周转{loseSlots.ToJoinString()}号吸嘴真空异常丢料，请处理"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转吸头在周转盘放料时丢料报警), loseSlots.ToJoinString()) ; alarmEntity = AlarmCollection.Get(AlarmConstID.周转吸头在周转盘放料时丢料报警).Transform(loseSlots.ToJoinString()); LogHelper.Debug(GetClassName() + alarmEntity.CN); //TestCenterMessageBox.Show(AlarmConstID.周转吸头在周转盘放料时丢料报警, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.周转吸头在周转盘放料时丢料报警); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Skip: logInfo = GetClassName() + $"点击了跳过按钮"; MessageQueue.Instance.Insert(logInfo); foreach (var slotIndex in loseSlots) { TransitNozzle nozzle = TransitNozzleManager.Instance.Nozzle(slotIndex); //关闭吸嘴的真空吸 nozzle.CloseVac(); //打开吸嘴的真空破 nozzle.OpenBreak(); //关闭吸嘴的真空破 nozzle.CloseBreak(); //清空吸嘴上的产品 nozzle.Clear(); } exit = true; //循环退出，重新检测一下粘料 Step = ETurnoverFlowStep.到周转盘放料位上方; break; case ETipButton.Yes: logInfo = GetClassName() + $"点击了移动到安全位按钮"; MessageQueue.Instance.Insert(logInfo); TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.TransitNozzle); break; default: break; } } } else { Step = ETurnoverFlowStep.到周转盘放料位下方1; } } else { //这里再次判断治具中是否还有产品未取出，如果都已取出，则到安全位，如果还有产品，则到治具位上放取料 if (TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have).Count > 0) { Step = ETurnoverFlowStep.到测试取料位上方; } else { Step = ETurnoverFlowStep.到安全位; } } } else { Step = ETurnoverFlowStep.到周转盘放料位下方1; } break; case ETurnoverFlowStep.到周转盘放料位下方1: if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if (GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset+1; } else { targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ")+1; } errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ , GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); /*提前打开周转盘真空吸*/ VacManager.TurnoverTrayVacSuction(EVacOperator.Open, false, hasProductNozzles.Select(n => n.ToIndex + 1).ToArray()); if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到周转盘放料位下方1"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到周转盘放料位下方1; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } else { Step = ETurnoverFlowStep.到周转盘放料位上方; } break; case ETurnoverFlowStep.等待到周转盘放料位下方1: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"已运动到周转盘放料位下方1"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.到周转盘放料位下方2; } else { Step = ETurnoverFlowStep.到周转盘放料位下方1; } } else { Step = ETurnoverFlowStep.到周转盘放料位上方; } } break; case ETurnoverFlowStep.到周转盘放料位下方2: targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"到周转盘放料位下方2"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到周转盘放料位下方2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待到周转盘放料位下方2: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { foreach (TransitNozzle nozzle in hasProductNozzles) { GlobalTray.TurnoverNozzle.ChangeStatus(nozzle.NozzleIndex, ESlotStatus.NotHave); } logInfo = GetClassName() + $"已运动到周转盘放料位下方2"; MessageQueue.Instance.Insert(logInfo); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); //TrayStatusManager.UpdateMultiSlotAsync("TurnoverNozzle", hasProductNozzles.Select(n => n.NozzleIndex).ToArray(), 0); /*关闭周转吸头真空吸*/ VacManager.TransitNozzleVacSuction(EVacOperator.Close, true, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray()); /*打开周转吸头真空破*/ VacManager.TransitNozzleVacBreak(EVacOperator.Open, true, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray()); /*关闭周转吸头真空破*/ VacManager.TransitNozzleVacBreak(EVacOperator.Close, true, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray()); Step = ETurnoverFlowStep.周转盘放料完成抬起1; } else { Step = ETurnoverFlowStep.到周转盘放料位下方2; } } else { Step = ETurnoverFlowStep.到周转盘放料位上方; } } break; case ETurnoverFlowStep.周转盘放料完成抬起1: if(GlobalVar.EnableTwoSpeed) { targetTurnoverZ = SysConfigParam.GetValue("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset; errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.PressLowSpeed); } else { targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); } if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"周转盘放料完成准备抬起1"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待周转盘放料完成抬起1; } else { // MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待周转盘放料完成抬起1: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { //hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); /*关闭周转吸头真空破*/ //VacManager.TransitNozzleVacBreak(EVacOperator.Close, true, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray()); logInfo = GetClassName() + $"周转盘放料完成已抬起1"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.周转盘放料完成抬起2; } else { Step = ETurnoverFlowStep.周转盘放料完成抬起1; } } break; case ETurnoverFlowStep.周转盘放料完成抬起2: targetTurnoverZ = SysConfigParam.GetValue("TurnoverSafeZ"); errCode = AxisControl.TurnoverZ.MovePos(targetTurnoverZ, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"周转盘放料完成准备抬起2"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待周转盘放料完成抬起2; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverZ, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverZ运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } break; case ETurnoverFlowStep.等待周转盘放料完成抬起2: if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverZIsInTargetPos(targetTurnoverZ)) { logInfo = GetClassName() + $"周转盘放料完成已抬起2"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.周转盘放料完成粘料检测; } else { Step = ETurnoverFlowStep.周转盘放料完成抬起2; } } break; case ETurnoverFlowStep.周转盘放料完成粘料检测: masticSlots.Clear(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); VacManager.TransitNozzleVacSuction(EVacOperator.Open, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles()) { //nozzle.OpenVac(); if (nozzle.HasVacSignal() && !GlobalVar.RunSpace) { logInfo = $"周转{nozzle.NozzleIndex}号吸嘴粘料"; MessageQueue.Instance.Warn(logInfo); masticSlots.Add(nozzle.NozzleIndex); } else { logInfo = $"周转{nozzle.NozzleIndex}号吸嘴无粘料"; MessageQueue.Instance.Insert(logInfo); nozzle.CloseVac(); } } if (masticSlots.Count > 0) { //粘料报警 bool exit = false; while (!exit) { //alarmInfo = $"周转{masticSlots.ToJoinString()}号吸嘴真空异常粘料，请手工处理"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转头粘料报警), masticSlots.ToJoinString()); alarmEntity = AlarmCollection.Get(AlarmConstID.周转头粘料报警).Transform(masticSlots.ToJoinString()); MessageQueue.Instance.Warn(GetClassName()+ alarmEntity.CN); //TestCenterMessageBox.Show(AlarmConstID.周转头粘料报警, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.周转头粘料报警); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Skip: logInfo = GetClassName() + "点击了跳过按钮"; MessageQueue.Instance.Insert(logInfo); foreach (int nozzleIndex in masticSlots.ToArray()) { TransitNozzle nozzle = TransitNozzleManager.Instance.Nozzle(nozzleIndex); if (!nozzle.HasVacSignal()) { nozzle.CloseVac(); nozzle.OpenBreak(); nozzle.CloseBreak(); nozzle.Clear(); masticSlots.Remove(nozzleIndex); } } if(masticSlots.Count==0) { exit = true; } break; case ETipButton.Yes: logInfo = GetClassName() + "点击了移动到安全位按钮"; MessageQueue.Instance.Insert(logInfo); TransitModuleSafePosFlow.Instance.GoSafePostion( EExceptionSafePos.TransitNozzle); break; default: break; } } } else { Step = ETurnoverFlowStep.周转盘放料完成后真空检测; } break; case ETurnoverFlowStep.周转盘放料完成后真空检测: hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); if (hasProductNozzles != null&&hasProductNozzles.Count>0) { bool needGoSafePos = false; foreach (var nozzle in hasProductNozzles) { TurnoverTraySlot slot = TurnoverTrayManager.Instance.Slot(nozzle.ToIndex + 1); //GlobalTray.TurnoverTray.ChangeStatus(nozzle.ToIndex, ESlotStatus.Have); //TurnoverTrayManager.Instance.Slot(nozzle.ToIndex).AddProduct(nozzle.SN, nozzle.NozzleIndex, TurnoverType.Turnover, nozzle.NozzleIndex); if (slot.HasVac() || GlobalVar.VirtualAxis || GlobalVar.RunSpace) { LogHelper.Debug( GetClassName()+ $"周转盘{slot.Index}穴位真空吸正常"); slot.AddProduct(nozzle); GlobalTray.TurnoverTray.ChangeStatus(slot.Index, ESlotStatus.Have); slot.VacException = false; nozzle.Clear(); } else { //1 退到安全位 LogHelper.Debug(GetClassName()+ $"通知周转模组回到安全位"); TransitModuleSafePosFlow.Instance.GoSafePostion( EExceptionSafePos.Socket); //2 排料轴上相机过来检测 LogHelper.Debug(GetClassName() + $"等待排料模组IDLE"); DischargeFlow.Instance.WaitCanMove(); LogHelper.Debug(GetClassName() + $"上相机到周转盘{slot.Index}号穴位定位检测"); VisionResult vr = UpCameraScanBarCodeFlow.Instance.ScanSingle(slot.Index, true,true,false); //VisionResult vr = UpCameraScanBarCodeFlow.Instance.WaitSingle(); needGoSafePos = true; if (!UpCameraScanBarCodeFlow.Instance.CheckResult(vr))//如果不在穴位中，就弹框报警 { LogHelper.Debug(GetClassName() + "检测到产品不在穴位中"); bool exit = false; while (!exit) { try { //alarmInfo = $"周转盘{slot.Index}号穴位真空吸异常，请选择处理"; //alarmInfo = string.Format(AlarmCollection.GetAlarm(AlarmConstID.周转吸头放料到周转盘后周转盘真空吸报警), slot.Index); alarmEntity = AlarmCollection.Get(AlarmConstID.周转吸头放料到周转盘后周转盘真空吸报警).Transform(slot.Index); LogHelper.Debug(GetClassName() + alarmEntity.CN); //msgBox = MsgBox.ShowDialog(AlarmConstID.周转吸头放料到周转盘后周转盘真空吸报警, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); ETipButton btnRet = AlarmMessageBox.ShowDialog(alarmEntity, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //switch (msgBox.Button) switch(btnRet) { case ETipButton.Retry: logInfo = GetClassName() + "选择了重试"; MessageQueue.Instance.Insert(logInfo); vr = UpCameraScanBarCodeFlow.Instance.ScanSingle(slot.Index, true, true, false); //vr = UpCameraScanBarCodeFlow.Instance.WaitSingle(); if (UpCameraScanBarCodeFlow.Instance.CheckResult(vr)) { slot.AddProduct(nozzle); GlobalTray.TurnoverTray.ChangeStatus(slot.Index, ESlotStatus.Have); slot.VacException = false; nozzle.Clear(); exit = true; } break; case ETipButton.Skip: logInfo = GetClassName() + "选择了跳过"; MessageQueue.Instance.Insert(logInfo); //检测穴位中还是否有料 if (!UpCameraCheckFlow.Instance.CheckTurnoverTrayHasProduct(null, slot.Index, true).HasProduct) { nozzle.Clear(); VacManager.TurnoverTrayVacSuction(EVacOperator.Close, true, slot.Index); exit = true; } break; case ETipButton.Yes: logInfo = GetClassName() + "选择了移动到安全位"; MessageQueue.Instance.Insert(logInfo); DischargeModuleGoSafePosFlow.Instance.GoSafePostion(); break; default: break; } } catch (Exception ex) { Msg.ShowError(ex.Message); } } } else { LogHelper.Debug(GetClassName() + "检测到产品在穴位中"); slot.AddProduct(nozzle); GlobalTray.TurnoverTray.ChangeStatus(slot.Index, ESlotStatus.Have); slot.VacException = false; nozzle.Clear(); } } } //排料轴回安全位 if(needGoSafePos) { DischargeFlow.Instance.WaitCanMove(); DischargeModuleGoSafePosFlow.Instance.GoSafePostion(); } } //检测治具盘中是否还有待取的料，如果有继续取，如果没有回安全位 if (TestTrayManager.Instance.GetSlots( ETestTraySlotStatus.Have).Count>0) { retakeNum++; Step = ETurnoverFlowStep.到测试取料位上方; } else { Step = ETurnoverFlowStep.到安全位; } break; case ETurnoverFlowStep.周转盘放料真空异常处理: { if(GlobalVar.EnableExceptionHandlingNozzle) { List vacExceptionSlots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.Tested, ETurnoverTraySlotStatus.VacException); if (vacExceptionSlots != null && vacExceptionSlots.Count > 0) { foreach (TurnoverTraySlot slot in vacExceptionSlots) { //通知大力吸嘴过来取料,如果取成功了，就把当前穴位的产品删除 } } } } break; case ETurnoverFlowStep.到安全位: MachineManage.Instance.TestStatus = ETestStatus.Idle; //这里判断周转载盘还有没有待测的产品，如果有就不动，如果没有就退到安全位 List hasProductSlots= TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have); if (hasProductSlots.Count > 0) { logInfo =GetClassName()+ $"周转盘{hasProductSlots.Select(s=>s.Index).ToJoinString()}穴位中有待测产品，就地等待周转盘取料指令"; MessageQueue.Instance.Insert(logInfo); //Step = ETurnoverFlowStep.上报中控任务完成; //如果周转盘有上料的穴位，这是自动生成上料任务 LoadAndUnloadTask.Instance.CreateTestLoadTask(); turnoverTakeFinishe = false; Step = ETurnoverFlowStep.到周转盘取料位上方; } else { targetTurnoverY = SysConfigParam.GetValue("PressTakeY"); errCode = AxisControl.TurnoverY.MovePos(targetTurnoverY, GlobalVar.WholeSpeed); if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) { if (GlobalVar.VirtualAxis) { Thread.Sleep(GlobalVar.VirtualAxisMoveTime); } logInfo = GetClassName() + $"周转吸头下料完成到安全位"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.等待到安全位; } else { //MsgBox.ShowAxisAlarmDialog(AxisControl.TurnoverY, errCode); alarmEntity = AlarmCollection.Get(AlarmConstID.TurnoverY运动异常).Transform(errCode.ToString()); AlarmMessageBox.ShowDialog(alarmEntity, ETipButton.Ok, null); } } break; case ETurnoverFlowStep.等待到安全位: if(Ops.IsStop("TurnoverX","TurnoverY") || GlobalVar.VirtualAxis) { //if(Ops.IsArrived(AxisControl.TurnoverX,AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if(AxisArrived.TurnoverYIsInTargetPos(targetTurnoverY)) { logInfo = GetClassName() + $"已运动到安全位，任务结束"; MessageQueue.Instance.Insert(logInfo); Step = ETurnoverFlowStep.上报中控任务完成; } else { Step = ETurnoverFlowStep.到安全位; } } break; case ETurnoverFlowStep.上报中控任务完成: if(GlobalVar.CleanOut) { unloadOk = true; MachineManage.Instance.SetTesterState(new TesterInfo() { State = ETesterState.NotReady, ReadySites = null }); LoadAndUnloadTask.Instance.Clear(1); Step = ETurnoverFlowStep.等待任务; } else { if (LoadAndUnloadTask.Instance.TestUnloadTaskArrived) { hasUnloadFlag = false; LoadAndUnloadTask.Instance.TestUnloadTaskArrived = false; MachineManage.Instance.SetTesterState(new TesterInfo() { State = ETesterState.NotReady, ReadySites = null }); logInfo = GetClassName() + "通知中控产品全部已从治具中取出，状态变成NotReady"; MessageQueue.Instance.Insert(logInfo); unloadOk = true; TestCenter.Instance.LoadTestUnLoadResult(); LoadAndUnloadTask.Instance.Clear(1); MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting); Step = ETurnoverFlowStep.等待任务; } } break; } } public bool LoadFinished() { return loadOk; } public bool UnloadFinished() { return unloadOk; } public string GetStep() { return Step.ToString(); } /// /// 检测周转Y轴是否可以到周转盘位置 /// /// private bool CanGoTurnoverTrayPos() { double curPos = Ops.GetCurPosition(AxisControl.LoadY); double maxPos = SysConfigParam.GetValue("Nozzle1CenterY") + 3; if (curPos > maxPos) return false; return true; } ManualResetEvent testTrayHasProductCheckEvent=new ManualResetEvent(false); private List testTrayHasProductList = new List(); private void TestTrayHasProduct() { Task.Run(() => { testTrayHasProductCheckEvent.Reset(); testTrayHasProductList.Clear(); //打开所有的真空 //VacManager.TestTrayVacSuction(EVacOperator.Open, true, TestTrayManager.Instance.Slots.Select(s => s.Index).ToArray()); //foreach (TestTraySlot slot in TestTrayManager.Instance.Slots) //{ // if(!GlobalVar.DisableFixtureVacuumCheck) // { // if (Ops.IsOn($"测试{slot.Index}号穴位真空吸检测")) // { // //testTrayHasProductList.Add(slot.Index); // } // } //} //VacManager.TestTrayVacSuction(EVacOperator.Close, true, TestTrayManager.Instance.Slots.Select(s => s.Index).ToArray()); testTrayHasProductCheckEvent.Set(); }); } } }