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

增加上相机扫码功能

Browse Source
master
lhiven 2 years ago
parent 856b234c2b
commit 37bc0300e4
10 changed files with 423 additions and 140 deletions
Show Stats Download Patch File Download Diff File

9
Rs.SkyLine/Commom/Enums.cs
Unescape Escape View File

@ -21,4 +21,13 @@ namespace Rs.MotionPlat.Commom
Test,
Warning
}
/// <summary>
/// IO操作
/// </summary>
public enum EIoOperate
{
Open,
Close
}
}

44
Rs.SkyLine/Commom/GlobalVar.cs
Unescape Escape View File

@ -452,5 +452,49 @@ namespace Rs.Framework
return SysConfigParam.GetValue<bool> (nameof(EnableTestFixtureFiberCheck));
}
}
/// <summary>
/// 排料吸嘴放料仓偏移
/// </summary>
public static double DischargeNozzleDumpStockTrayOffset
{
get
{
return SysConfigParam.GetValue<double>(nameof(DischargeNozzleDumpStockTrayOffset));
}
}
/// <summary>
/// 排料吸嘴放周转盘偏移
/// </summary>
public static double DischargeNozzleDumpTurnoverTrayOffset
{
get
{
return SysConfigParam.GetValue<double>(nameof(DischargeNozzleDumpTurnoverTrayOffset));
}
}
/// <summary>
/// 周转吸嘴放周转盘偏移
/// </summary>
public static double TurnoverNozzleDumpStockTrayOffset
{
get
{
return SysConfigParam.GetValue<double>(nameof(TurnoverNozzleDumpStockTrayOffset));
}
}
/// <summary>
/// 周转吸嘴放治具盘偏移
/// </summary>
public static double TurnoverNozzleDumpTurnoverTrayOffset
{
get
{
return SysConfigParam.GetValue<double>(nameof(TurnoverNozzleDumpTurnoverTrayOffset));
}
}
}
}

43
Rs.SkyLine/Commom/NozzleCollection.cs
Unescape Escape View File

@ -7,6 +7,7 @@ using System.Data;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Rs.MotionPlat.Commom
@ -73,6 +74,7 @@ namespace Rs.MotionPlat.Commom
public bool Reset()
{
this.Status = ENozzleStatus.IDLE;
this.SN = "";
//this.FromType = TurnoverType.Unknown;
//this.FromFloor = 0;
//this.FromIndex = 0;
@ -82,6 +84,47 @@ namespace Rs.MotionPlat.Commom
return Update();
}
/// <summary>
/// 真空吸操作
/// </summary>
public void VacSuction( EIoOperate op)
{
if(op== EIoOperate.Open)
{
Ops.On($"{NozzleIndex}号排料吸嘴真空吸");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacSuctionDelaytime);
}
else
{
Ops.Off($"{NozzleIndex}号排料吸嘴真空吸");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
}
}
/// <summary>
/// 真空破操作
/// </summary>
public void VacBreak(EIoOperate op)
{
if (op == EIoOperate.Open)
{
Ops.On($"{NozzleIndex}号排料吸嘴真空破");
}
else
{
Ops.Off($"{NozzleIndex}号排料吸嘴真空破");
}
}
/// <summary>
/// 通过真空吸判断吸嘴是否有产品
/// </summary>
/// <returns></returns>
public bool HasProduct()
{
return Ops.IsOn($"{NozzleIndex}号排料吸嘴真空吸");
}
}
public static class NozzleManager

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

@ -85,14 +85,14 @@ namespace Rs.MotionPlat.Flow
public const int StockLoadAlarm = 15;
/// <summary>
/// 周转吸嘴粘料报警
///吸嘴粘料报警
/// </summary>
public const int TransitNozzleTackinessAlarm = 16;
public const int NozzleTackinessAlarm = 16;
/// <summary>
/// 测试位上方丢料报警
/// 吸嘴丢料报警
/// </summary>
public const int TestPosLoseMaterialAlarm = 17;
public const int NozzlesLoseMaterialAlarm = 17;
/// <summary>
/// 周转吸头取料失败报警
@ -111,6 +111,8 @@ namespace Rs.MotionPlat.Flow
/// <summary>
/// 料仓缺料盘报警
/// </summary>
public const int StockLackTrayAlarm = 20;
public const int StockLackTrayAlarm = 21;
}
}

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

