lhiven
/
Rs.SkyLine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

优化取放料真空开关时机

Browse Source
master
lhiven 1 year ago
parent aa8e42f75e
commit 56b5b6630b
9 changed files with 186 additions and 106 deletions
Show Stats Download Patch File Download Diff File

23
Rs.SkyLine/Commom/SourceHelper.cs
Unescape Escape View File

@ -0,0 +1,23 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Rs.MotionPlat.Commom
{
public static class SourceHelper
{
public static int GetLineNum()
{
System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(1, true);
return st.GetFrame(0).GetFileLineNumber();
}
public static string GetCurSourceFileName()
{
System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(1, true);
return st.GetFrame(0).GetFileName();
}
}
}

30
Rs.SkyLine/Commom/VacManager.cs
Unescape Escape View File

@ -70,7 +70,7 @@ namespace Rs.MotionPlat.Commom
/// </summary> /// </summary>
/// <param name="eOperator"></param> /// <param name="eOperator"></param>
/// <param name="indexes"></param> /// <param name="indexes"></param>
public static void DischargeVacBreak(EVacOperator eOperator, params int[] indexes) public static void DischargeVacBreak(EVacOperator eOperator, bool needSleep, params int[] indexes)
{ {
if (indexes.Length > 0) if (indexes.Length > 0)
{ {
@ -88,12 +88,14 @@ namespace Rs.MotionPlat.Commom
if (eOperator == EVacOperator.Open) if (eOperator == EVacOperator.Open)
{ {
Thread.Sleep(GlobalVar.LoadNozzleOpenVacSuctionDelaytime); if (needSleep)
Thread.Sleep(GlobalVar.LoadNozzleOpenVacSuctionDelaytime);
MessageQueue.Instance.Insert($"打开排料{string.Join(",", indexes)}号吸嘴真空破"); MessageQueue.Instance.Insert($"打开排料{string.Join(",", indexes)}号吸嘴真空破");
} }
else else
{ {
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime); if (needSleep)
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
MessageQueue.Instance.Insert($"关闭排料{string.Join(",", indexes)}号吸嘴真空破"); MessageQueue.Instance.Insert($"关闭排料{string.Join(",", indexes)}号吸嘴真空破");
} }
} }
@ -140,7 +142,7 @@ namespace Rs.MotionPlat.Commom
/// </summary> /// </summary>
/// <param name="eOperator"></param> /// <param name="eOperator"></param>
/// <param name="indexes"></param> /// <param name="indexes"></param>
public static void TurnoverTrayVacBreak(EVacOperator eOperator, params int[] indexes) public static void TurnoverTrayVacBreak(EVacOperator eOperator,bool bNeedSleep, params int[] indexes)
{ {
if (indexes.Length > 0) if (indexes.Length > 0)
{ {
@ -158,12 +160,14 @@ namespace Rs.MotionPlat.Commom
if (eOperator == EVacOperator.Open) if (eOperator == EVacOperator.Open)
{ {
Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime); if (bNeedSleep)
Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime);
MessageQueue.Instance.Insert($"打开周转盘{indexes.ToJoinString()}号穴位真空破"); MessageQueue.Instance.Insert($"打开周转盘{indexes.ToJoinString()}号穴位真空破");
} }
else else
{ {
Thread.Sleep(GlobalVar.TurnoverTrayCloseVacBreakDelaytime); if (bNeedSleep)
Thread.Sleep(GlobalVar.TurnoverTrayCloseVacBreakDelaytime);
MessageQueue.Instance.Insert($"关闭周转盘{indexes.ToJoinString()}号穴位真空破"); MessageQueue.Instance.Insert($"关闭周转盘{indexes.ToJoinString()}号穴位真空破");
} }
} }
@ -174,7 +178,7 @@ namespace Rs.MotionPlat.Commom
/// </summary> /// </summary>
/// <param name="eOperator"></param> /// <param name="eOperator"></param>
/// <param name="indexes"></param> /// <param name="indexes"></param>
public static void TransitNozzleVacSuction(EVacOperator eOperator, params int[] indexes) public static void TransitNozzleVacSuction(EVacOperator eOperator, bool bNeedSleep, params int[] indexes)
{ {
if (indexes.Length > 0) if (indexes.Length > 0)
{ {
@ -192,12 +196,14 @@ namespace Rs.MotionPlat.Commom
if (eOperator == EVacOperator.Open) if (eOperator == EVacOperator.Open)
{ {
if(bNeedSleep)
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacSuctionDelaytime);
MessageQueue.Instance.Insert($"打开周转吸嘴{string.Join(",", indexes)}号真空吸"); MessageQueue.Instance.Insert($"打开周转吸嘴{string.Join(",", indexes)}号真空吸");
} }
else else
{ {
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacSuctionDelaytime); if (bNeedSleep)
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacSuctionDelaytime);
MessageQueue.Instance.Insert($"关闭周转吸嘴{string.Join(",", indexes)}号真空吸"); MessageQueue.Instance.Insert($"关闭周转吸嘴{string.Join(",", indexes)}号真空吸");
} }
} }
@ -208,7 +214,7 @@ namespace Rs.MotionPlat.Commom
/// </summary> /// </summary>
/// <param name="eOperator"></param> /// <param name="eOperator"></param>
/// <param name="indexes"></param> /// <param name="indexes"></param>
public static void TransitNozzleVacBreak(EVacOperator eOperator, params int[] indexes) public static void TransitNozzleVacBreak(EVacOperator eOperator,bool bNeedSleep, params int[] indexes)
{ {
if (indexes.Length > 0) if (indexes.Length > 0)
{ {
@ -226,12 +232,14 @@ namespace Rs.MotionPlat.Commom
if (eOperator == EVacOperator.Open) if (eOperator == EVacOperator.Open)
{ {
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacBreakDelaytime); if (bNeedSleep)
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacBreakDelaytime);
MessageQueue.Instance.Insert($"打开周转吸嘴{string.Join(",", indexes)}号真空破"); MessageQueue.Instance.Insert($"打开周转吸嘴{string.Join(",", indexes)}号真空破");
} }
else else
{ {
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacBreakDelaytime); if (bNeedSleep)
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacBreakDelaytime);
MessageQueue.Instance.Insert($"关闭周转吸嘴{string.Join(",", indexes)}号真空破"); MessageQueue.Instance.Insert($"关闭周转吸嘴{string.Join(",", indexes)}号真空破");
} }
} }

