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

优化上料逻辑，当周转吸头从周转盘取料到安全位后，通知中控可以排料

Browse Source
master
lhiven 2 years ago
parent 37d0d12ca2
commit bfe88bf480
7 changed files with 270 additions and 159 deletions
Show Stats Download Patch File Download Diff File

1
Rs.SkyLine/Commom/Ops.cs
Unescape Escape View File

@ -121,6 +121,7 @@ namespace Rs.MotionPlat.Commom
Ops.Off("下左相机光源触发"); Ops.Off("下左相机光源触发");
Ops.Off("下右相机光源触发"); Ops.Off("下右相机光源触发");
Ops.Off("上相机光源触发"); Ops.Off("上相机光源触发");
Ops.Off("夹爪气缸电磁阀");
} }
NozzleManager.Init(); NozzleManager.Init();
TrayPointManager.LoadPoint(); TrayPointManager.LoadPoint();

15
Rs.SkyLine/Commom/Scheduling.cs
Unescape Escape View File

@ -684,7 +684,11 @@ namespace Rs.MotionPlat.Commom
/// <summary> /// <summary>
/// 气压(double) /// 气压(double)
/// </summary> /// </summary>
AirPressure AirPressure,
/// <summary>
/// 测试机状态
/// </summary>
TesterState,
} }
} }
@ -1014,6 +1018,15 @@ namespace Rs.MotionPlat.Commom
NoDevice NoDevice
} }
/// <summary>
/// 测试机状态, <see cref="ETesterState"/>
/// </summary>
public enum ETesterState
{
NotReady,
Ready
}
/// <summary> /// <summary>
/// 设备按钮 /// 设备按钮
/// </summary> /// </summary>

9
Rs.SkyLine/Flow/LoadAndUnloadTask.cs
Unescape Escape View File

@ -234,22 +234,29 @@ namespace Rs.MotionPlat.Flow
/// <summary> /// <summary>
/// 清除任务 /// 清除任务
/// 任务类型，0=排料任务，1=测试任务
/// </summary> /// </summary>
public void Clear() public void Clear(int taskMode=0)
{ {
lock(this) lock(this)
{ {
if (turnoverResult != null) if (turnoverResult != null)
{
if (taskMode == 0)
{ {
turnoverResult.Clear(); turnoverResult.Clear();
loadTaskList.Clear(); loadTaskList.Clear();
unloadTaskList.Clear(); unloadTaskList.Clear();
changeTaskList.Clear(); changeTaskList.Clear();
}
else if(taskMode==1)
{
testLoadTaskList.Clear(); testLoadTaskList.Clear();
testUnloadTaskList.Clear(); testUnloadTaskList.Clear();
} }
} }
} }
}
/// <summary> /// <summary>
/// 向上下料任务中，添加任务 /// 向上下料任务中，添加任务

14
Rs.SkyLine/Flow/MachineManage.cs
Unescape Escape View File

@ -86,6 +86,11 @@ namespace Rs.MotionPlat.Flow
/// </summary> /// </summary>
public EInitializeState InitializeState { get; set; } = EInitializeState.Uninitialized; public EInitializeState InitializeState { get; set; } = EInitializeState.Uninitialized;
/// <summary>
/// 测试机状态
/// </summary>
private ETesterState testerState = ETesterState.NotReady;
/// <summary> /// <summary>
/// 物料分配模式(正常或空跑) /// 物料分配模式(正常或空跑)
/// </summary> /// </summary>
@ -102,6 +107,15 @@ namespace Rs.MotionPlat.Flow
RunStatus= status; RunStatus= status;
} }
public void SetTesterState(ETesterState _testerState)
{
testerState= _testerState;
}
public ETesterState GetTesterState() {
return testerState;
}
/// <summary> /// <summary>
/// 获取中控运行状态 /// 获取中控运行状态
/// </summary> /// </summary>

4
Rs.SkyLine/Flow/TestCenter.cs
Unescape Escape View File

@ -142,8 +142,8 @@ namespace Rs.MotionPlat.Flow
case SchedulingStatusInfo.InfoType.AssignMode: case SchedulingStatusInfo.InfoType.AssignMode:
statusInto.Info = EAssignMode.Normal.ToString(); statusInto.Info = EAssignMode.Normal.ToString();
break; break;
case SchedulingStatusInfo.InfoType.Temperature: case SchedulingStatusInfo.InfoType.TesterState:
statusInto.Info = "22"; statusInto.Info = MachineManage.Instance.GetTesterState().ToString();
break; break;
default: default:
break; break;

303
Rs.SkyLine/Flow/TurnoverFlow.cs
Unescape Escape View File

