using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Net;
|
using System.Text;
|
using System.Threading.Tasks;
|
using SA_LTT.Base;
|
using System.Collections;
|
using System.Threading;
|
|
namespace SA_LTT.Module
|
{
|
public enum VisionToControlCommand : short
|
{
|
VisionReadyAck = 150,
|
InspReadyEnd = 151,
|
|
WaferDetectionReadyAck = 250,
|
WaferDetectionReadyEnd = 251,
|
WaferDetectionStartAck= 252,
|
WaferDetectionResult = 253,
|
|
RecipeChangeSwitchAck = 750,
|
RecipeChangeUpdate = 751,
|
|
Alarm = 950,
|
AliveAck = 1050,
|
}
|
|
public enum ControlToVisionCommand : short
|
{
|
VisionReady = 100,
|
InspReadyEndAck = 101,
|
|
WaferDetectionReady = 200,
|
WaferDetectionReadyEndAck = 201,
|
WaferDetectionStart = 202,
|
WaferDetectionResultAck = 203,
|
|
RecipeSwitch = 700,
|
RecipeUpdateAck = 701,
|
|
AlarmAck = 900,
|
RequestAlive = 1000,
|
}
|
|
public class VisionControl : SocketClient
|
{
|
Equipment _equipment;
|
|
public Queue commandlist;
|
|
private bool IsDisposed = false;
|
private string _ip = "127.000.000.1";
|
private int _port = 9119;
|
|
private Thread communicationThread;
|
|
private int retry_connect_cnt;
|
|
private DateTime alive_check;
|
private DateTime connect_time_check;
|
|
private Dictionary<VisionToControlCommand, bool> _commnadAcks = new Dictionary<VisionToControlCommand, bool>();
|
private InspReadyEnd _inspectionReadyEndValue = new InspReadyEnd();
|
private WaferDetectionResult _waferDetectionResultValue = new WaferDetectionResult();
|
private RecipeSwitchAck _recipeSwitchAckValue = new RecipeSwitchAck();
|
private RecipeUpdate _recipeUpdateValue = new RecipeUpdate();
|
private AlarmOccured _alarmOccuredValue = new AlarmOccured();
|
private int _aliveAck;
|
|
public int AliveAck
|
{
|
get
|
{
|
return _aliveAck;
|
}
|
|
set
|
{
|
_aliveAck = value;
|
}
|
}
|
|
public Dictionary<VisionToControlCommand, bool> CommnadAcks { get => _commnadAcks; private set =>_commnadAcks = value; }
|
public InspReadyEnd InspectionReadyEndValue { get => _inspectionReadyEndValue; set => _inspectionReadyEndValue = value; }
|
public WaferDetectionResult WaferDetectionResultValue { get => _waferDetectionResultValue; set => _waferDetectionResultValue = value; }
|
public RecipeSwitchAck RecipeSwitchAckValue { get => _recipeSwitchAckValue; set => _recipeSwitchAckValue = value; }
|
public RecipeUpdate RecipeUpdateValue { get => _recipeUpdateValue; set => _recipeUpdateValue = value; }
|
public AlarmOccured AlarmOccuredValue { get => _alarmOccuredValue; set => _alarmOccuredValue = value; }
|
|
public VisionControl(Equipment equipment)
|
{
|
_equipment = equipment;
|
|
ChangeAddress(IPAddress.Parse("127.000.000.1"), 9119);
|
alive_check = DateTime.Now;
|
connect_time_check = DateTime.Now;
|
|
foreach(VisionToControlCommand value in Enum.GetValues(typeof(VisionToControlCommand)))
|
{
|
CommnadAcks.Add(value, false);
|
}
|
|
Add_received_event(Received);
|
|
commandlist = new Queue();
|
communicationThread = new Thread(CommandTrigger);
|
communicationThread.Start();
|
}
|
|
public new bool Connect()
|
{
|
try
|
{
|
if (base.Connect())
|
{
|
Thread.Sleep(50);
|
|
if (isConnected)
|
{
|
alive_check = DateTime.Now;
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
catch (Exception ex)
|
{
|
return false;
|
}
|
}
|
|
public void CommandTrigger()
|
{
|
DateTime heartBeatTime = DateTime.Now;
|
while (!_equipment.IsDisposed)
|
{
|
try
|
{
|
Thread.Sleep(10);
|
|
if (commandlist.Count > 0)
|
{
|
byte[] recvData = (byte[])commandlist.Dequeue();
|
byte[] size = new byte[4];
|
byte[] bcode = new byte[2];
|
|
Array.Copy(recvData, size, size.Length);
|
Array.Copy(recvData, 4, bcode, 0, bcode.Length);
|
short code = BitConverter.ToInt16(bcode, 0);
|
|
switch (code)
|
{
|
case (short)VisionToControlCommand.VisionReadyAck:
|
{
|
SendInspReadyEndAck();
|
break;
|
}
|
case (short)VisionToControlCommand.InspReadyEnd:
|
{
|
RecvInspReadyEnd(recvData, out _inspectionReadyEndValue);
|
|
break;
|
}
|
case (short)VisionToControlCommand.WaferDetectionReadyAck:
|
{
|
|
break;
|
}
|
case (short)VisionToControlCommand.WaferDetectionReadyEnd:
|
{
|
SendInspReadyEndAck();
|
break;
|
}
|
case (short)VisionToControlCommand.WaferDetectionStartAck:
|
{
|
break;
|
}
|
case (short)VisionToControlCommand.WaferDetectionResult:
|
{
|
RecvWaferDetectionResult(recvData, out _waferDetectionResultValue);
|
SendWaferDetectionResultAck();
|
break;
|
}
|
case (short)VisionToControlCommand.RecipeChangeSwitchAck:
|
{
|
RecvRecipeSwitchAck(recvData, out _recipeSwitchAckValue);
|
break;
|
}
|
case (short)VisionToControlCommand.RecipeChangeUpdate:
|
{
|
RecvRecipeUpdate(recvData, out _recipeUpdateValue);
|
break;
|
}
|
case (short)VisionToControlCommand.Alarm:
|
{
|
RecvAlarm(recvData, out _alarmOccuredValue);
|
break;
|
}
|
case (short)VisionToControlCommand.AliveAck:
|
{
|
AliveAck aliveAck;
|
RecvAliveAck(recvData, out aliveAck);
|
|
AliveAck = aliveAck.Run;
|
break;
|
}
|
default:
|
break;
|
}
|
|
alive_check = DateTime.Now;
|
|
if (CommnadAcks.ContainsKey((VisionToControlCommand)code))
|
{
|
CommnadAcks[(VisionToControlCommand)code] = true;
|
}
|
}
|
else
|
{
|
if((DateTime.Now - heartBeatTime).TotalSeconds > _equipment.settingParameterManager.SettingParameter.VisionHeartBeatTimeOut - 0.5)
|
{
|
SendRequestAlive();
|
heartBeatTime = DateTime.Now;
|
}
|
}
|
|
if ((DateTime.Now - alive_check).TotalSeconds > _equipment.settingParameterManager.SettingParameter.VisionHeartBeatTimeOut)
|
{
|
if (isConnected)
|
{
|
Disconnect();
|
continue;
|
}
|
}
|
|
if (isConnected == false)
|
{
|
if ((DateTime.Now - connect_time_check).TotalSeconds > 3)
|
{
|
if (Connect())
|
{
|
retry_connect_cnt = 0;
|
}
|
else
|
{
|
if (retry_connect_cnt > 3)
|
{
|
//Alarm.
|
}
|
|
retry_connect_cnt++;
|
}
|
|
connect_time_check = DateTime.Now;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
|
}
|
}
|
}
|
|
public void Received(object sender, ReceiveEventArgs events)
|
{
|
byte[] data = new byte[events.stateobject.Received_data.Length];
|
|
Array.Copy(events.stateobject.buffer, data, data.Length);
|
|
//===============================================
|
ArrayList recvList = new ArrayList();
|
byte[] data1;
|
byte[] data2;
|
while (true)
|
{
|
bool check = RecvData(data, out data1, out data2);
|
|
if (check)
|
{
|
if (data1 != null)
|
recvList.Add(data1);
|
|
break;
|
}
|
else
|
{
|
recvList.Add(data1);
|
|
data = data2;
|
}
|
}
|
//===============================================
|
|
foreach (byte[] commands in recvList)
|
{
|
commandlist.Enqueue(commands);
|
}
|
}
|
|
private bool RecvData(byte[] recvData, out byte[] Data1, out byte[] Data2)
|
{
|
try
|
{
|
ArrayList list = new ArrayList();
|
|
byte[] data = new byte[recvData.Length];
|
|
Array.Copy(recvData, data, data.Length);
|
|
byte[] bsize = new byte[4];
|
Array.Copy(data, bsize, bsize.Length);
|
|
int size = BitConverter.ToInt32(bsize, 0) + 6;
|
|
if (recvData.Length > size)
|
{
|
Data1 = new byte[size];
|
Array.Copy(recvData, Data1, Data1.Length);
|
|
Data2 = new byte[recvData.Length - size];
|
Array.Copy(recvData, Data1.Length, Data2, 0, Data2.Length);
|
|
return false;
|
}
|
else if (recvData.Length == size)
|
{
|
Data1 = new byte[size];
|
Array.Copy(recvData, Data1, Data1.Length);
|
|
Data2 = null;
|
|
return true;
|
}
|
else
|
{
|
Data1 = recvData;
|
Data2 = null;
|
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
Data1 = null;
|
Data2 = null;
|
return true;
|
}
|
}
|
|
public bool SendVisionReady(string recipeName)
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
byte[] sendRecipeName = new byte[20];
|
|
Array.Copy(Encoding.ASCII.GetBytes(recipeName), sendRecipeName, recipeName.Length);
|
body.InsertRange(body.Count, sendRecipeName);
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.VisionReady));
|
sendData.InsertRange(sendData.Count, body);
|
|
CommnadAcks[VisionToControlCommand.VisionReadyAck] = false;
|
CommnadAcks[VisionToControlCommand.InspReadyEnd] = false;
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendInspReadyEndAck()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.InspReadyEndAck));
|
sendData.InsertRange(sendData.Count, body);
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendWaferDetectionReady()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.WaferDetectionReady));
|
sendData.InsertRange(sendData.Count, body);
|
|
CommnadAcks[VisionToControlCommand.WaferDetectionReadyAck] = false;
|
CommnadAcks[VisionToControlCommand.WaferDetectionReadyEnd] = false;
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendWaferDetectionReadyEndAck()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.WaferDetectionReadyEndAck));
|
sendData.InsertRange(sendData.Count, body);
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendWaferDetectionStart()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.WaferDetectionStart));
|
sendData.InsertRange(sendData.Count, body);
|
|
CommnadAcks[VisionToControlCommand.WaferDetectionStartAck] = false;
|
CommnadAcks[VisionToControlCommand.WaferDetectionResult] = false;
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendWaferDetectionResultAck()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.WaferDetectionResultAck));
|
sendData.InsertRange(sendData.Count, body);
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendRecipeSwitch(string recipeName)
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
byte[] sendRecipeName = new byte[20];
|
|
Array.Copy(Encoding.ASCII.GetBytes(recipeName), sendRecipeName, recipeName.Length);
|
body.InsertRange(body.Count, sendRecipeName);
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.RecipeSwitch));
|
sendData.InsertRange(sendData.Count, body);
|
|
CommnadAcks[VisionToControlCommand.RecipeChangeSwitchAck] = false;
|
CommnadAcks[VisionToControlCommand.RecipeChangeUpdate] = false;
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendRecipeUpdateAck()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.RecipeUpdateAck));
|
sendData.InsertRange(sendData.Count, body);
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendAlarmAck()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.AlarmAck));
|
sendData.InsertRange(sendData.Count, body);
|
|
CommnadAcks[VisionToControlCommand.Alarm] = false;
|
|
return SendData(sendData.ToArray());
|
}
|
|
public bool SendRequestAlive()
|
{
|
List<byte> sendData = new List<byte>();
|
List<byte> body = new List<byte>();
|
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes(body.Count));
|
sendData.InsertRange(sendData.Count, BitConverter.GetBytes((short)ControlToVisionCommand.RequestAlive));
|
sendData.InsertRange(sendData.Count, body);
|
|
CommnadAcks[VisionToControlCommand.AliveAck] = false;
|
return SendData(sendData.ToArray());
|
}
|
|
private new bool SendData(byte[] data)
|
{
|
try
|
{
|
if (isConnected)
|
{
|
string str = string.Empty;
|
foreach (byte bt in data)
|
{
|
str += $"{bt} ";
|
}
|
|
return base.SendData(data);
|
}
|
else
|
{
|
return false;
|
}
|
}
|
catch (Exception ex)
|
{
|
return false;
|
}
|
}
|
|
//=================================================================
|
|
private void RecvInspReadyEnd(byte[] recvData, out InspReadyEnd value)
|
{
|
byte[] size = new byte[4];
|
byte[] command = new byte[2];
|
byte[] recipeName = new byte[20];
|
|
int copylength = 0;
|
Array.Copy(recvData, size, size.Length);
|
copylength += size.Length;
|
Array.Copy(recvData, copylength, command, 0, command.Length);
|
copylength += command.Length;
|
Array.Copy(recvData, copylength, recipeName, 0, recipeName.Length);
|
copylength += recipeName.Length;
|
|
string resultRecipeName = BitConverter.ToString(recipeName, 0);
|
|
value = new InspReadyEnd(resultRecipeName);
|
}
|
|
private void RecvWaferDetectionResult(byte[] recvData, out WaferDetectionResult value)
|
{
|
byte[] size = new byte[4];
|
byte[] command = new byte[2];
|
byte[] byteResult = new byte[4];
|
byte[] byteResultX = new byte[8];
|
byte[] byteResultY = new byte[8];
|
byte[] byteResultT = new byte[8];
|
|
int copylength = 0;
|
Array.Copy(recvData, size, size.Length);
|
copylength += size.Length;
|
Array.Copy(recvData, copylength, command, 0, command.Length);
|
copylength += command.Length;
|
Array.Copy(recvData, copylength, byteResult, 0, byteResult.Length);
|
copylength += byteResult.Length;
|
Array.Copy(recvData, copylength, byteResultX, 0, byteResultX.Length);
|
copylength += byteResultX.Length;
|
Array.Copy(recvData, copylength, byteResultY, 0, byteResultY.Length);
|
copylength += byteResultY.Length;
|
Array.Copy(recvData, copylength, byteResultT, 0, byteResultT.Length);
|
copylength += byteResultT.Length;
|
|
int result = BitConverter.ToInt32(byteResult, 0);
|
double resultX = BitConverter.ToDouble(byteResultX, 0);
|
double resultY = BitConverter.ToDouble(byteResultY, 0);
|
double resultT = BitConverter.ToDouble(byteResultT, 0);
|
|
resultY = -resultY;
|
|
value = new WaferDetectionResult(result, resultX, resultY, resultT);
|
}
|
|
private void RecvRecipeSwitchAck(byte[] recvData, out RecipeSwitchAck value)
|
{
|
byte[] size = new byte[4];
|
byte[] command = new byte[2];
|
byte[] byteResult = new byte[4];
|
|
int copylength = 0;
|
Array.Copy(recvData, size, size.Length);
|
copylength += size.Length;
|
Array.Copy(recvData, copylength, command, 0, command.Length);
|
copylength += command.Length;
|
Array.Copy(recvData, copylength, byteResult, 0, byteResult.Length);
|
copylength += byteResult.Length;
|
|
int result = BitConverter.ToInt32(byteResult, 0);
|
value = new RecipeSwitchAck(result);
|
}
|
|
private void RecvRecipeUpdate(byte[] recvData, out RecipeUpdate value)
|
{
|
byte[] size = new byte[4];
|
byte[] command = new byte[2];
|
byte[] recipeName = new byte[20];
|
|
int copylength = 0;
|
Array.Copy(recvData, size, size.Length);
|
copylength += size.Length;
|
Array.Copy(recvData, copylength, command, 0, command.Length);
|
copylength += command.Length;
|
Array.Copy(recvData, copylength, recipeName, 0, recipeName.Length);
|
copylength += recipeName.Length;
|
|
string resultRecipeName = BitConverter.ToString(recipeName, 0);
|
|
value = new RecipeUpdate(resultRecipeName);
|
}
|
|
private void RecvAlarm(byte[] recvData, out AlarmOccured value)
|
{
|
byte[] size = new byte[4];
|
byte[] command = new byte[2];
|
byte[] byteAlarmCode = new byte[4];
|
|
int copylength = 0;
|
Array.Copy(recvData, size, size.Length);
|
copylength += size.Length;
|
Array.Copy(recvData, copylength, command, 0, command.Length);
|
copylength += command.Length;
|
Array.Copy(recvData, copylength, byteAlarmCode, 0, byteAlarmCode.Length);
|
copylength += byteAlarmCode.Length;
|
|
int alarmCode = BitConverter.ToInt32(byteAlarmCode, 0);
|
|
value = new AlarmOccured(alarmCode);
|
}
|
|
private void RecvAliveAck(byte[] recvData, out AliveAck value)
|
{
|
byte[] size = new byte[4];
|
byte[] command = new byte[2];
|
byte[] byteResult = new byte[4];
|
|
int copylength = 0;
|
Array.Copy(recvData, size, size.Length);
|
copylength += size.Length;
|
Array.Copy(recvData, copylength, command, 0, command.Length);
|
copylength += command.Length;
|
Array.Copy(recvData, copylength, byteResult, 0, byteResult.Length);
|
copylength += byteResult.Length;
|
|
int result = BitConverter.ToInt32(byteResult, 0);
|
|
value = new AliveAck(result);
|
}
|
}
|
|
public struct VisionReadyAck
|
{
|
public int result { get; private set; }
|
|
public VisionReadyAck(int result = 0)
|
{
|
this.result = result;
|
}
|
}
|
|
public struct InspReadyEnd
|
{
|
public string RecipeName { get; private set; }
|
|
public InspReadyEnd(string recipeName)
|
{
|
this.RecipeName = recipeName;
|
}
|
}
|
|
public struct WaferDetectionResult
|
{
|
public int Result { get; private set; }
|
public double ResultX { get; private set; }
|
public double ResultY { get; private set; }
|
public double ResultT { get; private set; }
|
|
public WaferDetectionResult(int result, double resultX, double resultY, double resultT)
|
{
|
this.Result = result;
|
this.ResultX = resultX;
|
this.ResultY = resultY;
|
this.ResultT = resultT;
|
}
|
}
|
|
public struct RecipeSwitchAck
|
|
{
|
public int Result { get; private set; }
|
|
public RecipeSwitchAck(int result)
|
{
|
this.Result = result;
|
}
|
}
|
|
public struct RecipeUpdate
|
{
|
public string RecipeName { get; private set; }
|
|
public RecipeUpdate(string recipeName)
|
{
|
this.RecipeName = recipeName;
|
}
|
}
|
|
public struct AlarmOccured
|
{
|
public int AlarmCode { get; private set; }
|
|
public AlarmOccured(int alarmCode)
|
{
|
this.AlarmCode = alarmCode;
|
}
|
}
|
|
public struct AliveAck
|
{
|
public int Run { get; private set; }
|
|
public AliveAck(int run)
|
{
|
this.Run = run;
|
}
|
}
|
}
|