4
Rs.SkyLine/Entitys/TransitNozzleManager.cs
Unescape Escape View File

@ -157,7 +157,7 @@ namespace Rs.MotionPlat.Commom
/// </summary> /// </summary>
public void OpenBreak() public void OpenBreak()
{ {
VacManager.TransitNozzleVacBreak(EVacOperator.Open, NozzleIndex); VacManager.TransitNozzleVacBreak(EVacOperator.Open, true,NozzleIndex);
} }
/// <summary> /// <summary>
@ -165,7 +165,7 @@ namespace Rs.MotionPlat.Commom
/// </summary> /// </summary>
public void CloseBreak() public void CloseBreak()
{ {
VacManager.TransitNozzleVacBreak(EVacOperator.Open, NozzleIndex); VacManager.TransitNozzleVacBreak(EVacOperator.Open, true, NozzleIndex);
} }
} }
} }

15
Rs.SkyLine/Flow/AlarmConstID.cs
Unescape Escape View File

@ -267,5 +267,20 @@ namespace Rs.MotionPlat.Flow
/// 排料吸嘴R9运动异常 /// 排料吸嘴R9运动异常
/// </summary> /// </summary>
public const int NozzleR9MoveFailAlarm = 54; public const int NozzleR9MoveFailAlarm = 54;
/// <summary>
/// 镭射头检测异常
/// </summary>
public const int LaserCheckFailAlarm = 55;
/// <summary>
/// 轴不在原点报警
/// </summary>
public const int AxisNotAtHomeAlarm = 56;
/// <summary>
/// 测试治具光前异常报警
/// </summary>
public const int TextFixtureFiberAlarm = 57;
} }
} }

114
Rs.SkyLine/Flow/NormalFlow/DischargeFlow.cs
Unescape Escape View File

