internal SecsEventSubscription(string toolId, SecsMessage filter, bool recoverable, Action<SecsMessage> callback) {
this.Id = (toolId + filter.Name + callback.Method.DeclaringType + callback.Method.Name).Replace('\\', '-').Replace('+', '-').Replace(';', '-').Replace(',', '_').Replace('"', '|');
this.ToolId = toolId;
this.Recoverable = recoverable;
this._handler = callback;
this.Filter = filter;
}
public SecsMessageViewModel(SecsMessage secsMsg)
: base(null, false)
{
_secsMsg = secsMsg;
if (secsMsg.SecsItem != null)
base.Children.Add(new SecsItemViewModel(secsMsg.SecsItem, this));
}
void EQP_WaferStatusChange(SecsMessage msg) {
Item dataList = msg.SecsItem.Items[2].Items[0].Items[1];
string pjId = dataList.Items[0].GetValue<string>();
string carrier_slot_port = (string)dataList.Items[1];
int i = carrier_slot_port.IndexOf('.');
string carrierId = carrier_slot_port.Substring(0, i);
byte slotNo = Convert.ToByte(carrier_slot_port.Substring(i + 1, 2));
string state = dataList.Items[2].GetValue<string>();
switch (state) {
case "SubstLocChamber":
EAP.Report(new WaferStartReport {
ProcessJobId = GetProcessJob(carrierId,slotNo).Id,
CarrierId = carrierId,
SlotNo = slotNo
});
break;
case "SubstLocLowerArm":
EAP.Report(new WaferEndReport {
ProcessJobId = GetProcessJob(carrierId,slotNo).Id,
CarrierId = carrierId,
SlotNo = slotNo
});
break;
}
}
void EQP_CarrierIDRead(SecsMessage msg) {
byte portNo = (byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
string carrierID = msg.SecsItem.Items[2].Items[0].Items[1].Items[1].GetValue<string>().Trim();
EAP.Report(new CarrierIDReport {
LoadPortId = GetPortID(portNo),
CarrierId = carrierID
});
}
void EQP_UnloadComplete(SecsMessage msg) {
string portId = GetPortID((byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0]);
EAP.Report(new UnloadCompleteReport {
PortID = portId
});
//清除相關Loadport上的ProcessJob物件
_ProcessingJobs.RemoveAll(pj => pj.Carriers.First().LoadPortId == portId);
}
public static bool IsMatch(this SecsMessage src, SecsMessage target)
{
if (object.ReferenceEquals(src, target))
{
return(true);
}
return(src.S == target.S &&
src.F == target.F &&
(target.SecsItem == null || src.SecsItem.IsMatch(target.SecsItem)));
}
void EQP_SlotMapReport(SecsMessage msg) {
byte portNo = (byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
string carrierId = (string)msg.SecsItem.Items[2].Items[0].Items[1].Items[1];
string map = (string)msg.SecsItem.Items[2].Items[0].Items[1].Items[1 + portNo];
EAP.Report(new SlotMapReport {
LoadPortID = GetPortID(portNo),
CarrierID = carrierId,
Slots = from i in Enumerable.Range(0, map.Length)
where map[i] == '1'
select (byte)(i + 1)
});
}
void EQP_SlotMapReport(SecsMessage msg) {
byte portNo = (byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
string carrierID = msg.SecsItem.Items[2].Items[0].Items[1].Items[1].GetValue<string>().Trim();
var mapItem = msg.SecsItem.Items[2].Items[0].Items[1].Items[2].Items;
EAP.Report(new SlotMapReport {
LoadPortID = GetPortID(portNo),
CarrierID = carrierID,
Slots = from i in Enumerable.Range(0, mapItem.Count)
where mapItem[i].GetValue<byte>() == 4
select (byte)(i + 1)
});
}
async void EQP_LoadComplete(SecsMessage msg) {
byte portNo = (byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
string portId = GetPortID(portNo);
EAP.Report(new LoadCompReport {
PortID = portId
});
// Wait CarrierIDRead Event 10 sec.
{
// Method 1:
//ThreadPool.QueueUserWorkItem(delegate {
// EapLogger.Notice(portId + " StartAsync CarrierIDRead Timer");
// using (var ev = new ManualResetEvent(false)) {
// var callback = new Action<SecsMessage>(secsMsg => {
// if (portNo == (byte)secsMsg.SecsItem.Items[2].Items[0].Items[1].Items[0])
// ev.Set();
// });
// using (EAP.SubscribeS6F11("CarrierIDRead", callback))
// using (EAP.SubscribeS6F11("CarrierIDReadFail", callback)) {
// if (!ev.WaitOne(10000)) {
// EapLogger.Error(portId + " CarrierIDRead Timeout!!");
// EAP.Report(new CarrierIDReport {
// LoadPortId = portId
// });
// }
// }
// }
//});
}
{
// Method 2:
//EapLogger.Notice(portId + " StartAsync CarrierIDRead Timer");
//var ev = new ManualResetEvent(false);
//var callback = new Action<SecsMessage>(secsMsg => {
// if (portNo == (byte)secsMsg.SecsItem.Items[2].Items[0].Items[1].Items[0])
// ev.Set();
//});
//var read = EAP.SubscribeS6F11("CarrierIDRead", callback);
//var readfail = EAP.SubscribeS6F11("CarrierIDReadFail", callback);
//ThreadPool.RegisterWaitForSingleObject(ev, (state, timeout) => {
// if (read != null)
// read.Dispose();
// if (readfail != null)
// readfail.Dispose();
// if (timeout) {
// EapLogger.Error(portId + " CarrierIDRead Timeout!!");
// EAP.Report(new CarrierIDReport {
// LoadPortId = portId
// });
// }
//}, null, 10000, true);
}
}
internal void EndProcess(SecsMessage replyMsg, bool timeout)
{
if (replyMsg != null)
{
_secondary = replyMsg;
_secondary.Name = Primary.Name;
}
_timeout = timeout;
IsCompleted = !timeout;
_ev.Set();
_callback?.Invoke(this);
}
async Task ChangeAccessMode(AccessMode changeAccessMode, byte portNo) {
var S3F23 = new SecsMessage(3, 23, "ChangeAccessMode",
Item.L(
Item.A(),
Item.U1((byte)changeAccessMode),
Item.L(
Item.U1(portNo))));
var S3F24 = await EAP.SendAsync(S3F23);
byte returnCode = (byte)S3F24.SecsItem.Items[0];
if (returnCode != 0 && returnCode != 4)
throw new ScenarioException("Change Loadport[" + portNo + "] access mode fial. " + S3F24.SecsItem.Items[1].Items[1].GetValue<string>());
}
SecsAsyncResult SendDataMessage(SecsMessage msg, int systembyte, AsyncCallback callback = null, object syncState = null)
{
if (State != ConnectionState.Selected)
{
throw new SecsException("Device is not selected");
}
var header = new Header(new byte[10])
{
S = msg.S,
F = msg.F,
ReplyExpected = msg.ReplyExpected,
DeviceId = DeviceId,
SystemBytes = systembyte
};
var buffer = new EncodedBuffer(header.Bytes, msg.RawDatas);
SecsAsyncResult ar = null;
if (msg.ReplyExpected)
{
ar = new SecsAsyncResult(msg, callback, syncState);
_replyExpectedMsgs[systembyte] = ar;
ThreadPool.RegisterWaitForSingleObject(ar.AsyncWaitHandle,
(state, timeout) =>
{
SecsAsyncResult ars;
if (_replyExpectedMsgs.TryRemove((int)state, out ars) && timeout)
{
_tracer.TraceError($"T3 Timeout[id=0x{state:X8}]");
ars.EndProcess(null, timeout);
}
}, systembyte, T3, true);
}
SocketError error;
_socket.Send(buffer, SocketFlags.None, out error);
if (error != SocketError.Success)
{
var errorMsg = "Socket send error :" + new SocketException((int)error).Message;
_tracer.TraceError(errorMsg);
CommunicationStateChanging(ConnectionState.Retry);
throw new SecsException(errorMsg);
}
_tracer.TraceMessageOut(msg, systembyte);
return(ar);
}
/// <summary>
/// Each PrimaryMessageWrapper can invoke Reply method once.
/// Since message replied, method return false.
/// </summary>
/// <param name="replyMessage"></param>
/// <returns>ture, if reply message sent.</returns>
public bool Reply(SecsMessage replyMessage)
{
if (Interlocked.Exchange(ref _isReplied, 1) == 1)
return false;
if (!Message.ReplyExpected)
return true;
replyMessage = replyMessage ?? new SecsMessage(9, 7, false, "Unknown Message", Item.B(_header.Bytes));
replyMessage.ReplyExpected = false;
_secsGem.SendDataMessageAsync(replyMessage, replyMessage.S == 9 ? _secsGem.NewSystemId : _header.SystemBytes);
return true;
}
public static bool IsMatch(this SecsMessage src, SecsMessage target)
{
if (src.S != target.S)
{
return(false);
}
if (src.F != target.F)
{
return(false);
}
if (target.SecsItem == null)
{
return(true);
}
return(src.SecsItem.IsMatch(target.SecsItem));
}
void EQP_WaferProcessData_PVD(SecsMessage msg) {
Item tempList = msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
string pjID = tempList.Items[1].GetValue<string>();
byte slotNo = (byte)tempList.Items[4].Items[0].Items[1];
tempList = tempList.Items[4].Items[0].Items[2].Items[0];
string chamber = tempList.Items[0].Items[1].GetValue<string>();
var dc = new DataCollectionReport(GetProcessJob(pjID));
try {
dc.AddLotData("CIWW", chamber);
} finally {
EAP.Report(dc);
}
}
/// <summary>
/// Each PrimaryMessageWrapper can invoke Reply method once.
/// If the message already replied, will return false.
/// </summary>
/// <param name="replyMessage"></param>
/// <returns>true, if reply message sent.</returns>
public Task <bool> ReplyAsync(SecsMessage replyMessage)
{
if (Interlocked.Exchange(ref _isReplied, 1) == 1)
{
return(ReplyAsyncFalseCache);
}
if (!Message.ReplyExpected || !_secsGem.TryGetTarget(out var secsGem))
{
return(ReplyAsyncTrueCache);
}
replyMessage = replyMessage ?? new SecsMessage(9, 7, false, "Unknown Message", Item.B(_header.EncodeTo(new byte[10])));
replyMessage.ReplyExpected = false;
return(secsGem.SendDataMessageAsync(replyMessage, replyMessage.S == 9 ? secsGem.NewSystemId : _header.SystemBytes)
.ContinueWith(ContinueWithFunc));
}
void EQP_DataCollection(SecsMessage msg) {
Item dataList = msg.SecsItem.Items[2].Items[0].Items[1];
string pjId = dataList.Items[0].GetValue<string>();
string carrier_slot_port = (string)dataList.Items[1];
int i = carrier_slot_port.IndexOf('.');
byte slotNo = Convert.ToByte(carrier_slot_port.Substring(i + 1, 2));
string carrierId = carrier_slot_port.Substring(0, i);
var dc = new DataCollectionReport(GetProcessJob(carrierId,slotNo));
try {
dc.AddWaferData("SNW0", slotNo, slotNo);
dc.AddWaferData("PTW0", slotNo, dataList.Items[2]);
dc.AddWaferData("TXW0", slotNo, (uint)dataList.Items[3] / 100);
dc.AddWaferData("TIW0", slotNo, (uint)dataList.Items[4] / 100);
dc.AddWaferData("TAW0", slotNo, (uint)dataList.Items[5] / 100);
} finally {
EAP.Report(dc);
}
}
/// <summary>
/// Each PrimaryMessageWrapper can invoke Reply method once.
/// Since message replied, method return false.
/// </summary>
/// <param name="replyMessage"></param>
/// <returns>true, if reply message sent.</returns>
public async Task <bool> ReplyAsync(SecsMessage replyMessage)
{
if (Interlocked.Exchange(ref _isReplied, 1) == 1)
{
return(false);
}
if (!Message.ReplyExpected)
{
return(true);
}
replyMessage = replyMessage ?? new SecsMessage(9, 7, false, "Unknown Message", Item.B(_header.Bytes));
replyMessage.ReplyExpected = false;
await _secsGem.SendDataMessageAsync(replyMessage, replyMessage.S == 9?_secsGem.NewSystemId : _header.SystemBytes);
return(true);
}
void EQP_WaferProcessData_LLH_LHC(SecsMessage msg) {
Item tempList = msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
string pjID = tempList.Items[1].GetValue<string>();
byte slotNo = (byte)tempList.Items[4].Items[0].Items[1];
tempList = tempList.Items[4].Items[0].Items[2].Items[0];
var dc = new DataCollectionReport(GetProcessJob(pjID));
try {
dc.AddWaferData("CIWD", slotNo, tempList.Items[0].Items[1]);
tempList = tempList.Items[2].Items[0].Items[2];
dc.AddWaferData("C1W1", slotNo, tempList.Items[3]);
dc.AddWaferData("C1W2", slotNo, tempList.Items[6]);
dc.AddWaferData("C2W1", slotNo, tempList.Items[9]);
dc.AddWaferData("C2W2", slotNo, tempList.Items[12]);
} finally {
EAP.Report(dc);
}
}
internal Task <SecsMessage> SendDataMessageAsync(SecsMessage msg, int systembyte)
{
if (State != ConnectionState.Selected)
{
throw new SecsException("Device is not selected");
}
var token = new TaskCompletionSourceToken(msg, systembyte);
if (msg.ReplyExpected)
{
_replyExpectedMsgs[systembyte] = token;
}
var header = new MessageHeader
{
S = msg.S,
F = msg.F,
ReplyExpected = msg.ReplyExpected,
DeviceId = DeviceId,
SystemBytes = systembyte
};
var bufferList = msg.RawDatas.Value;
bufferList[1] = new ArraySegment <byte>(header.Bytes);
var eap = new SocketAsyncEventArgs
{
BufferList = bufferList,
UserToken = token,
};
eap.Completed += _sendDataMessageCompleteHandler;
if (!_socket.SendAsync(eap))
{
SendDataMessageCompleteHandler(_socket, eap);
}
return(token.Task);
}
void HandleDataMessage(MessageHeader header, SecsMessage msg)
{
int systembyte = header.SystemBytes;
if (header.DeviceId != DeviceId && msg.S != 9 && msg.F != 1)
{
_logger.MessageIn(msg, systembyte);
_logger.Warning("Received Unrecognized Device Id Message");
SendDataMessageAsync(new SecsMessage(9, 1, false, "Unrecognized Device Id", Item.B(header.Bytes)), NewSystemId);
return;
}
if (msg.F % 2 != 0)
{
if (msg.S != 9)
{
//Primary message
_logger.MessageIn(msg, systembyte);
_taskFactory.StartNew(
wrapper => PrimaryMessageReceived(this, Unsafe.As <PrimaryMessageWrapper>(wrapper)),
new PrimaryMessageWrapper(this, header, msg));
return;
}
// Error message
var headerBytes = (byte[])msg.SecsItem.Values;
systembyte = BitConverter.ToInt32(new[] { headerBytes[9], headerBytes[8], headerBytes[7], headerBytes[6] }, 0);
}
// Secondary message
_logger.MessageIn(msg, systembyte);
TaskCompletionSourceToken ar;
if (_replyExpectedMsgs.TryGetValue(systembyte, out ar))
{
ar.HandleReplyMessage(msg);
}
}
private void parseMessage(byte[] bytes, int length, bool isMessageComplelte = false)
{
if (isMessageComplelte == true)
{
}
else
{
if (length == 14 && isHeader == true)
{
//it is a header
isHeader = false;
Array.Copy(bytes, messageBytes, length);
byte[] messageLengths = new byte[4];
Array.Copy(bytes, 0, messageLengths, 0, 4);
Array.Reverse(messageLengths, 0, 4);
_messageDataLength = (int)BitConverter.ToUInt32(messageLengths, 0);
MsgHeader = MessageHeader.Decode(bytes, 4);
}
else
{
isHeader = true;
if (_messageDataLength - 10 == length)
{
//it is the message
int index = 0;
Item item = decoder.BufferedDecodeItem(bytes, ref index);
Msg = new SecsMessage(MsgHeader.S, MsgHeader.F, MsgHeader.ReplyExpected, "", item);
SecsDataReceivedEventArgs arg = new SecsDataReceivedEventArgs(Msg, SCESEquipment);
DataReceived(SocketClient, arg);
}
}
}
}
public Task <SecsMessage> SendDataMessage(SecsMessage msg)
{
int systembyte = NewSystemId;
var token = new TaskCompletionSourceToken(msg, systembyte, MessageType.DataMessage);
if (msg.ReplyExpected)
{
_replyExpectedMsgs[systembyte] = token;
}
var header = new MessageHeader
{
S = msg.S,
F = msg.F,
ReplyExpected = msg.ReplyExpected,
DeviceId = DeviceId,
SystemBytes = systembyte
};
var bufferList = msg.RawDatas.Value;
bufferList[1] = new ArraySegment <byte>(header.EncodeTo(new byte[10]));
var eap = new SocketAsyncEventArgs
{
BufferList = bufferList,
UserToken = token,
};
eap.Completed += _sendDataMessageCompleteHandler;
SocketClient.Send(eap.BufferList.ToArray(), SocketFlags.None);
//if (!sockClient.SendAsync(eap))
// SendDataMessageCompleteHandler(sockClient, eap);
return(token.Task);
}
void EQP_DataCollectionComplete(SecsMessage msg) {
Item tmpList = msg.SecsItem.Items[2].Items[0].Items[1];
string carrier_slot_port = (string)tmpList.Items[1];
int i = carrier_slot_port.IndexOf('.');
string carrierId = carrier_slot_port.Substring(0, i);
byte slotNo = Convert.ToByte(carrier_slot_port.Substring(i + 1, 2));
char portNo = carrier_slot_port[carrier_slot_port.Length - 1];
var processJob = GetProcessJob(carrierId, slotNo);
var dc = new DataCollectionReport(processJob);
var dcc = new DataCollectionCompleteReport(processJob);
try {
dc.AddLotData("PJL0", processJob.Id);
dc.AddLotData("CJL0", carrierId);
dc.AddLotData("SNL0", slotNo);
dc.AddLotData("PIL0", Convert.ToByte(portNo));
dc.AddLotData("RIL0", tmpList.Items[2]);
dc.AddLotData("LTL0", (uint)tmpList.Items[3] / 100);
} finally {
EAP.Report(dc);
EAP.Report(dcc);
}
}
public SecsDataReceivedEventArgs(SecsMessage secsMessage, SCESEquipment sCESEquipment)
{
SecsMessage = secsMessage;
SCESEquipment = sCESEquipment;
}
public virtual void TraceMessageOut(SecsMessage msg, int systembyte)
{
}
void EQP_ControlJobEnd(SecsMessage msg) {
EAP.Report(new ControlJobEndReport {
ControlJobID = msg.SecsItem.Items[2].Items[0].Items[1].Items[1].GetValue<string>().Trim()
});
}
internal PrimaryMessageWrapper(SecsGem secsGem, MessageHeader header, SecsMessage msg)
{
_secsGem = secsGem;
_header = header;
Message = msg;
}
public void MessageOut(SecsMessage msg, int systembyte)
{
_form.Invoke((MethodInvoker)delegate {
_form.richTextBox1.SelectionColor = Color.Black;
_form.richTextBox1.AppendText($"--> [0x{systembyte:X8}] {msg.ToSML()}\n");
});
}
public void MessageOut(SecsMessage msg, int systembyte) {
Trace.WriteLine($"--> [0x{systembyte:X8}] {msg}");
}
public static void WriteTo(this SecsMessage msg, TextWriter writer) {
writer.WriteLine(msg.ToString());
Write(writer, msg.SecsItem, SmlIndent);
writer.Write('.');
}
internal SecsAsyncResult(SecsMessage primaryMsg, AsyncCallback callback = null, object state = null)
{
Primary = primaryMsg;
AsyncState = state;
_callback = callback;
}
protected SecsException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
SecsMsg = info.GetValue("msg", typeof(SecsMessage)) as SecsMessage;
}
/// <summary> /// Send SECS message asynchronously to device . /// </summary> /// <param name="msg"></param> /// <returns></returns> public async Task <SecsMessage> SendAsync(SecsMessage msg) => await Task.Factory.FromAsync(BeginSend, EndSend, msg, null, TaskCreationOptions.PreferFairness);
public SecsException(SecsMessage msg, string description)
: base(description)
{
SecsMsg = msg;
}
/// <summary> /// Send SECS message to device. /// </summary> /// <param name="msg"></param> /// <returns>Device's reply msg if msg.ReplyExpected is true;otherwise, null.</returns> public SecsMessage Send(SecsMessage msg) => EndSend(BeginSend(msg));
void EQP_ProcessJobEnd(SecsMessage msg) {
EAP.Report(new ProcessJobEndReport {
ProcessJobID = (string)msg.SecsItem.Items[2].Items[0].Items[1].Items[0]
});
}
void EQP_ProcessJobEnd(SecsMessage msg) {
string id = msg.SecsItem.Items[2].Items[0].Items[1].Items[0].GetValue<string>().Trim();
EAP.Report(new ProcessJobEndReport { ProcessJobID = id });
EAP.Report(new DataCollectionCompleteReport(GetProcessJob(id)));
}
public void MessageOut(SecsMessage msg, int systembyte) => WriteLine($"--> [0x{systembyte:X8}] {msg}");
void ProcessMessage(SecsMessage msg)
{
DataMsgHandler(_msgHeader, msg);
_messageLength = 0;
}
public static bool IsMatch(this SecsMessage src, SecsMessage target)
{
return(src.S == target.S && src.F == target.F &&
(target.SecsItem == null || src.SecsItem.IsMatch(target.SecsItem)));
}
void EQP_CarrierIdRead(SecsMessage msg) {
EAP.Report(new CarrierIDReport {
LoadPortId = GetPortID((byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0]),
CarrierId = (string)msg.SecsItem.Items[2].Items[0].Items[1].Items[1]
});
}
public static IDisposable Subscribe(this ISecsDevice device, SecsMessage filter, bool recoverable, Action<SecsMessage> callback)
{
var subscription = new SecsEventSubscription(device.ToolId, filter, recoverable, callback);
device.Subscribe(subscription);
return subscription;
}
/// <summary> /// Asynchronously send message to device . /// </summary> /// <param name="msg">primary message</param> /// <returns>secondary message</returns> public Task <SecsMessage> SendAsync(SecsMessage msg) => SendDataMessageAsync(msg, NewSystemId);
public static string ToSML(this SecsMessage msg) {
using (var sw = new StringWriter()) {
msg.WriteTo(sw);
return sw.ToString();
}
}
static void DefineLinkSuccess(SecsMessage msg) {
if (msg.SecsItem.GetValue<byte>() != 0)
throw new ScenarioException("Define Link failed : " + msg.Name);
}
protected override void HandleToolAlarm(SecsMessage msg)
{
}
internal protected abstract void HandleToolAlarm(SecsMessage msg);
void EQP_ControlJobStart(SecsMessage msg) {
EAP.Report(new ControlJobStartReport {
ControlJobID = (string)msg.SecsItem.Items[2].Items[0].Items[1].Items[0]
});
}
void EQP_UnloadComplete(SecsMessage msg) {
EAP.Report(new UnloadCompleteReport {
PortID = GetPortID((byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0])
});
}
void EQP_ReadyToLoad(SecsMessage msg) {
EAP.Report(new ReadyToLoadReport {
PortID = GetPortID((byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0])
});
}
void EQP_CarrierIDReadFail(SecsMessage msg) {
byte portNo = (byte)msg.SecsItem.Items[2].Items[0].Items[1].Items[0];
EAP.Report(new CarrierIDReport {
LoadPortId = GetPortID(portNo)
});
}
internal PrimaryMessageWrapper(SecsGem secsGem, MessageHeader header, SecsMessage msg)
{
_secsGem = new WeakReference <SecsGem>(secsGem);
_header = header;
Message = msg;
}
public void MessageIn(SecsMessage secsMessage, int systembyte) => Trace.WriteLine($"<-- [0x{systembyte:X8}] {secsMessage}");
public static bool IsMatch(this SecsMessage src, in SecsMessage target)
public void MessageOut(SecsMessage secsMessage, int systembyte) => Trace.WriteLine($"--> [0x{systembyte:X8}] {secsMessage}");
public void MessageIn(SecsMessage msg, int systembyte) => WriteLine($"<-- [0x{systembyte:X8}] {msg}");
public static IDisposable Subscribe(this ISecsDevice device, SecsMessage filter, Action<SecsMessage> callback)
=> device.Subscribe(filter, false, callback);
/// <summary> /// Send SECS message asynchronously to device . /// </summary> /// <param name="msg"></param> /// <param name="callback">Device's reply message handler callback.</param> /// <param name="state">synchronize state object</param> /// <returns>An IAsyncResult that references the asynchronous send if msg.ReplyExpected is true;otherwise, null.</returns> public IAsyncResult BeginSend(SecsMessage msg, AsyncCallback callback = null, object state = null) => SendDataMessage(msg, NewSystemByte(), callback, state);
public void MessageIn(SecsMessage msg, int systembyte) {
Trace.WriteLine($"<-- [0x{systembyte:X8}] {msg}");
}
