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}"); }