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

增加重排功能

Browse Source
master
lhiven 1 year ago
parent 0b4868e0a0
commit e6533555f6
3 changed files with 488 additions and 460 deletions
Show Stats Download Patch File Download Diff File

37
Rs.SkyLine/Commom/RearrangeManager.cs
Unescape Escape View File

@ -1,4 +1,5 @@
using System;
using Rs.Controls;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
@ -11,30 +12,34 @@ namespace Rs.MotionPlat.Commom
/// </summary>
public static class RearrangeManager
{
public static List<TurnoverInfo> GeneralRearrangeTask(TurnoverType turnovertype,int slotNo,int floor)
public static List<TurnoverInfo> GeneralRearrangeTask(TurnoverType fromtray, TurnoverType totray, RsTray tray, TraySlot slot,int floor)
{
int needTakeNum = 0;
List<TurnoverInfo> task= new List<TurnoverInfo>();
//需要取几颗料
int lastRowCount = slotNo % 10;
if(lastRowCount> 5)
List<TurnoverInfo> task = new List<TurnoverInfo>();
//首先判断总列数是奇数还是偶数
if (tray.ColumnNum % 2 == 0)//偶数
{
needTakeNum = 10 - (slotNo % 10);
if (slot.Column+1 > tray.ColumnNum/2)
{
needTakeNum = tray.ColumnNum - slot.Column;
}
else
{
needTakeNum = slot.Column;
}
}
else
{
needTakeNum = lastRowCount;
}
int baseIndex=(slotNo /10) * 10 ;
//找到要搬运的行的第一个和最后一个
int last = slot.Index + (tray.ColumnNum - (slot.Column + 1));
int first = slot.Index - slot.Column;
for( int i=0;i<needTakeNum;i++)
{
TurnoverInfo ti = new TurnoverInfo();
ti.Instruction = EInstruction.LoadAndUnload;
ti.FromType = turnovertype;
ti.FromIndex = baseIndex + i;
ti.FromType = fromtray;
ti.FromIndex = first-1 + i;
ti.FromFloor= floor;
ti.ToType = turnovertype;
ti.ToIndex = baseIndex + 10 - i -1;
ti.ToType = totray;
ti.ToIndex = last - 1-i;
task.Add(ti);
}
return task;

817
Rs.SkyLine/Flow/RearrangeFlow.cs
Unescape Escape View File

@ -40,8 +40,9 @@ namespace Rs.MotionPlat.Flow
}
public class RearrangeFlow:BaseFlow
public class RearrangeFlow
{
private string logInfo = string.Empty;
private static RearrangeFlow instance;
public static RearrangeFlow Instance
{
@ -63,475 +64,487 @@ namespace Rs.MotionPlat.Flow
double targetY = 0.0;
int FetchNum = 0;//取料次数
ErrorCode errCode = ErrorCode.Ok;
public override void Run()
public void Rearrange()
{
switch (flowStep)
bool finished = false;
flowStep = ERearrangeFlowStep.等待任务;
while (!finished)
{
case ERearrangeFlowStep.等待任务:
if (RearrangeTask.HasTask() && WorkEnvironment.Instance.EnvironmentOk)
{
DischargeFlow.Instance.Stop();
logInfo = $"接收重排任务";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到取料位上方;
}
break;
case ERearrangeFlowStep.到取料位上方:
curTask = RearrangeTask.GetTask();
curNozzle = NozzleManager.GetIdelNozzle();
if (curTask != null && curNozzle != null)
{
if (SafeControl.Instance.XYCanMove() || GlobalVar.VirtualAxis)
switch (flowStep)
{
case ERearrangeFlowStep.等待任务:
if (RearrangeTask.HasTask() && WorkEnvironment.Instance.EnvironmentOk)
{
curSlotPoint = null;
ETrayType traytype = ETrayType.Ok;
switch (curTask.FromType)
{
case TurnoverType.Passed:
traytype = ETrayType.Ok;
break;
case TurnoverType.Failed:
traytype = ETrayType.Ng;
break;
case TurnoverType.Multifunction:
traytype = ETrayType.Multi;
break;
default:
break;
}
logInfo = $"吸嘴{curNozzle.NozzleIndex} 去{traytype}盘 {curTask.FromIndex+1} 号穴位取料";
curSlotPoint = TrayPointManager.GetSlotPoint( traytype, curTask.FromIndex+1);
DischargeFlow.Instance.Stop();
logInfo = $"接收重排任务";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
if (curSlotPoint != null)
flowStep = ERearrangeFlowStep.到取料位上方;
}
break;
case ERearrangeFlowStep.到取料位上方:
curTask = RearrangeTask.GetTask();
curNozzle = NozzleManager.GetIdelNozzle(true);
if (curTask != null && curNozzle != null)
{
if (SafeControl.Instance.XYCanMove() || GlobalVar.VirtualAxis)
{
nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
targetX = curSlotPoint.X + nozzleDist.X;
targetY = curSlotPoint.Y + nozzleDist.Y;
errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
curSlotPoint = null;
ETrayType traytype = ETrayType.Ok;
switch (curTask.FromType)
{
case TurnoverType.Passed:
traytype = ETrayType.Ok;
break;
case TurnoverType.Failed:
traytype = ETrayType.Ng;
break;
case TurnoverType.Multifunction:
traytype = ETrayType.Multi;
break;
default:
break;
}
logInfo = $"吸嘴{curNozzle.NozzleIndex} 去{traytype}盘 {curTask.FromIndex + 1} 号穴位取料";
curSlotPoint = TrayPointManager.GetSlotPoint(traytype, curTask.FromIndex + 1);
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
if (curSlotPoint != null)
{
errCode = AxisControl.GetAxis($"NozzleR{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<Double>($"NozzleR{curNozzle.NozzleIndex}StartPos"), (int)(GlobalVar.WholeSpeed));
errCode = AxisControl.LoadY.MovePos(targetY, (int)(GlobalVar.WholeSpeed));
if (errCode == ErrorCode.Ok | GlobalVar.VirtualAxis)
nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
targetX = curSlotPoint.X + nozzleDist.X;
targetY = curSlotPoint.Y + nozzleDist.Y;
errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待到取料位上方;
errCode = AxisControl.GetAxis($"NozzleR{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<Double>($"NozzleR{curNozzle.NozzleIndex}StartPos"), (int)(GlobalVar.WholeSpeed));
errCode = AxisControl.LoadY.MovePos(targetY, (int)(GlobalVar.WholeSpeed));
if (errCode == ErrorCode.Ok | GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待到取料位上方;
}
}
}
}
else
{
logInfo = "x y move isn't safe";
Msg.ShowError(logInfo);
LogHelper.Error(logInfo);
MessageQueue.Instance.Warn(logInfo);
}
}
break;
case ERearrangeFlowStep.等待到取料位上方:
if (Ops.IsStop("LoadX", "LoadY", $"NozzleR{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "已运动到取料位上方";
Thread.Sleep(100);
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到取料位下方;
}
break;
case ERearrangeFlowStep.到取料位下方:
if (GlobalVar.VirtualAxis)
{
Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
flowStep = ERearrangeFlowStep.等待到取料位下方;
}
else
{
logInfo = "x y move isn't safe";
Msg.ShowError(logInfo);
LogHelper.Error(logInfo);
MessageQueue.Instance.Warn(logInfo);
if (AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").HomeStatus == EHomeStatus.Finished)
{
logInfo = "准备运动到取料位下方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(GetVacOffsetHeight(FetchNum) + SysConfigParam.GetValue<double>($"TrayNozzle{curNozzle.NozzleIndex}TakeHeight"), GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok)
{
flowStep = ERearrangeFlowStep.等待到取料位下方;
}
}
else
{
logInfo = $"NozzleZ{curNozzle.NozzleIndex} 不在原点，请手动回原后点击确定";
Msg.ShowError(logInfo);
LogHelper.Error(logInfo);
}
}
}
break;
case ERearrangeFlowStep.等待到取料位上方:
if (Ops.IsStop("LoadX", "LoadY", $"NozzleR{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "已运动到取料位上方";
Thread.Sleep(100);
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到取料位下方;
}
break;
case ERearrangeFlowStep.到取料位下方:
if (GlobalVar.VirtualAxis)
{
Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
flowStep = ERearrangeFlowStep.等待到取料位下方;
}
else
{
if (AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").HomeStatus == EHomeStatus.Finished)
break;
case ERearrangeFlowStep.等待到取料位下方:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "准备运动到取料位下方";
logInfo = "已运动到取料位下方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(GetVacOffsetHeight(FetchNum) + SysConfigParam.GetValue<double>($"TrayNozzle{curNozzle.NozzleIndex}TakeHeight"), GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok)
{
flowStep = ERearrangeFlowStep.等待到取料位下方;
}
flowStep = ERearrangeFlowStep.开真空;
}
break;
case ERearrangeFlowStep.开真空:
if (GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.取料完成抬起;
}
else
{
logInfo = $"NozzleZ{curNozzle.NozzleIndex} 不在原点，请手动回原后点击确定";
Msg.ShowError(logInfo);
LogHelper.Error(logInfo);
Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacSuctionDelaytime);
logInfo = $"打开{curNozzle.NozzleIndex}号吸嘴真空吸";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.取料完成抬起;
}
}
break;
case ERearrangeFlowStep.等待到取料位下方:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "已运动到取料位下方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.开真空;
}
break;
case ERearrangeFlowStep.开真空:
if (GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.取料完成抬起;
}
else
{
Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacSuctionDelaytime);
logInfo = $"打开{curNozzle.NozzleIndex}号吸嘴真空吸";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.取料完成抬起;
}
break;
case ERearrangeFlowStep.取料完成抬起:
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
logInfo = "取料完成准备抬起";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.等待取料完成抬起;
}
break;
case ERearrangeFlowStep.等待取料完成抬起:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "取料完成已运动到抬起位，准备真空检测";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.取料真空检测;
}
break;
case ERearrangeFlowStep.取料真空检测:
if (Ops.IsOn($"{curNozzle.NozzleIndex}号吸嘴真空吸检测") || GlobalVar.RunSpace || GlobalVar.VirtualAxis)
{
FetchNum = 0;
logInfo = $"吸嘴{curNozzle.NozzleIndex}真空检测 OK";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
break;
curNozzle.Status = ENozzleStatus.ToUnload;
curNozzle.FromType = curTask.FromType;
curNozzle.ToType = curTask.ToType;
curNozzle.ToIndex = curTask.ToIndex;
curTask.SuckerNo = curNozzle.NozzleIndex;
curNozzle.TurnoverGUID = curTask.GUID;
if (curTask.FromType == TurnoverType.Passed)
case ERearrangeFlowStep.取料完成抬起:
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
curNozzle.FromFloor = StockManager.Instance.GetStock(ETrayType.Ok).GetFloor();// StockManager.Instance.GetTray(EStockType.Ok).GetFloor();
curNozzle.SN = "";
curNozzle.FromIndex = curTask.FromIndex;
GlobalTray.OkTary.ChangeStatus(curNozzle.FromIndex+1, ESlotStatus.NotHave);
logInfo = "取料完成准备抬起";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.等待取料完成抬起;
}
else if (curTask.FromType == TurnoverType.Failed)
break;
case ERearrangeFlowStep.等待取料完成抬起:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
curNozzle.FromFloor = StockManager.Instance.GetStock(ETrayType.Ng).GetFloor();//StockManager.Instance.GetTray(EStockType.Ng).GetFloor();
curNozzle.SN = "";
curNozzle.FromIndex = curTask.FromIndex;
GlobalTray.NgTray.ChangeStatus(curNozzle.FromIndex + 1, ESlotStatus.NotHave);
logInfo = "取料完成已运动到抬起位，准备真空检测";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.取料真空检测;
}
curNozzle.Update();
curTask.Dealed = true;
if (RearrangeTask.HasTask() && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
break;
case ERearrangeFlowStep.取料真空检测:
if (Ops.IsOn($"{curNozzle.NozzleIndex}号吸嘴真空吸检测") || GlobalVar.RunSpace || GlobalVar.VirtualAxis)
{
logInfo = $"检测到还有条任务未执行，继续执行";
FetchNum = 0;
logInfo = $"吸嘴{curNozzle.NozzleIndex}真空检测 OK";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到取料位上方;
curNozzle.Status = ENozzleStatus.ToUnload;
curNozzle.FromType = curTask.FromType;
curNozzle.ToType = curTask.ToType;
curNozzle.ToIndex = curTask.ToIndex;
curTask.SuckerNo = curNozzle.NozzleIndex;
curNozzle.TurnoverGUID = curTask.GUID;
if (curTask.FromType == TurnoverType.Passed)
{
curNozzle.FromFloor = StockManager.Instance.GetStock(ETrayType.Ok).GetFloor();// StockManager.Instance.GetTray(EStockType.Ok).GetFloor();
curNozzle.SN = GlobalTray.OkTary.GetSlot(curTask.FromIndex+1).SN;
curNozzle.FromIndex = curTask.FromIndex;
GlobalTray.OkTary.ChangeStatus(curNozzle.FromIndex + 1, ESlotStatus.NotHave);
}
else if (curTask.FromType == TurnoverType.Failed)
{
curNozzle.FromFloor = StockManager.Instance.GetStock(ETrayType.Ng).GetFloor();//StockManager.Instance.GetTray(EStockType.Ng).GetFloor();
curNozzle.SN = GlobalTray.NgTray.GetSlot(curTask.FromIndex + 1).SN;
curNozzle.FromIndex = curTask.FromIndex;
GlobalTray.NgTray.ChangeStatus(curNozzle.FromIndex + 1, ESlotStatus.NotHave);
}
else if (curTask.FromType == TurnoverType.Multifunction)
{
curNozzle.FromFloor = StockManager.Instance.GetStock(ETrayType.Multi).GetFloor();//StockManager.Instance.GetTray(EStockType.Ng).GetFloor();
curNozzle.SN = GlobalTray.MultiTray.GetSlot(curTask.FromIndex + 1).SN;
curNozzle.FromIndex = curTask.FromIndex;
GlobalTray.MultiTray.ChangeStatus(curNozzle.FromIndex + 1, ESlotStatus.NotHave);
}
curNozzle.Update();
curTask.Dealed = true;
if (RearrangeTask.HasTask() && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
{
logInfo = $"检测到还有条任务未执行，继续执行";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到取料位上方;
}
else
{
flowStep = ERearrangeFlowStep.到放料位上方;
}
}
else
{
flowStep = ERearrangeFlowStep.到放料位上方;
}
}
else
{
//FetchNum++;
//if (FetchNum == 6)
//{
// //DialogResult dr = Msg.ShowError($"吸嘴{curNozzle.NozzleIndex}取料{FetchNum}次失败报警,请处理后点击确定", MessageBoxButtons.RetryCancel);
// CloseResult cr = new TakeFailMsg().ShowMsg($"吸嘴{curNozzle.NozzleIndex}取料{FetchNum}次失败报警,请处理后点击确定");
// if (cr.Result == ECloseButton.Retry)
// {
// FetchNum = 0;
// flowStep = ERearrangeFlowStep.到取料位下方;
// }
// else if (cr.Result == ECloseButton.Skip)//switch
// {
// FetchNum = 0;
// if (curTask.FromType == TurnoverType.Turnover)
// {
// GlobalTray.TurnoverTray.ChangeStatus(curTask.FromIndex + 1, ESlotStatus.NotHave);
// }
// else if (curTask.FromType == TurnoverType.ToBeTested)
// {
// GlobalTray.InputTray.ChangeStatus(GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index, ESlotStatus.NotHave);
// }
// if (LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode) > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
// {
// flowStep = ERearrangeFlowStep.到取料位上方;
// }
// else
// {
// flowStep = ERearrangeFlowStep.到下相机拍照起始位;
// }
// }
// else if (cr.Result == ECloseButton.EndInput)
// {
// FetchNum = 0;
// TestCenter.Instance.EndInput();
// LoadAndUnloadTask.Instance.ClearUndoTask();
// if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count > 0)
// {
// flowStep = ERearrangeFlowStep.到下相机拍照起始位;
// }
// else
// {
// flowStep = ERearrangeFlowStep.任务结束到安全位;
// }
// }
// else if (cr.Result == ECloseButton.Continue)
// {
// FetchNum = 0;
// curNozzle.Status = ENozzleStatus.ToUnload;
// curNozzle.FromType = curTask.FromType;
// curNozzle.FromFloor = curTask.FromFloor;
//FetchNum++;
//if (FetchNum == 6)
//{
// //DialogResult dr = Msg.ShowError($"吸嘴{curNozzle.NozzleIndex}取料{FetchNum}次失败报警,请处理后点击确定", MessageBoxButtons.RetryCancel);
// CloseResult cr = new TakeFailMsg().ShowMsg($"吸嘴{curNozzle.NozzleIndex}取料{FetchNum}次失败报警,请处理后点击确定");
// if (cr.Result == ECloseButton.Retry)
// {
// FetchNum = 0;
// flowStep = ERearrangeFlowStep.到取料位下方;
// }
// else if (cr.Result == ECloseButton.Skip)//switch
// {
// FetchNum = 0;
// if (curTask.FromType == TurnoverType.Turnover)
// {
// GlobalTray.TurnoverTray.ChangeStatus(curTask.FromIndex + 1, ESlotStatus.NotHave);
// }
// else if (curTask.FromType == TurnoverType.ToBeTested)
// {
// GlobalTray.InputTray.ChangeStatus(GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index, ESlotStatus.NotHave);
// }
// if (LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode) > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
// {
// flowStep = ERearrangeFlowStep.到取料位上方;
// }
// else
// {
// flowStep = ERearrangeFlowStep.到下相机拍照起始位;
// }
// }
// else if (cr.Result == ECloseButton.EndInput)
// {
// FetchNum = 0;
// TestCenter.Instance.EndInput();
// LoadAndUnloadTask.Instance.ClearUndoTask();
// if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count > 0)
// {
// flowStep = ERearrangeFlowStep.到下相机拍照起始位;
// }
// else
// {
// flowStep = ERearrangeFlowStep.任务结束到安全位;
// }
// }
// else if (cr.Result == ECloseButton.Continue)
// {
// FetchNum = 0;
// curNozzle.Status = ENozzleStatus.ToUnload;
// curNozzle.FromType = curTask.FromType;
// curNozzle.FromFloor = curTask.FromFloor;
// curNozzle.ToType = curTask.ToType;
// curNozzle.ToIndex = curTask.ToIndex;
// curTask.SuckerNo = curNozzle.NozzleIndex;
// curNozzle.TurnoverGUID = curTask.GUID;
// if (curTask.FromType == TurnoverType.Turnover)
// {
// curNozzle.SN = curTask.SN;
// curNozzle.FromIndex = curTask.FromIndex;
// GlobalTray.TurnoverTray.ChangeStatus(curTask.FromIndex + 1, ESlotStatus.NotHave);
// }
// else if (curTask.FromType == TurnoverType.ToBeTested)
// {
// curNozzle.FromIndex = GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index;
// GlobalTray.InputTray.ChangeStatus(GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index, ESlotStatus.NotHave);
// }
// curNozzle.Update();
// curTask.Dealed = true;
// if (LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode) > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
// {
// flowStep = ERearrangeFlowStep.到取料位上方;
// }
// else
// {
// if (GlobalVar.VirtualAxis)
// {
// foreach (Nozzle nl in NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload))
// {
// if (string.IsNullOrEmpty(nl.SN))
// nl.SN = nl.FromIndex.ToString().PadLeft(18, '0');
// //nl.SN = GuidHelper.Create();
// }
// mrs = new List<MatchResult>();
// for (int i = 0; i < needGrabNum; i++)
// {
// mrs.Add(new MatchResult());
// }
// flowStep = ERearrangeFlowStep.到放料位上方;
// }
// else
// {
// flowStep = ERearrangeFlowStep.到下相机拍照起始位;
// }
// curNozzle.ToType = curTask.ToType;
// curNozzle.ToIndex = curTask.ToIndex;
// curTask.SuckerNo = curNozzle.NozzleIndex;
// curNozzle.TurnoverGUID = curTask.GUID;
// if (curTask.FromType == TurnoverType.Turnover)
// {
// curNozzle.SN = curTask.SN;
// curNozzle.FromIndex = curTask.FromIndex;
// GlobalTray.TurnoverTray.ChangeStatus(curTask.FromIndex + 1, ESlotStatus.NotHave);
// }
// else if (curTask.FromType == TurnoverType.ToBeTested)
// {
// curNozzle.FromIndex = GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index;
// GlobalTray.InputTray.ChangeStatus(GlobalTray.InputTray.GetSlot(ESlotStatus.Have).Index, ESlotStatus.NotHave);
// }
// curNozzle.Update();
// curTask.Dealed = true;
// if (LoadAndUnloadTask.Instance.GetTaskNum(curTask.taskMode) > 0 && NozzleManager.GetNozzlesByStatus(ENozzleStatus.IDLE).Count > 0)
// {
// flowStep = ERearrangeFlowStep.到取料位上方;
// }
// else
// {
// if (GlobalVar.VirtualAxis)
// {
// foreach (Nozzle nl in NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload))
// {
// if (string.IsNullOrEmpty(nl.SN))
// nl.SN = nl.FromIndex.ToString().PadLeft(18, '0');
// //nl.SN = GuidHelper.Create();
// }
// mrs = new List<MatchResult>();
// for (int i = 0; i < needGrabNum; i++)
// {
// mrs.Add(new MatchResult());
// }
// flowStep = ERearrangeFlowStep.到放料位上方;
// }
// else
// {
// flowStep = ERearrangeFlowStep.到下相机拍照起始位;
// }
// }
// }
//}
//else
//{
// flowStep = ERearrangeFlowStep.到取料位下方;
//}
}
break;
case ERearrangeFlowStep.到放料位上方:
if (SafeControl.Instance.XYCanMove() || GlobalVar.VirtualAxis)
{
targetX = 0.0;
targetY = 0.0;
///获取需要放料的吸嘴
curSlotPoint = null;
curNozzle = NozzleManager.GetToUnloadNozzle();
if (curNozzle != null)
{
curSlotPoint = GetSlotPoint(curNozzle.ToType);
// }
// }
//}
//else
//{
// flowStep = ERearrangeFlowStep.到取料位下方;
//}
}
if (curSlotPoint != null)
break;
case ERearrangeFlowStep.到放料位上方:
if (SafeControl.Instance.XYCanMove() || GlobalVar.VirtualAxis)
{
nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
targetX = curSlotPoint.X + nozzleDist.X;
targetY = curSlotPoint.Y + nozzleDist.Y;
errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
targetX = 0.0;
targetY = 0.0;
///获取需要放料的吸嘴
curSlotPoint = null;
curNozzle = NozzleManager.GetToUnloadNozzle();
if (curNozzle != null)
{
curSlotPoint = GetSlotPoint(curNozzle.ToType);
}
if (curSlotPoint != null)
{
errCode = AxisControl.LoadY.MovePos(targetY, GlobalVar.WholeSpeed);
nozzleDist = TrayPointManager.GetDistToNozzle1(curNozzle.NozzleIndex);
targetX = curSlotPoint.X + nozzleDist.X;
targetY = curSlotPoint.Y + nozzleDist.Y;
errCode = AxisControl.LoadX.MovePos(targetX, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
errCode = AxisControl.GetAxis($"NozzleR{curNozzle.NozzleIndex}").MoveOffset(0, GlobalVar.WholeSpeed);
errCode = AxisControl.LoadY.MovePos(targetY, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待到放料位上方;
errCode = AxisControl.GetAxis($"NozzleR{curNozzle.NozzleIndex}").MoveOffset(0, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待到放料位上方;
}
}
}
}
}
}
else
{
Msg.ShowError("x y move isn't safe");
}
break;
case ERearrangeFlowStep.等待到放料位上方:
if (Ops.IsStop("LoadX", "LoadY", $"NozzleR{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
Thread.Sleep(100);
logInfo = "已运动到放料位上方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到放料位下方;
else
{
Msg.ShowError("x y move isn't safe");
}
break;
case ERearrangeFlowStep.等待到放料位上方:
if (Ops.IsStop("LoadX", "LoadY", $"NozzleR{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
Thread.Sleep(100);
logInfo = "已运动到放料位上方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.到放料位下方;
}
break;
case ERearrangeFlowStep.到放料位下方:
logInfo = "到放料位下方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight") + 3, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待到放料位下方;
}
break;
case ERearrangeFlowStep.等待到放料位下方:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "已运动到放料位下方";
}
break;
case ERearrangeFlowStep.到放料位下方:
logInfo = "到放料位下方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
flowStep = ERearrangeFlowStep.放料完成抬起;
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight") + 3, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待到放料位下方;
}
break;
case ERearrangeFlowStep.等待到放料位下方:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "已运动到放料位下方";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
flowStep = ERearrangeFlowStep.放料完成抬起;
}
break;
case ERearrangeFlowStep.放料完成抬起:
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
logInfo = "放料完成抬起";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.等待放料完成抬起;
}
break;
case ERearrangeFlowStep.等待放料完成抬起:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "放料完成已运动到抬起位，准备真空检测";
}
break;
case ERearrangeFlowStep.放料完成抬起:
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
logInfo = "放料完成抬起";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.等待放料完成抬起;
}
break;
case ERearrangeFlowStep.等待放料完成抬起:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = "放料完成已运动到抬起位，准备真空检测";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.放料真空检测;
}
break;
case ERearrangeFlowStep.放料真空检测:
flowStep = ERearrangeFlowStep.放料任务完成;
break;
case ERearrangeFlowStep.放料任务完成:
logInfo = "放料任务完成";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
flowStep = ERearrangeFlowStep.放料真空检测;
}
break;
case ERearrangeFlowStep.放料真空检测:
flowStep = ERearrangeFlowStep.放料任务完成;
break;
case ERearrangeFlowStep.放料任务完成:
logInfo = "放料任务完成";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").Home();
if (curNozzle.ToType == TurnoverType.Passed)
{
GlobalTray.OkTary.ChangeStatus(curNozzle.ToIndex+1, ESlotStatus.Have);
}
else if (curNozzle.ToType == TurnoverType.Failed)
{
GlobalTray.NgTray.ChangeStatus(curNozzle.ToIndex + 1, ESlotStatus.Have);
}
else if (curNozzle.ToType == TurnoverType.Multifunction)
{
GlobalTray.MultiTray.ChangeStatus(curNozzle.ToIndex + 1, ESlotStatus.Have);
}
curNozzle.Reset();
Thread.Sleep(100);
RearrangeTask.AddWaitReportTask(curNozzle);
if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count > 0)
{
flowStep = ERearrangeFlowStep.到放料位上方;
}
else
{
if (RearrangeTask.HasTask())
AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").Home();
if (curNozzle.ToType == TurnoverType.Passed)
{
flowStep = ERearrangeFlowStep.到取料位上方;
GlobalTray.OkTary.ChangeStatus(curNozzle.ToIndex + 1, ESlotStatus.Have);
}
else if (curNozzle.ToType == TurnoverType.Failed)
{
GlobalTray.NgTray.ChangeStatus(curNozzle.ToIndex + 1, ESlotStatus.Have);
}
else if (curNozzle.ToType == TurnoverType.Multifunction)
{
GlobalTray.MultiTray.ChangeStatus(curNozzle.ToIndex + 1, ESlotStatus.Have);
}
curNozzle.Reset();
Thread.Sleep(100);
RearrangeTask.AddWaitReportTask(curNozzle);
if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload).Count > 0)
{
flowStep = ERearrangeFlowStep.到放料位上方;
}
else
{
flowStep = ERearrangeFlowStep.任务结束到安全位;
if (RearrangeTask.HasTask())
{
flowStep = ERearrangeFlowStep.到取料位上方;
}
else
{
flowStep = ERearrangeFlowStep.任务结束到安全位;
}
}
}
break;
break;
case ERearrangeFlowStep.任务结束到安全位:
logInfo = "任务结束到安全位";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
errCode = AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>("LoadXStartPos"), GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
errCode = AxisControl.LoadY.MovePos(SysConfigParam.GetValue<double>("LoadYStartPos"), GlobalVar.WholeSpeed);
case ERearrangeFlowStep.任务结束到安全位:
logInfo = "任务结束到安全位";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
errCode = AxisControl.LoadX.MovePos(SysConfigParam.GetValue<double>("LoadXStartPos"), GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待任务结束到安全位;
errCode = AxisControl.LoadY.MovePos(SysConfigParam.GetValue<double>("LoadYStartPos"), GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
flowStep = ERearrangeFlowStep.等待任务结束到安全位;
}
}
}
break;
case ERearrangeFlowStep.等待任务结束到安全位:
if (Ops.IsStop("LoadX", "LoadY") || GlobalVar.VirtualAxis)
{
logInfo = "任务结束已回到安全位";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
if (RearrangeTask.ReportCenter()>0)
break;
case ERearrangeFlowStep.等待任务结束到安全位:
if (Ops.IsStop("LoadX", "LoadY") || GlobalVar.VirtualAxis)
{
logInfo = "通知中控任务完成";
logInfo = "任务结束已回到安全位";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
if (RearrangeTask.ReportCenter() > 0)
{
logInfo = "通知中控任务完成";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
RearrangeTask.RemoveAll();
logInfo = "任务完成，清除任务";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
RearrangeTask.RemoveAll();
logInfo = "任务完成，清除任务";
MessageQueue.Instance.Insert(logInfo);
LogHelper.Debug(logInfo);
}
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
finished = true;
}
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
flowStep = ERearrangeFlowStep.等待任务;
}
break;
default:
break;
break;
default:
break;
}
}
}

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

