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.

566 lines
26 KiB
C#

11 months ago
using HalconDotNet;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
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.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);
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:
GlobalVar.DisableFixtureVacuumCheck = bool.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("收到中控停止命令");
Ops.Stop();
}
//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:
DeviceTemprature.Instance.TargetTemprature = double.Parse(ssi.Info);
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))
{
Scheduling schedule = JsonConvert.DeserializeObject<Scheduling>(json);
EInstruction eInstructioneInstruction = schedule.Instruction;
if (eInstructioneInstruction != EInstruction.InquireStatus)
{
LogHelper.Debug(" >>> " + json);
}
switch (eInstructioneInstruction)
{
case EInstruction.Cleanout:
MachineManage.Instance.SetLoadUnloadStatus(ERunState.Busying);
ReportToTestCenter(schedule);
Thread.Sleep(100);
//在这里启动
GlobalVar.CleanOut = true;
Ops.Start();
CleanOutFlow.Instance.CleanOut();
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;
case SchedulingStatusInfo.InfoType.Temperature:
statusInto.Info = DeviceTemprature.Instance.CurTemprature.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:
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);
}
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 = ESiloStatus.Standby;// TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Input).Status);
break;
case SchedulingSiloBase.ESiloType.Passed:
inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Ok).Status);
break;
case SchedulingSiloBase.ESiloType.Failed:
inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Ng).Status);
break;
case SchedulingSiloBase.ESiloType.Multifunction:
inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Multi).Status);
break;
case SchedulingSiloBase.ESiloType.EmptyInput:
inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Empty1).Status);
break;
case SchedulingSiloBase.ESiloType.EmptyOutput:
inquireSilo.SiloStatus = ESiloStatus.Standby; //TranlateSiloStatus(StockManager.Instance.GetStock(ETrayType.Empty2).Status);
break;
}
TestCenter.instance.ReportToTestCenter(inquireSilo);
//查询料仓状态
}
/// <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:
// MessageQueue.Instance.Insert($"{ETrayType.Input}料仓收到切盘命令");
// //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:
// 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, 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 ShowMsgBox(SchedulingMessageBox msgBox)
{
try
{
string content = JsonConvert.SerializeObject(msgBox, new StringEnumConverter());
LogHelper.Debug($"<<< send to center: {content}");
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);
}
}
}