void IConnectionReport.OnSocketMessage(string Msg)
{
try
{
string[] MsgList = Msg.Split('\n');
foreach (string each in MsgList)
{
//logger.Debug("OnSocketMessage:" + each);
if (each.Trim().Equals(""))
{
continue;
}
ReturnMsg eachMsg = new ReturnMsg(each);
timeOutTimer.Enabled = false;
switch (eachMsg.GetFLG())
{
case "ACK":
if (LastSendCommand.GetFLG().Equals("CMD")) //如果送出的指令不是CMD，就做下一步，否則必須等待FIN才能繼續
{
SetStatus(Runing);
actionTimeOutTimer.Enabled = true;
tObj.On_Command_Excuted(ControllerName, eachMsg, LastSendCommand, LastJob);
}
else
{
SetStatus(Idle);
tObj.On_Command_Excuted(ControllerName, eachMsg, LastSendCommand, LastJob);
}
break;
case "NAK":
SetStatus(Idle);
tObj.On_Command_Error(ControllerName, eachMsg, LastSendCommand, LastJob);
//錯誤發生
logger.Error("Error happen:error code=" + eachMsg.GetDAT());
break;
case "FIN":
actionTimeOutTimer.Enabled = false;
SetStatus(Idle);
//下一步
if (eachMsg.GetDAT().Equals("00000000"))
{
tObj.On_Command_Finished(ControllerName, eachMsg, LastSendCommand, LastJob);
}
else
{
//錯誤發生
tObj.On_Command_Error(ControllerName, eachMsg, LastSendCommand, LastJob);
logger.Error("Error happen:error code=" + eachMsg.GetDAT());
}
break;
}
}
}
catch (Exception ex)
{
logger.Error("OnSocketMessage:" + ex.Message + "\n" + ex.StackTrace);
}
}
public void On_Connection_Message(object MsgObj)
{
try
{
List <ReturnMessage> ReturnMsgList;
string Msg = MsgObj.ToString();
logger.Debug(_Config.DeviceName + "Recieve:" + Msg.Replace("\r", ""));
//lock (_Decoder)
//{
ReturnMsgList = _Decoder.GetMessage(Msg);
//}
if (ReturnMsgList == null)
{
logger.Debug(_Config.DeviceName + " Decode parse error:" + Msg.Replace("\r", ""));
return;
}
if (ReturnMsgList.Count == 0)
{
logger.Debug(_Config.DeviceName + " Decode parse error:" + Msg.Replace("\r", ""));
}
foreach (ReturnMessage ReturnMsg in ReturnMsgList)
{
logger.Debug(_Config.DeviceName + "Each ReturnMsg:" + JsonConvert.SerializeObject(ReturnMsg));
try
{
Transaction Txn;
Node Node;
if (ReturnMsg != null)
{
Node = NodeManagement.GetByController(_Config.DeviceName, ReturnMsg.NodeAdr);
if (Node == null)
{
logger.Debug("Node not found!" + _Config.DeviceName + " - " + ReturnMsg.NodeAdr);
return;
}
//lock (TransactionList)
//{
lock (Node)
{
if (ReturnMsg.Type == ReturnMessage.ReturnType.Event)
{
_ReportTarget.On_Event_Trigger(Node, ReturnMsg);
}
else if (TransactionList.TryRemove(ReturnMsg.NodeAdr + ReturnMsg.IsInterrupt.ToString(), out Txn))
{
logger.Debug("Txn removed.");
switch (ReturnMsg.Type)
{
case ReturnMessage.ReturnType.Excuted:
if (!Txn.CommandType.Equals("CMD") && !Txn.CommandType.Equals("MOV"))
{
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
}
else
{
Txn.SetTimeOutMonitor(false);
Txn.SetTimeOut(15000);
Txn.SetTimeOutMonitor(true);
TransactionList.TryAdd(ReturnMsg.NodeAdr + ReturnMsg.IsInterrupt.ToString(), Txn);
}
_ReportTarget.On_Command_Excuted(Node, Txn, ReturnMsg);
break;
case ReturnMessage.ReturnType.Finished:
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
_ReportTarget.On_Command_Finished(Node, Txn, ReturnMsg);
break;
case ReturnMessage.ReturnType.Error:
Txn.SetTimeOutMonitor(false);
_ReportTarget.On_Command_Error(Node, Txn, ReturnMsg);
break;
case ReturnMessage.ReturnType.Information:
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
_ReportTarget.On_Command_Finished(Node, Txn, ReturnMsg);
//SpinWait.SpinUntil(() => false, 300);
ThreadPool.QueueUserWorkItem(new WaitCallback(conn.Send), ReturnMsg.FinCommand);
logger.Debug(_Config.DeviceName + "Send:" + ReturnMsg.FinCommand);
break;
}
}
else
{
logger.Debug(_Config.DeviceName + "(On_Connection_Message Txn is not found. msg:" + Msg);
switch (ReturnMsg.Type)
{
case ReturnMessage.ReturnType.Information:
case ReturnMessage.ReturnType.ReInformation:
ThreadPool.QueueUserWorkItem(new WaitCallback(conn.Send), ReturnMsg.FinCommand);
logger.Debug(_Config.DeviceName + "Send:" + ReturnMsg.FinCommand);
break;
}
}
}
//}
}
else
{
logger.Debug(_Config.DeviceName + "(On_Connection_Message Message decode fail:" + Msg);
}
}
catch (Exception e)
{
logger.Error(_Config.DeviceName + "(On_Connection_Message " + _Config.IPAdress + ":" + _Config.Port.ToString() + ")" + e.Message + "\n" + e.StackTrace);
}
}
}
catch (Exception e)
{
logger.Error(_Config.DeviceName + "(On_Connection_Message " + _Config.IPAdress + ":" + _Config.Port.ToString() + ")" + e.Message + "\n" + e.StackTrace);
}
}
public void DoWork(Transaction orgTxn, bool WaitForData = false)
{
Transaction Txn = null;
Txn = orgTxn;
if (Txn.CommandEncodeStr.Equals("GetMappingDummy"))
{
string mappingData = "";
if (Txn.NodeName.Equals("LOADPORT01"))
{
//mappingData = "1111111111111111111111111";
mappingData = SystemConfig.Get().FakeDataP1;
}
else if (Txn.NodeName.Equals("LOADPORT02"))
{
mappingData = SystemConfig.Get().FakeDataP2;
}
else if (Txn.NodeName.Equals("LOADPORT03"))
{
mappingData = SystemConfig.Get().FakeDataP3;
}
else if (Txn.NodeName.Equals("LOADPORT04"))
{
mappingData = SystemConfig.Get().FakeDataP4;
}
CommandReturnMessage cm = new CommandReturnMessage();
//cm.CommandType = Transaction.Command.LoadPortType.GetMapping;
cm.Value = mappingData;
//Txn.Method= Transaction.Command.LoadPortType.GetMapping;
_ReportTarget.On_Command_Excuted(NodeManagement.Get(Txn.NodeName), Txn, cm);
}
//conn.WaitForData(WaitForData);
// lock (TransactionList)
List <CommandReturnMessage> msgList = _Decoder.GetMessage(Txn.CommandEncodeStr);
if (!Txn.NodeType.Equals("OCR"))
{
if (msgList.Count != 0)
{
Txn.Type = msgList[0].Command;
//Txn.CommandType = msgList[0].CommandType;
}
}
else
{
Txn.Type = "";
//Txn.CommandType = "";
}
string key = "";
if (Vendor.ToUpper().Equals("KAWASAKI"))
{
key = Txn.Seq;
}
if (DeviceType.ToUpper().Equals("SMARTTAG"))
{
key = "00";
}
else if (Vendor.ToUpper().Equals("HST") || Vendor.ToUpper().Equals("COGNEX"))
{
key = "1" + Txn.Type;
}
else if (Vendor.ToUpper().Equals("SANWA") || Vendor.ToUpper().Equals("ATEL_NEW"))
{
key = Txn.AdrNo + Txn.Type;
//支援同時多發命令
for (int seq = 0; seq <= 99; seq++)
{
string tmpKey = key + seq.ToString("00");
if (!TransactionList.ContainsKey(tmpKey))
{
key = tmpKey;
break;
}
if (seq == 99)
{
logger.Error("seq is run out!");
}
}
}
else
{
if (Vendor.ToUpper().Equals("SANWA_MC"))
{
if (orgTxn.CommandEncodeStr.Contains("MCR:"))
{
Txn.CommandType = "CMD";
}
if (Txn.Method == Transaction.Command.LoadPortType.Reset)
{
key = "0";
}
else
{
key = Txn.AdrNo;
}
//}
//else
//{
// key = "0" + msgList[0].Command;
//}
}
else
{
key = Txn.AdrNo + Txn.Type;
}
}
if (TransactionList.TryAdd(key, Txn) || Txn.Method.Equals("Stop"))
{
Txn.SetTimeOutReport(this);
Txn.SetTimeOutMonitor(true);
//if (Vendor.ToUpper().Equals("ACDT"))
//{
// byte[] byteAry = Encoding.UTF8.GetBytes(Txn.CommandEncodeStr);
// logger.Debug(DeviceName + " Send:" + BitConverter.ToString(byteAry) + " Wafer:" + waferids);
//}
//else
//{
if (Txn.CommandType.Equals(""))
{
Txn.CommandType = _Decoder.GetMessage(Txn.CommandEncodeStr)[0].CommandType;
}
//if (Txn.CommandType.Equals("GET") || Txn.CommandType.IndexOf("FS") != -1)
//{
//}
if (Txn.Method.Equals(Transaction.Command.LoadPortType.Reset))
{
Txn.SetTimeOut(15000);
}
else
{
Txn.SetTimeOut(Txn.AckTimeOut);
}
try
{
//logger.Info(DeviceName + " Send:" + Txn.CommandEncodeStr.Replace("\r", ""));
//if (!this.Vendor.ToUpper().Equals("MITSUBISHI_PLC"))
//{
// _ReportTarget.On_Message_Log("CMD", DeviceName + " Send:" + Txn.CommandEncodeStr.Replace("\r", ""));
//}
//if (this.Vendor.Equals("SMARTTAG8200") || this.Vendor.Equals("SMARTTAG8400"))
//{
// //if (Txn.Method == Transaction.Command.SmartTagType.GetLCDData)
// //{
// // conn.WaitForData(true);
// //}
// ThreadPool.QueueUserWorkItem(new WaitCallback(conn.SendHexData), Txn.CommandEncodeStr);
//}
//else
//{
// ThreadPool.QueueUserWorkItem(new WaitCallback(conn.Send), Txn.CommandEncodeStr);
//}
if (Txn.NodeName.ToUpper().Equals("SMIF1"))
{
ch1Send = Txn.CommandEncodeStr;
}
else if (Txn.NodeName.ToUpper().Equals("SMIF2"))
{
ch2Send = Txn.CommandEncodeStr;
}
}
catch (Exception eex)
{
logger.Error(eex.StackTrace);
_ReportTarget.On_Message_Log("CMD", DeviceName + " Err:" + eex.StackTrace);
Txn.SetTimeOutMonitor(false);
Transaction tmp;
TransactionList.TryRemove(key, out tmp);
CommandReturnMessage rm = new CommandReturnMessage();
rm.Value = "ConnectionError";
_ReportTarget.On_Command_Error(NodeManagement.Get(Txn.NodeName), Txn, rm);
}
}
else
{
Transaction workingTxn;
TransactionList.TryRemove(key, out workingTxn);
logger.Debug(DeviceName + "(DoWork " + IPAdress + ":" + Port.ToString() + ":" + Txn.CommandEncodeStr + ") Same type command " + workingTxn.CommandEncodeStr + " is already excuting.");
_ReportTarget.On_Message_Log("CMD", DeviceName + "(DoWork " + IPAdress + ":" + Port.ToString() + ":" + Txn.CommandEncodeStr + ") Same type command " + workingTxn.CommandEncodeStr + " is already excuting.");
Txn.SetTimeOutMonitor(false);
CommandReturnMessage rm = new CommandReturnMessage();
rm.Value = "AlreadyExcuting";
_ReportTarget.On_Command_Error(NodeManagement.Get(Txn.NodeName), Txn, rm);
}
}
public void On_Connection_Message(object MsgObj)
{
try
{
string Msg = (string)MsgObj;
logger.Debug(_Config.DeviceName + " Recieve:" + Msg.Replace("\r", ""));
List <ReturnMessage> ReturnMsgList = _Decoder.GetMessage(Msg);
foreach (ReturnMessage ReturnMsg in ReturnMsgList)
{
if (WaitingForSync)
{
if (ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Error))
{
ReturnForSync = Msg;
WaitingForSync = false;
return;
}
else if (ReturnTypeForSync.Equals("CMD"))
{
if (ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Finished))
{
ReturnForSync = Msg;
WaitingForSync = false;
return;
}
else
{
continue;
}
}
else
{
if (ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Excuted))
{
ReturnForSync = Msg;
WaitingForSync = false;
return;
}
else
{
continue;
}
}
}
string key = "";
if (_Config.Vendor.ToUpper().Equals("KAWASAKI"))
{
key = ReturnMsg.Seq;
}
else if (_Config.Vendor.ToUpper().Equals("HST") || _Config.Vendor.ToUpper().Equals("COGNEX"))
{
key = "1" + ReturnMsg.Command;
}
else
{
key = ReturnMsg.NodeAdr + ReturnMsg.Command;
}
try
{
Transaction Txn = null;
Node Node = null;
if (ReturnMsg != null)
{
if (_Config.Vendor.ToUpper().Equals("KAWASAKI"))
{
if (TransactionList.TryGetValue(key, out Txn))
{
Node = NodeManagement.Get(Txn.NodeName);
if (!Txn.CommandType.Equals("GET") && !Txn.CommandType.Equals("SET") && !Txn.CommandType.Equals("CMD"))
{
Txn.CommandType = Encoder.GetCommandType(Txn.CommandType);
}
if (!Txn.CommandType.Equals("CMD"))
{
if (ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Excuted))
{
continue;
}
else if (ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Finished))
{
ReturnMsg.Type = ReturnMessage.ReturnType.Excuted;
}
}
}
else
{
logger.Debug("Transaction not exist:key=" + key);
return;
}
}
else if (_Config.Vendor.ToUpper().Equals("TDK"))
{
if (TransactionList.TryGetValue(key, out Txn))
{
Node = NodeManagement.Get(Txn.NodeName);
if (Txn.CommandType.Equals("SET") && ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Excuted))
{
continue;
}
}
else
{
Node = NodeManagement.GetByController(_Config.DeviceName, ReturnMsg.NodeAdr);
}
}
else
{
Node = NodeManagement.GetByController(_Config.DeviceName, ReturnMsg.NodeAdr);
if (Node == null)
{
Node = NodeManagement.GetOCRByController(_Config.DeviceName);
}
}
//lock (TransactionList)
//{
lock (Node)
{
if (ReturnMsg.Type == ReturnMessage.ReturnType.Event)
{
//_ReportTarget.On_Event_Trigger(Node, ReturnMsg);
}
else if (TransactionList.TryRemove(key, out Txn))
{
// Node.InitialComplete = false;
switch (ReturnMsg.Type)
{
case ReturnMessage.ReturnType.Excuted:
if (!Txn.CommandType.Equals("CMD") && !Txn.CommandType.Equals("MOV"))
{
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
}
else
{
Txn.SetTimeOutMonitor(false);
Txn.SetTimeOut(60000);
Txn.SetTimeOutMonitor(true);
TransactionList.TryAdd(key, Txn);
}
//_ReportTarget.On_Command_Excuted(Node, Txn, ReturnMsg);
break;
case ReturnMessage.ReturnType.Finished:
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
//_ReportTarget.On_Command_Finished(Node, Txn, ReturnMsg);
break;
case ReturnMessage.ReturnType.Error:
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
//_ReportTarget.On_Command_Error(Node, Txn, ReturnMsg);
break;
case ReturnMessage.ReturnType.Information:
logger.Debug("Txn timmer stoped.");
Txn.SetTimeOutMonitor(false);
if (_Config.Vendor.ToUpper().Equals("TDK") && Txn.CommandType.Equals("SET"))
{
ReturnMsg.Type = ReturnMessage.ReturnType.Excuted;
}
else
{
ReturnMsg.Type = ReturnMessage.ReturnType.Finished;
}
SpinWait.SpinUntil(() => false, 50);
//ThreadPool.QueueUserWorkItem(new WaitCallback(conn.Send), ReturnMsg.FinCommand);
conn.Send(ReturnMsg.FinCommand);
logger.Debug(_Config.DeviceName + "Send:" + ReturnMsg.FinCommand);
break;
}
}
else
{
if (ReturnMsg.Type.Equals(ReturnMessage.ReturnType.Information))
{
//ThreadPool.QueueUserWorkItem(new WaitCallback(conn.Send), ReturnMsg.FinCommand);
conn.Send(ReturnMsg.FinCommand);
logger.Debug(_Config.DeviceName + "Send:" + ReturnMsg.FinCommand);
}
else
{
logger.Debug(_Config.DeviceName + "(On_Connection_Message Txn is not found. msg:" + Msg);
return;
}
}
}
switch (ReturnMsg.Type)
{
case ReturnMessage.ReturnType.Information:
case ReturnMessage.ReturnType.Event:
Transaction t = new Transaction();
t.NodeName = Node.Name;
t.NodeType = Node.Type;
t.Value = ReturnMsg.Value;
t.CommandEncodeStr = ReturnMsg.OrgMsg;
t.Method = ReturnMsg.Command;
TransactionRecord.New(t, ReturnMsg.Type);
//TransactionRecord.AddDetail(TransactionRecord.GetUUID(), Node.Name,Node.Type,ReturnMsg.Type,ReturnMsg.Value);
_ReportTarget.On_Event_Trigger(Node, ReturnMsg);
break;
case ReturnMessage.ReturnType.Excuted:
TransactionRecord.Update(Txn, ReturnMsg);
_ReportTarget.On_Command_Excuted(Node, Txn, ReturnMsg);
if (Txn.CommandType.Equals("CMD") && !Node.Type.Equals("LOADPORT"))
{
_ReportTarget.On_Node_State_Changed(Node, "Run");
}
break;
case ReturnMessage.ReturnType.Finished:
TransactionRecord.Update(Txn, ReturnMsg);
if (Node.Type.Equals("LOADPORT"))
{
Node.InterLock = false;
}
_ReportTarget.On_Command_Finished(Node, Txn, ReturnMsg);
if (!Node.Type.Equals("LOADPORT"))
{
_ReportTarget.On_Node_State_Changed(Node, "Idle");
}
break;
case ReturnMessage.ReturnType.Error:
TransactionRecord.Update(Txn, ReturnMsg);
if (Node.Type.Equals("LOADPORT"))
{
Node.InterLock = false;
}
_ReportTarget.On_Command_Error(Node, Txn, ReturnMsg);
break;
}
}
else
{
logger.Debug(_Config.DeviceName + "(On_Connection_Message Message decode fail:" + Msg);
}
}
catch (Exception e)
{
logger.Error(_Config.DeviceName + "(On_Connection_Message " + _Config.IPAdress + ":" + _Config.Port.ToString() + ")" + e.Message + "\n" + e.StackTrace);
}
}
}
catch (Exception e)
{
logger.Error(_Config.DeviceName + "(On_Connection_Message " + _Config.IPAdress + ":" + _Config.Port.ToString() + ")" + e.Message + "\n" + e.StackTrace);
}
}
