using DIT.SharedMemory;
|
using log4net;
|
using log4net.Appender;
|
using log4net.Layout;
|
using log4net.Repository.Hierarchy;
|
using SocketCommunication;
|
using System;
|
using System.Collections;
|
using System.Net;
|
using System.Text;
|
using System.Threading;
|
|
namespace SHARP_CLAS_UI
|
{
|
public class Client_Align:IDisposable
|
{
|
#region Logger
|
/// <summary>
|
/// Exception Log
|
/// </summary>
|
private ILog ClientLog = LogManager.GetLogger("SHARP_CLAS_VISION_Align_Vision");
|
|
/// <summary>
|
/// Exception Log Write
|
/// </summary>
|
/// <param name="Methodname">Method name of exception that occurred</param>
|
/// <param name="ex">exception</param>
|
public void WriteClientLog(string message)
|
{
|
if (ClientLog != null) ClientLog.Debug($"{message}");
|
}
|
#endregion
|
|
#region Property
|
public bool isConnected { get { return client == null ? false : client.isConnected; } }
|
|
public string Ip { get { return ip; } }
|
public int Port { get { return port; } }
|
#endregion
|
|
#region Field
|
Equipment _equip;
|
|
private SocketClient client;
|
public Queue commandlist;
|
|
Vision_Control vision_control;
|
|
SharedMemory sm;
|
|
private bool IsDisposed = false;
|
public readonly string Clientname = "Align_PC";
|
private string ip = "126.100.100.11";
|
private int port = 8119;
|
|
private Thread communicationThread;
|
|
private int retry_connect_cnt;
|
|
private DateTime alive_check;
|
private DateTime connect_time_check;
|
#endregion
|
|
#region Construct
|
public Client_Align(Equipment _equip, string ip, int port)
|
{
|
Create_Client_logger();
|
|
this._equip = _equip;
|
|
sm = new SharedMemory("SHARP_CLAS", 10000, true);
|
sm.Open();
|
|
vision_control = new Vision_Control();
|
|
alive_check = DateTime.Now;
|
connect_time_check = DateTime.Now;
|
|
this.ip = ip;
|
this.port = port;
|
|
Init_Client();
|
|
commandlist = new Queue();
|
communicationThread = new Thread(Command_trigger);
|
communicationThread.Start();
|
}
|
#endregion
|
|
#region Function
|
/// <summary>
|
/// Create excepton logger
|
/// </summary>
|
private void Create_Client_logger()
|
{
|
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
|
RollingFileAppender rollingAppender = new RollingFileAppender();
|
|
PatternLayout layout = new PatternLayout();
|
hierarchy.Configured = true;
|
|
rollingAppender.Name = "ClientRollingFile";
|
rollingAppender.LockingModel = new RollingFileAppender.MinimalLock();
|
rollingAppender.File = $@"D:\Logger\Align_Vision\";
|
rollingAppender.AppendToFile = true;
|
rollingAppender.DatePattern = "yyyy\\\\MM\\\\'Align_Vision'_dd'.log'";
|
rollingAppender.RollingStyle = RollingFileAppender.RollingMode.Composite;
|
rollingAppender.MaxSizeRollBackups = 10;
|
rollingAppender.MaximumFileSize = "100MB";
|
rollingAppender.StaticLogFileName = false;
|
rollingAppender.Encoding = Encoding.UTF8;
|
rollingAppender.PreserveLogFileNameExtension = true;
|
layout = new PatternLayout("%d{yyyy/MM/dd HH:mm:ss.fff} %m%n");
|
layout.ActivateOptions();
|
rollingAppender.Layout = layout;
|
rollingAppender.ActivateOptions();
|
|
hierarchy.GetLogger("SHARP_CLAS_VISION_AOI_Vision");
|
ILog log = LogManager.GetLogger("SHARP_CLAS_VISION_Align_Vision");
|
Logger l = (Logger)log.Logger;
|
l.Level = log4net.Core.Level.Debug;
|
l.AddAppender(rollingAppender);
|
|
ClientLog = LogManager.GetLogger("SHARP_CLAS_VISION_Align_Vision");
|
}
|
|
private void Init_Client()
|
{
|
if (client != null) client.Disconnect();
|
|
client = new SocketClient(IPAddress.Parse(ip), port, Clientname);
|
client.Add_received_event(Received);
|
}
|
|
public bool Connect()
|
{
|
try
|
{
|
if (client.Connect())
|
{
|
Thread.Sleep(50);
|
|
if (client.isConnected)
|
{
|
WriteClientLog("Connection Success.");
|
alive_check = DateTime.Now;
|
return true;
|
}
|
else
|
{
|
WriteClientLog("Connection Fail.");
|
return false;
|
}
|
}
|
else
|
{
|
WriteClientLog("Connection Fail.");
|
Init_Client();
|
return false;
|
}
|
}
|
catch (Exception ex)
|
{
|
return false;
|
}
|
}
|
|
public void DisConnect()
|
{
|
client.Disconnect();
|
}
|
|
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;
|
}
|
}
|
//===============================================
|
WriteClientLog("Get data.");
|
|
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)
|
{
|
WriteClientLog($"{ex.Message}");
|
Data1 = null;
|
Data2 = null;
|
return true;
|
}
|
}
|
|
public bool SendData(byte[] data)
|
{
|
try
|
{
|
if (client != null && client.isConnected)
|
{
|
string str = string.Empty;
|
foreach (byte bt in data)
|
{
|
str += $"{bt} ";
|
}
|
|
return client.SendData(data);
|
}
|
else
|
throw new Exception($"{Clientname.ToString()} is not connected.");
|
}
|
catch (Exception ex)
|
{
|
return false;
|
}
|
}
|
|
public void Command_trigger()
|
{
|
while (!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 210:
|
{
|
RecipeChangeAck recipe_change_Ack;
|
vision_control.Recv_Recipe_Change_Ack(Recvdata, out recipe_change_Ack);
|
|
WriteClientLog($"[Recv]Recipe_Change, Result : {recipe_change_Ack.result}");
|
|
sm.Set_Bit(Vision_Address.Align_PC_Recipe_Change_Ack, true);
|
sm.Set_Value(Vision_Address.Align_PC_Recipe_Change_Result, recipe_change_Ack.result);
|
|
break;
|
}
|
case 220:
|
{
|
GrabReadyAck grab_ready_Ack;
|
vision_control.Recv_Grab_Read_Ack(Recvdata, out grab_ready_Ack);
|
|
if (grab_ready_Ack.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge Grab Ready, Result : {grab_ready_Ack.result}");
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Ready_Ack, true);
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
|
}
|
else if (grab_ready_Ack.SeqType == (int)En_SeqType.Pre_Align)
|
{
|
WriteClientLog($"[Recv]Pre Align Grab Ready, Result : {grab_ready_Ack.result}");
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Ready_Ack, true);
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
|
}
|
else if (grab_ready_Ack.SeqType == (int)En_SeqType.Fine_Align)
|
{
|
WriteClientLog($"[Recv]Fine Align Grab Ready, Result : {grab_ready_Ack.result}");
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Ready_Ack, true);
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
|
}
|
else if (grab_ready_Ack.SeqType == (int)En_SeqType.Measurement)
|
{
|
WriteClientLog($"[Recv]Measurement Grab Ready, Result : {grab_ready_Ack.result}");
|
sm.Set_Bit(Vision_Address.Measurement_Grab_Ready_Ack, true);
|
sm.Set_Bit(Vision_Address.Measurement_Grab_Ready_Result, grab_ready_Ack.result == 0 ? false : true);
|
}
|
|
break;
|
}
|
case 230:
|
{
|
GrabStartAck grab_start_Ack;
|
vision_control.Recv_Grab_Start_Ack(Recvdata, out grab_start_Ack);
|
|
if (grab_start_Ack.ModuleIdx == (int)En_Module_Idx.Left)
|
{
|
if (grab_start_Ack.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge Left Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Left_Ack, true);
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
else if (grab_start_Ack.SeqType == (int)En_SeqType.Pre_Align)
|
{
|
WriteClientLog($"[Recv]Pre Align Left Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Left_Ack, true);
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
else if (grab_start_Ack.SeqType == (int)En_SeqType.Fine_Align)
|
{
|
WriteClientLog($"[Recv]Fine Align Left Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Left_Ack, true);
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
else if (grab_start_Ack.SeqType == (int)En_SeqType.Measurement)
|
{
|
WriteClientLog($"[Recv]Measurement Left Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Left_Ack, true);
|
sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Left_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
}
|
else if (grab_start_Ack.ModuleIdx == (int)En_Module_Idx.Right)
|
{
|
if (grab_start_Ack.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge Right Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Right_Ack, true);
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
else if (grab_start_Ack.SeqType == (int)En_SeqType.Pre_Align)
|
{
|
WriteClientLog($"[Recv]Pre Align Right Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Right_Ack, true);
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
else if (grab_start_Ack.SeqType == (int)En_SeqType.Fine_Align)
|
{
|
WriteClientLog($"[Recv]Fine Align Right Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Right_Ack, true);
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
else if (grab_start_Ack.SeqType == (int)En_SeqType.Measurement)
|
{
|
WriteClientLog($"[Recv]Measurement Right Grab Start, Result : {grab_start_Ack.result}");
|
sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Right_Ack, true);
|
sm.Set_Bit(Vision_Address.Measurement_Grab_Start_Right_Result, grab_start_Ack.result == 0 ? false : true);
|
}
|
}
|
|
break;
|
}
|
case 241:
|
{
|
FilmJudgeResultAck film_judge_result_Ack;
|
vision_control.Recv_Film_Judge_Result(Recvdata, out film_judge_result_Ack);
|
if(film_judge_result_Ack.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge Left Result, Result : {film_judge_result_Ack.film_result}");
|
sm.Set_Bit(Vision_Address.Film_Judge_Left_Ack, true);
|
sm.Set_Value(Vision_Address.Film_Judge_Left_Result, film_judge_result_Ack.film_result);
|
}
|
|
break;
|
}
|
case 242:
|
{
|
FilmJudgeResultAck film_judge_result_Ack;
|
vision_control.Recv_Film_Judge_Result(Recvdata, out film_judge_result_Ack);
|
|
if (film_judge_result_Ack.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge Right Result, Result : {film_judge_result_Ack.film_result}");
|
sm.Set_Bit(Vision_Address.Film_Judge_Right_Ack, true);
|
sm.Set_Value(Vision_Address.Film_Judge_Right_Result, film_judge_result_Ack.film_result);
|
}
|
break;
|
}
|
case 251:
|
{
|
AlignResultAck align_result_Ack;
|
vision_control.Recv_Align_Result(Recvdata, out align_result_Ack);
|
|
WriteClientLog($"[Recv]Pre Align Left Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}");
|
sm.Set_Bit(Vision_Address.Pre_Align_Left_Ack, true);
|
sm.Set_Value(Vision_Address.Pre_Align_Left_Result, align_result_Ack.align_result);
|
sm.Set_Value(Vision_Address.Pre_Align_Left_Offset_X, align_result_Ack.AlignX);
|
sm.Set_Value(Vision_Address.Pre_Align_Left_Offset_Y, align_result_Ack.AlignY);
|
sm.Set_Value(Vision_Address.Pre_Align_Left_Offset_T, align_result_Ack.AlignAngle);
|
|
break;
|
}
|
case 252:
|
{
|
AlignResultAck align_result_Ack;
|
vision_control.Recv_Align_Result(Recvdata, out align_result_Ack);
|
|
WriteClientLog($"[Recv]Pre Align Right Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}");
|
sm.Set_Bit(Vision_Address.Pre_Align_Right_Ack, true);
|
sm.Set_Value(Vision_Address.Pre_Align_Right_Result, align_result_Ack.align_result);
|
sm.Set_Value(Vision_Address.Pre_Align_Right_Offset_X, align_result_Ack.AlignX);
|
sm.Set_Value(Vision_Address.Pre_Align_Right_Offset_Y, align_result_Ack.AlignY);
|
sm.Set_Value(Vision_Address.Pre_Align_Right_Offset_T, align_result_Ack.AlignAngle);
|
|
break;
|
}
|
case 261:
|
{
|
MeasurementResultAck measurement_result_Ack;
|
vision_control.Recv_Measurement_Result(Recvdata, out measurement_result_Ack);
|
|
if (measurement_result_Ack.moduleIdx == (int)En_Module_Idx.Left)
|
{
|
WriteClientLog($"[Recv]Measurement Left Result, Result : {measurement_result_Ack.align_result}, Mark_1_Point_1 : {measurement_result_Ack.Mark1Point1}, Mark_1_Point_2 : {measurement_result_Ack.Mark1Point2}, Mark_2_Point_1 : {measurement_result_Ack.Mark2Point1}, Mark_2_Point_2 : {measurement_result_Ack.Mark2Point2}, Mark_Distance : {measurement_result_Ack.MarkDistance}, Align_Result : {measurement_result_Ack.align_result}");
|
sm.Set_Bit(Vision_Address.Measurement_Left_Ack, true);
|
sm.Set_Value(Vision_Address.Measurement_Left_Result, measurement_result_Ack.measurement_result);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_1_Point_1, measurement_result_Ack.Mark1Point1);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_1_Point_2, measurement_result_Ack.Mark1Point2);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_2_Point_1, measurement_result_Ack.Mark2Point1);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_2_Point_2, measurement_result_Ack.Mark2Point2);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_3_Point_1, measurement_result_Ack.Mark3Point1);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_3_Point_2, measurement_result_Ack.Mark3Point2);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_4_Point_1, measurement_result_Ack.Mark4Point1);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_4_Point_2, measurement_result_Ack.Mark4Point2);
|
sm.Set_Value(Vision_Address.Measurement_Left_Mark_Distance, measurement_result_Ack.MarkDistance);
|
sm.Set_Value(Vision_Address.Measurement_Left_Align_Result, measurement_result_Ack.align_result);
|
}
|
break;
|
}
|
case 262:
|
{
|
MeasurementResultAck measurement_result_Ack;
|
vision_control.Recv_Measurement_Result(Recvdata, out measurement_result_Ack);
|
if (measurement_result_Ack.moduleIdx == (int)En_Module_Idx.Right)
|
{
|
WriteClientLog($"[Recv]Measurement Right Result, Result : {measurement_result_Ack.align_result}, Mark_1_Point_1 : {measurement_result_Ack.Mark1Point1}, Mark_1_Point_2 : {measurement_result_Ack.Mark1Point2}, Mark_2_Point_1 : {measurement_result_Ack.Mark2Point1}, Mark_2_Point_2 : {measurement_result_Ack.Mark2Point2}, Mark_Distance : {measurement_result_Ack.MarkDistance}, Align_Result : {measurement_result_Ack.align_result}");
|
sm.Set_Bit(Vision_Address.Measurement_Right_Ack, true);
|
sm.Set_Value(Vision_Address.Measurement_Right_Result, measurement_result_Ack.measurement_result);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_1_Point_1, measurement_result_Ack.Mark1Point1);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_1_Point_2, measurement_result_Ack.Mark1Point2);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_2_Point_1, measurement_result_Ack.Mark2Point1);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_2_Point_2, measurement_result_Ack.Mark2Point2);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_3_Point_1, measurement_result_Ack.Mark3Point1);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_3_Point_2, measurement_result_Ack.Mark3Point2);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_4_Point_1, measurement_result_Ack.Mark4Point1);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_4_Point_2, measurement_result_Ack.Mark4Point2);
|
sm.Set_Value(Vision_Address.Measurement_Right_Mark_Distance, measurement_result_Ack.MarkDistance);
|
sm.Set_Value(Vision_Address.Measurement_Right_Align_Result, measurement_result_Ack.align_result);
|
}
|
break;
|
}
|
case 271:
|
{
|
FineAlignResultAck align_result_Ack;
|
vision_control.Recv_Fine_Align_Result(Recvdata, out align_result_Ack);
|
|
WriteClientLog($"[Recv]Fine Align Left Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}, Mark Distance : {align_result_Ack.Mark_Distance}");
|
sm.Set_Bit(Vision_Address.Fine_Align_Left_Ack, true);
|
sm.Set_Value(Vision_Address.Fine_Align_Left_Result, align_result_Ack.align_result);
|
sm.Set_Value(Vision_Address.Fine_Align_Left_Offset_X, align_result_Ack.AlignX);
|
sm.Set_Value(Vision_Address.Fine_Align_Left_Offset_Y, align_result_Ack.AlignY);
|
sm.Set_Value(Vision_Address.Fine_Align_Left_Offset_T, align_result_Ack.AlignAngle);
|
sm.Set_Value(Vision_Address.Fine_Align_Left_Mark_Distance, align_result_Ack.Mark_Distance);
|
|
break;
|
}
|
case 272:
|
{
|
FineAlignResultAck align_result_Ack;
|
vision_control.Recv_Fine_Align_Result(Recvdata, out align_result_Ack);
|
|
WriteClientLog($"[Recv]Fine Align Right Result, Result : {align_result_Ack.align_result}, Offset X : {align_result_Ack.AlignX}, Offset Y : {align_result_Ack.AlignY}, Offset T : {align_result_Ack.AlignAngle}, Mark Distance : {align_result_Ack.Mark_Distance}");
|
sm.Set_Bit(Vision_Address.Fine_Align_Right_Ack, true);
|
sm.Set_Value(Vision_Address.Fine_Align_Right_Result, align_result_Ack.align_result);
|
sm.Set_Value(Vision_Address.Fine_Align_Right_Offset_X, align_result_Ack.AlignX);
|
sm.Set_Value(Vision_Address.Fine_Align_Right_Offset_Y, align_result_Ack.AlignY);
|
sm.Set_Value(Vision_Address.Fine_Align_Right_Offset_T, align_result_Ack.AlignAngle);
|
sm.Set_Value(Vision_Address.Fine_Align_Right_Mark_Distance, align_result_Ack.Mark_Distance);
|
|
break;
|
}
|
case 281:
|
{
|
MotorPosMoveReq motor_pos_move_Req;
|
vision_control.Recv_Motor_Pos_Move_Req(Recvdata, out motor_pos_move_Req);
|
if (motor_pos_move_Req.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
|
sm.Set_Bit(Vision_Address.Film_Judge_Motor_Pos_Ack, true);
|
sm.Set_Value(Vision_Address.Film_Judge_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
|
sm.Set_Value(Vision_Address.Film_Judge_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
|
}
|
else if (motor_pos_move_Req.SeqType == (int)En_SeqType.Pre_Align)
|
{
|
WriteClientLog($"[Recv]Pre Align Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
|
sm.Set_Bit(Vision_Address.Pre_Align_Motor_Pos_Ack, true);
|
sm.Set_Value(Vision_Address.Pre_Align_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
|
sm.Set_Value(Vision_Address.Pre_Align_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
|
}
|
else if (motor_pos_move_Req.SeqType == (int)En_SeqType.Fine_Align)
|
{
|
WriteClientLog($"[Recv]Fine Align Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
|
sm.Set_Bit(Vision_Address.Fine_Align_Motor_Pos_Ack, true);
|
sm.Set_Value(Vision_Address.Fine_Align_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
|
sm.Set_Value(Vision_Address.Fine_Align_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
|
}
|
else if (motor_pos_move_Req.SeqType == (int)En_SeqType.Measurement)
|
{
|
WriteClientLog($"[Recv]Measurement Motor Pos Move, moduleIdx : {motor_pos_move_Req.moduleIdx}, GrabIdx : {motor_pos_move_Req.GrabIdx}");
|
sm.Set_Bit(Vision_Address.Measurement_Motor_Pos_Ack, true);
|
sm.Set_Value(Vision_Address.Measurement_Motor_Pos_Module_Index, motor_pos_move_Req.moduleIdx);
|
sm.Set_Value(Vision_Address.Measurement_Motor_Pos_Grab_index, motor_pos_move_Req.GrabIdx);
|
}
|
break;
|
}
|
case 291:
|
{
|
UserCommandAck user_command_Ack;
|
vision_control.Recv_User_Command_Ack(Recvdata, out user_command_Ack);
|
|
if (user_command_Ack.SeqType == (int)En_SeqType.Film_Judge)
|
{
|
WriteClientLog($"[Recv]Film Judge User Command, Result : {user_command_Ack.result}");
|
sm.Set_Bit(Vision_Address.Film_Judge_User_Command_Ack, true);
|
sm.Set_Value(Vision_Address.Film_Judge_User_Command_Result, user_command_Ack.result);
|
}
|
else if (user_command_Ack.SeqType == (int)En_SeqType.Pre_Align)
|
{
|
WriteClientLog($"[Recv]Pre Align User Command, Result : {user_command_Ack.result}");
|
sm.Set_Bit(Vision_Address.Pre_Align_User_Command_Ack, true);
|
sm.Set_Value(Vision_Address.Pre_Align_User_Command_Result, user_command_Ack.result);
|
}
|
else if (user_command_Ack.SeqType == (int)En_SeqType.Fine_Align)
|
{
|
WriteClientLog($"[Recv]Fine Align User Command, Result : {user_command_Ack.result}");
|
sm.Set_Bit(Vision_Address.Fine_Align_User_Command_Ack, true);
|
sm.Set_Value(Vision_Address.Fine_Align_User_Command_Result, user_command_Ack.result);
|
}
|
else if (user_command_Ack.SeqType == (int)En_SeqType.Measurement)
|
{
|
WriteClientLog($"[Recv]Measurement User Command, Result : {user_command_Ack.result}");
|
sm.Set_Bit(Vision_Address.Measurement_User_Command_Ack, true);
|
sm.Set_Value(Vision_Address.Measurement_User_Command_Result, user_command_Ack.result);
|
}
|
break;
|
}
|
case 292:
|
{
|
SystemTimeSyncAck system_time_sync_Ack;
|
vision_control.Recv_System_Time_Sync_Ack(Recvdata, out system_time_sync_Ack);
|
|
WriteClientLog($"[Recv]System Time Sync, Result : {system_time_sync_Ack.result}");
|
sm.Set_Bit(Vision_Address.Align_PC_System_Time_Sync_Ack, true);
|
sm.Set_Value(Vision_Address.Align_PC_System_Time_Sync_Result, system_time_sync_Ack.result);
|
break;
|
}
|
case 100:
|
{
|
VisionAliveAck vision_alive_Ack;
|
vision_control.Recv_Vision_Alive(Recvdata, out vision_alive_Ack);
|
|
if (vision_alive_Ack.Controller == 1)
|
{
|
sm.Set_Bit(Vision_Address.Align_PC_Vision_Alive_Ack, true);
|
sm.Set_Value(Vision_Address.Align_PC_Vision_Alive_Heart_Beat, vision_alive_Ack.HeartBeat);
|
}
|
else if (vision_alive_Ack.Controller == 2)
|
{
|
sm.Set_Bit(Vision_Address.AOI_PC_Vision_Alive_Ack, true);
|
sm.Set_Value(Vision_Address.AOI_PC_Vision_Alive_Heart_Beat, vision_alive_Ack.HeartBeat);
|
}
|
|
alive_check = DateTime.Now;
|
break;
|
}
|
default:
|
break;
|
}
|
}
|
|
if ((DateTime.Now - alive_check).TotalSeconds > _equip.Setting.Vision_Connect_Time)
|
{
|
if (client.isConnected)
|
{
|
client.Disconnect();
|
continue;
|
}
|
}
|
|
if (!client.isConnected)
|
{
|
if ((DateTime.Now - connect_time_check).TotalSeconds > 3)
|
{
|
if (Connect())
|
{
|
retry_connect_cnt = 0;
|
}
|
else
|
{
|
if (retry_connect_cnt > 3)
|
{
|
//Alarm.
|
}
|
|
//Init_Client();
|
retry_connect_cnt++;
|
}
|
|
connect_time_check = DateTime.Now;
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
}
|
}
|
}
|
|
public void Dispose()
|
{
|
IsDisposed = true;
|
client.Disconnect();
|
}
|
#endregion
|
|
#region Send_Function
|
/// <summary>
|
/// Send Recipe Change Req
|
/// </summary>
|
/// <param name="RecipeMode">Recipe Move, 1 : 추가 , 2 : 변경(default), 3 : 삭제 => 현재 변경 고정 사용</param>
|
/// <param name="RecipeName">제품 구분 정보(레시피 명)</param>
|
public bool Send_Recipe_Change_Req(int RecipeMode, string RecipeName)
|
{
|
sm.Set_Bit(Vision_Address.Align_PC_Recipe_Change_Ack, false);
|
|
WriteClientLog($"[Send]Recipe_Change, RecipeMode : {RecipeMode}, RecipeName : {RecipeName}");
|
|
return SendData(vision_control.Send_Recipe_Change_Req(RecipeMode, RecipeName));
|
}
|
|
/// <summary>
|
/// Send Grab Ready Req
|
/// </summary>
|
/// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="GrabDir">단축 Grab(Default), 1: 단축 Grab</param>
|
/// <param name="PnlDir">0: 단면 물류 흐름 방향, 1: 장면 물류 흐름 방향</param>
|
/// <param name="StageNo">현재 검사를 위한 Panel이 로딩된 Stage 번호</param>
|
/// <param name="SlotNo">Tray Slot 번호</param>
|
/// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
|
/// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
|
public bool Send_Film_Judge_Grab_Ready(int ModuleIdx, int GrabDir, int PnlDir, int StageNo, int SlotNo, int PnlIdx, string PanelID)
|
{
|
int SeqType = 0;
|
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Ready_Ack, false);
|
|
if (ModuleIdx == 0)
|
sm.Set_Bit(Vision_Address.Film_Judge_Left_Ack, false);
|
else
|
sm.Set_Bit(Vision_Address.Film_Judge_Right_Ack, false);
|
|
WriteClientLog($"[Send]Film Judge Grab Ready, ModuleIdx : {ModuleIdx}, GrabDir : {GrabDir}, PnlDir : {PnlDir}, StageNo : {StageNo}, SlotNo : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
|
|
return SendData(vision_control.Send_Grab_Ready_Req(SeqType, ModuleIdx, GrabDir, PnlDir, StageNo, SlotNo, PnlIdx, PanelID));
|
}
|
|
/// <summary>
|
/// Send Grab Start Req
|
/// </summary>
|
/// <param name="ModelIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="MarkIdx">마크 위치 (0:Left, 1: Right)</param>
|
/// <param name="MotorOffsetX">현재 Motor Position X</param>
|
/// <param name="MotorOffsetY">현재 Motor Position Y</param>
|
public bool Send_Film_Judge_Grab_Start(int ModelIdx, int MarkIdx, double MotorOffsetX, double MotorOffsetY)
|
{
|
int SeqType = 0;
|
|
if (ModelIdx == 0)
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Left_Ack, false);
|
else
|
sm.Set_Bit(Vision_Address.Film_Judge_Grab_Start_Right_Ack, false);
|
|
WriteClientLog($"[Send]Film Judge Grab Start, ModelIdx : {ModelIdx}, MarkIdx : {MarkIdx}, MotorOffsetX : {MotorOffsetX}, MotorOffsetY : {MotorOffsetY}");
|
|
return SendData(vision_control.Send_Grab_Start_Req(SeqType, ModelIdx, MarkIdx, MotorOffsetX, MotorOffsetY));
|
}
|
|
/// <summary>
|
/// Send Command Req
|
/// </summary>
|
/// <param name="CmdType">0: Scrap(제거, 1: Retry(재시도), 3: Skip(NG), 4: Pass(OK), 5: User(수동선택)</param>
|
/// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="Slot_No">Tray Slot 번호</param>
|
/// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
|
/// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
|
public bool Send_Film_Judge_Command(int CmdType, int ModuleIdx, int Slot_No, int PnlIdx, string PanelID)
|
{
|
int SeqType = 0;
|
|
sm.Set_Bit(Vision_Address.Film_Judge_User_Command_Ack, false);
|
|
WriteClientLog($"[Send]Film Judge Command, CmdType : {CmdType}, ModuleIdx : {ModuleIdx}, Slot_No : {Slot_No}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
|
|
return SendData(vision_control.Send_Command_Req(CmdType, SeqType, ModuleIdx, Slot_No, PnlIdx, PanelID));
|
}
|
|
/// <summary>
|
/// Send Grab Ready Req
|
/// </summary>
|
/// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="GrabDir">단축 Grab(Default), 1: 단축 Grab</param>
|
/// <param name="PnlDir">0: 단면 물류 흐름 방향, 1: 장면 물류 흐름 방향</param>
|
/// <param name="StageNo">현재 검사를 위한 Panel이 로딩된 Stage 번호</param>
|
/// <param name="SlotNo">Tray Slot 번호</param>
|
/// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
|
/// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
|
public bool Send_Pre_Align_Grab_Ready(int ModuleIdx, int GrabDir, int PnlDir, int StageNo, int SlotNo, int PnlIdx, string PanelID)
|
{
|
int SeqType = 1;
|
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Ready_Ack, false);
|
|
if (ModuleIdx == 0)
|
sm.Set_Bit(Vision_Address.Pre_Align_Left_Ack, false);
|
else
|
sm.Set_Bit(Vision_Address.Pre_Align_Right_Ack, false);
|
|
WriteClientLog($"[Send]Pre Align Grab Ready, ModuleIdx : {ModuleIdx}, GrabDir : {GrabDir}, PnlDir : {PnlDir}, StageNo : {StageNo}, SlotNo : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
|
|
return SendData(vision_control.Send_Grab_Ready_Req(SeqType, ModuleIdx, GrabDir, PnlDir, StageNo, SlotNo, PnlIdx, PanelID));
|
}
|
|
/// <summary>
|
/// Send Grab Start Req
|
/// </summary>
|
/// <param name="ModelIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="MarkIdx">마크 위치 (0:Left, 1: Right)</param>
|
/// <param name="MotorOffsetX">현재 Motor Position X</param>
|
/// <param name="MotorOffsetY">현재 Motor Position Y</param>
|
public bool Send_Pre_Align_Grab_Start(int ModelIdx, int MarkIdx, double MotorOffsetX, double MotorOffsetY)
|
{
|
int SeqType = 1;
|
|
if (ModelIdx == 0)
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Left_Ack, false);
|
else
|
sm.Set_Bit(Vision_Address.Pre_Align_Grab_Start_Right_Ack, false);
|
|
WriteClientLog($"[Send]Pre Align Grab Start, ModelIdx : {ModelIdx}, MarkIdx : {MarkIdx}, MotorOffsetX : {MotorOffsetX}, MotorOffsetY : {MotorOffsetY}");
|
|
return SendData(vision_control.Send_Grab_Start_Req(SeqType, ModelIdx, MarkIdx, MotorOffsetX, MotorOffsetY));
|
}
|
|
/// <summary>
|
/// Send Command Req
|
/// </summary>
|
/// <param name="CmdType">0: Scrap(제거), 1: Retry(재시도), 2: Skip(NG), 3: Pass(OK), 4: User(수동선택)</param>
|
/// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="Slot_No">Tray Slot 번호</param>
|
/// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
|
/// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
|
public bool Send_Pre_Align_Command(int CmdType, int ModuleIdx, int Slot_No, int PnlIdx, string PanelID)
|
{
|
int SeqType = 1;
|
|
sm.Set_Bit(Vision_Address.Pre_Align_User_Command_Ack, false);
|
|
WriteClientLog($"[Send]Pre Align Command, CmdType : {CmdType}, ModuleIdx : {ModuleIdx}, Slot_No : {Slot_No}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
|
|
return SendData(vision_control.Send_Command_Req(CmdType, SeqType, ModuleIdx, Slot_No, PnlIdx, PanelID));
|
}
|
|
/// <summary>
|
/// Send Grab Ready Req
|
/// </summary>
|
/// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="GrabDir">단축 Grab(Default), 1: 단축 Grab</param>
|
/// <param name="PnlDir">0: 단면 물류 흐름 방향, 1: 장면 물류 흐름 방향</param>
|
/// <param name="StageNo">현재 검사를 위한 Panel이 로딩된 Stage 번호</param>
|
/// <param name="SlotNo">Tray Slot 번호</param>
|
/// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
|
/// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
|
public bool Send_Fine_Align_Grab_Ready(int ModuleIdx, int GrabDir, int PnlDir, int StageNo, int SlotNo, int PnlIdx, string PanelID)
|
{
|
int SeqType = 2;
|
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Ready_Ack, false);
|
|
if (ModuleIdx == 0)
|
sm.Set_Bit(Vision_Address.Fine_Align_Left_Ack, false);
|
else
|
sm.Set_Bit(Vision_Address.Fine_Align_Right_Ack, false);
|
|
WriteClientLog($"[Send]Fine Align Grab Ready, ModuleIdx : {ModuleIdx}, GrabDir : {GrabDir}, PnlDir : {PnlDir}, StageNo : {StageNo}, SlotNo : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
|
|
return SendData(vision_control.Send_Grab_Ready_Req(SeqType, ModuleIdx, GrabDir, PnlDir, StageNo, SlotNo, PnlIdx, PanelID));
|
}
|
|
/// <summary>
|
/// Send Grab Start Req
|
/// </summary>
|
/// <param name="ModelIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="MarkIdx">마크 위치 (0:Left, 1: Right)</param>
|
/// <param name="MotorOffsetX">현재 Motor Position X</param>
|
/// <param name="MotorOffsetY">현재 Motor Position Y</param>
|
public bool Send_Fine_Align_Grab_Start(int ModelIdx, int MarkIdx, double MotorOffsetX, double MotorOffsetY)
|
{
|
int SeqType = 2;
|
|
if (ModelIdx == 0)
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Left_Ack, false);
|
else
|
sm.Set_Bit(Vision_Address.Fine_Align_Grab_Start_Right_Ack, false);
|
|
WriteClientLog($"[Send]Fine Align Grab Start, ModelIdx : {ModelIdx}, MarkIdx : {MarkIdx}, MotorOffsetX : {MotorOffsetX}, MotorOffsetY : {MotorOffsetY}");
|
|
return SendData(vision_control.Send_Grab_Start_Req(SeqType, ModelIdx, MarkIdx, MotorOffsetX, MotorOffsetY));
|
}
|
|
/// <summary>
|
/// Send Command Req
|
/// </summary>
|
/// <param name="CmdType">0: Scrap(제거, 1: Retry(재시도), 3: Skip(NG), 4: Pass(OK), 5: User(수동선택)</param>
|
/// <param name="ModuleIdx">카메라 Module Idx (0: Left, 1: Right)</param>
|
/// <param name="SlotNo">Tray Slot 번호</param>
|
/// <param name="PnlIdx">Tray 내 Panel이 위치한 Idx 번호</param>
|
/// <param name="PanelID">Panel을 식별하기위한 ID (*없는 경우 NULL)</param>
|
public bool Send_Fine_Align_Command(int CmdType, int ModuleIdx, int SlotNo, int PnlIdx, string PanelID)
|
{
|
int SeqType = 2;
|
|
sm.Set_Bit(Vision_Address.Fine_Align_User_Command_Ack, false);
|
|
WriteClientLog($"[Send]Fine Align Command, CmdType : {CmdType}, ModuleIdx : {ModuleIdx}, Slot_No : {SlotNo}, PnlIdx : {PnlIdx}, PanelID : {PanelID}");
|
|
return SendData(vision_control.Send_Command_Req(CmdType, SeqType, ModuleIdx, SlotNo, PnlIdx, PanelID));
|
}
|
|
/// <summary>
|
/// Send Motor Pos Move Ack
|
/// </summary>
|
/// <param name="Return"> 0 : 위치 이동 완료 (Success), n : 기타 에러(Fail) 제어 정의.</param>
|
public bool Send_Motor_Pos_Move_Ack(int Return)
|
{
|
sm.Set_Bit(Vision_Address.Fine_Align_Motor_Pos_Ack, false);
|
|
WriteClientLog($"[Send]Motor_Pos_Move, Return : {Return}");
|
|
return SendData(vision_control.Send_Motor_Pos_Move_Ack(Return));
|
}
|
|
/// <summary>
|
/// Send System Time Sync Req
|
/// </summary>
|
public bool Send_System_Time_Sync()
|
{
|
sm.Set_Bit(Vision_Address.AOI_PC_System_Time_Sync_Ack, false);
|
|
return SendData(vision_control.Send_System_Time_Sync_Req());
|
}
|
#endregion
|
}
|
}
|