@ -189,7 +189,7 @@ namespace Rs.MotionPlat.Flow
{ {
curSlotPoint = TrayPointManager.GetSlotPoint( ETrayType.Turnover, curTask.FromIndex + 1); curSlotPoint = TrayPointManager.GetSlotPoint( ETrayType.Turnover, curTask.FromIndex + 1);
curNozzle.FromIndex = curTask.FromIndex; curNozzle.FromIndex = curTask.FromIndex;
logInfo = GetClassName()+ $"排料{curNozzle.NozzleIndex}号吸嘴到周转盘{curNozzle.FromIndex + 1}号穴位取料"; logInfo = GetClassName()+ $"排料{curNozzle.NozzleIndex}号吸嘴到{curTask.FromType.ToString()}盘{curNozzle.FromIndex + 1}号穴位取料";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
} }
else if (curTask.FromType == TurnoverType.ToBeTested) else if (curTask.FromType == TurnoverType.ToBeTested)
@ -199,12 +199,12 @@ namespace Rs.MotionPlat.Flow
{ {
curSlotPoint = TrayPointManager.GetSlotPoint( ETrayType.Input, slot.Index); curSlotPoint = TrayPointManager.GetSlotPoint( ETrayType.Input, slot.Index);
curNozzle.FromIndex= slot.Index-1; curNozzle.FromIndex= slot.Index-1;
logInfo =GetClassName()+ $"排料{curNozzle.NozzleIndex}号吸嘴到Input盘{curNozzle.FromIndex+1}号穴位取料"; logInfo =GetClassName()+ $"排料{curNozzle.NozzleIndex}号吸嘴到{curTask.FromType.ToString()}盘{curNozzle.FromIndex+1}号穴位取料";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
} }
else else
{ {
logInfo = GetClassName()+ $"检测到Input料盘无料,准备切换料盘"; logInfo = GetClassName()+ $"{curTask.FromType.ToString()}盘无料,准备切换料盘";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
TakeTrayFlow.Instance.Take(ETrayType.Input, ETrayType.Empty1, TakeTrayFlow.Instance.Take(ETrayType.Input, ETrayType.Empty1,
() => () =>
@ -271,7 +271,7 @@ namespace Rs.MotionPlat.Flow
} }
else else
{ {
logInfo = "x y r move isn't safe"; logInfo = "x y r move is unsafe";
Msg.ShowError(logInfo); Msg.ShowError(logInfo);
MessageQueue.Instance.Warn(logInfo); MessageQueue.Instance.Warn(logInfo);
} }
@ -293,6 +293,7 @@ namespace Rs.MotionPlat.Flow
if (curTask.FromType == TurnoverType.Turnover) if (curTask.FromType == TurnoverType.Turnover)
{ {
targetPos = GetVacOffsetHeight(reFetchNum) + SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight"); targetPos = GetVacOffsetHeight(reFetchNum) + SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight");
//在周转盘取料，提前把真空吸打开
VacManager.DischargeVacSuction(EVacOperator.Open, false, curNozzle.NozzleIndex); VacManager.DischargeVacSuction(EVacOperator.Open, false, curNozzle.NozzleIndex);
VacManager.TurnoverTrayVacSuction(EVacOperator.Close, false, curNozzle.FromIndex + 1); VacManager.TurnoverTrayVacSuction(EVacOperator.Close, false, curNozzle.FromIndex + 1);
} }
@ -320,8 +321,7 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = GetClassName()+ $"NozzleZ{curNozzle.NozzleIndex} 不在原点，请手动回原后点击确定"; logInfo = GetClassName()+ $"NozzleZ{curNozzle.NozzleIndex} 不在原点，请手动回原后点击确定";
MessageQueue.Instance.Warn(logInfo); MessageQueue.Instance.Warn(logInfo);
TestCenterMessageBox.Show(1111, logInfo, ETipButton.Ok); MsgBox.ShowDialog(AlarmConstID.AxisNotAtHomeAlarm, logInfo, ETipButton.Ok);
TestCenterMessageBox.WaitResult(1111);
} }
break; break;
@ -354,7 +354,7 @@ namespace Rs.MotionPlat.Flow
//Ops.On($"周转盘{curTask.FromIndex + 1}号穴位真空破"); //Ops.On($"周转盘{curTask.FromIndex + 1}号穴位真空破");
//Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime); //Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime);
//MessageQueue.Instance.Insert(logInfo); //MessageQueue.Instance.Insert(logInfo);
VacManager.TurnoverTrayVacBreak( EVacOperator.Open,curNozzle.FromIndex + 1); VacManager.TurnoverTrayVacBreak( EVacOperator.Open,true,curNozzle.FromIndex + 1);
/*关闭周转盘真空破*/ /*关闭周转盘真空破*/
//logInfo = GetClassName() + $"关闭周转盘{curTask.FromIndex + 1}号穴位真空破"; //logInfo = GetClassName() + $"关闭周转盘{curTask.FromIndex + 1}号穴位真空破";
//Ops.Off($"周转盘{curTask.FromIndex + 1}号穴位真空破"); //Ops.Off($"周转盘{curTask.FromIndex + 1}号穴位真空破");
@ -377,7 +377,7 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = GetClassName()+ $"取{WitchTrayWitchSlot(curNozzle.FromType, curNozzle.FromIndex)}号穴位产品完成准备抬起"; logInfo = GetClassName()+ $"取{WitchTrayWitchSlot(curNozzle.FromType, curNozzle.FromIndex)}号穴位产品完成抬起";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.等待取料完成抬起; flowStep = EDischargeFlowStep.等待取料完成抬起;
} }
@ -393,7 +393,8 @@ namespace Rs.MotionPlat.Flow
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
if (curTask.FromType == TurnoverType.Turnover) if (curTask.FromType == TurnoverType.Turnover)
{ {
VacManager.TurnoverTrayVacBreak(EVacOperator.Close, curNozzle.FromIndex + 1); ///周转盘取料抬起后把真空破关闭,这里关破真空不等待
VacManager.TurnoverTrayVacBreak(EVacOperator.Close,false, curNozzle.FromIndex + 1);
} }
flowStep = EDischargeFlowStep.取料完成后真空检测; flowStep = EDischargeFlowStep.取料完成后真空检测;
} }
@ -408,7 +409,7 @@ namespace Rs.MotionPlat.Flow
undoTaskNum = LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode); undoTaskNum = LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode);
if (undoTaskNum > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0) if (undoTaskNum > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
{ {
logInfo =GetClassName()+ $"检测到还有{undoTaskNum}条任务未执行，并且有空闲吸嘴，继续取料"; logInfo =GetClassName()+ $"还有{undoTaskNum}条任务未执行，并且有空闲吸嘴，继续取料";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.到取料位上方; flowStep = EDischargeFlowStep.到取料位上方;
} }
@ -443,9 +444,8 @@ namespace Rs.MotionPlat.Flow
buttonText.Add(ETipButton.No, "结束上料|EndInput"); buttonText.Add(ETipButton.No, "结束上料|EndInput");
btnText |= ETipButton.No; btnText |= ETipButton.No;
} }
//alarmInfo = $"{curNozzle.NozzleIndex}排料吸嘴取料{reFetchNum}次失败"; //TestCenterMessageBox.Show(AlarmConstID.TrayTakeFailAlarm, alarmInfo, btnText, buttonText);
TestCenterMessageBox.Show(AlarmConstID.TrayTakeFailAlarm, alarmInfo, btnText, buttonText); SchedulingMessageBox box = MsgBox.ShowDialog(AlarmConstID.TrayTakeFailAlarm, alarmInfo, btnText, buttonText);// TestCenterMessageBox.WaitResult(AlarmConstID.TrayTakeFailAlarm);
SchedulingMessageBox box = TestCenterMessageBox.WaitResult(AlarmConstID.TrayTakeFailAlarm);
switch (box.Button) switch (box.Button)
{ {
case ETipButton.Retry: case ETipButton.Retry:
@ -580,17 +580,16 @@ namespace Rs.MotionPlat.Flow
case EDischargeFlowStep.到下相机拍照起始位: case EDischargeFlowStep.到下相机拍照起始位:
if (XYCanMove() || GlobalVar.VirtualAxis) if (XYCanMove() || GlobalVar.VirtualAxis)
{ {
if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count > 0)
logInfo = GetClassName() + $"到下相机拍照起始位";
MessageQueue.Instance.Insert(logInfo);
if(!GlobalVar.VirtualAxis)
{
ImageProcess.ClearAutoTrigger();
HikCamera.Instance.SetExposure("locationCamera", GlobalVar.FlyGrabExposureTime);
HikCamera.Instance.SetGain("locationCamera", GlobalVar.FlyGrabGain);
}
if(NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count>0)
{ {
logInfo = GetClassName() + $"到下相机拍照起始位";
MessageQueue.Instance.Insert(logInfo);
if(!GlobalVar.VirtualAxis)
{
ImageProcess.ClearAutoTrigger();
HikCamera.Instance.SetExposure("locationCamera", GlobalVar.FlyGrabExposureTime);
HikCamera.Instance.SetGain("locationCamera", GlobalVar.FlyGrabGain);
}
if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType == TurnoverType.Turnover) if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType == TurnoverType.Turnover)
{ {
needGrabNum = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count(); needGrabNum = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count();
@ -627,6 +626,8 @@ namespace Rs.MotionPlat.Flow
} }
else else
{ {
logInfo = GetClassName() + $"检测到排料吸嘴没有需要下料的产品，任务结束回安全位";
MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.任务结束到安全位; flowStep = EDischargeFlowStep.任务结束到安全位;
} }
} }
@ -667,7 +668,7 @@ namespace Rs.MotionPlat.Flow
} }
else else
{ {
//TestCenterMessageBox.Show(1,$"轴LoadX运动异常,ret={errCode}", ETipButton.Ok); MsgBox.ShowAxisAlarmDialog(AxisControl.LoadX, errCode);
} }
} }
break; break;
@ -811,15 +812,15 @@ namespace Rs.MotionPlat.Flow
reGrabCount = 0; reGrabCount = 0;
alarmInfo = $"{string.Join(",", errCodeList)}号排料吸嘴拍照失败"; alarmInfo = $"{string.Join(",", errCodeList)}号排料吸嘴拍照失败";
//DialogResult dr = Msg.ShowQuestion(, System.Windows.Forms.MessageBoxButtons.RetryCancel); //DialogResult dr = Msg.ShowQuestion(, System.Windows.Forms.MessageBoxButtons.RetryCancel);
TestCenterMessageBox.Show(AlarmConstID.DownCameraFlyFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Cancel); //TestCenterMessageBox.Show(AlarmConstID.DownCameraFlyFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Cancel);
box = TestCenterMessageBox.WaitResult(AlarmConstID.DownCameraFlyFailAlarm); box = MsgBox.ShowDialog(AlarmConstID.DownCameraFlyFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Cancel);// TestCenterMessageBox.WaitResult(AlarmConstID.DownCameraFlyFailAlarm);
if (box.Button== ETipButton.Cancel) if (box.Button== ETipButton.Cancel)
{ {
flowStep = EDischargeFlowStep.到放料位上方; flowStep = EDischargeFlowStep.到放料位上方;
} }
else if (box.Button == ETipButton.Retry) else if (box.Button == ETipButton.Retry)
{ {
Thread.Sleep(1000); Thread.Sleep(500);
flowStep = EDischargeFlowStep.到下相机拍照起始位; flowStep = EDischargeFlowStep.到下相机拍照起始位;
} }
} }
@ -959,7 +960,7 @@ namespace Rs.MotionPlat.Flow
{ {
curNozzle.ToIndex = downSlot.Index - 1; curNozzle.ToIndex = downSlot.Index - 1;
curSlotPoint = TrayPointManager.GetSlotPoint(ETrayType.Multi, downSlot.Index); curSlotPoint = TrayPointManager.GetSlotPoint(ETrayType.Multi, downSlot.Index);
logInfo = GetClassName() + $"排料吸嘴{curNozzle.NozzleIndex}号到{curNozzle.ToType}盘{curNozzle.ToIndex + 1}号穴位上方"; logInfo = GetClassName() + $"排料吸嘴{curNozzle.NozzleIndex}号到{curNozzle.ToType}盘{curNozzle.ToIndex + 1}号穴位上方,SN={curNozzle.SN}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
} }
else else
@ -989,7 +990,7 @@ namespace Rs.MotionPlat.Flow
if (curSlotPoint!=null) if (curSlotPoint!=null)
{ {
nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex); nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
if(mrs[curNozzle.NozzleIndex - 1].OffsetRow <5 && mrs[curNozzle.NozzleIndex - 1].OffsetCol<5) if(mrs[curNozzle.NozzleIndex - 1].OffsetRow <3 && mrs[curNozzle.NozzleIndex - 1].OffsetCol<3)
{ {
targetX = mrs[curNozzle.NozzleIndex -1].OffsetCol + curSlotPoint.X + nozzleDist.X+ turnoverOffsetPoint.X; targetX = mrs[curNozzle.NozzleIndex -1].OffsetCol + curSlotPoint.X + nozzleDist.X+ turnoverOffsetPoint.X;
targetY = mrs[curNozzle.NozzleIndex- 1].OffsetRow +curSlotPoint.Y + nozzleDist.Y + turnoverOffsetPoint.Y; targetY = mrs[curNozzle.NozzleIndex- 1].OffsetRow +curSlotPoint.Y + nozzleDist.Y + turnoverOffsetPoint.Y;
@ -999,6 +1000,8 @@ namespace Rs.MotionPlat.Flow
targetX = curSlotPoint.X + nozzleDist.X + turnoverOffsetPoint.X; targetX = curSlotPoint.X + nozzleDist.X + turnoverOffsetPoint.X;
targetY = curSlotPoint.Y + nozzleDist.Y + turnoverOffsetPoint.Y; targetY = curSlotPoint.Y + nozzleDist.Y + turnoverOffsetPoint.Y;
} }
logInfo = $"运动到放料位上方 X:{targetX}Y:{targetY}";
MessageQueue.Instance.Insert(logInfo);
errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed); errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis ) if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis )
{ {
@ -1034,7 +1037,7 @@ namespace Rs.MotionPlat.Flow
{ {
alarmInfo = "x y r move isn't safe"; alarmInfo = "x y r move isn't safe";
MessageQueue.Instance.Warn(alarmInfo); MessageQueue.Instance.Warn(alarmInfo);
TestCenterMessageBox.Show(AlarmConstID.MoveUnsafeAlarm, alarmInfo, ETipButton.Ok); MsgBox.ShowDialog(AlarmConstID.MoveUnsafeAlarm, alarmInfo, ETipButton.Ok);
} }
break; break;
case EDischargeFlowStep.等待到放料位上方: case EDischargeFlowStep.等待到放料位上方:
@ -1052,9 +1055,9 @@ namespace Rs.MotionPlat.Flow
while (!exit) while (!exit)
{ {
//弹框报警 //弹框报警
alarmInfo = $"检测到{curNozzle.NozzleIndex}吸嘴真空吸异常，可能丢料，请检查吸嘴的状态"; alarmInfo = $"{curNozzle.NozzleIndex}吸嘴真空吸异常，可能丢料，请检查吸嘴的状态";
TestCenterMessageBox.Show(AlarmConstID.DischargeNozzleLostProductAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //TestCenterMessageBox.Show(AlarmConstID.DischargeNozzleLostProductAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.DischargeNozzleLostProductAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.DischargeNozzleLostProductAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.DischargeNozzleLostProductAlarm);
switch (msgBox.Button) switch (msgBox.Button)
{ {
case ETipButton.Skip: case ETipButton.Skip:
@ -1158,9 +1161,7 @@ namespace Rs.MotionPlat.Flow
if (curNozzle.ToType == TurnoverType.Turnover) if (curNozzle.ToType == TurnoverType.Turnover)
{ {
targetPos = SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight"); targetPos = SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight");
/*打开周转盘真空吸*/ /*提前打开周转盘真空吸*/
logInfo = GetClassName() + $"打开周转盘{curNozzle.ToIndex + 1}号穴位真空吸";
MessageQueue.Instance.Insert(logInfo);
VacManager.TurnoverTrayVacSuction(EVacOperator.Open, false, curNozzle.ToIndex + 1); VacManager.TurnoverTrayVacSuction(EVacOperator.Open, false, curNozzle.ToIndex + 1);
} }
else else
@ -1188,39 +1189,39 @@ namespace Rs.MotionPlat.Flow
if (curNozzle.ToType == TurnoverType.Turnover) if (curNozzle.ToType == TurnoverType.Turnover)
{ {
/*关闭排料吸嘴真空吸*/ /*关闭排料吸嘴真空吸*/
logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸"; //logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸";
MessageQueue.Instance.Insert(logInfo); //MessageQueue.Instance.Insert(logInfo);
//Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");//关闭真空 //Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");//关闭真空
//Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime); //Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
VacManager.DischargeVacSuction(EVacOperator.Close, true, curNozzle.NozzleIndex); VacManager.DischargeVacSuction(EVacOperator.Close, false, curNozzle.NozzleIndex);
/*打开排料吸嘴真空破*/ /*打开排料吸嘴真空破*/
logInfo = GetClassName() + $"打开{curNozzle.NozzleIndex}号排料吸嘴真空破"; //logInfo = GetClassName() + $"打开{curNozzle.NozzleIndex}号排料吸嘴真空破";
MessageQueue.Instance.Insert(logInfo); //MessageQueue.Instance.Insert(logInfo);
//Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀"); //Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
//Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime); //Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
VacManager.DischargeVacBreak(EVacOperator.Open, curNozzle.NozzleIndex); VacManager.DischargeVacBreak(EVacOperator.Open, true,curNozzle.NozzleIndex);
flowStep = EDischargeFlowStep.到放料关破真空位; flowStep = EDischargeFlowStep.到放料关破真空位;
} }
else else
{ {
/*关闭排料吸嘴真空吸*/ /*关闭排料吸嘴真空吸*/
logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸"; //logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸";
MessageQueue.Instance.Insert(logInfo); //MessageQueue.Instance.Insert(logInfo);
//Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀"); //Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
//Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime); //Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
VacManager.DischargeVacSuction(EVacOperator.Close,true, curNozzle.NozzleIndex); VacManager.DischargeVacSuction(EVacOperator.Close,false, curNozzle.NozzleIndex);
/*打开排料吸嘴真空破*/ /*打开排料吸嘴真空破*/
logInfo = GetClassName() + $"打开{curNozzle.NozzleIndex}号排料吸嘴真空破"; //logInfo = GetClassName() + $"打开{curNozzle.NozzleIndex}号排料吸嘴真空破";
MessageQueue.Instance.Insert(logInfo); //MessageQueue.Instance.Insert(logInfo);
//Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀"); //Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
//Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime); //Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
VacManager.DischargeVacBreak(EVacOperator.Open, curNozzle.NozzleIndex); VacManager.DischargeVacBreak(EVacOperator.Open,true, curNozzle.NozzleIndex);
/*关闭排料吸嘴真空破*/ /*关闭排料吸嘴真空破*/
logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空破"; //logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空破";
MessageQueue.Instance.Insert(logInfo); //MessageQueue.Instance.Insert(logInfo);
//Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀"); //Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
//Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime); //Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
VacManager.DischargeVacBreak(EVacOperator.Close, curNozzle.NozzleIndex); VacManager.DischargeVacBreak(EVacOperator.Close,false, curNozzle.NozzleIndex);
flowStep = EDischargeFlowStep.放料完成抬起; flowStep = EDischargeFlowStep.放料完成抬起;
} }
} }
@ -1245,7 +1246,7 @@ namespace Rs.MotionPlat.Flow
/*关闭排料吸嘴真空破*/ /*关闭排料吸嘴真空破*/
//Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀"); //Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
//Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime); //Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
VacManager.DischargeVacBreak(EVacOperator.Close, curNozzle.NozzleIndex); VacManager.DischargeVacBreak(EVacOperator.Close,false,curNozzle.NozzleIndex);
logInfo = GetClassName() + $"关闭排料{curNozzle.NozzleIndex}号吸嘴真空破"; logInfo = GetClassName() + $"关闭排料{curNozzle.NozzleIndex}号吸嘴真空破";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.放料完成抬起; flowStep = EDischargeFlowStep.放料完成抬起;
@ -1287,8 +1288,8 @@ namespace Rs.MotionPlat.Flow
//粘料报警,提示用户粘料，移动到安全位，或者点击跳过 //粘料报警,提示用户粘料，移动到安全位，或者点击跳过
alarmInfo = $"排料{curNozzle.NozzleIndex}号吸嘴可能粘料，请查看吸嘴状态后处理"; alarmInfo = $"排料{curNozzle.NozzleIndex}号吸嘴可能粘料，请查看吸嘴状态后处理";
MessageQueue.Instance.Warn(GetClassName()+ alarmInfo); MessageQueue.Instance.Warn(GetClassName()+ alarmInfo);
TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm);
switch (msgBox.Button) switch (msgBox.Button)
{ {
case ETipButton.Skip: case ETipButton.Skip:
@ -1350,8 +1351,8 @@ namespace Rs.MotionPlat.Flow
{ {
alarmInfo = $"周转盘{curNozzle.ToIndex + 1}号穴位真空吸异常"; alarmInfo = $"周转盘{curNozzle.ToIndex + 1}号穴位真空吸异常";
MessageQueue.Instance.Warn(GetClassName() + alarmInfo); MessageQueue.Instance.Warn(GetClassName() + alarmInfo);
TestCenterMessageBox.Show(AlarmConstID.TurnoverDumpFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Skip | ETipButton.Yes, buttons); //TestCenterMessageBox.Show(AlarmConstID.TurnoverDumpFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Skip | ETipButton.Yes, buttons);
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverDumpFailAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.TurnoverDumpFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Skip | ETipButton.Yes, buttons);// TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverDumpFailAlarm);
if (msgBox != null) if (msgBox != null)
{ {
switch (msgBox.Button) switch (msgBox.Button)
@ -1598,7 +1599,6 @@ namespace Rs.MotionPlat.Flow
break; break;
case EDischargeFlowStep.任务结束到安全位: case EDischargeFlowStep.任务结束到安全位:
errCode = AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>("LoadXStartPos"), GlobalVar.WholeSpeed); errCode = AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>("LoadXStartPos"), GlobalVar.WholeSpeed);
if(errCode== ErrorCode.Ok || GlobalVar.VirtualAxis) if(errCode== ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {

97
Rs.SkyLine/Flow/NormalFlow/TurnoverFlow.cs
Unescape Escape View File

@ -235,10 +235,10 @@ namespace Rs.MotionPlat.Flow
bool exit = false; bool exit = false;
while (!exit) while (!exit)
{ {
alarmInfo = GetClassName() + $"周转盘{string.Join(",", untestSlots.Select(s => s.Index))}号穴位异常"; alarmInfo = GetClassName() + $"周转盘{string.Join(",", untestSlots.Select(s => s.Index))}号穴位取料异常";
TestCenterMessageBox.Show(AlarmConstID.TurnoverTakeFailAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), //TestCenterMessageBox.Show(AlarmConstID.TurnoverTakeFailAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(),
MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverTakeFailAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.TurnoverTakeFailAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(),MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverTakeFailAlarm);
switch (msgBox.Button) switch (msgBox.Button)
{ {
case ETipButton.Retry: case ETipButton.Retry:
@ -297,10 +297,19 @@ namespace Rs.MotionPlat.Flow
break; break;
case ETurnoverFlowStep.到周转盘下方取料位1: case ETurnoverFlowStep.到周转盘下方取料位1:
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset; if(GlobalVar.EnableTwoSpeed)
{
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset;
}
else
{
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ");
}
errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.WholeSpeed); errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.WholeSpeed);
if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {
/*提前打开周转吸嘴真空吸*/
VacManager.TransitNozzleVacSuction(EVacOperator.Open, false,undealTasks.Select(t => t.ToIndex + 1).ToArray());
if (GlobalVar.VirtualAxis) if (GlobalVar.VirtualAxis)
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
@ -347,17 +356,22 @@ namespace Rs.MotionPlat.Flow
logInfo = GetClassName() + $"已运动到周转盘下方取料位2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; logInfo = GetClassName() + $"已运动到周转盘下方取料位2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal);
/*打开周转吸嘴真空吸*/
VacManager.TransitNozzleVacSuction(EVacOperator.Open, undealTasks.Select(t => t.ToIndex + 1).ToArray());
/*关闭周转盘真空吸*/ /*关闭周转盘真空吸*/
VacManager.TurnoverTrayVacSuction(EVacOperator.Close, true, undealTasks.Select(t => t.FromIndex + 1).ToArray()); VacManager.TurnoverTrayVacSuction(EVacOperator.Close, false, undealTasks.Select(t => t.FromIndex + 1).ToArray());
/*打开周转盘真空破*/ /*打开周转盘真空破*/
VacManager.TurnoverTrayVacBreak(EVacOperator.Open, undealTasks.Select(t => t.FromIndex + 1).ToArray()); VacManager.TurnoverTrayVacBreak(EVacOperator.Open, true,undealTasks.Select(t => t.FromIndex + 1).ToArray());
Step = ETurnoverFlowStep.到周转盘取料破真空位; Step = ETurnoverFlowStep.到周转盘取料破真空位;
} }
break; break;
case ETurnoverFlowStep.到周转盘取料破真空位: case ETurnoverFlowStep.到周转盘取料破真空位:
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ")+GlobalVar.CloseVacOffsetHeight; if(GlobalVar.EnableTwoSpeed)
{
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ") + GlobalVar.CloseVacOffsetHeight;
}
else
{
targetPos = SysConfigParam.GetValue<double>("TurnoverSafeZ");
}
errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.WholeSpeed); errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.WholeSpeed);
if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {
@ -381,7 +395,7 @@ namespace Rs.MotionPlat.Flow
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal); undealTasks = LoadAndUnloadTask.Instance.GetTurnoverToTestTasks(ETaskDealStatus.Undeal);
/*关闭周转盘真空破*/ /*关闭周转盘真空破*/
VacManager.TurnoverTrayVacBreak(EVacOperator.Close, undealTasks.Select(t => t.FromIndex + 1).ToArray()); VacManager.TurnoverTrayVacBreak(EVacOperator.Close,false,undealTasks.Select(t => t.FromIndex + 1).ToArray());
Step = ETurnoverFlowStep.周转盘取料完成抬起; Step = ETurnoverFlowStep.周转盘取料完成抬起;
} }
break; break;
@ -424,6 +438,10 @@ namespace Rs.MotionPlat.Flow
GlobalTray.TurnoverTray.ChangeStatus(task.FromIndex + 1, ESlotStatus.NotHave); GlobalTray.TurnoverTray.ChangeStatus(task.FromIndex + 1, ESlotStatus.NotHave);
task.Dealed = true; task.Dealed = true;
} }
else
{
MessageQueue.Instance.Warn($"周转{task.ToIndex + 1}号吸嘴真空吸检测异常");
}
} }
hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
if (hasProductNozzles.Count > 0) if (hasProductNozzles.Count > 0)
@ -505,8 +523,8 @@ namespace Rs.MotionPlat.Flow
while (!exit) while (!exit)
{ {
alarmInfo = $"周转{loseSlots.ToJoinString()}号吸嘴真空异常丢料，请处理"; alarmInfo = $"周转{loseSlots.ToJoinString()}号吸嘴真空异常丢料，请处理";
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm);
switch (msgBox.Button) switch (msgBox.Button)
{ {
case ETipButton.Skip: case ETipButton.Skip:
@ -515,11 +533,11 @@ namespace Rs.MotionPlat.Flow
exit = true; exit = true;
List<TransitNozzle> hasProducts = TransitNozzleManager.Instance.GetHasProductNozzles(); List<TransitNozzle> hasProducts = TransitNozzleManager.Instance.GetHasProductNozzles();
//把吸嘴的真空吸关闭 //把吸嘴的真空吸关闭
VacManager.TransitNozzleVacSuction(EVacOperator.Close, loseSlots.ToArray()); VacManager.TransitNozzleVacSuction(EVacOperator.Close,false, loseSlots.ToArray());
//打开周转吸嘴的真空破 //打开周转吸嘴的真空破
VacManager.TransitNozzleVacBreak(EVacOperator.Open, loseSlots.ToArray()); VacManager.TransitNozzleVacBreak(EVacOperator.Open,true, loseSlots.ToArray());
//关闭周转吸嘴的真空破 //关闭周转吸嘴的真空破
VacManager.TransitNozzleVacBreak(EVacOperator.Close, loseSlots.ToArray()); VacManager.TransitNozzleVacBreak(EVacOperator.Close,false, loseSlots.ToArray());
foreach(int nozzleIndex in loseSlots) foreach(int nozzleIndex in loseSlots)
{ {
TransitNozzleManager.Instance.Nozzle(nozzleIndex).Clear(); TransitNozzleManager.Instance.Nozzle(nozzleIndex).Clear();
@ -566,10 +584,21 @@ namespace Rs.MotionPlat.Flow
break; break;
case ETurnoverFlowStep.到测试放料位下方1: case ETurnoverFlowStep.到测试放料位下方1:
targetPos = SysConfigParam.GetValue<double>("PressDumpZ")+GlobalVar.PressLowSpeedOffset; if(GlobalVar.EnableTwoSpeed)
{
targetPos = SysConfigParam.GetValue<double>("PressDumpZ") + GlobalVar.PressLowSpeedOffset;
}
else
{
targetPos = SysConfigParam.GetValue<double>("PressDumpZ");
}
errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.WholeSpeed); errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.WholeSpeed);
if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis ) if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis )
{ {
//获取需要放料的吸嘴
hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
/*打开测试穴位真空吸*/
VacManager.TestTrayVacSuction(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
if (GlobalVar.VirtualAxis) if (GlobalVar.VirtualAxis)
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
@ -618,13 +647,12 @@ namespace Rs.MotionPlat.Flow
logInfo =GetClassName()+ $"已运动到到测试放料位下方2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; logInfo =GetClassName()+ $"已运动到到测试放料位下方2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
/*打开测试穴位真空吸*/ /*打开测试穴位真空吸*/
VacManager.TestTrayVacSuction(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); //VacManager.TestTrayVacSuction(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
/*关闭周转吸头真空吸*/ /*关闭周转吸头真空吸*/
VacManager.TransitNozzleVacSuction(EVacOperator.Close, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); VacManager.TransitNozzleVacSuction(EVacOperator.Close, false,hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
/*打开周转吸头真空破*/ /*打开周转吸头真空破*/
VacManager.TransitNozzleVacBreak(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); VacManager.TransitNozzleVacBreak(EVacOperator.Open,true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
/*关闭周转吸头真空破*/
VacManager.TransitNozzleVacBreak(EVacOperator.Close, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
Step = ETurnoverFlowStep.测试位放料完成抬起; Step = ETurnoverFlowStep.测试位放料完成抬起;
} }
break; break;
@ -649,6 +677,11 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待测试位放料完成抬起: case ETurnoverFlowStep.等待测试位放料完成抬起:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
//获取需要放料的吸嘴
hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
/*关闭周转吸头真空破*/
VacManager.TransitNozzleVacBreak(EVacOperator.Close, false, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
logInfo = GetClassName()+$"测试位放料完成抬起完成"; logInfo = GetClassName()+$"测试位放料完成抬起完成";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.测试位放料完成粘料检测; Step = ETurnoverFlowStep.测试位放料完成粘料检测;
@ -658,7 +691,7 @@ namespace Rs.MotionPlat.Flow
masticSlots.Clear(); masticSlots.Clear();
hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
//打开全部吸嘴的真空吸 //打开全部吸嘴的真空吸
VacManager.TransitNozzleVacSuction(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); VacManager.TransitNozzleVacSuction(EVacOperator.Open,true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles()) foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles())
{ {
//nozzle.OpenVac(); //nozzle.OpenVac();
@ -675,8 +708,8 @@ namespace Rs.MotionPlat.Flow
{ {
//粘料报警 //粘料报警
alarmInfo = $"周转吸头{masticSlots.ToJoinString()}号吸嘴真空异常粘料，请手工处理"; alarmInfo = $"周转吸头{masticSlots.ToJoinString()}号吸嘴真空异常粘料，请手工处理";
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText()); //TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm);
switch (msgBox.Button) switch (msgBox.Button)
{ {
case ETipButton.Skip: case ETipButton.Skip:
@ -729,8 +762,8 @@ namespace Rs.MotionPlat.Flow
{ {
alarmInfo = $"测试治具{nozzle.NozzleIndex}号穴位光纤异常，有可能叠料，请处理"; alarmInfo = $"测试治具{nozzle.NozzleIndex}号穴位光纤异常，有可能叠料，请处理";
MessageQueue.Instance.Warn(GetClassName() + alarmInfo); MessageQueue.Instance.Warn(GetClassName() + alarmInfo);
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText()); //TestCenterMessageBox.Show(AlarmConstID.TextFixtureFiberAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm); msgBox = MsgBox.ShowDialog(AlarmConstID.TextFixtureFiberAlarm, alarmInfo, MessageButtonManager.GetRetry_Skip_MoveToSafe_Button(), MessageButtonManager.GetRetry_Skip_MoveToSafe_ButtonText());// TestCenterMessageBox.WaitResult(AlarmConstID.TextFixtureFiberAlarm);
switch (msgBox.Button) switch (msgBox.Button)
{ {
case ETipButton.Retry: case ETipButton.Retry:
@ -1197,7 +1230,7 @@ namespace Rs.MotionPlat.Flow
undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal); undealTasks = LoadAndUnloadTask.Instance.GetTestToTurnoverTasks(ETaskDealStatus.Undeal);
int[] indexes = undealTasks.Select(t => t.FromIndex + 1).ToArray(); int[] indexes = undealTasks.Select(t => t.FromIndex + 1).ToArray();
/*打开周转吸头真空吸*/ /*打开周转吸头真空吸*/
VacManager.TransitNozzleVacSuction(EVacOperator.Open, indexes); VacManager.TransitNozzleVacSuction(EVacOperator.Open, true, indexes);
/*关闭测试穴位真空吸*/ /*关闭测试穴位真空吸*/
VacManager.TestTrayVacSuction(EVacOperator.Close, indexes); VacManager.TestTrayVacSuction(EVacOperator.Close, indexes);
/*打开测试穴位真空破*/ /*打开测试穴位真空破*/
@ -1481,9 +1514,9 @@ namespace Rs.MotionPlat.Flow
/*打开周转盘真空吸*/ /*打开周转盘真空吸*/
VacManager.TurnoverTrayVacSuction(EVacOperator.Open, true, hasProductNozzles.Select(n => n.ToIndex+1).ToArray()); VacManager.TurnoverTrayVacSuction(EVacOperator.Open, true, hasProductNozzles.Select(n => n.ToIndex+1).ToArray());
/*关闭周转吸头真空吸*/ /*关闭周转吸头真空吸*/
VacManager.TransitNozzleVacSuction( EVacOperator.Close,hasProductNozzles.Select(n=>n.FromIndex + 1).ToArray()); VacManager.TransitNozzleVacSuction( EVacOperator.Close,true,hasProductNozzles.Select(n=>n.FromIndex + 1).ToArray());
/*打开周转吸头真空破*/ /*打开周转吸头真空破*/
VacManager.TransitNozzleVacBreak(EVacOperator.Open, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray()); VacManager.TransitNozzleVacBreak(EVacOperator.Open, true, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray());
Step = ETurnoverFlowStep.周转盘放料完成抬起1; Step = ETurnoverFlowStep.周转盘放料完成抬起1;
} }
break; break;
@ -1511,7 +1544,7 @@ namespace Rs.MotionPlat.Flow
{ {
hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
/*关闭周转吸头真空破*/ /*关闭周转吸头真空破*/
VacManager.TransitNozzleVacBreak(EVacOperator.Close, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray()); VacManager.TransitNozzleVacBreak(EVacOperator.Close, true, hasProductNozzles.Select(n => n.FromIndex + 1).ToArray());
logInfo = GetClassName() + $"周转盘放料完成已抬起1"; logInfo = GetClassName() + $"周转盘放料完成已抬起1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.周转盘放料完成抬起2; Step = ETurnoverFlowStep.周转盘放料完成抬起2;
@ -1547,7 +1580,7 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.周转盘放料完成粘料检测: case ETurnoverFlowStep.周转盘放料完成粘料检测:
masticSlots.Clear(); masticSlots.Clear();
hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles(); hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
VacManager.TransitNozzleVacSuction(EVacOperator.Open, hasProductNozzles.Select(n => n.NozzleIndex).ToArray()); VacManager.TransitNozzleVacSuction(EVacOperator.Open, true, hasProductNozzles.Select(n => n.NozzleIndex).ToArray());
foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles()) foreach (var nozzle in TransitNozzleManager.Instance.GetHasProductNozzles())
{ {
//nozzle.OpenVac(); //nozzle.OpenVac();

6
Rs.SkyLine/Flow/SubFlow/WarningSuckerNgFlow.cs
Unescape Escape View File

@ -184,7 +184,7 @@ namespace Rs.MotionPlat.Flow.NgFlow
//关闭周转盘真空吸 //关闭周转盘真空吸
VacManager.TurnoverTrayVacSuction(EVacOperator.Close, true, exceptionSlotIndex); VacManager.TurnoverTrayVacSuction(EVacOperator.Close, true, exceptionSlotIndex);
//打开周转盘这空破 //打开周转盘这空破
VacManager.TurnoverTrayVacBreak(EVacOperator.Open, exceptionSlotIndex); VacManager.TurnoverTrayVacBreak(EVacOperator.Open, true,exceptionSlotIndex);
step = EWarningSuckerNgFlowStep.取料完成到安全位; step = EWarningSuckerNgFlowStep.取料完成到安全位;
} }
else else
@ -220,7 +220,7 @@ namespace Rs.MotionPlat.Flow.NgFlow
logInfo = GetClassName() + "已运动到异常处理位安全位"; logInfo = GetClassName() + "已运动到异常处理位安全位";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
//关闭周转盘真空破 //关闭周转盘真空破
VacManager.TurnoverTrayVacBreak(EVacOperator.Close, exceptionSlotIndex); VacManager.TurnoverTrayVacBreak(EVacOperator.Close,true, exceptionSlotIndex);
step = EWarningSuckerNgFlowStep.镭射头检测; step = EWarningSuckerNgFlowStep.镭射头检测;
} }
else else
@ -262,7 +262,7 @@ namespace Rs.MotionPlat.Flow.NgFlow
{ {
TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.Socket); TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.Socket);
alarmInfo = $"{exceptionTray}盘{exceptionSlotIndex}穴位产品未取出，请人工处理"; alarmInfo = $"{exceptionTray}盘{exceptionSlotIndex}穴位产品未取出，请人工处理";
msgBox = MsgBox.ShowDialog(AlarmConstID.TurnoverTakeFailAlarm, alarmInfo, ETipButton.Ok); msgBox = MsgBox.ShowDialog(AlarmConstID.LaserCheckFailAlarm, alarmInfo, ETipButton.Ok);
step = EWarningSuckerNgFlowStep.手动处理后镭射头检测; step = EWarningSuckerNgFlowStep.手动处理后镭射头检测;
} }
else else

2
Rs.SkyLine/Program.cs
Unescape Escape View File

@ -5,6 +5,7 @@ using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Flow; using Rs.MotionPlat.Flow;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
@ -24,7 +25,6 @@ namespace Rs.MotionPlat
Application.EnableVisualStyles(); Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false); Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new FormIO2()); //Application.Run(new FormIO2());
Application.Run(new Home()); Application.Run(new Home());
} }
} }

1
Rs.SkyLine/Rs.SkyLine.csproj
Unescape Escape View File

@ -132,6 +132,7 @@
<Compile Include="Commom\RearrangeManager.cs" /> <Compile Include="Commom\RearrangeManager.cs" />
<Compile Include="Commom\Scheduling.cs" /> <Compile Include="Commom\Scheduling.cs" />
<Compile Include="Commom\SlotPoint.cs" /> <Compile Include="Commom\SlotPoint.cs" />
<Compile Include="Commom\SourceHelper.cs" />
<Compile Include="Commom\TestCenterMessageBox.cs" /> <Compile Include="Commom\TestCenterMessageBox.cs" />
<Compile Include="Commom\VirtualBarCode.cs" /> <Compile Include="Commom\VirtualBarCode.cs" />
<Compile Include="Entitys\TransitNozzleManager.cs" /> <Compile Include="Entitys\TransitNozzleManager.cs" />

Write Preview
Loading…
Cancel
Save