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("夹爪气缸电磁阀");
}
NozzleManager.Init();
TrayPointManager.LoadPoint();

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

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

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

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

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

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

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

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

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

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

57
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);
}
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++)
//{
@ -1189,30 +1191,41 @@ namespace Rs.MotionPlat.Flow
/// </summary>
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.Load)>0
|| LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Unload) > 0
|| LoadAndUnloadTask.Instance.GetTaskNum(ETaskMode.Change) > 0)
{
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.到取料位上方;
}
turnoverToTray = true;
logInfo = $"接收到排料任务";
MessageQueue.Instance.Insert(logInfo);
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