@ -18,7 +18,7 @@ namespace Rs.MotionPlat.Flow
enum ETurnoverFlowStep enum ETurnoverFlowStep
{ {
等待命令, 等待任务,
到周转盘取料位上方, 到周转盘取料位上方,
等待运动到周转盘取料位上方, 等待运动到周转盘取料位上方,
到周转盘下方取料位1, 到周转盘下方取料位1,
@ -68,8 +68,10 @@ namespace Rs.MotionPlat.Flow
到周转盘放料位下方2, 到周转盘放料位下方2,
等待到周转盘放料位下方2, 等待到周转盘放料位下方2,
周转盘放料完成后真空检测, 周转盘放料完成后真空检测,
周转盘放料完成抬起, 周转盘放料完成抬起1,
等待周转盘放料完成抬起, 等待周转盘放料完成抬起1,
周转盘放料完成抬起2,
等待周转盘放料完成抬起2,
到安全位, 到安全位,
等待到安全位, 等待到安全位,
@ -125,24 +127,46 @@ namespace Rs.MotionPlat.Flow
string logInfo = ""; string logInfo = "";
List<int> slots = new List<int>(); List<int> slots = new List<int>();
List<int> ngList = new List<int>(); List<int> ngList = new List<int>();
ETurnoverFlowStep Step = ETurnoverFlowStep.等待命令; ETurnoverFlowStep Step = ETurnoverFlowStep.等待任务;
double targetPos = 0.0; double targetPos = 0.0;
Motion.ErrorCode errCode = Motion.ErrorCode.Ok; Motion.ErrorCode errCode = Motion.ErrorCode.Ok;
public override void Run() public override void Run()
{ {
switch (Step) switch (Step)
{ {
case ETurnoverFlowStep.等待命令: case ETurnoverFlowStep.等待任务:
if(pressLoad)//测试位上料 if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestLoad) > 0)
{ {
pressLoad = false; slots.Clear();
foreach (var slot in LoadAndUnloadTask.Instance.GetTestLoadTasks())
{
slots.Add(slot.FromIndex + 1);
}
logInfo = $"接收到测试工位上料任务";
MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.到周转盘取料位上方; Step = ETurnoverFlowStep.到周转盘取料位上方;
} }
if(pressUnload)//测试位下料 else if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestUnload) > 0)
{
slots.Clear();
foreach (var slot in LoadAndUnloadTask.Instance.GetTestUnLoadTasks())
{ {
pressUnload = false; slots.Add(slot.FromIndex + 1);
}
logInfo = $"接收到测试工位下料任务";
MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.测试完成抬起到高速位; Step = ETurnoverFlowStep.测试完成抬起到高速位;
} }
//if (pressLoad)//测试位上料
//{
// pressLoad = false;
// Step = ETurnoverFlowStep.到周转盘取料位上方;
//}
//if(pressUnload)//测试位下料
//{
// pressUnload = false;
// Step = ETurnoverFlowStep.测试完成抬起到高速位;
//}
break; break;
case ETurnoverFlowStep.到周转盘取料位上方: case ETurnoverFlowStep.到周转盘取料位上方:
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeY"); targetPos = SysConfigParam.GetValue<double>("TurnoverTakeY");
@ -179,9 +203,8 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"到周转盘下方取料位"; logInfo = $"到周转盘下方取料位1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待运动到周转盘下方取料位1; Step = ETurnoverFlowStep.等待运动到周转盘下方取料位1;
} }
else else
@ -192,7 +215,8 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待运动到周转盘下方取料位1: case ETurnoverFlowStep.等待运动到周转盘下方取料位1:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已运动到周转盘下方取料位 at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; logInfo = $"已运动到周转盘下方取料位1 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}";
MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.到周转盘下方取料位2; Step = ETurnoverFlowStep.到周转盘下方取料位2;
} }
break; break;
@ -205,9 +229,8 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"到周转盘下方取料位"; logInfo = $"到周转盘下方取料位2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待运动到周转盘下方取料位2; Step = ETurnoverFlowStep.等待运动到周转盘下方取料位2;
} }
else else
@ -218,28 +241,30 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待运动到周转盘下方取料位2: case ETurnoverFlowStep.等待运动到周转盘下方取料位2:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已运动到周转盘下方取料位 at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; logInfo = $"已运动到周转盘下方取料位2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*打开周转吸头真空吸*/
//打开真空吸
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"周转{slot}号吸嘴真空吸"); Ops.On($"周转{slot}号吸嘴真空吸");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacSuctionDelaytime);
MessageQueue.Instance.Insert($"打开周转吸头{string.Join(",",slots)}号真空吸");
/*关闭周转盘真空吸*/
//关闭周转盘真空吸
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.Off($"周转盘{slot}号穴位真空吸"); Ops.Off($"周转盘{slot}号穴位真空吸");
} }
Thread.Sleep(GlobalVar.TurnoverTrayCloseVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverTrayCloseVacSuctionDelaytime);
//打开周转盘真空破 MessageQueue.Instance.Insert($"关闭周转盘{string.Join(",", slots)}号穴位真空吸");
/*打开周转盘真空破*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"周转盘{slot}号穴位真空破"); Ops.On($"周转盘{slot}号穴位真空破");
} }
Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime); Thread.Sleep(GlobalVar.TurnoverTrayOpenVacBreakDelaytime);
MessageQueue.Instance.Insert($"打开周转盘{string.Join(",", slots)}号穴位真空破");
Step = ETurnoverFlowStep.到周转盘取料破真空位; Step = ETurnoverFlowStep.到周转盘取料破真空位;
} }
break; break;
@ -254,7 +279,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到周转盘取料破真空位"; logInfo = $"到周转盘取料破真空位";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到周转盘取料破真空位; Step = ETurnoverFlowStep.等待到周转盘取料破真空位;
} }
else else
@ -267,13 +291,13 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已到周转盘取料破真空位"; logInfo = $"已到周转盘取料破真空位";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*关闭周转盘真空破*/
//关闭周转盘真空破
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.Off($"周转盘{slot}号穴位真空破"); Ops.Off($"周转盘{slot}号穴位真空破");
} }
Thread.Sleep(GlobalVar.TurnoverTrayCloseVacBreakDelaytime); Thread.Sleep(GlobalVar.TurnoverTrayCloseVacBreakDelaytime);
MessageQueue.Instance.Insert($"关闭周转盘{string.Join(",",slots)}号穴位真空破");
Step = ETurnoverFlowStep.周转盘取料完成抬起; Step = ETurnoverFlowStep.周转盘取料完成抬起;
} }
break; break;
@ -288,7 +312,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"周转盘取料完成抬起"; logInfo = $"周转盘取料完成抬起";
MessageQueue.Instance.Insert (logInfo); MessageQueue.Instance.Insert (logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待周转盘取料完成抬起; Step = ETurnoverFlowStep.等待周转盘取料完成抬起;
} }
else else
@ -299,9 +322,8 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待周转盘取料完成抬起: case ETurnoverFlowStep.等待周转盘取料完成抬起:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已周转盘取料完成抬起"; logInfo = $"已到周转盘取料完成抬起";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.周转盘取料完成真空检测; Step = ETurnoverFlowStep.周转盘取料完成真空检测;
} }
break; break;
@ -309,20 +331,26 @@ namespace Rs.MotionPlat.Flow
ngList = CheckNozzleVac(); ngList = CheckNozzleVac();
if(ngList.Count==0||GlobalVar.RunSpace || GlobalVar.VirtualAxis) if(ngList.Count==0||GlobalVar.RunSpace || GlobalVar.VirtualAxis)
{ {
logInfo = $"真空检测OK"; logInfo = $"周转吸头{string.Join(",",slots)}号真空检测OK";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到测试放料位上方; Step = ETurnoverFlowStep.到测试放料位上方;
} }
else else
{ {
string msg = string.Join(",", ngList.ToArray()); string msg = $"周转吸头{string.Join(",", ngList.ToArray())}号真空异常";
logInfo = $"周转吸嘴 {msg} 真空值未达到"; MessageQueue.Instance.Warn(msg);
MessageQueue.Instance.Insert(logInfo); TestCenterMessageBox.Show(AlarmConstID.TurnoverTakeFailAlarm, msg, SchedulingMessageBox.ETipButton.Retry | SchedulingMessageBox.ETipButton.Cancel);
LogHelper.Debug(logInfo); SchedulingMessageBox msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverTakeFailAlarm);
Msg.ShowError($"周转吸嘴 {msg} 真空值未达到，请处理后点击确定"); //Msg.ShowError($"周转吸嘴 {msg} 真空值未达到，请处理后点击确定");
if(msgBox.Button== SchedulingMessageBox.ETipButton.Retry)
{
Step = ETurnoverFlowStep.到周转盘取料位上方;
}
else if(msgBox.Button== SchedulingMessageBox.ETipButton.Cancel)
{
Step = ETurnoverFlowStep.到测试放料位上方; Step = ETurnoverFlowStep.到测试放料位上方;
} }
}
break; break;
case ETurnoverFlowStep.到测试放料位上方: case ETurnoverFlowStep.到测试放料位上方:
targetPos = SysConfigParam.GetValue<double>("PressDumpY"); targetPos = SysConfigParam.GetValue<double>("PressDumpY");
@ -335,7 +363,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到测试放料位上方"; logInfo = $"到测试放料位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待运动到测试放料位上方; Step = ETurnoverFlowStep.等待运动到测试放料位上方;
} }
else else
@ -346,9 +373,19 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待运动到测试放料位上方: case ETurnoverFlowStep.等待运动到测试放料位上方:
if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverY) || GlobalVar.VirtualAxis)
{ {
List<TurnoverInfo> testLoadList = LoadAndUnloadTask.Instance.GetTestLoadTasks();
TestCenter.Instance.LoadTestLoadResult();
//切换穴位状态
foreach (TurnoverInfo turnoverInfo in testLoadList)
{
GlobalTray.TurnoverTray.ChangeStatus(turnoverInfo.FromIndex + 1, ESlotStatus.NotHave);
}
LoadAndUnloadTask.Instance.Clear(1);
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
MessageQueue.Instance.Insert("通知中控周转载盘产品已取走,可以继续排料");
logInfo = $"已运动到测试放料位上方"; logInfo = $"已运动到测试放料位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到测试放料位下方1; Step = ETurnoverFlowStep.到测试放料位下方1;
} }
break; break;
@ -361,9 +398,8 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"到测试放料位下方"; logInfo = $"到测试放料位下方1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待运动到到测试放料位下方1; Step = ETurnoverFlowStep.等待运动到到测试放料位下方1;
} }
else else
@ -374,9 +410,8 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待运动到到测试放料位下方1: case ETurnoverFlowStep.等待运动到到测试放料位下方1:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已运动到到测试放料位下方 at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; logInfo = $"已运动到到测试放料位下方1 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到测试放料位下方2; Step = ETurnoverFlowStep.到测试放料位下方2;
} }
break; break;
@ -389,7 +424,7 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"到测试放料位下方"; logInfo = $"到测试放料位下方2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待运动到到测试放料位下方2; Step = ETurnoverFlowStep.等待运动到到测试放料位下方2;
@ -402,23 +437,30 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待运动到到测试放料位下方2: case ETurnoverFlowStep.等待运动到到测试放料位下方2:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已运动到到测试放料位下方 at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}"; logInfo = $"已运动到到测试放料位下方2 TurnoverZ at:{Ops.GetCurPosition(AxisAlias.TurnoverZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*打开测试穴位真空吸*/
OpenPressVac(); OpenPressVac();
Thread.Sleep(GlobalVar.PressOpenVacSuctionDelaytime); Thread.Sleep(GlobalVar.PressOpenVacSuctionDelaytime);
MessageQueue.Instance.Insert($"打开测试{string.Join(",",slots)}号穴位真空吸");
/*关闭周转吸头真空吸*/
CloseNozzleVac(); CloseNozzleVac();
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacSuctionDelaytime);
MessageQueue.Instance.Insert($"关闭周转吸头{string.Join(",", slots)}号真空吸");
/*打开周转吸头真空破*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"周转{slot}号吸嘴真空破"); Ops.On($"周转{slot}号吸嘴真空破");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacBreakDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacBreakDelaytime);
MessageQueue.Instance.Insert($"打开周转吸头{string.Join(",", slots)}号真空破");
/*关闭周转吸头真空破*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.Off($"周转{slot}号吸嘴真空破"); Ops.Off($"周转{slot}号吸嘴真空破");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacBreakDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacBreakDelaytime);
MessageQueue.Instance.Insert($"关闭周转吸头{string.Join(",", slots)}号真空破");
Step = ETurnoverFlowStep.测试位放料完成抬起; Step = ETurnoverFlowStep.测试位放料完成抬起;
} }
break; break;
@ -433,7 +475,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"测试位放料完成抬起"; logInfo = $"测试位放料完成抬起";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待测试位放料完成抬起; Step = ETurnoverFlowStep.等待测试位放料完成抬起;
} }
else else
@ -446,7 +487,6 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"测试位放料完成抬起完成"; logInfo = $"测试位放料完成抬起完成";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
if(GlobalVar.RunSpace) if(GlobalVar.RunSpace)
{ {
Step = ETurnoverFlowStep.到测试保压位上方; Step = ETurnoverFlowStep.到测试保压位上方;
@ -465,14 +505,17 @@ namespace Rs.MotionPlat.Flow
} }
else else
{ {
string msg = string.Join(",", ngList.ToArray()); //string msg = string.Join(",", ngList.ToArray());
logInfo = $"测试穴位 {msg} 真空异常"; logInfo = $"测试 {string.Join(",", ngList.ToArray())} 号穴位放料真空异常,请手动处理完成后点击确定";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Warn(logInfo);
LogHelper.Debug(logInfo); TestCenterMessageBox.Show(AlarmConstID.TestDumpFailAlarm, logInfo, SchedulingMessageBox.ETipButton.Ok);
LogHelper.Debug(logInfo); SchedulingMessageBox msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TestDumpFailAlarm);
Msg.ShowError($"测试穴位 {msg} 真空异常，请处理后点击确定"); if(msgBox.Button== SchedulingMessageBox.ETipButton.Ok)
{
Step = ETurnoverFlowStep.到测试保压位上方; Step = ETurnoverFlowStep.到测试保压位上方;
} }
//Msg.ShowError($"测试穴位 {msg} 真空异常，请处理后点击确定");
}
break; break;
case ETurnoverFlowStep.到测试保压位上方: case ETurnoverFlowStep.到测试保压位上方:
targetPos = SysConfigParam.GetValue<double>("PressY"); targetPos = SysConfigParam.GetValue<double>("PressY");
@ -485,7 +528,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到测试保压位上方"; logInfo = $"到测试保压位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到测试保压位上方; Step = ETurnoverFlowStep.等待到测试保压位上方;
} }
else else
@ -498,7 +540,6 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到测试保压位上方"; logInfo = $"已运动到测试保压位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到测试保压位下方1; Step = ETurnoverFlowStep.到测试保压位下方1;
} }
break; break;
@ -514,8 +555,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到测试保压位下方1"; logInfo = $"到测试保压位下方1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到测试保压位下方1; Step = ETurnoverFlowStep.等待到测试保压位下方1;
} }
else else
@ -528,11 +567,6 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已到测试保压位下方1 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; logInfo = $"已到测试保压位下方1 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
//ClosePressVac();
//Thread.Sleep(GlobalVar.PresseCloseVacSuctionDelaytime);
//loadOk = true;
Step = ETurnoverFlowStep.到测试保压位下方2; Step = ETurnoverFlowStep.到测试保压位下方2;
} }
break; break;
@ -548,8 +582,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到测试保压位下方2"; logInfo = $"到测试保压位下方2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到测试保压位下方2; Step = ETurnoverFlowStep.等待到测试保压位下方2;
} }
else else
@ -562,16 +594,18 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已到测试保压位下方2 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; logInfo = $"已到测试保压位下方2 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*关闭测试穴位真空吸*/
ClosePressVac(); ClosePressVac();
Thread.Sleep(GlobalVar.PresseCloseVacSuctionDelaytime); Thread.Sleep(GlobalVar.PresseCloseVacSuctionDelaytime);
MessageQueue.Instance.Insert($"关闭测试{string.Join(",",slots)}号穴位真空吸");
loadOk = true; loadOk = true;
Step = ETurnoverFlowStep.等待命令; MachineManage.Instance.SetTesterState(ETesterState.Ready);
MessageQueue.Instance.Insert("通知中控测试位就绪，可以开始测试");
Step = ETurnoverFlowStep.等待任务;
} }
break; break;
//-----------------------------------------------测试位下料 //-----------------------------------------------测试位下料---------------------------------------------------------------------------------------------------------
case ETurnoverFlowStep.测试完成抬起到高速位: case ETurnoverFlowStep.测试完成抬起到高速位:
targetPos = SysConfigParam.GetValue<double>("PressZ")+GlobalVar.PressLowSpeedOffset; targetPos = SysConfigParam.GetValue<double>("PressZ")+GlobalVar.PressLowSpeedOffset;
double curPos = Ops.GetCurPosition(AxisAlias.PressZ); double curPos = Ops.GetCurPosition(AxisAlias.PressZ);
@ -590,7 +624,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = "测试完成准备抬起"; logInfo = "测试完成准备抬起";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待测试完成抬起到高速位; Step = ETurnoverFlowStep.等待测试完成抬起到高速位;
} }
} }
@ -600,13 +633,11 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"测试完成已抬起 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}"; logInfo = $"测试完成已抬起 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.测试完成抬起安全位; Step = ETurnoverFlowStep.测试完成抬起安全位;
} }
break; break;
case ETurnoverFlowStep.测试完成抬起安全位: case ETurnoverFlowStep.测试完成抬起安全位:
targetPos = SysConfigParam.GetValue<double>("PressSafeZ"); targetPos = SysConfigParam.GetValue<double>("PressSafeZ");
errCode = AxisControl.PressZ.MovePos(targetPos, GlobalVar.WholeSpeed); errCode = AxisControl.PressZ.MovePos(targetPos, GlobalVar.WholeSpeed);
if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {
@ -614,19 +645,16 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = "测试完成准备抬起"; logInfo = "测试完成抬起安全位";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待测试完成抬起安全位; Step = ETurnoverFlowStep.等待测试完成抬起安全位;
} }
break; break;
case ETurnoverFlowStep.等待测试完成抬起安全位: case ETurnoverFlowStep.等待测试完成抬起安全位:
if (Ops.IsStop(AxisControl.PressZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.PressZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"测试完成已抬起到安全位 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}";
logInfo = $"测试完成已抬起 PressZ at:{Ops.GetCurPosition(AxisAlias.PressZ)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到测试取料位上方; Step = ETurnoverFlowStep.到测试取料位上方;
} }
break; break;
@ -641,8 +669,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到测试取料位上方"; logInfo = $"到测试取料位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
MessageQueue.Instance.Insert($"goto press take product up position");
Step = ETurnoverFlowStep.等待到测试取料位上方; Step = ETurnoverFlowStep.等待到测试取料位上方;
} }
break; break;
@ -651,7 +677,6 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到测试取料位上方 TurnoverY at:{Ops.GetCurPosition(AxisAlias.TurnoverY)}"; logInfo = $"已运动到测试取料位上方 TurnoverY at:{Ops.GetCurPosition(AxisAlias.TurnoverY)}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到测试取料位下方1; Step = ETurnoverFlowStep.到测试取料位下方1;
} }
break; break;
@ -664,9 +689,8 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"到测试取料位下方"; logInfo = $"到测试取料位下方1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到测试取料位下方1; Step = ETurnoverFlowStep.等待到测试取料位下方1;
} }
break; break;
@ -674,6 +698,8 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待到测试取料位下方1: case ETurnoverFlowStep.等待到测试取料位下方1:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已运动到到测试取料位下方1";
MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.到测试取料位下方2; Step = ETurnoverFlowStep.到测试取料位下方2;
} }
break; break;
@ -686,9 +712,8 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"到测试取料位下方"; logInfo = $"到测试取料位下方2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到测试取料位下方2; Step = ETurnoverFlowStep.等待到测试取料位下方2;
} }
break; break;
@ -696,33 +721,33 @@ namespace Rs.MotionPlat.Flow
case ETurnoverFlowStep.等待到测试取料位下方2: case ETurnoverFlowStep.等待到测试取料位下方2:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"已运动到测试取料位下方 TurnoverZ at:{Ops.GetCurPosition("TurnoverZ")}"; logInfo = $"已运动到测试取料位下方2 TurnoverZ at:{Ops.GetCurPosition("TurnoverZ")}";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*打开周转吸头真空吸*/
//打开吸嘴真空吸
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"周转{slot}号吸嘴真空吸"); Ops.On($"周转{slot}号吸嘴真空吸");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacSuctionDelaytime);
MessageQueue.Instance.Insert($"打开周转{string.Join(",",slots)}号吸头真空吸");
/*打开测试穴位真空破*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"测试{slot}号穴位真空破"); Ops.On($"测试{slot}号穴位真空破");
} }
Thread.Sleep(GlobalVar.PresseOpenVacBreakDelaytime); Thread.Sleep(GlobalVar.PresseOpenVacBreakDelaytime);
MessageQueue.Instance.Insert($"打开测试{string.Join(",", slots)}号穴位真空破");
Step = ETurnoverFlowStep.到测试破真空位; Step = ETurnoverFlowStep.到测试破真空位;
} }
break; break;
case ETurnoverFlowStep.到测试破真空位: case ETurnoverFlowStep.到测试破真空位:
logInfo = $"到测试破真空位";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
targetPos = SysConfigParam.GetValue<double>("PressTakeZ")+GlobalVar.PressLowSpeedOffset; targetPos = SysConfigParam.GetValue<double>("PressTakeZ")+GlobalVar.PressLowSpeedOffset;
errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.PressLowSpeed); errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.PressLowSpeed);
if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {
logInfo = $"到测试破真空位";
MessageQueue.Instance.Insert(logInfo);
if (GlobalVar.VirtualAxis) if (GlobalVar.VirtualAxis)
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
@ -735,12 +760,13 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到测试破真空位"; logInfo = $"已运动到测试破真空位";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*关闭测试穴位真空破*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.Off($"测试{slot}号穴位真空破"); Ops.Off($"测试{slot}号穴位真空破");
} }
Thread.Sleep(GlobalVar.PressCloseVacBreakDelaytime); Thread.Sleep(GlobalVar.PressCloseVacBreakDelaytime);
MessageQueue.Instance.Insert($"关闭测试{string.Join(",",slots)}号穴位真空破");
Step = ETurnoverFlowStep.测试位取料完成抬起; Step = ETurnoverFlowStep.测试位取料完成抬起;
} }
break; break;
@ -755,7 +781,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"测试位取料完成准备抬起"; logInfo = $"测试位取料完成准备抬起";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待测试位取料完成抬起; Step = ETurnoverFlowStep.等待测试位取料完成抬起;
} }
break; break;
@ -764,7 +789,6 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"测试位取料完成已抬起"; logInfo = $"测试位取料完成已抬起";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.测试位取料完成后真空检测; Step = ETurnoverFlowStep.测试位取料完成后真空检测;
} }
break; break;
@ -772,18 +796,27 @@ namespace Rs.MotionPlat.Flow
ngList = CheckNozzleVac(); ngList = CheckNozzleVac();
if (ngList.Count==0 || GlobalVar.RunSpace|| GlobalVar.VirtualAxis) if (ngList.Count==0 || GlobalVar.RunSpace|| GlobalVar.VirtualAxis)
{ {
MachineManage.Instance.SetTesterState( ETesterState.NotReady );
MessageQueue.Instance.Insert("通知中控产品已取走");
Step = ETurnoverFlowStep.到周转盘放料位上方; Step = ETurnoverFlowStep.到周转盘放料位上方;
} }
else else
{ {
string msg = string.Join(",", ngList.ToArray()); string msg = $"周转吸头{string.Join(",", ngList.ToArray())}号真空异常";
DialogResult dr = Msg.ShowError($"吸嘴{msg}真空值未达到，请处理", MessageBoxButtons.RetryCancel); MessageQueue.Instance.Warn(msg);
if(dr== DialogResult.Retry) TestCenterMessageBox.Show(AlarmConstID.TestTakeFailAlarm, msg, SchedulingMessageBox.ETipButton.Retry | SchedulingMessageBox.ETipButton.Cancel);
SchedulingMessageBox msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TestTakeFailAlarm);
//DialogResult dr = Msg.ShowError($"吸嘴{msg}真空值未达到，请处理", MessageBoxButtons.RetryCancel);
//if(dr== DialogResult.Retry)
if (msgBox.Button== SchedulingMessageBox.ETipButton.Retry)
{ {
Step = ETurnoverFlowStep.到测试取料位上方; Step = ETurnoverFlowStep.到测试取料位上方;
} }
else else if (msgBox.Button == SchedulingMessageBox.ETipButton.Cancel)
{ {
MessageQueue.Instance.Insert("通知中控产品已取走");
MachineManage.Instance.SetTesterState(ETesterState.NotReady);
Step = ETurnoverFlowStep.到周转盘放料位上方; Step = ETurnoverFlowStep.到周转盘放料位上方;
} }
@ -791,7 +824,6 @@ namespace Rs.MotionPlat.Flow
break; break;
case ETurnoverFlowStep.到周转盘放料位上方: case ETurnoverFlowStep.到周转盘放料位上方:
targetPos = SysConfigParam.GetValue<double>("TurnoverDumpY"); targetPos = SysConfigParam.GetValue<double>("TurnoverDumpY");
//targetPos = SysConfigParam.GetValue<double>("TurnoverTakeY");
errCode = AxisControl.TurnoverY.MovePos(targetPos, GlobalVar.WholeSpeed); errCode = AxisControl.TurnoverY.MovePos(targetPos, GlobalVar.WholeSpeed);
if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {
@ -801,7 +833,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到周转盘放料位上方"; logInfo = $"到周转盘放料位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到周转盘放料位上方; Step = ETurnoverFlowStep.等待到周转盘放料位上方;
} }
break; break;
@ -810,12 +841,10 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到周转盘放料位上方"; logInfo = $"已运动到周转盘放料位上方";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到周转盘放料位下方1; Step = ETurnoverFlowStep.到周转盘放料位下方1;
} }
break; break;
case ETurnoverFlowStep.到周转盘放料位下方1: case ETurnoverFlowStep.到周转盘放料位下方1:
//targetPos = SysConfigParam.GetValue<double>("TurnoverDumpZ");
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset; targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset;
errCode = AxisControl.TurnoverZ.MovePos(targetPos+1, GlobalVar.WholeSpeed); errCode = AxisControl.TurnoverZ.MovePos(targetPos+1, GlobalVar.WholeSpeed);
if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
@ -826,7 +855,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到周转盘放料位下方1"; logInfo = $"到周转盘放料位下方1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到周转盘放料位下方1; Step = ETurnoverFlowStep.等待到周转盘放料位下方1;
} }
break; break;
@ -835,15 +863,13 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到周转盘放料位下方1"; logInfo = $"已运动到周转盘放料位下方1";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.到周转盘放料位下方2; Step = ETurnoverFlowStep.到周转盘放料位下方2;
} }
break; break;
case ETurnoverFlowStep.到周转盘放料位下方2: case ETurnoverFlowStep.到周转盘放料位下方2:
//targetPos = SysConfigParam.GetValue<double>("TurnoverDumpZ");
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ"); targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ");
errCode = AxisControl.TurnoverZ.MovePos(targetPos + 1, GlobalVar.PressLowSpeed); errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.PressLowSpeed);
if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis) if (errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{ {
if (GlobalVar.VirtualAxis) if (GlobalVar.VirtualAxis)
@ -852,7 +878,6 @@ namespace Rs.MotionPlat.Flow
} }
logInfo = $"到周转盘放料位下方2"; logInfo = $"到周转盘放料位下方2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到周转盘放料位下方2; Step = ETurnoverFlowStep.等待到周转盘放料位下方2;
} }
break; break;
@ -861,35 +886,61 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到周转盘放料位下方2"; logInfo = $"已运动到周转盘放料位下方2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); /*打开周转盘真空吸*/
//打开周转盘真空吸
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"周转盘{slot + 8}号穴位真空吸"); Ops.On($"周转盘{slot + 8}号穴位真空吸");
} }
Thread.Sleep(GlobalVar.TurnoverTrayOpenVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverTrayOpenVacSuctionDelaytime);
//关闭吸嘴真空吸 MessageQueue.Instance.Insert($"打开周转盘{string.Join(",",slots)}号穴位真空吸");
/*关闭周转吸头真空吸*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.Off($"周转{slot}号吸嘴真空吸"); Ops.Off($"周转{slot}号吸嘴真空吸");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacSuctionDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacSuctionDelaytime);
//打开吸嘴真空破 MessageQueue.Instance.Insert($"关闭周转{string.Join(",", slots)}号吸头真空吸");
/*打开周转吸头真空破*/
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.On($"周转{slot}号吸嘴真空破"); Ops.On($"周转{slot}号吸嘴真空破");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacBreakDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleOpenVacBreakDelaytime);
MessageQueue.Instance.Insert($"打开周转{string.Join(",", slots)}号吸头真空破");
foreach (var slot in slots) foreach (var slot in slots)
{ {
Ops.Off($"周转{slot}号吸嘴真空破"); Ops.Off($"周转{slot}号吸嘴真空破");
} }
Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacBreakDelaytime); Thread.Sleep(GlobalVar.TurnoverNozzleCloseVacBreakDelaytime);
Step = ETurnoverFlowStep.周转盘放料完成抬起; Step = ETurnoverFlowStep.周转盘放料完成抬起1;
} }
break; break;
case ETurnoverFlowStep.周转盘放料完成抬起: case ETurnoverFlowStep.周转盘放料完成抬起1:
targetPos = SysConfigParam.GetValue<double>("TurnoverTakeZ") + GlobalVar.PressLowSpeedOffset;
errCode = AxisControl.TurnoverZ.MovePos(targetPos, GlobalVar.PressLowSpeed);
if(errCode == Motion.ErrorCode.Ok || GlobalVar.VirtualAxis)
{
if (GlobalVar.VirtualAxis)
{
Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
}
logInfo = $"周转盘放料完成准备抬起1";
MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.等待周转盘放料完成抬起1;
}
break;
case ETurnoverFlowStep.等待周转盘放料完成抬起1:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{
logInfo = $"周转盘放料完成已抬起";
MessageQueue.Instance.Insert(logInfo);
Step = ETurnoverFlowStep.周转盘放料完成抬起2;
}
break;
case ETurnoverFlowStep.周转盘放料完成抬起2:
targetPos = SysConfigParam.GetValue<double>("TurnoverSafeZ"); 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)
@ -898,18 +949,16 @@ namespace Rs.MotionPlat.Flow
{ {
Thread.Sleep(GlobalVar.VirtualAxisMoveTime); Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
} }
logInfo = $"周转盘放料完成准备抬起"; logInfo = $"周转盘放料完成准备抬起2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo); Step = ETurnoverFlowStep.等待周转盘放料完成抬起2;
Step = ETurnoverFlowStep.等待周转盘放料完成抬起;
} }
break; break;
case ETurnoverFlowStep.等待周转盘放料完成抬起: case ETurnoverFlowStep.等待周转盘放料完成抬起2:
if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis) if (Ops.IsStop(AxisControl.TurnoverZ) || GlobalVar.VirtualAxis)
{ {
logInfo = $"周转盘放料完成已抬起"; logInfo = $"周转盘放料完成已抬起2";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.周转盘放料完成后真空检测; Step = ETurnoverFlowStep.周转盘放料完成后真空检测;
} }
@ -935,9 +984,16 @@ namespace Rs.MotionPlat.Flow
} }
else else
{ {
string msg = string.Join(",", ngList); string msg = $"周转盘{string.Join(",", ngList)}号穴位真空异常";// string.Join(",", ngList);
Msg.ShowError($"周转穴位{msg}真空异常，请处理后点击确定"); MessageQueue.Instance.Insert(msg);
TestCenterMessageBox.Show(AlarmConstID.TurnoverDumpFailAlarm, msg, SchedulingMessageBox.ETipButton.Ok);
SchedulingMessageBox msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TurnoverDumpFailAlarm);
if(msgBox.Button== SchedulingMessageBox.ETipButton.Ok)
{
Step = ETurnoverFlowStep.到安全位; Step = ETurnoverFlowStep.到安全位;
}
//Msg.ShowError($"周转穴位{msg}真空异常，请处理后点击确定");
//判断周转盘是否有需要测试的穴位 //判断周转盘是否有需要测试的穴位
//List<TraySlot> haveSlots = GlobalTray.TurnoverTray.GetSlots(ESlotStatus.Have); //List<TraySlot> haveSlots = GlobalTray.TurnoverTray.GetSlots(ESlotStatus.Have);
//var loadList = haveSlots.Where(slot => ((slot.Index >= 1 && slot.Index <= 8) || (slot.Index >= 17 && slot.Index <= 24))); //var loadList = haveSlots.Where(slot => ((slot.Index >= 1 && slot.Index <= 8) || (slot.Index >= 17 && slot.Index <= 24)));
@ -957,9 +1013,8 @@ namespace Rs.MotionPlat.Flow
errCode = AxisControl.TurnoverY.MovePos(SysConfigParam.GetValue<double>("PressY"), GlobalVar.WholeSpeed); errCode = AxisControl.TurnoverY.MovePos(SysConfigParam.GetValue<double>("PressY"), GlobalVar.WholeSpeed);
if ((errCode == Motion.ErrorCode.Ok) || GlobalVar.VirtualAxis) if ((errCode == Motion.ErrorCode.Ok) || GlobalVar.VirtualAxis)
{ {
logInfo = $"到安全位"; logInfo = $"周转吸头下料完成到安全位";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Step = ETurnoverFlowStep.等待到安全位; Step = ETurnoverFlowStep.等待到安全位;
} }
else else
@ -972,9 +1027,17 @@ namespace Rs.MotionPlat.Flow
{ {
logInfo = $"已运动到安全位，任务结束"; logInfo = $"已运动到安全位，任务结束";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
unloadOk = true; unloadOk = true;
Step = ETurnoverFlowStep.等待命令; TestCenter.Instance.LoadTestUnLoadResult();
List<TurnoverInfo> testUnLoadList = LoadAndUnloadTask.Instance.GetTestUnLoadTasks();
//切换穴位状态
foreach (TurnoverInfo turnoverInfo in testUnLoadList)
{
GlobalTray.TurnoverTray.ChangeStatus(turnoverInfo.ToIndex + 1, ESlotStatus.Have);
}
LoadAndUnloadTask.Instance.Clear(1);
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
Step = ETurnoverFlowStep.等待任务;
} }
break; break;
} }

