You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1054 lines
39 KiB
C#

11 months ago
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Rs.DataAccess;
using Rs.Framework;
using Rs.MotionPlat.Commom;
using Rs.MotionPlat.Entitys.Trays;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Rs.MotionPlat.Flow
{
public enum ETaskDealStatus
{
/// <summary>
/// 未处理过的任务
/// </summary>
Undeal,
/// <summary>
/// 已处理过的任务
/// </summary>
Dealed,
/// <summary>
/// 所有
/// </summary>
All
}
/// <summary>
/// 中控发过来的任务的类型
/// </summary>
public enum ETaskType
{
/// <summary>
/// 中转盘上料
/// </summary>
Load,
/// <summary>
/// 中转盘下料
/// </summary>
Unload,
/// <summary>
/// 中转盘换料
/// </summary>
Change,
/// <summary>
/// 测试工位上料
/// </summary>
TestLoad,
/// <summary>
/// 测试工位下料
/// </summary>
TestUnload
}
public class LoadAndUnloadTask
{
private SchedulingMaterial m_schedulingMaterial;
#region 中控发过来的任务
/// <summary>
/// 中转盘上料任务
/// </summary>
List<TurnoverInfo> loadTaskList = new List<TurnoverInfo>();
/// <summary>
/// 中转盘下料任务
/// </summary>
List<TurnoverInfo> unloadTaskList = new List<TurnoverInfo>();
/// <summary>
/// 中转盘换料任务
/// </summary>
List<TurnoverInfo> changeTaskList = new List<TurnoverInfo>();
/// <summary>
/// 测试位上料任务
/// </summary>
List<TurnoverInfo> testLoadTaskList = new List<TurnoverInfo>();
/// <summary>
/// 测试位下料任务
/// </summary>
List<TurnoverInfo> testUnloadTaskList = new List<TurnoverInfo>();
#endregion
List<TurnoverInfo> turnoverResult = new List<TurnoverInfo>();
SqliteHelper db = new SqliteHelper();
private LoadAndUnloadTask()
{
Categories = new List<TurnoverType>();
MoveDir = new List<string>();
}
public bool CanRunTask()
{
lock(this)
{
int count1 = GetTaskNum(ETaskType.Load) + GetTaskNum(ETaskType.Unload) + GetTaskNum(ETaskType.Change);
int count2 = GetTaskNum(ETaskType.TestLoad) + GetTaskNum(ETaskType.TestUnload);
if (count1 > 0 && count2 > 0)
return false;
return true;
}
}
private static LoadAndUnloadTask instance;
public static LoadAndUnloadTask Instance
{
get
{
if(instance==null)
{
instance = new LoadAndUnloadTask();
}
return instance;
}
}
public List<TurnoverInfo> GetTask()
{
List<TurnoverInfo> tilist = new List<TurnoverInfo>();
tilist.AddRange(loadTaskList);
tilist.AddRange(unloadTaskList);
tilist.AddRange(changeTaskList);
return tilist;
}
/// <summary>
/// 获取未执行的任务
/// </summary>
/// <returns></returns>
public List<TurnoverInfo> GetUnDealedTask()
{
List<TurnoverInfo> tilist = new List<TurnoverInfo>();
tilist.AddRange(loadTaskList.Where(tr=>tr.Dealed==false));
tilist.AddRange(unloadTaskList.Where(tr => tr.Dealed == false));
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>
public void ClearUndoTask()
{
List<TurnoverInfo> removeList = loadTaskList.Where(t => t.Dealed == false).ToList();
foreach(var t in removeList)
{
loadTaskList.Remove(t);
}
}
public void AddTurnoverResult(Nozzle nozzle)
{
TurnoverInfo turnoverInfo = new TurnoverInfo();
turnoverInfo.FromType = nozzle.FromType;
turnoverInfo.FromFloor = nozzle.FromFloor;
turnoverInfo.FromIndex = nozzle.FromIndex;
turnoverInfo.ToType = nozzle.ToType;
turnoverInfo.ToFloor = nozzle.ToFloor;
turnoverInfo.ToIndex = nozzle.ToIndex;
turnoverInfo.SN = nozzle.SN;
turnoverInfo.Dealed = true;
turnoverInfo.SuckerNo = nozzle.NozzleIndex;
turnoverResult.Add(turnoverInfo);
}
public void CopyBarcodeToTask(int slotIndex,string sn)
{
TurnoverInfo ti = turnoverResult.Where(r => r.ToIndex == slotIndex && r.ToType == TurnoverType.Turnover).First();
if(ti!=null)
{
ti.SN = sn;
}
}
/// <summary>
/// 获取测试治具上料的任务信息
/// </summary>
/// <param name="turnoverInfoList"></param>
/// <returns></returns>
public string GetLoadString()
{
TurnoverInfos infos = new TurnoverInfos();
infos.Instruction = EInstruction.LoadAndUnloadResult;
infos.GroupID = m_schedulingMaterial.GroupID;
infos.TurnoverID = m_schedulingMaterial.TurnoverID;
infos.Infos = turnoverResult;
string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
return content;
}
public string GetTestLoadString()
{
List<TurnoverInfo> turnoverInfos= new List<TurnoverInfo>();
//1、获取有产品的吸嘴
List<TransitNozzle> transitNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
foreach (TransitNozzle nozzle in transitNozzles)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = nozzle.FromType;
ti.FromFloor = nozzle.FromFloor;
ti.FromIndex = nozzle.FromIndex;
ti.SN = nozzle.SN;
ti.ToType = nozzle.ToType;
ti.ToFloor =nozzle.ToFloor;
ti.ToIndex = nozzle.ToIndex;
ti.SuckerNo = nozzle.NozzleIndex;
turnoverInfos.Add(ti);
}
//2、获取测试盘中有产品的穴位
List<TestTraySlot> testSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have);
foreach (TestTraySlot slot in testSlots)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = slot.FromType;
ti.FromFloor = 0;
ti.FromIndex = slot.FromIndex;
ti.SN = slot.SN;
ti.ToType = TurnoverType.Tester;
ti.ToFloor = 0;
ti.ToIndex = slot.Index-1;
turnoverInfos.Add(ti);
}
TurnoverInfos infos = new TurnoverInfos();
infos.Instruction = EInstruction.LoadAndUnloadResult;
infos.GroupID = m_schedulingMaterial.GroupID;
infos.TurnoverID = m_schedulingMaterial.TurnoverID;
infos.Infos = turnoverInfos;
string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
return content;
}
/// <summary>
/// 获取测试治具下料的任务信息
/// </summary>
/// <returns></returns>
public string GetTestUnLoadString()
{
//TurnoverInfos infos = new TurnoverInfos();
//infos.Instruction = EInstruction.LoadAndUnloadResult;
//infos.GroupID = m_schedulingMaterial.GroupID;
//infos.TurnoverID = m_schedulingMaterial.TurnoverID;
//infos.Infos = testUnloadTaskList;
//string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
//LogHelper.Debug("发送:" + content);
//return content;
List<TurnoverInfo> turnoverInfos = new List<TurnoverInfo>();
//1、获取有产品的吸嘴
List<TurnoverTraySlot> transitNozzles = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.Tested, ETurnoverTraySlotStatus.Have);
foreach (TurnoverTraySlot slot in transitNozzles)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = slot.FromType;
ti.FromFloor = 1;
ti.FromIndex = slot.FromIndex;
ti.SN = slot.SN;
ti.ToType = TurnoverType.Turnover;
ti.ToFloor = 1;
ti.ToIndex = slot.Index - 1;
ti.SuckerNo = slot.SuckerNo;
turnoverInfos.Add(ti);
}
TurnoverInfos infos = new TurnoverInfos();
infos.Instruction = EInstruction.LoadAndUnloadResult;
infos.GroupID = m_schedulingMaterial.GroupID;
infos.TurnoverID = m_schedulingMaterial.TurnoverID;
infos.Infos = turnoverInfos;
string content = JsonConvert.SerializeObject(infos, new StringEnumConverter());
return content;
}
/// <summary>
/// 获取从中转盘到测试位的任务
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
public List<TurnoverInfo> GetTurnoverToTestTasks(ETaskDealStatus status= ETaskDealStatus.All)
{
List<TurnoverInfo> reslut = new List<TurnoverInfo>();
switch (status)
{
case ETaskDealStatus.Undeal:
reslut = testLoadTaskList?.Where(t => t.Dealed == false).ToList();
break;
case ETaskDealStatus.Dealed:
reslut = testLoadTaskList?.Where(t => t.Dealed == true).ToList();
break;
case ETaskDealStatus.All:
reslut = testLoadTaskList;
break;
default:
break;
}
return reslut;
}
/// <summary>
/// 获取从测试位到的中转盘任务
/// </summary>
/// <returns></returns>
public List<TurnoverInfo> GetTestToTurnoverTasks(ETaskDealStatus status = ETaskDealStatus.All)
{
List<TurnoverInfo> reslut = new List<TurnoverInfo>();
switch (status)
{
case ETaskDealStatus.Undeal:
reslut = testUnloadTaskList?.Where(t => t.Dealed == false).ToList();
break;
case ETaskDealStatus.Dealed:
reslut = testUnloadTaskList?.Where(t => t.Dealed == true).ToList();
break;
case ETaskDealStatus.All:
reslut = testUnloadTaskList;
break;
default:
break;
}
return reslut;
}
/// <summary>
/// 根据任务的fromIndex获取任务
/// </summary>
/// <param name="fromIndex"></param>
/// <returns></returns>
public TurnoverInfo GetTestUnloadTask(int fromIndex)
{
return testUnloadTaskList.Where(t => t.FromIndex == fromIndex-1).First();
}
/// <summary>
/// 获取任务的个数
/// </summary>
/// <param name="taskMode"></param>
/// <returns></returns>
public int GetTaskNum(ETaskType taskMode)
{
lock(this)
{
switch (taskMode)
{
case ETaskType.Load:
if (loadTaskList == null) return 0;
return loadTaskList.Where(t => t.Dealed == false).Count();
case ETaskType.Unload:
if (unloadTaskList == null) return 0;
return unloadTaskList.Where(t => t.Dealed == false).Count();
case ETaskType.Change:
if (changeTaskList == null) return 0;
return changeTaskList.Where(t => t.Dealed == false).Count();
case ETaskType.TestLoad:
if (testLoadTaskList == null) return 0;
return testLoadTaskList.Where(t => t.Dealed == false).Count();
case ETaskType.TestUnload:
if (testUnloadTaskList == null) return 0;
return testUnloadTaskList.Where(t => t.Dealed == false).Count();
}
return 0;
}
}
/// <summary>
/// 任务数量
/// </summary>
public int Count
{
get
{
lock (this)
{
return loadTaskList.Count + unloadTaskList.Count + changeTaskList.Count + testLoadTaskList.Count + testUnloadTaskList.Count;
}
}
}
/// <summary>
/// 任务种类
/// </summary>
public List<TurnoverType> Categories { get; set; }
/// <summary>
/// 周转时的运动方向
/// </summary>
public List<string> MoveDir { get; set; }
/// <summary>
/// 清除任务
/// 任务类型0=排料任务1=测试任务
/// </summary>
public void Clear(int taskMode=0)
{
lock(this)
{
if (turnoverResult != null)
{
if (taskMode == 0)
{
turnoverResult.Clear();
loadTaskList.Clear();
unloadTaskList.Clear();
changeTaskList.Clear();
}
else if(taskMode==1)
{
testLoadTaskList.Clear();
testUnloadTaskList.Clear();
}
}
}
}
public SchedulingMaterial GetCurTask()
{
return m_schedulingMaterial;
}
/// <summary>
/// 向上下料任务中,添加任务
/// </summary>
/// <param name="sm"></param>
/// <returns></returns>
public bool AddTask(SchedulingMaterial sm)
{
lock (this)
{
m_schedulingMaterial = sm;
//加载上料任务
DealLoadTask(sm);
DealUnloadTask(sm);
DealChangeTask(sm);
DealTestLoadTask(sm);
DealTestUnLoadTask(sm);
}
//lock(this)
//{
// if (Categories != null && Categories.Count > 0)
// Categories.Clear();
// if (MoveDir != null && MoveDir.Count > 0)
// MoveDir.Clear();
// List<ActionItem> turnOverTaskList = new List<ActionItem>();
// List<ActionItem> otherTaskList = new List<ActionItem>();
// bool bHaveTurnover = false;
// bool bHaveOther = false;
// if (turnoverInfoList != null && turnoverInfoList.Count > 0)
// return false;
// //这里开始任务的分配
// //如果有从周转载盘到其他盘,
// var types = sm.ActionItems.GroupBy(ai => ai.Load.Type);
// foreach (var type in types)
// {
// if (type.Key == TurnoverType.Turnover)
// {
// bHaveTurnover = true;
// }
// else
// {
// bHaveOther = true;
// }
// Categories.Add(type.Key);
// }
// if (bHaveTurnover)
// {
// //turnOverTaskList = sm.ActionItems.Where(ai => ai.Load.Type == TurnoverType.Turnover).OrderBy(t => t.To.Type).ToList();
// turnOverTaskList = sm.ActionItems.Where(ai => ai.Load.Type == TurnoverType.Turnover).OrderBy(t => t.Load.Index).ToList();
// }
// if (bHaveOther)
// {
// otherTaskList = sm.ActionItems.Where(ai => ai.Load.Type != TurnoverType.Turnover).ToList();
// }
// if (bHaveTurnover && bHaveOther)
// {
// // 1 2 3 4 5 6 7
// // 1 2 3 4 5 6 7 8
// int maxNum = Math.Max(turnOverTaskList.Count, otherTaskList.Count);
// int nozzleNum = NozzleManager.GetNozzles().Count;
// for (int i = 0; i < maxNum; i += nozzleNum)
// {
// for(int nozzle=0;nozzle< nozzleNum; nozzle++)
// {
// if (turnOverTaskList.Count > i + nozzle)
// {
// TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + nozzle]);
// turnoverInfoList.Add(ti);
// }
// }
// for (int nozzle = 0; nozzle < nozzleNum; nozzle++)
// {
// if (otherTaskList.Count > i + nozzle)
// {
// TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + nozzle]);
// turnoverInfoList.Add(ti);
// }
// }
// //if (turnOverTaskList.Count >= i + 1)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 2)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 1]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 3)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 2]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 4)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 3]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 5)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 4]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 6)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 5]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 7)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 6]);
// // turnoverInfoList.Add(ti);
// //}
// //if (turnOverTaskList.Count >= i + 8)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, turnOverTaskList[i + 7]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 1)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 2)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 1]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 3)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 2]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 4)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 3]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 5)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 4]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 6)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 5]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 7)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 6]);
// // turnoverInfoList.Add(ti);
// //}
// //if (otherTaskList.Count >= i + 8)
// //{
// // TurnoverInfo ti = ActionItem2TurnoverInfo(sm, otherTaskList[i + 7]);
// // turnoverInfoList.Add(ti);
// //}
// }
// }
// else if (bHaveTurnover)
// {
// foreach (ActionItem ai in turnOverTaskList)
// {
// TurnoverInfo ti = ActionItem2TurnoverInfo(sm, ai);
// turnoverInfoList.Add(ti);
// }
// }
// else if (bHaveOther)
// {
// foreach (ActionItem ai in otherTaskList)
// {
// TurnoverInfo ti = ActionItem2TurnoverInfo(sm, ai);
// turnoverInfoList.Add(ti);
// }
// }
//}
//if(turnoverInfoList.Count>0)
//{
// Insert2Db();
//}
return true;
}
/// <summary>
/// 加载上料任务
/// </summary>
private void DealLoadTask(SchedulingMaterial sm)
{
if (sm == null)
return;
List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.ToBeTested).ToList();
if (ais != null && ais.Count > 0)
{
TurnoverFlow.Instance.CannotMoveFromTestTrayToTurnoverTray();
foreach (ActionItem item in ais)
{
loadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.Load));
}
}
}
/// <summary>
/// 加载下料任务
/// </summary>
private void DealUnloadTask(SchedulingMaterial sm)
{
if (sm == null)
return;
List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Turnover && (l.To.Type != TurnoverType.Turnover && l.To.Type != TurnoverType.Tester)).ToList();
if (ais != null && ais.Count > 0)
{
TurnoverFlow.Instance.CannotMoveFromTestTrayToTurnoverTray();
foreach (ActionItem item in ais)
{
unloadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.Unload));
}
}
}
/// <summary>
/// 加载换料任务
/// </summary>
private void DealChangeTask(SchedulingMaterial sm)
{
if (sm == null)
return;
List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Turnover && l.To.Type == TurnoverType.Turnover).ToList();
if(ais!=null&&ais.Count>0)
{
TurnoverFlow.Instance.CannotMoveFromTestTrayToTurnoverTray();
foreach (ActionItem item in ais)
{
changeTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.Change));
}
}
}
/// <summary>
/// 加载上料任务
/// </summary>
private void DealTestLoadTask(SchedulingMaterial sm)
{
lock(obj)
{
if (sm == null)
return;
List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Turnover && l.To.Type == TurnoverType.Tester).ToList();
if (ais != null && ais.Count > 0)
{
TestloadTaskArrived = true;
//如果上料任务列表里面有任务,说明是自己生成的任务,就不再向里面添加了
if (testLoadTaskList.Count > 0)
return;
foreach (ActionItem item in ais)
{
testLoadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.TestLoad));
}
}
}
}
/// <summary>
/// 测试治具下料任务是否已经到达
/// </summary>
public bool TestUnloadTaskArrived = false;
/// <summary>
/// 测试治具上料任务是否已经到达
/// </summary>
public bool TestloadTaskArrived = false;
/// <summary>
/// 加载上料任务
/// </summary>
private void DealTestUnLoadTask(SchedulingMaterial sm)
{
lock(obj)
{
if (sm == null)
return;
List<ActionItem> ais = sm.ActionItems.Where(l => l.Load.Type == TurnoverType.Tester && l.To.Type == TurnoverType.Turnover).ToList();
if (ais != null && ais.Count > 0)
{
TestUnloadTaskArrived = true;
//如果下料任务列表里面有任务,说明是自己生成的任务,就不再向里面添加了
if (testUnloadTaskList.Count > 0)
return;
foreach (ActionItem item in ais)
{
testUnloadTaskList.Add(ActionItem2TurnoverInfo(sm, item, ETaskType.TestUnload));
}
}
}
}
public TurnoverInfo GetLoadTask()
{
if (loadTaskList == null)
return null;
else
{
return loadTaskList.Where(t=>t.Dealed==false).First();
}
}
public TurnoverInfo GetUnLoadTask()
{
if (unloadTaskList == null || unloadTaskList.Where(t => t.Dealed == false).Count()==0)
return null;
else
{
return unloadTaskList.Where(t => t.Dealed == false).First();
}
}
public TurnoverInfo GetChangeTask()
{
if (changeTaskList == null)
return null;
else
{
return changeTaskList.Where(t => t.Dealed == false).First();
}
}
public TurnoverInfo GetTestLoadTask()
{
if (changeTaskList == null)
return null;
else
{
return testLoadTaskList.Where(t => t.Dealed == false).First();
}
}
public TurnoverInfo GetTestUnLoadTask()
{
if (changeTaskList == null)
return null;
else
{
return testUnloadTaskList.Where(t => t.Dealed == false).First();
}
}
private TurnoverInfo ActionItem2TurnoverInfo(SchedulingMaterial sm,ActionItem ai, ETaskType taskMode)
{
TurnoverInfo ti=new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = ai.Load.Type;
ti.FromFloor = ai.Load.Floor;
ti.FromIndex = ai.Load.Index;
ti.SN = ai.SN;
ti.ToType = ai.To.Type;
ti.ToFloor = ai.To.Floor;
ti.ToIndex = ai.To.Index;
ti.taskMode = taskMode;
ti.Instruction = sm.Instruction;
ti.GroupID = sm.GroupID;
ti.TurnoverID = sm.TurnoverID;
//MoveDir.Add(ti.FromType.ToString()+"_"+ti.ToType.ToString());
return ti;
}
/// <summary>
/// 创建测试治具上料任务
/// </summary>
public void CreateTestLoadTask()
{
lock(obj)
{
testLoadTaskList.Clear();
//从周转盘生成测试治具的上料任务
List<TurnoverTraySlot> slots = TurnoverTrayManager.Instance.GetSlots(ETurnoverTraySlotType.WaitTest, ETurnoverTraySlotStatus.Have);
foreach (TurnoverTraySlot slot in slots)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = TurnoverType.Turnover;
ti.FromFloor = 1;
ti.FromIndex = slot.Index - 1;
ti.SN = slot.SN;
ti.ToType = TurnoverType.Tester;
ti.ToFloor = 1;
ti.ToIndex = TestLoadSlotIndexChange(slot.Index) - 1;
ti.taskMode = ETaskType.TestLoad;
ti.Instruction = EInstruction.LoadAndUnload;
ti.GroupID = 0;
ti.TurnoverID = 0;
testLoadTaskList.Add(ti);
}
}
}
private static object obj = new object();
/// <summary>
/// 创建测试治具下料任务
/// </summary>
public void CreateTestUnLoadTask()
{
lock(obj)
{
testUnloadTaskList.Clear();
//从周转盘生成测试治具的上料任务
List<TestTraySlot> slots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have);
foreach (TestTraySlot slot in slots)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = TurnoverType.Tester;
ti.FromFloor = 1;
ti.FromIndex = slot.Index - 1;
ti.SN = slot.SN;
ti.ToType = TurnoverType.Turnover;
ti.ToFloor = 1;
ti.ToIndex = TestUnLoadSlotIndexChange(slot.Index) - 1;
ti.taskMode = ETaskType.TestLoad;
ti.Instruction = EInstruction.LoadAndUnload;
ti.GroupID = 0;
ti.TurnoverID = 0;
testUnloadTaskList.Add(ti);
}
}
}
/// <summary>
/// 测试位上料索引转换
/// </summary>
/// <returns></returns>
private int TestLoadSlotIndexChange(int slotIndex)
{
if (slotIndex <= 8) return slotIndex;
else return slotIndex - 8;
}
/// <summary>
/// 测试位下料到周转盘索引转换
/// </summary>
/// <param name="slotIndex"></param>
/// <returns></returns>
private int TestUnLoadSlotIndexChange(int slotIndex)
{
if (slotIndex <= 8) return slotIndex + 8;
else return slotIndex + 16;
}
/// <summary>
/// 创建从排料吸嘴到多功能料仓的下料任务
/// </summary>
public void CreateDischargeNozzleCleanOutTask()
{
lock(this)
{
List<Nozzle> unloadNozzles = NozzleManager.GetNozzlesByStatus(ENozzleStatus.ToUnload);
if (unloadNozzles != null && unloadNozzles.Count > 0)
{
foreach (Nozzle nozzle in unloadNozzles)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = TurnoverType.Turnover;
ti.FromFloor = 1;
ti.FromIndex = nozzle.NozzleIndex-1;
ti.SN = "";
ti.ToType = TurnoverType.Multifunction;
ti.ToFloor = 1;
ti.ToIndex = 0;
ti.taskMode = ETaskType.Unload;
ti.Instruction = EInstruction.LoadAndUnload;
ti.GroupID = 0;
ti.TurnoverID = 0;
unloadTaskList.Add(ti);
}
}
}
}
/// <summary>
/// 创建周转盘清料任务
/// </summary>
public void CreateTurnoverTrayCleanTask()
{
lock(this)
{
foreach(TurnoverTraySlot slot in TurnoverTrayManager.Instance.Slots)
{
if(slot.IsHasProduct)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = TurnoverType.Turnover;
ti.FromFloor = 1;
ti.FromIndex = slot.Index - 1;
ti.SN = "";
ti.ToType = TurnoverType.Multifunction;
ti.ToFloor = 1;
ti.ToIndex = 0;
ti.taskMode = ETaskType.Unload;
ti.Instruction = EInstruction.LoadAndUnload;
ti.GroupID = 0;
ti.TurnoverID = 0;
unloadTaskList.Add(ti);
}
}
}
}
/// <summary>
/// 创建周转吸嘴
/// </summary>
public void CreateTurnoverNozzleTestTrayCleanTask()
{
lock(this)
{
List<TransitNozzle> hasProductNozzles = TransitNozzleManager.Instance.GetHasProductNozzles();
if (hasProductNozzles != null && hasProductNozzles.Count > 0)
{
foreach (TransitNozzle nozzle in hasProductNozzles)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = TurnoverType.Tester;
ti.FromFloor = 1;
ti.FromIndex = nozzle.NozzleIndex-1;
ti.SN = "";
ti.ToType = TurnoverType.Turnover;
ti.ToFloor = 1;
ti.ToIndex = TestUnLoadSlotIndexChange(nozzle.NozzleIndex) - 1;
ti.taskMode = ETaskType.TestLoad;
ti.Instruction = EInstruction.LoadAndUnload;
ti.GroupID = 0;
ti.TurnoverID = 0;
testUnloadTaskList.Add(ti);
}
}
List<TestTraySlot> hasProductSlots = TestTrayManager.Instance.GetSlots(ETestTraySlotStatus.Have);
if (hasProductSlots != null && hasProductSlots.Count > 0)
{
foreach (TestTraySlot slot in hasProductSlots)
{
TurnoverInfo ti = new TurnoverInfo();
ti.GUID = GuidHelper.Create();
ti.FromType = TurnoverType.Tester;
ti.FromFloor = 1;
ti.FromIndex = slot.Index - 1;
ti.SN = "";
ti.ToType = TurnoverType.Turnover;
ti.ToFloor = 1;
ti.ToIndex = TestUnLoadSlotIndexChange(slot.Index) - 1;
ti.taskMode = ETaskType.TestLoad;
ti.Instruction = EInstruction.LoadAndUnload;
ti.GroupID = 0;
ti.TurnoverID = 0;
testUnloadTaskList.Add(ti);
}
}
}
}
}
/// <summary>
/// 排料任务管理
/// </summary>
public class DischargeTaskManager
{
private DischargeTaskManager() { }
private static DischargeTaskManager instance;
public static DischargeTaskManager Instance
{
get
{
if(instance==null)
instance = new DischargeTaskManager();
return instance;
}
}
public ETaskStatus Status { get; set; } = ETaskStatus.Idle;
private SchedulingMaterial m_schedulingMaterial;
/// <summary>
/// 上料任务
/// </summary>
List<TurnoverInfo> stockTray2TurnoverTrayList = new List<TurnoverInfo>();
/// <summary>
/// 下料任务
/// </summary>
List<TurnoverInfo> turnoverTray2StockTrayList = new List<TurnoverInfo>();
/// <summary>
/// 换料任务
/// </summary>
List<TurnoverInfo> turnoverTray2turnoverTrayList = new List<TurnoverInfo>();
}
/// <summary>
/// 周转任务管理
/// </summary>
public class TransitTaskManager
{
public ETaskStatus Status { get; set; } = ETaskStatus.Idle;
private SchedulingMaterial m_schedulingMaterial;
}
/// <summary>
/// 任务状态
/// </summary>
public enum ETaskStatus
{
Idle,
Running
}
}