@ -272,50 +272,60 @@ namespace Rs.MotionPlat.Flow
SiloRearrange info = JsonConvert.DeserializeObject<SiloRearrange>(json);
ReportToTestCenter(info);
Thread.Sleep(200);
//if(info.SiloType== SchedulingSiloBase.ESiloType.Multifunction)
if (info.SiloType == SchedulingSiloBase.ESiloType.Multifunction)
{
TurnoverInfos tis = new TurnoverInfos();
tis.GroupID = 0;
tis.Instruction = EInstruction.RearrangeResult;
ReportToTestCenter(tis);
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
TraySlot ts = GlobalTray.MultiTray.GetSlot(Controls.ESlotStatus.NotHave);
if (ts.Column == 0)//无需重排
{
TurnoverInfos tis = new TurnoverInfos();
tis.GroupID = 0;
tis.Instruction = EInstruction.RearrangeResult;
ReportToTestCenter(tis);
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
}
else
{
List<TurnoverInfo> rearrangeList = RearrangeManager.GeneralRearrangeTask(TurnoverType.Multifunction,TurnoverType.Multifunction, GlobalTray.MultiTray, ts, 1);
RearrangeTask.AddRanage(rearrangeList);
RearrangeFlow.Instance.Rearrange();
}
}
else if (info.SiloType == SchedulingSiloBase.ESiloType.Passed)
{
TraySlot ts = GlobalTray.OkTary.GetSlot(Controls.ESlotStatus.NotHave);
if (ts.Column==0)//无需重排
{
TurnoverInfos tis = new TurnoverInfos();
tis.GroupID = 0;
tis.Instruction = EInstruction.RearrangeResult;
ReportToTestCenter(tis);
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
}
else
{
List<TurnoverInfo> rearrangeList = RearrangeManager.GeneralRearrangeTask(TurnoverType.Passed,TurnoverType.Passed, GlobalTray.OkTary, ts, 1);
RearrangeTask.AddRanage(rearrangeList);
RearrangeFlow.Instance.Rearrange();
}
}
else if (info.SiloType == SchedulingSiloBase.ESiloType.Failed)
{
TraySlot ts = GlobalTray.NgTray.GetSlot(ESlotStatus.NotHave);
if (ts.Column == 0)
{
TurnoverInfos tis = new TurnoverInfos();
tis.GroupID = 0;
tis.Instruction = EInstruction.RearrangeResult;
ReportToTestCenter(tis);
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
}
else
{
List<TurnoverInfo> rearrangeList = RearrangeManager.GeneralRearrangeTask(TurnoverType.Failed,TurnoverType.Failed, GlobalTray.NgTray,ts, 1);
RearrangeTask.AddRanage(rearrangeList);
RearrangeFlow.Instance.Rearrange();
}
}
//else if(info.SiloType== SchedulingSiloBase.ESiloType.Passed)
//{
// TraySlot ts = GlobalTray.OkTary.GetSlot(Controls.ESlotStatus.NotHave);
// if((ts.Index-1)%10==0)
// {
// TurnoverInfos tis = new TurnoverInfos();
// tis.GroupID = 0;
// tis.Instruction = EInstruction.RearrangeResult;
// Send(tis);
// MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
// }
// else
// {
// List<TurnoverInfo> rearrangeList = RearrangeManager.GeneralRearrangeTask(TurnoverType.Passed, ts.Index-1, StockManager.Instance.GetTray(EStockType.Ok).GetFloor());
// RearrangeTask.AddRanage(rearrangeList);
// RearrangeFlow.Instance.Start();
// }
//}
//else if (info.SiloType == SchedulingSiloBase.ESiloType.Failed)
//{
// TraySlot ts = GlobalTray.NgTray.GetSlot(ESlotStatus.NotHave);
// if ((ts.Index-1) % 10 == 0)
// {
// TurnoverInfos tis = new TurnoverInfos();
// tis.GroupID = 0;
// tis.Instruction = EInstruction.RearrangeResult;
// Send(tis);
// MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
// }
// else
// {
// List<TurnoverInfo> rearrangeList = RearrangeManager.GeneralRearrangeTask(TurnoverType.Failed, ts.Index-1, StockManager.Instance.GetTray(EStockType.Ng).GetFloor());
// RearrangeTask.AddRanage(rearrangeList);
// RearrangeFlow.Instance.Start();
// }
//}
}
private void LoadAndUnload(string json)

Write Preview
Loading…
Cancel
Save