49
Rs.SkyLine/Flow/WorkFlow.cs
Unescape Escape View File

@ -1052,7 +1052,9 @@ namespace Rs.MotionPlat.Flow
GlobalTray.TurnoverTray.ChangeStatus(turnoverInfo.FromIndex+1, ESlotStatus.NotHave); GlobalTray.TurnoverTray.ChangeStatus(turnoverInfo.FromIndex+1, ESlotStatus.NotHave);
} }
LoadAndUnloadTask.Instance.Clear(); LoadAndUnloadTask.Instance.Clear();
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting); MachineManage.Instance.SetTesterState(ETesterState.Ready);
MessageQueue.Instance.Insert("通知中控测试位就绪，可以开始测试");
//MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
//for (int i = 1; i < 9; i++) //for (int i = 1; i < 9; i++)
//{ //{
@ -1189,30 +1191,41 @@ namespace Rs.MotionPlat.Flow
/// </summary> /// </summary>
private void WaitTask() private void WaitTask()
{ {
if (LoadAndUnloadTask.Instance.Count > 0 && WorkEnvironment.Instance.EnvironmentOk) //if (LoadAndUnloadTask.Instance.Count > 0 && WorkEnvironment.Instance.EnvironmentOk)
{ if (WorkEnvironment.Instance.EnvironmentOk)
if (LoadAndUnloadTask.Instance.CanRunTask())
{
if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestLoad) > 0)
{
logInfo = $"接收到测试工位上料任务";
MessageQueue.Instance.Insert(logInfo);
flowStep = EWorkFlowStep.测试工位上料;
}
else if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestUnload) > 0)
{ {
logInfo = $"接收到测试工位下料任务"; if(LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Load)>0
MessageQueue.Instance.Insert(logInfo); || LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Unload) > 0
flowStep = EWorkFlowStep.测试工位下料; || LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Change) > 0)
}
else
{ {
turnoverToTray = true; turnoverToTray = true;
logInfo = $"接收到排料任务"; logInfo = $"接收到排料任务";
MessageQueue.Instance.Insert(logInfo); MessageQueue.Instance.Insert(logInfo);
flowStep = EWorkFlowStep.到取料位上方; flowStep = EWorkFlowStep.到取料位上方;
} }
}
//if (LoadAndUnloadTask.Instance.CanRunTask())
//{
// if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestLoad) > 0)
// {
// logInfo = $"接收到测试工位上料任务";
// MessageQueue.Instance.Insert(logInfo);
// flowStep = EWorkFlowStep.测试工位上料;
// }
// else if (LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.TestUnload) > 0)
// {
// logInfo = $"接收到测试工位下料任务";
// MessageQueue.Instance.Insert(logInfo);
// flowStep = EWorkFlowStep.测试工位下料;
// }
// else
// {
// turnoverToTray = true;
// logInfo = $"接收到排料任务";
// MessageQueue.Instance.Insert(logInfo);
// flowStep = EWorkFlowStep.到取料位上方;
// }
//}
} }
} }

Write Preview
Loading…
Cancel
Save