@ -139,6 +139,18 @@ namespace Rs.MotionPlat.Flow
tilist.AddRange(changeTaskList.Where(tr => tr.Dealed == false));
return tilist;
}
/// <summary>
/// 获取还没有执行的放到周转盘的任务
/// </summary>
/// <returns></returns>
public List<TurnoverInfo> GetUndealedLoadToTurnoverTask()
{
List<TurnoverInfo> tilist = new List<TurnoverInfo>();
tilist.AddRange(loadTaskList.Where(tr => tr.Dealed == false));
tilist.AddRange(changeTaskList.Where(tr => tr.Dealed == false));
return tilist;
}
/// <summary>
/// 清除未执行的任务
/// </summary>

4
Rs.SkyLine/Flow/NgFlow/TransitModuleTackinessCheck.cs
Unescape Escape View File

@ -42,8 +42,8 @@ namespace Rs.MotionPlat.Flow.NgFlow
//弹框粘料报警
alarmInfo = $"周转吸嘴{string.Join(",", ngNozzle)}号粘料，请移动到安全位后手动处理";
LogHelper.Debug(alarmInfo);
TestCenterMessageBox.Show(AlarmConstID.TransitNozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TransitNozzleTackinessAlarm);
TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm);
switch (msgBox.Button)
{
case ETipButton.Skip:

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

@ -14,6 +14,7 @@ using Rs.MotionPlat.Flow.SubFlow;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Eventing.Reader;
using System.IO;
using System.Linq;
using System.Text;
@ -44,6 +45,7 @@ namespace Rs.MotionPlat.Flow
等待视觉处理结果,
到放料位上方,
等待到放料位上方,
丢料检测,
到放料位下方,
等待到放料位下方,
到放料关破真空位,
@ -52,6 +54,7 @@ namespace Rs.MotionPlat.Flow
放料完成抬起,
等待放料完成抬起,
放料真空检测,
粘料检测,
周转盘放料真空报警,
放料任务完成,
任务结束到安全位,
@ -566,7 +569,7 @@ namespace Rs.MotionPlat.Flow
if (XYCanMove() || GlobalVar.VirtualAxis)
{
StockTrayToTurnoverTray = !StockTrayToTurnoverTray;
logInfo = $"{nameof(DischargeFlow)}-到下相机拍照起始位";
logInfo = GetClassName() + $"到下相机拍照起始位";
MessageQueue.Instance.Insert(logInfo);
if(!GlobalVar.VirtualAxis)
{
@ -593,7 +596,7 @@ namespace Rs.MotionPlat.Flow
case EDischargeFlowStep.等待到下相机拍照起始位:
if (Ops.IsStop("LoadX", "LoadY") || GlobalVar.VirtualAxis)
{
logInfo = $"{nameof(DischargeFlow)}-已运动到下相机拍照起始位";
logInfo = GetClassName() + $"已运动到下相机拍照起始位";
MessageQueue.Instance.Insert(logInfo);
if (!GlobalVar.VirtualAxis)
{
@ -633,7 +636,7 @@ namespace Rs.MotionPlat.Flow
case EDischargeFlowStep.到下相机拍照结束位:
if (XYCanMove() || GlobalVar.VirtualAxis)
{
logInfo = $"{nameof(DischargeFlow)}-到下相机拍照结束位";
logInfo = GetClassName() + $"到下相机拍照结束位";
MessageQueue.Instance.Insert(logInfo);
IoManager.Instance.WriteOut("下左相机光源触发", 1);
Thread.Sleep(50);
@ -659,7 +662,7 @@ namespace Rs.MotionPlat.Flow
case EDischargeFlowStep.等待到下相机拍照结束位:
if (Ops.IsStop("LoadX") || GlobalVar.VirtualAxis)
{
logInfo = $"{nameof(DischargeFlow)}-已运动到下相机拍照结束位";
logInfo = GetClassName() + $"已运动到下相机拍照结束位";
MessageQueue.Instance.Insert(logInfo);
if(!GlobalVar.VirtualAxis)
{
@ -673,7 +676,7 @@ namespace Rs.MotionPlat.Flow
imgs = ImageProcess.GetAutoImage();
if ((imgs != null && imgs.Length == needGrabNum)|| GlobalVar.VirtualAxis)
{
logInfo = $"{nameof(DischargeFlow)}-相机拍照完成，准备处理照片";
logInfo = GetClassName() + $"相机拍照完成，准备处理照片";
MessageQueue.Instance.Insert(logInfo);
if (NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload)[0].ToType == TurnoverType.Turnover)
{
@ -707,7 +710,7 @@ namespace Rs.MotionPlat.Flow
mrs = VisionProcess.Instance.MatchDownCam(imgs);
if (mrs != null && mrs.Count == imgs.Length && (mrs.Where(m=>m.IsOK==true).Count()==imgs.Length || GlobalVar.DownCameraFlyRegrabNum==0))
{
logInfo = $"{nameof(DischargeFlow)}-图片处理完成，准备放料";
logInfo = GetClassName() + $"图片处理完成，准备放料";
MessageQueue.Instance.Insert(logInfo);
int count = 0;
foreach (Nozzle nozzle in NozzleManager.GetNozzlesByStatus( ENozzleStatus.ToUnload))
@ -751,7 +754,7 @@ namespace Rs.MotionPlat.Flow
else
{
reGrabCount = 0;
alarmInfo = $"【{string.Join(",", errCodeList)}】号排料吸嘴拍照失败";
alarmInfo = $"{string.Join(",", errCodeList)}号排料吸嘴拍照失败";
//DialogResult dr = Msg.ShowQuestion(, System.Windows.Forms.MessageBoxButtons.RetryCancel);
TestCenterMessageBox.Show(AlarmConstID.DownCameraFlyFailAlarm, alarmInfo, ETipButton.Retry | ETipButton.Cancel);
box = TestCenterMessageBox.WaitResult(AlarmConstID.DownCameraFlyFailAlarm);
@ -781,24 +784,24 @@ namespace Rs.MotionPlat.Flow
{
if (curNozzle.ToType == TurnoverType.Turnover)
{
logInfo = $"{nameof(DischargeFlow)}-{curNozzle.NozzleIndex}号排料吸嘴到周转盘{curNozzle.ToIndex + 1}号穴位上方";
logInfo = GetClassName() + $"号排料吸嘴到周转盘{curNozzle.ToIndex + 1}号穴位上方";
MessageQueue.Instance.Insert(logInfo);
curSlotPoint = TrayPointManager.GetSlotPoint( EStockType.Turnover, curNozzle.ToIndex + 1);
turnoverOffsetPoint = TurnoverSlotOffset.GetOffsetPoint(curNozzle.ToIndex + 1);
}
else if (curNozzle.ToType == TurnoverType.ToBeTested)
{
downSlot = GlobalTray.InputTray.GetSlot(ESlotStatus.NotHave);
if (downSlot != null)
{
curSlotPoint = TrayPointManager.GetSlotPoint( EStockType.Input, downSlot.Index);
logInfo = $"{nameof(DischargeFlow)}-{curNozzle.NozzleIndex}号排料吸嘴到input盘{downSlot.Index}号穴位上方";
MessageQueue.Instance.Insert(logInfo);
}
else
{
//downSlot = GlobalTray.InputTray.GetSlot(ESlotStatus.NotHave);
//if (downSlot != null)
//{
// curSlotPoint = TrayPointManager.GetSlotPoint( EStockType.Input, downSlot.Index);
// logInfo = $"{nameof(DischargeFlow)}-{curNozzle.NozzleIndex}号排料吸嘴到input盘{downSlot.Index}号穴位上方";
// MessageQueue.Instance.Insert(logInfo);
//}
//else
//{
}
//}
}
else if (curNozzle.ToType == TurnoverType.Passed)
{
@ -918,120 +921,192 @@ namespace Rs.MotionPlat.Flow
{
logInfo = $"{nameof(DischargeFlow)}-{curNozzle.NozzleIndex}号排料吸嘴已运动到放料位上方";
MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.丢料检测;
}
break;
case EDischargeFlowStep.丢料检测:
//获取所有需要放料的吸嘴，检测真空是否还在，如果真空异常则报警
List<Nozzle> lostNozzles = new List<Nozzle>();
List<Nozzle> toUnloadNozzles = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload);
foreach (var nozzle in toUnloadNozzles)
{
if(!Ops.IsOn(""))
{
lostNozzles.Add(nozzle);
}
}
if(lostNozzles.Count>0)
{
//弹框报警
alarmInfo = $"{lostNozzles.Select(ln=>ln.NozzleIndex).ToJoinString()}丢料报警";
//TestCenterMessageBox.Show(1, alarmInfo,);
msgBox = TestCenterMessageBox.WaitResult(1);
switch (msgBox.Button)
{
case ETipButton.Skip:
lostNozzles.ForEach(ln => ln.Reset());
break;
case ETipButton.Yes:
DischargeModuleGoSafePosFlow.Instance.GoSafePostion();
break;
default:
break;
}
}
else
{
flowStep = EDischargeFlowStep.到放料位下方;
}
break;
//case EDischargeFlowStep.到放料位下方:
// DischargeDumpFlow.Instance.Start(curNozzle.ToType, curNozzle.NozzleIndex, curNozzle.ToIndex);
// flowStep = EDischargeFlowStep.等待放料完成抬起;
// break;
case EDischargeFlowStep.到放料位下方:
DischargeDumpFlow.Instance.Start(curNozzle.ToType, curNozzle.NozzleIndex, curNozzle.ToIndex);
flowStep = EDischargeFlowStep.等待放料完成抬起;
if (curNozzle.ToType == TurnoverType.Turnover)
{
targetPos = SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight");
}
else
{
targetPos = SysConfigParam.GetValue<double>($"TrayNozzle{curNozzle.NozzleIndex}TakeHeight") + GlobalVar.DischargeNozzleDumpStockTrayOffset;
}
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(targetPos, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
logInfo = GetClassName() + $"{curNozzle.NozzleIndex}号排料吸嘴到放料位下方";
MessageQueue.Instance.Insert(logInfo);
VirtualAxisSleep();
flowStep = EDischargeFlowStep.等待到放料位下方;
}
else
{
MoveFailAlarm($"NozzleZ{curNozzle.NozzleIndex}", errCode);
}
break;
case EDischargeFlowStep.等待到放料位下方:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = GetClassName()+ $"{curNozzle.NozzleIndex}号排料吸嘴已运动到放料位下方";
MessageQueue.Instance.Insert(logInfo);
if (curNozzle.ToType == TurnoverType.Turnover)
{
/*打开周转盘真空吸*/
logInfo = GetClassName() + $"打开周转盘{curNozzle.ToIndex + 1}号穴位真空吸";
MessageQueue.Instance.Insert(logInfo);
Ops.On($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸");
Thread.Sleep(GlobalVar.TurnoverTrayOpenVacSuctionDelaytime);
/*关闭排料吸嘴真空吸*/
logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸";
MessageQueue.Instance.Insert(logInfo);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");//关闭真空
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
/*打开排料吸嘴真空破*/
logInfo = GetClassName() + $"打开{curNozzle.NozzleIndex}号排料吸嘴真空破";
MessageQueue.Instance.Insert(logInfo);
Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
flowStep = EDischargeFlowStep.到放料关破真空位;
}
else
{
/*关闭排料吸嘴真空吸*/
logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸";
MessageQueue.Instance.Insert(logInfo);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
/*关闭排料吸嘴真空吸*/
logInfo = GetClassName() + $"打开{curNozzle.NozzleIndex}号排料吸嘴真空破";
MessageQueue.Instance.Insert(logInfo);
Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
/*关闭排料吸嘴真空吸*/
logInfo = GetClassName() + $"关闭{curNozzle.NozzleIndex}号排料吸嘴真空破";
MessageQueue.Instance.Insert(logInfo);
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
flowStep = EDischargeFlowStep.放料完成抬起;
}
}
break;
case EDischargeFlowStep.到放料关破真空位:
targetPos = SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight")+GlobalVar.DischargeNozzleDumpTurnoverTrayOffset;
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(targetPos, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
logInfo = GetClassName() + $"{curNozzle.NozzleIndex}号排料吸嘴周转盘放料完成，准备抬起{GlobalVar.DischargeNozzleDumpTurnoverTrayOffset}mm后关闭破真空";
MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.等待到放料关破真空位;
}
else
{
MoveFailAlarm($"NozzleZ{curNozzle.NozzleIndex}", errCode);
}
break;
case EDischargeFlowStep.等待到放料关破真空位:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
/*关闭排料吸嘴真空破*/
Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
logInfo = GetClassName() + $"{curNozzle.NozzleIndex}号排料吸嘴抬起{GlobalVar.DischargeNozzleDumpTurnoverTrayOffset}mm后关闭破真空";
MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.放料完成抬起;
}
break;
case EDischargeFlowStep.放料完成抬起:
errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
{
logInfo = GetClassName() + $"{curNozzle.NozzleIndex}号排料吸嘴放料完成抬起";
MessageQueue.Instance.Insert(logInfo);
if (GlobalVar.VirtualAxis)
{
Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
}
flowStep = EDischargeFlowStep.等待放料完成抬起;
}
else
{
MoveFailAlarm($"NozzleZ{curNozzle.NozzleIndex}", errCode);
}
break;
//case EWorkFlowStep.到放料位下方:
// logInfo = $"【{curNozzle.NozzleIndex}】号排料吸嘴到放料位下方";
// MessageQueue.Instance.Insert(logInfo);
// if (curNozzle.ToType == TurnoverType.Turnover)
// {
// targetPos = SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight");
// }
// else
// {
// targetPos = SysConfigParam.GetValue<double>($"TrayNozzle{curNozzle.NozzleIndex}TakeHeight") + 1;
// }
// errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(targetPos, GlobalVar.WholeSpeed);
// if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
// {
// VirtualAxisSleep();
// flowStep = EWorkFlowStep.等待到放料位下方;
// }
// else
// {
// MoveFailAlarm($"NozzleZ{curNozzle.NozzleIndex}", errCode);
// }
// break;
//case EWorkFlowStep.等待到放料位下方:
// if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
// {
// logInfo = $"【{curNozzle.NozzleIndex}】号排料吸嘴已运动到放料位下方";
// MessageQueue.Instance.Insert(logInfo);
// if (curNozzle.ToType== TurnoverType.Turnover)
// {
// /*打开周转盘真空吸*/
// MessageQueue.Instance.Insert($"打开周转盘{curNozzle.ToIndex + 1}号穴位真空吸");
// Ops.On($"周转盘{curNozzle.ToIndex + 1}号穴位真空吸");
// Thread.Sleep(GlobalVar.TurnoverTrayOpenVacSuctionDelaytime);
// /*关闭排料吸嘴真空吸*/
// MessageQueue.Instance.Insert($"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸");
// Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");//关闭真空
// Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
// /*打开排料吸嘴真空破*/
// MessageQueue.Instance.Insert($"打开{curNozzle.NozzleIndex}号排料吸嘴真空破");
// Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
// Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
// flowStep = EWorkFlowStep.到放料关破真空位;
// }
// else
// {
// /*关闭排料吸嘴真空吸*/
// MessageQueue.Instance.Insert($"关闭{curNozzle.NozzleIndex}号排料吸嘴真空吸");
// Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空吸电磁阀");
// Thread.Sleep(GlobalVar.LoadNozzleCloseVacSuctionDelaytime);
// /*关闭排料吸嘴真空吸*/
// MessageQueue.Instance.Insert($"打开{curNozzle.NozzleIndex}号排料吸嘴真空破");
// Ops.On($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
// Thread.Sleep(GlobalVar.LoadNozzleOpenVacBreakDelaytime);
// /*关闭排料吸嘴真空吸*/
// MessageQueue.Instance.Insert($"关闭{curNozzle.NozzleIndex}号排料吸嘴真空破");
// Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
// Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
// flowStep = EWorkFlowStep.放料完成抬起;
// }
// }
// break;
//case EWorkFlowStep.到放料关破真空位:
// targetPos = SysConfigParam.GetValue<double>($"TurnoverNozzle{curNozzle.NozzleIndex}TakeHeight");
// errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(targetPos + 1, GlobalVar.WholeSpeed);
// if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
// {
// MessageQueue.Instance.Insert($"{curNozzle.NozzleIndex}号排料吸嘴周转盘放料完成，准备微微抬起");
// flowStep = EWorkFlowStep.等待到放料关破真空位;
// }
// else
// {
// MoveFailAlarm($"NozzleZ{curNozzle.NozzleIndex}", errCode);
// }
// break;
//case EWorkFlowStep.等待到放料关破真空位:
// if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
// {
// /*关闭排料吸嘴真空破*/
// Ops.Off($"{curNozzle.NozzleIndex}号吸嘴真空破电磁阀");
// Thread.Sleep(GlobalVar.LoadNozzleCloseVacBreakDelaytime);
// MessageQueue.Instance.Insert($"{curNozzle.NozzleIndex}号排料吸嘴微微抬起后关闭破真空");
// flowStep = EWorkFlowStep.放料完成抬起;
// }
// break;
//case EWorkFlowStep.放料完成抬起:
// errCode = AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").MovePos(0, GlobalVar.WholeSpeed);
// if (errCode == ErrorCode.Ok || GlobalVar.VirtualAxis)
// {
// if (GlobalVar.VirtualAxis)
// {
// Thread.Sleep(GlobalVar.VirtualAxisMoveTime);
// }
// logInfo = $"{curNozzle.NozzleIndex}号排料吸嘴放料完成抬起";
// MessageQueue.Instance.Insert(logInfo);
// flowStep = EWorkFlowStep.等待放料完成抬起;
// }
// else
// {
// MoveFailAlarm($"NozzleZ{curNozzle.NozzleIndex}", errCode);
// }
// break;
case EDischargeFlowStep.等待放料完成抬起:
if (Ops.IsStop($"NozzleZ{curNozzle.NozzleIndex}") || GlobalVar.VirtualAxis)
{
logInfo = $"{nameof(DischargeFlow)}-{curNozzle.NozzleIndex}号排料吸嘴放料完成已起位，准备真空检测";
logInfo = GetClassName()+$"{curNozzle.NozzleIndex}号排料吸嘴放料完成已起位，准备真空检测";
MessageQueue.Instance.Insert(logInfo);
flowStep = EDischargeFlowStep.放料真空检测;
flowStep = EDischargeFlowStep.粘料检测;
}
break;
case EDischargeFlowStep.粘料检测:
curNozzle.VacSuction(EIoOperate.Open);
if(curNozzle.HasProduct())
{
//粘料报警,提示用户粘料，移动到安全位，或者点击跳过
alarmInfo = $"{curNozzle.NozzleIndex}号吸嘴可能粘料，请查看吸嘴状态后处理";
TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm);
switch (msgBox.Button)
{
case ETipButton.Skip:
logInfo =GetClassName()+ "选择了跳过按钮";
MessageQueue.Instance.Insert(logInfo);
break;
case ETipButton.Yes:
logInfo = GetClassName() + "选择了移动到安全位按钮";
MessageQueue.Instance.Insert(logInfo);
DischargeModuleGoSafePosFlow.Instance.GoSafePostion();
TestCenterMessageBox.Show(AlarmConstID.NozzleTackinessAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzleTackinessAlarm);
break;
}
}
else
{
curNozzle.VacSuction(EIoOperate.Close);
flowStep = EDischargeFlowStep.放料任务完成;
}
break;
case EDischargeFlowStep.放料真空检测:
@ -1114,7 +1189,7 @@ namespace Rs.MotionPlat.Flow
}
break;
case EDischargeFlowStep.放料任务完成:
logInfo = $"{nameof(DischargeFlow)}-放料任务完成";
logInfo = GetClassName()+ $"{curNozzle.ToType}盘放料任务完成";
MessageQueue.Instance.Insert(logInfo);
//AxisControl.GetAxis($"NozzleZ{curNozzle.NozzleIndex}").Home();
//MessageQueue.Instance.Insert($"{curNozzle.NozzleIndex}号排料吸嘴回原");
@ -1156,6 +1231,14 @@ namespace Rs.MotionPlat.Flow
}
else
{
if(curNozzle.ToType== TurnoverType.Turnover)
{
if (LoadAndUnloadTask.Instance.GetUndealedLoadToTurnoverTask().Count == 0)
{
//没有需要给周转盘上料的任务后，就开始上相机扫码
}
}
if (LoadAndUnloadTask.Instance.GetUnDealedTask().Count > 0)
{
flowStep = EDischargeFlowStep.到取料位上方;
@ -1406,6 +1489,6 @@ namespace Rs.MotionPlat.Flow
{
return flowStep.ToString();
}
}
}

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

@ -465,8 +465,8 @@ namespace Rs.MotionPlat.Flow
if (loseSlots.Count > 0)
{
alarmInfo = $"周转{string.Join(",", loseSlots)}号吸嘴真空异常丢料，请处理";
TestCenterMessageBox.Show(AlarmConstID.TestPosLoseMaterialAlarm, alarmInfo,MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TestPosLoseMaterialAlarm);
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo,MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm);
switch (msgBox.Button)
{
case ETipButton.Skip:
@ -599,8 +599,8 @@ namespace Rs.MotionPlat.Flow
{
//粘料报警
alarmInfo = $"周转{string.Join(",", loseSlots)}号吸嘴真空异常粘料，请手工处理";
TestCenterMessageBox.Show(AlarmConstID.TestPosLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TestPosLoseMaterialAlarm);
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm);
switch (msgBox.Button)
{
case ETipButton.Skip:
@ -1076,8 +1076,8 @@ namespace Rs.MotionPlat.Flow
if (loseSlots.Count > 0)
{
alarmInfo = $"周转{string.Join(",", loseSlots)}号吸嘴真空异常丢料，请处理";
TestCenterMessageBox.Show(AlarmConstID.TestPosLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TestPosLoseMaterialAlarm);
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm);
switch (msgBox.Button)
{
case ETipButton.Skip:
@ -1223,8 +1223,8 @@ namespace Rs.MotionPlat.Flow
{
//粘料报警
alarmInfo = $"周转{string.Join(",", loseSlots)}号吸嘴真空异常粘料，请手工处理";
TestCenterMessageBox.Show(AlarmConstID.TestPosLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.TestPosLoseMaterialAlarm);
TestCenterMessageBox.Show(AlarmConstID.NozzlesLoseMaterialAlarm, alarmInfo, MessageButtonManager.GetSkip_MoveToSafe_Button(), MessageButtonManager.GetSkip_MoveToSafe_ButtonText());
msgBox = TestCenterMessageBox.WaitResult(AlarmConstID.NozzlesLoseMaterialAlarm);
switch (msgBox.Button)
{
case ETipButton.Skip:

89
Rs.SkyLine/Flow/SubFlow/UpCameraScanBarCodeFlow.cs
Unescape Escape View File

@ -0,0 +1,89 @@
using Rs.Framework;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Entitys.Trays;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Rs.MotionPlat.Flow.SubFlow
{
enum EUpCameraScanBarCodeFlowStep
{
到扫码起始位,
到扫码结束位,
等待扫码结束,
拍照结果处理,
到扫码位上方,
等待运动到扫码位上方,
定点扫码,
定点扫码结果处理
}
/// <summary>
/// 上相机扫码流程
/// </summary>
public class UpCameraScanBarCodeFlow
{
private UpCameraScanBarCodeFlow() { }
private static UpCameraScanBarCodeFlow instance;
public static UpCameraScanBarCodeFlow Instance
{
get
{
if(instance == null)
instance = new UpCameraScanBarCodeFlow();
return instance;
}
}
private EUpCameraScanBarCodeFlowStep step = EUpCameraScanBarCodeFlowStep.到扫码起始位;
/// <summary>
/// 开始扫码，先把所有的穴位全部扫一遍，扫不到的最后再定点扫码,
/// 如果定位失败的穴位，即便没有扫到码，也不再扫码
/// </summary>
public void Scan()
{
int row = 1;
List<TurnoverTraySlot> slots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have);
slots.Where(s => s.Index > GlobalTray.TurnoverTray.ColumnNum).ToList();
while(true)
{
if(row==1)
{
slots.Where(s => s.Index <= GlobalTray.TurnoverTray.ColumnNum).ToList();
}
if(MachineManage.Instance.MachineStatus == EMachineStatus.Stop)
{
Thread.Sleep(10);
continue;
}
switch (step)
{
case EUpCameraScanBarCodeFlowStep.到扫码起始位:
break;
case EUpCameraScanBarCodeFlowStep.到扫码结束位:
break;
case EUpCameraScanBarCodeFlowStep.等待扫码结束:
break;
case EUpCameraScanBarCodeFlowStep.拍照结果处理:
break;
case EUpCameraScanBarCodeFlowStep.到扫码位上方:
break;
case EUpCameraScanBarCodeFlowStep.等待运动到扫码位上方:
break;
case EUpCameraScanBarCodeFlowStep.定点扫码:
break;
case EUpCameraScanBarCodeFlowStep.定点扫码结果处理:
break;
}
}
}
}
}

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

@ -184,6 +184,7 @@
<Compile Include="Flow\MonitorSystemButton.cs" />
<Compile Include="Flow\NgFlow\LoadUnloadTurnoverTrayDumpNgFlow.cs" />
<Compile Include="Flow\NgFlow\TransitModuleTackinessCheck.cs" />
<Compile Include="Flow\SubFlow\UpCameraScanBarCodeFlow.cs" />
<Compile Include="Flow\SubFlow\WarningSuckerNgFlow.cs" />
<Compile Include="Flow\RearrangeFlow.cs" />
<Compile Include="Flow\RearrangeTask.cs" />

Write Preview
Loading…
Cancel
Save