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.
581 lines
26 KiB
C#
581 lines
26 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.SubFlow;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
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);
|
|
SchedulingResult schedulResult = new SchedulingResult();
|
|
SchedulingMaterial sm;
|
|
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.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("收到中控停止命令");
|
|
Task.Run(() => {
|
|
while(true)
|
|
{
|
|
bool bInput = (StockManager.Instance.GetStock(ETrayType.Input).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Input).Status == EStockTrayStatus.Unloaded);
|
|
|
|
bool bOk = (StockManager.Instance.GetStock(ETrayType.Ok).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Ok).Status == EStockTrayStatus.Unloaded);
|
|
|
|
bool bNg = (StockManager.Instance.GetStock(ETrayType.Ng).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Ng).Status == EStockTrayStatus.Unloaded);
|
|
|
|
bool bMulti = (StockManager.Instance.GetStock(ETrayType.Multi).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Multi).Status == EStockTrayStatus.Unloaded);
|
|
|
|
bool bEmpty2 = (StockManager.Instance.GetStock(ETrayType.Empty2).Status == EStockTrayStatus.Loaded
|
|
|| StockManager.Instance.GetStock(ETrayType.Empty2).Status == EStockTrayStatus.Unloaded);
|
|
if (bInput && bOk && bNg && bMulti && bEmpty2)
|
|
{
|
|
Ops.Stop();
|
|
break;
|
|
}
|
|
Thread.Sleep(10);
|
|
}
|
|
});
|
|
}
|
|
//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);
|
|
|
|
foreach (string json in Scheduling.GetJsons(msg))
|
|
{
|
|
Scheduling schedule = JsonConvert.DeserializeObject<Scheduling>(json);
|
|
EInstruction eInstructioneInstruction = schedule.Instruction;
|
|
if(eInstructioneInstruction!= EInstruction.InquireStatus)
|
|
{
|
|
LogHelper.Debug(" >>> " +json);
|
|
}
|
|
switch (eInstructioneInstruction)
|
|
{
|
|
case EInstruction.TransferSiloTray:
|
|
ReportToTestCenter(schedule);
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
|
|
NgTrayToInputTrayFlow.Instance.MoveToInput();
|
|
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Waiting);
|
|
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);
|
|
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());
|
|
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:
|
|
break;
|
|
case EInstruction.TakingError:
|
|
break;
|
|
case EInstruction.CancelTakingError:
|
|
break;
|
|
case EInstruction.ScanBarcode:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//string msg=Encoding.UTF8.GetString(data);
|
|
//LogHelper.TestCenterLog("接收:"+msg);
|
|
//ReciveTaskEvent?.Invoke(msg);
|
|
|
|
}
|
|
|
|
/// <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);
|
|
if (info.SiloType == SchedulingSiloBase.ESiloType.Multifunction)
|
|
{
|
|
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();
|
|
}
|
|
}
|
|
}
|
|
|
|
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:
|
|
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Input}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Input).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Passed:
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Ok}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Ok).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Failed:
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Ng}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Ng).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.Multifunction:
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Multi}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Multi).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.EmptyInput:
|
|
Task.Run(() => {
|
|
MessageQueue.Instance.Insert($"{ETrayType.Empty1}料仓收到切盘命令");
|
|
StockManager.Instance.GetStock(ETrayType.Empty1).Unload(EStockTrayUnLoadMode.Whole, null);
|
|
});
|
|
break;
|
|
case SchedulingSiloBase.ESiloType.EmptyOutput:
|
|
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) > 0;
|
|
}
|
|
|
|
public bool LoadTestLoadResult()
|
|
{
|
|
string content = LoadAndUnloadTask.Instance.GetTestLoadString();
|
|
return Send(content) > 0;
|
|
}
|
|
|
|
public bool LoadTestUnLoadResult()
|
|
{
|
|
string content = LoadAndUnloadTask.Instance.GetTestUnLoadString();
|
|
return Send(content) > 0;
|
|
}
|
|
|
|
public int Send(string content,bool writeLog=true)
|
|
{
|
|
int len = client.Send(content);
|
|
if(len>0 && writeLog)
|
|
{
|
|
LogHelper.Debug(" <<< " + content);
|
|
return len;
|
|
}
|
|
return 0;
|
|
}
|
|
/// <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,false);
|
|
}
|
|
else
|
|
{
|
|
string content = JsonConvert.SerializeObject(scheduing, new StringEnumConverter());
|
|
return Send(content);
|
|
}
|
|
}
|
|
|
|
public void EndInput()
|
|
{
|
|
Scheduling s = new Scheduling();
|
|
s.Instruction = EInstruction.EndInput;
|
|
string content = JsonConvert.SerializeObject(s, new StringEnumConverter());
|
|
Send(content);
|
|
}
|
|
|
|
|
|
public void ShowMsgBox(SchedulingMessageBox msgBox)
|
|
{
|
|
string content = JsonConvert.SerializeObject(msgBox, new StringEnumConverter());
|
|
client.Send(content,Encoding.UTF8);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|