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.
813 lines
39 KiB
C#
813 lines
39 KiB
C#
using HalconDotNet;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Converters;
|
|
using Rs.AutoDischarge.V3.Flow;
|
|
using Rs.Controls;
|
|
using Rs.Framework;
|
|
using Rs.MotionPlat.Commom;
|
|
using Rs.MotionPlat.Flow.Camera;
|
|
using Rs.MotionPlat.Flow.SafePosFlow;
|
|
using Rs.MotionPlat.Flow.SubFlow;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using static Rs.MotionPlat.Commom.SchedulingAlarms;
|
|
using static Rs.MotionPlat.Commom.SchedulingSilo;
|
|
using static System.Windows.Forms.AxHost;
|
|
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
|
|
|
|
namespace Rs.MotionPlat.Flow
|
|
{
|
|
public class TestCenter
|
|
{
|
|
TcpClientHelper client = new TcpClientHelper("127.0.0.1",2048);
|
|
//TcpClientHelper client = new TcpClientHelper("192.168.110.162", 2048);
|
|
SchedulingResult schedulResult = new SchedulingResult();
|
|
SchedulingMaterial sm;
|
|
Dictionary<int, AlarmItem> alarmInfos = new Dictionary<int, AlarmItem>();
|
|
public event Action<string> ReciveTaskEvent;
|
|
public event Action<string> ReplayTaskEvent;
|
|
private TestCenter() {
|
|
client.OnConnected += Client_OnConnected;
|
|
client.OnDisconnected += Client_OnDisconnected;
|
|
client.DataRecived += Client_DataRecived;
|
|
}
|
|
|
|
|
|
int slotIndex = 0;
|
|
|
|
private void SwitchStatus(SchedulingStatusInfo ssi)
|
|
{
|
|
switch (ssi.Type)
|
|
{
|
|
case SchedulingStatusInfo.InfoType.OneCycle:
|
|
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.DisableFixtureVacuumCheck:
|
|
LogHelper.Debug($"测试软件 >>> DisableFixtureVacuumCheck: {ssi.Info}");
|
|
GlobalVar.DisableFixtureVacuumCheck = bool.Parse(ssi.Info);
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.FixtureOpticalSensorCheck:
|
|
LogHelper.Debug($"测试软件 >>> FixtureOpticalSensorCheck:{ssi.Info}");
|
|
GlobalVar.EnableTestFixtureFiberCheck = bool.Parse(ssi.Info);
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.BarcodeLength:
|
|
LogHelper.Debug($"二维码长度设置 >>> BarcodeLength: {ssi.Info}");
|
|
GlobalVar.QrcodeLength = int.Parse(ssi.Info);
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.State:
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.RunStatus:
|
|
if(ssi.Info== "Started")
|
|
{
|
|
MachineManage.Instance.SetCenterMachineStatus(ERunStatus.Started);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Interrupt);
|
|
MessageQueue.Instance.Insert("收到中控启动命令");
|
|
Ops.Start();
|
|
}
|
|
else if(ssi.Info== "Stopped")
|
|
{
|
|
MessageQueue.Instance.Insert($"收到中控停止命令：{ssi.Info}");
|
|
Ops.Stop();
|
|
}
|
|
//else if(ssi.Info== "EndFlow")//Stopped
|
|
//{
|
|
|
|
//}
|
|
//WorkEnvironment.Instance.Ready();
|
|
//Task.Run(() => {
|
|
// if (WorkEnvironment.Instance.EnvReadyOkEvent.WaitOne())
|
|
// {
|
|
// WorkFlow.Instance.Start();
|
|
// TurnoverFlow.Instance.Start();
|
|
// MachineManage.Instance.RunState = ERunState.Waiting;
|
|
// MachineManage.Instance.MachineStatus = EMachineStatus.Working;
|
|
// }
|
|
//});
|
|
//MachineManage.Instance.RunStatus = ERunStatus.Started;
|
|
//MachineManage.Instance.RunState = ERunState.Interrupt;
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.RunMode://手动自动
|
|
MachineManage.Instance.RunMode = (ERunMode)Enum.Parse(typeof(ERunMode), ssi.Info.ToString());
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.InitializeState:
|
|
if(ssi.Info==EInitializeState.Initializing.ToString())
|
|
{
|
|
Ops.GoHome();
|
|
//MonitorSystemButton.Instance.ButtonPressed(ESystemButton.ResetPressed);
|
|
}
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.AssignMode:
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.Temperature:
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.AirPressure:
|
|
break;
|
|
}
|
|
client.Send(ssi.ToString());
|
|
LogHelper.Info(" <<< " + ssi.ToString());
|
|
}
|
|
private void Client_DataRecived(System.Net.Sockets.Socket socket, byte[] data)
|
|
{
|
|
string msg = Encoding.UTF8.GetString(data);
|
|
try
|
|
{
|
|
foreach (string json in Scheduling.GetJsons(msg))
|
|
{
|
|
//MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
Scheduling schedule = JsonConvert.DeserializeObject<Scheduling>(json);
|
|
EInstruction eInstructioneInstruction = schedule.Instruction;
|
|
if (eInstructioneInstruction != EInstruction.InquireStatus)
|
|
{
|
|
LogHelper.Debug(" >>> " + json);
|
|
}
|
|
switch (eInstructioneInstruction)
|
|
{
|
|
case EInstruction.EndFlow:
|
|
ReportToTestCenter(schedule);
|
|
MessageQueue.Instance.Insert("收到中控停止命令:EndFlow,等待各个料盘就绪");
|
|
EndFlow();
|
|
break;
|
|
case EInstruction.CheckTray:
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
|
|
ReportToTestCenter(schedule);
|
|
//这里开始检测料盘
|
|
List<int> hasProduct = new List<int>();
|
|
SchedulingCheckTray checkTraySchedule = (SchedulingCheckTray)json;
|
|
int checkNum = checkTraySchedule.ProductCount;
|
|
int lastIndex = DischargeFlow.Instance.GetLastTakeSlotIndex();
|
|
for(int i=0;i<checkNum;i++)
|
|
{
|
|
lastIndex++;
|
|
if(lastIndex <= (GlobalTray.InputTray.RowNum * GlobalTray.InputTray.ColumnNum))
|
|
{
|
|
SlotProductHasOrNotResult result = UpCameraCheckFlow.Instance.CheckStockTrayHasProduct(ETrayType.Input, lastIndex, true);
|
|
if (result.HasProduct)
|
|
{
|
|
hasProduct.Add(lastIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
checkTraySchedule.Instruction = EInstruction.CheckTrayResult;
|
|
checkTraySchedule.ProductCount = hasProduct.Count;
|
|
ReportToTestCenter(checkTraySchedule);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
break;
|
|
case EInstruction.MoveTurnoverArmToSafePoint:
|
|
ReportToTestCenter(schedule);
|
|
Task.Run(() => {
|
|
TransitModuleSafePosFlow.Instance.GoSafePostion(EExceptionSafePos.Socket,true);
|
|
});
|
|
break;
|
|
case EInstruction.Cleanout:
|
|
if(TurnoverFlow.Instance.GetStep()=="等待任务"&& DischargeFlow.Instance.GetCurStep()== "等待任务")
|
|
{
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
|
|
ReportToTestCenter(schedule);
|
|
Thread.Sleep(100);
|
|
//在这里启动
|
|
GlobalVar.CleanOut = true;
|
|
Ops.Start();
|
|
CleanOutFlow.Instance.CleanOut();
|
|
}
|
|
|
|
break;
|
|
case EInstruction.TransferSiloTray:
|
|
ReportToTestCenter(schedule);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
|
|
NgTrayToInputTrayFlow.Instance.MoveToInput();
|
|
//TakeTrayFlow.Instance.Take(ETrayType.Empty2, ETrayType.Ng,)
|
|
TakeTrayFlow.Instance.Take(ETrayType.Empty2, ETrayType.Ng,
|
|
() =>
|
|
{
|
|
GlobalTray.GetTray(ETrayType.Empty2).ChangeStatus(Controls.ESlotStatus.Null);
|
|
Task.Run(() =>
|
|
{
|
|
StockManager.Instance.GetStock(ETrayType.Empty2).Load(EStockTrayLoadMode.Whole, null);
|
|
});
|
|
|
|
}, null,
|
|
() =>
|
|
{
|
|
Task.Run(() =>
|
|
{
|
|
StockManager.Instance.GetStock(ETrayType.Ng).Load(EStockTrayLoadMode.AfterTakeTray, null);
|
|
});
|
|
});
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
MessageQueue.Instance.Insert("料盘搬运完成，设置等待指令状态");
|
|
//Ops.Stop();
|
|
break;
|
|
case EInstruction.TestFinished:
|
|
MessageQueue.Instance.Insert("测试完成:" + JsonConvert.SerializeObject(schedule, new StringEnumConverter()));
|
|
ReportToTestCenter(schedule);
|
|
MachineManage.Instance.TestStatus = ETestStatus.Finished;
|
|
break;
|
|
case EInstruction.Rearrange:
|
|
Rearrange(json);
|
|
break;
|
|
case EInstruction.InquireSiloStatus:
|
|
InquireSiloStatus(json);
|
|
break;
|
|
case EInstruction.RequestSwitchTray:
|
|
RequestSwitchTray(json);
|
|
break;
|
|
case EInstruction.InquireConnectionInfo:
|
|
InquireConnectionInfo(json);
|
|
break;
|
|
case EInstruction.LoadAndUnload:
|
|
LoadAndUnload(json);
|
|
break;
|
|
case EInstruction.CancelLoadAndUnload:
|
|
//schedulResult = new SchedulingResult() { Instruction = EInstruction.CancelLoadAndUnload, State = ERunState.Busying, GroupID = sm.GroupID, TurnoverID = sm.TurnoverID };
|
|
ReportToTestCenter(schedule);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
break;
|
|
case EInstruction.InquireStatus:
|
|
SchedulingStatusInfo statusInto = JsonConvert.DeserializeObject<SchedulingStatusInfo>(json);
|
|
switch (statusInto.Type)
|
|
{
|
|
case SchedulingStatusInfo.InfoType.State:
|
|
statusInto.Info = MachineManage.Instance.GetLoadUnloadStatus().ToString();// ERunState.Waiting.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.RunStatus:
|
|
statusInto.Info = MachineManage.Instance.GetCenterRunStatus().ToString();// ERunStatus.Started.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.RunMode:
|
|
statusInto.Info = MachineManage.Instance.RunMode.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.InitializeState:
|
|
statusInto.Info = MachineManage.Instance.InitializeState.ToString();// EInitializeState.Initialized.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.AssignMode:
|
|
statusInto.Info = EAssignMode.Normal.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.TesterState:
|
|
statusInto.Info = JsonConvert.SerializeObject(MachineManage.Instance.GetTesterInfo());//.ToString();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
ReportToTestCenter(statusInto);
|
|
//LogHelper.Debug(statusInto.ToString());
|
|
ReplayTaskEvent?.Invoke(statusInto.ToString());
|
|
break;
|
|
case EInstruction.SwitchStatus:
|
|
SchedulingStatusInfo switchStatus = JsonConvert.DeserializeObject<SchedulingStatusInfo>(msg);
|
|
SwitchStatus(switchStatus);
|
|
//MachineManage.Instance.MachineStatus= EMachineStatus.
|
|
//if (ss.TryConvertInfoTo<ERunMode>(out ERunMode runMode))
|
|
// MachineManage.Instance.RunMode = runMode;
|
|
//client.Send(ss.ToString());
|
|
//ReplayTaskEvent?.Invoke(ss.ToString());
|
|
break;
|
|
case EInstruction.ClearAlarm:
|
|
break;
|
|
case EInstruction.GetRecipeList:
|
|
SchedulingResult sr = JsonConvert.DeserializeObject<SchedulingResult>(msg);
|
|
sr.Message = "Default";
|
|
client.Send(sr.ToString());
|
|
ReplayTaskEvent?.Invoke(sr.ToString());
|
|
break;
|
|
case EInstruction.SetRecipe:
|
|
break;
|
|
case EInstruction.GetCurrentRecipe:
|
|
SchedulingResult srcur = JsonConvert.DeserializeObject<SchedulingResult>(msg);
|
|
srcur.Message = GlobalVar.CurRecipe;
|
|
client.Send(srcur.ToString());
|
|
ReplayTaskEvent?.Invoke(srcur.ToString());
|
|
break;
|
|
case EInstruction.TurnoverReady:
|
|
break;
|
|
case EInstruction.ChangeState:
|
|
SchedulingResult cs = JsonConvert.DeserializeObject<SchedulingResult>(msg);
|
|
client.Send(cs.ToString());
|
|
if(cs.State== ERunState.Error)
|
|
{
|
|
MessageQueue.Instance.Insert("中控报警");
|
|
Ops.Stop(() => {
|
|
LightManger.Instance.SetStatus(ELightStatus.Red);
|
|
});
|
|
}
|
|
ReplayTaskEvent?.Invoke(cs.ToString());
|
|
break;
|
|
case EInstruction.ShowMessage:
|
|
break;
|
|
case EInstruction.CloseMessage:
|
|
SchedulingMessageBox mbox = JsonConvert.DeserializeObject<SchedulingMessageBox>(json);
|
|
TestCenterMessageBox.RecivedMsg(mbox);
|
|
//TestCenterMessageBoxManager.GetMsgbox(mbox.ID)?.Recived(mbox);
|
|
break;
|
|
case EInstruction.MachineButtonDown:
|
|
break;
|
|
case EInstruction.MachineButtonUp:
|
|
break;
|
|
case EInstruction.TrayProductRange:
|
|
break;
|
|
case EInstruction.ClearTrayProductRange:
|
|
schedulResult = JsonConvert.DeserializeObject<SchedulingResult>(msg);
|
|
client.Send(schedulResult.ToString());
|
|
ReplayTaskEvent?.Invoke(schedulResult.ToString());
|
|
break;
|
|
case EInstruction.BeginSwitchTray:
|
|
break;
|
|
case EInstruction.MoveScanner:
|
|
break;
|
|
case EInstruction.InquireMoveScannerState:
|
|
break;
|
|
case EInstruction.SetAlarms:
|
|
break;
|
|
case EInstruction.CancelAlarms:
|
|
SchedulingAlarms alarms = JsonConvert.DeserializeObject<SchedulingAlarms>(msg);
|
|
if (alarms != null && alarms.Alarms != null && alarms.Alarms.Count > 0)
|
|
{
|
|
foreach (AlarmItem alarm in alarms.Alarms)
|
|
{
|
|
AlarmMessageBox.Close(alarm);
|
|
//if (!alarmInfos.ContainsKey(alarm.NO))
|
|
//{
|
|
// alarmInfos.Add(alarm.NO, alarm);
|
|
//}
|
|
}
|
|
}
|
|
break;
|
|
case EInstruction.TakingError:
|
|
break;
|
|
case EInstruction.CancelTakingError:
|
|
break;
|
|
case EInstruction.ScanBarcode:
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogHelper.Debug("receivedata:" + msg);
|
|
LogHelper.Debug("接收数据异常:"+ex.Message);
|
|
}
|
|
//string msg=Encoding.UTF8.GetString(data);
|
|
//LogHelper.TestCenterLog("接收:"+msg);
|
|
//ReciveTaskEvent?.Invoke(msg);
|
|
|
|
}
|
|
|
|
|
|
public AlarmItem? GetAlarm(int no)
|
|
{
|
|
AlarmItem? ret = null;
|
|
if (alarmInfos.ContainsKey(no))
|
|
{
|
|
ret = alarmInfos[no];
|
|
alarmInfos.Remove(no);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 重排
|
|
/// </summary>
|
|
/// <param name="json"></param>
|
|
private void Rearrange(string json)
|
|
{
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
|
|
SiloRearrange info = JsonConvert.DeserializeObject<SiloRearrange>(json);
|
|
ReportToTestCenter(info);
|
|
Thread.Sleep(200);
|
|
|
|
//TurnoverInfos tis = new TurnoverInfos();
|
|
//tis.GroupID = 0;
|
|
//tis.Instruction = EInstruction.RearrangeResult;
|
|
//ReportToTestCenter(tis);
|
|
//MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
//return;
|
|
if (info.SiloType == SchedulingSiloBase.ESiloType.Multifunction)
|
|
{
|
|
TraySlot ts = GlobalTray.MultiTray.GetSlot(Controls.ESlotStatus.NotHave);
|
|
if (ts == null || ts.Column == 0)//无需重排
|
|
{
|
|
TurnoverInfos tis = new TurnoverInfos();
|
|
tis.GroupID = 0;
|
|
tis.Instruction = EInstruction.RearrangeResult;
|
|
ReportToTestCenter(tis);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
}
|
|
else
|
|
{
|
|
Task.Run(() => {
|
|
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 == null || ts.Column == 0)//无需重排
|
|
{
|
|
TurnoverInfos tis = new TurnoverInfos();
|
|
tis.GroupID = 0;
|
|
tis.Instruction = EInstruction.RearrangeResult;
|
|
ReportToTestCenter(tis);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
}
|
|
else
|
|
{
|
|
Task.Run(() => {
|
|
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 == null || ts.Column == 0)
|
|
{
|
|
TurnoverInfos tis = new TurnoverInfos();
|
|
tis.GroupID = 0;
|
|
tis.Instruction = EInstruction.RearrangeResult;
|
|
ReportToTestCenter(tis);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
}
|
|
else
|
|
{
|
|
Task.Run(() => {
|
|
List<TurnoverInfo> rearrangeList = RearrangeManager.GeneralRearrangeTask(TurnoverType.Failed, TurnoverType.Failed, GlobalTray.NgTray, ts, 1);
|
|
RearrangeTask.AddRanage(rearrangeList);
|
|
RearrangeFlow.Instance.Rearrange();
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadAndUnload(string json)
|
|
{
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
|
|
sm = JsonConvert.DeserializeObject<SchedulingMaterial>(json);
|
|
schedulResult = new SchedulingResult() { Instruction = sm.Instruction, State = ERunState.Busying, GroupID = sm.GroupID, TurnoverID = sm.TurnoverID };
|
|
ReportToTestCenter(schedulResult);
|
|
LoadAndUnloadTask.Instance.AddTask(sm);
|
|
}
|
|
/// <summary>
|
|
/// 查询 状态
|
|
/// </summary>
|
|
/// <param name="json"></param>
|
|
private void InquireConnectionInfo(string json)
|
|
{
|
|
SchedulingConnectionInfo info = JsonConvert.DeserializeObject<SchedulingConnectionInfo>(json);
|
|
info.Type = SchedulingConnectionInfo.EType.Scheduling;
|
|
TestCenter.instance.ReportToTestCenter(info);
|
|
}
|
|
/// <summary>
|
|
/// 查询料仓状态
|
|
/// </summary>
|
|
/// <param name="json"></param>
|
|
private void InquireSiloStatus(string json)
|
|
{
|
|
SchedulingSilo inquireSilo = JsonConvert.DeserializeObject<SchedulingSilo>(json);
|
|
inquireSilo.SiloFloor = 1;
|
|
switch (inquireSilo.SiloType)
|
|
{
|
|
case SchedulingSiloBase.ESiloType.ToBeTested:
|
|
|
|
inquireSilo.SiloStatus = TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Input).Status);
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Passed:
|
|
inquireSilo.SiloStatus = TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Ok).Status);
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Failed:
|
|
inquireSilo.SiloStatus = TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Ng).Status);
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Multifunction:
|
|
inquireSilo.SiloStatus = TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Multi).Status);
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.EmptyInput:
|
|
inquireSilo.SiloStatus = TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Empty1).Status);
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.EmptyOutput:
|
|
inquireSilo.SiloStatus = TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Empty2).Status);
|
|
break;
|
|
}
|
|
TestCenter.instance.ReportToTestCenter(inquireSilo);
|
|
//查询料仓状态
|
|
}
|
|
|
|
private ESiloStatus TranlateSiloStatus(EStockTrayStatus status)
|
|
{
|
|
if (status == EStockTrayStatus.Loading || status == EStockTrayStatus.Unloading)
|
|
return ESiloStatus.Switching;
|
|
else if (status == EStockTrayStatus.Loaded )
|
|
return ESiloStatus.Standby;
|
|
else if(status == EStockTrayStatus.Unloaded)
|
|
{
|
|
return ESiloStatus.None;
|
|
}
|
|
return ESiloStatus.Stopped;
|
|
}
|
|
/// <summary>
|
|
/// 请求切盘
|
|
/// </summary>
|
|
private void RequestSwitchTray(string json)
|
|
{
|
|
SchedulingSilo inquireSilo = JsonConvert.DeserializeObject<SchedulingSilo>(json);
|
|
if(inquireSilo.Orientation== ESwitchOrientation.Recycle)
|
|
{
|
|
switch (inquireSilo.SiloType)
|
|
{
|
|
case SchedulingSiloBase.ESiloType.ToBeTested:
|
|
//StockManager.Instance.GetStock(ETrayType.Input).ChangeStatus(EStockTrayStatus.Unloading, true);
|
|
MessageQueue.Instance.Insert($"{ETrayType.Input}料仓收到切盘命令");
|
|
//Task.Run(() => {
|
|
|
|
//StockManager.Instance.GetStock(ETrayType.Input).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
TakeTrayFlow.Instance.Take(ETrayType.Input, ETrayType.Empty1, () => {
|
|
//StockManager.Instance.GetStock(ETrayType.Input).Status = EStockTrayStatus.Unloaded;
|
|
StockManager.Instance.GetStock(ETrayType.Input).ChangeStatus(EStockTrayStatus.Unloaded, true);
|
|
}, null, () => {
|
|
Task.Run(() => {
|
|
StockManager.Instance.GetStock(ETrayType.Empty1).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
});
|
|
//});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Passed:
|
|
StockManager.Instance.GetStock(ETrayType.Ok).ChangeStatus(EStockTrayStatus.Unloading, true);
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Ok}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Ok).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Failed:
|
|
StockManager.Instance.GetStock(ETrayType.Ng).ChangeStatus(EStockTrayStatus.Unloading, true);
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Ng}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Ng).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Multifunction:
|
|
StockManager.Instance.GetStock(ETrayType.Multi).ChangeStatus(EStockTrayStatus.Unloading, true);
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Multi}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Multi).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.EmptyInput:
|
|
StockManager.Instance.GetStock(ETrayType.Empty1).ChangeStatus(EStockTrayStatus.Unloading, true);
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Empty1}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Empty1).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.EmptyOutput:
|
|
StockManager.Instance.GetStock(ETrayType.Empty2).ChangeStatus(EStockTrayStatus.Unloading, true);
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Empty2}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Empty2).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
}
|
|
ReportToTestCenter(inquireSilo);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 断开连接
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
private void Client_OnDisconnected(System.Net.Sockets.Socket obj)
|
|
{
|
|
MessageQueue.Instance.Insert($"中控断开连接");
|
|
}
|
|
|
|
/// <summary>
|
|
/// 连接成功
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
private void Client_OnConnected(System.Net.Sockets.Socket obj)
|
|
{
|
|
MessageQueue.Instance.Insert($"中控连接成功");
|
|
}
|
|
|
|
private static TestCenter instance;
|
|
public static TestCenter Instance
|
|
{
|
|
get
|
|
{
|
|
if(instance==null)
|
|
{
|
|
instance = new TestCenter();
|
|
}
|
|
return instance;
|
|
}
|
|
}
|
|
|
|
public void Init()
|
|
{
|
|
client.Connect();
|
|
}
|
|
|
|
public bool LoadResult()
|
|
{
|
|
string content = LoadAndUnloadTask.Instance.GetLoadString();
|
|
return Send(content, Encoding.ASCII) > 0;
|
|
}
|
|
|
|
public bool LoadTestLoadResult()
|
|
{
|
|
string content = LoadAndUnloadTask.Instance.GetTestLoadString();
|
|
return Send(content, Encoding.ASCII) > 0;
|
|
}
|
|
|
|
public bool LoadTestUnLoadResult()
|
|
{
|
|
string content = LoadAndUnloadTask.Instance.GetTestUnLoadString();
|
|
return Send(content, Encoding.ASCII) > 0;
|
|
}
|
|
|
|
public int Send(string content,Encoding encode,bool writeLog=true)
|
|
{
|
|
// while (true)
|
|
{
|
|
int len = client.Send(content, encode);
|
|
|
|
if (len > 0)
|
|
{
|
|
if(writeLog)
|
|
{
|
|
LogHelper.Debug(" <<< " + content);
|
|
}
|
|
return len;
|
|
}
|
|
return len;
|
|
//Thread.Sleep(1000);
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
/// 上报信息给中控
|
|
/// </summary>
|
|
/// <param name="scheduing"></param>
|
|
/// <returns></returns>
|
|
public int ReportToTestCenter(Scheduling scheduing)
|
|
{
|
|
if(scheduing.Instruction== EInstruction.InquireStatus)
|
|
{
|
|
string content = JsonConvert.SerializeObject(scheduing, new StringEnumConverter());
|
|
return Send(content, Encoding.ASCII,false);
|
|
}
|
|
else
|
|
{
|
|
string content = JsonConvert.SerializeObject(scheduing, new StringEnumConverter());
|
|
return Send(content, Encoding.ASCII);
|
|
}
|
|
}
|
|
|
|
public void EndInput()
|
|
{
|
|
Scheduling s = new Scheduling();
|
|
s.Instruction = EInstruction.EndInput;
|
|
string content = JsonConvert.SerializeObject(s, new StringEnumConverter());
|
|
Send(content, Encoding.ASCII);
|
|
}
|
|
|
|
|
|
|
|
public void EndFlow()
|
|
{
|
|
|
|
Task.Run(() => {
|
|
while (true)
|
|
{
|
|
bool bInput = (StockManager.Instance.GetStock(ETrayType.Input).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Input).Status == EStockTrayStatus.Unloaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Input).Status == EStockTrayStatus.Empty);
|
|
|
|
bool bOk = (StockManager.Instance.GetStock(ETrayType.Ok).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Ok).Status == EStockTrayStatus.Unloaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Ok).Status == EStockTrayStatus.Empty);
|
|
|
|
bool bNg = (StockManager.Instance.GetStock(ETrayType.Ng).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Ng).Status == EStockTrayStatus.Unloaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Ng).Status == EStockTrayStatus.Empty);
|
|
|
|
bool bMulti = (StockManager.Instance.GetStock(ETrayType.Multi).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Multi).Status == EStockTrayStatus.Unloaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Multi).Status == EStockTrayStatus.Empty);
|
|
|
|
bool bEmpty2 = (StockManager.Instance.GetStock(ETrayType.Empty2).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Empty2).Status == EStockTrayStatus.Unloaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Empty2).Status == EStockTrayStatus.Empty);
|
|
|
|
if (bInput && bOk && bNg && bMulti && bEmpty2)
|
|
{
|
|
DischargeFlow.Instance.ResetScanNum();
|
|
Ops.Stop();
|
|
MessageQueue.Instance.Insert("料仓已全部就绪，设备停止运行");
|
|
break;
|
|
}
|
|
Thread.Sleep(100);
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
public void ShowMsgBox(SchedulingMessageBox msgBox)
|
|
{
|
|
try
|
|
{
|
|
string content = JsonConvert.SerializeObject(msgBox, new StringEnumConverter());
|
|
if (client.Send(content, Encoding.UTF8) > 0)
|
|
{
|
|
LogHelper.Debug($"<<< send to center:{content} success");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogHelper.Error($"ShowMsgBox {ex.Message}");
|
|
}
|
|
|
|
}
|
|
|
|
public void SwitchTray(ETrayType stockType,int floor)
|
|
{
|
|
SchedulingSilo tray = new SchedulingSilo();
|
|
tray.Instruction = EInstruction.BeginSwitchTray;
|
|
tray.SiloFloor = floor;
|
|
tray.TurnoverID = 0;
|
|
tray.GroupID = 0;
|
|
tray.SiloStatus = ESiloStatus.Switching;
|
|
switch (stockType)
|
|
{
|
|
case ETrayType.Empty1:
|
|
tray.SiloType = SchedulingSiloBase.ESiloType.EmptyInput;
|
|
break;
|
|
case ETrayType.Input:
|
|
tray.SiloType = SchedulingSiloBase.ESiloType.ToBeTested;
|
|
break;
|
|
case ETrayType.Ok:
|
|
tray.SiloType = SchedulingSiloBase.ESiloType.Passed;
|
|
break;
|
|
case ETrayType.Ng:
|
|
tray.SiloType = SchedulingSiloBase.ESiloType.Failed;
|
|
break;
|
|
case ETrayType.Multi:
|
|
tray.SiloType = SchedulingSiloBase.ESiloType.Multifunction;
|
|
break;
|
|
case ETrayType.Empty2:
|
|
tray.SiloType = SchedulingSiloBase.ESiloType.EmptyOutput;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
ReportToTestCenter(tray);
|
|
}
|
|
|
|
public void ReportStatusToCenter(SchedulingStatusInfo.InfoType intoType)
|
|
{
|
|
SchedulingStatusInfo statusInto = new SchedulingStatusInfo();
|
|
statusInto.Type=intoType;
|
|
statusInto.Instruction = EInstruction.InquireStatus;
|
|
switch (intoType)
|
|
{
|
|
case SchedulingStatusInfo.InfoType.State:
|
|
statusInto.Info = MachineManage.Instance.GetLoadUnloadStatus().ToString();// ERunState.Waiting.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.RunStatus:
|
|
statusInto.Info = MachineManage.Instance.GetCenterRunStatus().ToString();// ERunStatus.Started.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.RunMode:
|
|
statusInto.Info = MachineManage.Instance.RunMode.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.InitializeState:
|
|
statusInto.Info = MachineManage.Instance.InitializeState.ToString();// EInitializeState.Initialized.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.AssignMode:
|
|
statusInto.Info = EAssignMode.Normal.ToString();
|
|
break;
|
|
case SchedulingStatusInfo.InfoType.TesterState:
|
|
statusInto.Info = JsonConvert.SerializeObject(MachineManage.Instance.GetTesterInfo());//.ToString();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
ReportToTestCenter(statusInto);
|
|
}
|
|
}
|
|
}
|