881 lines
29 KiB
C#
881 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO.Ports;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Aitex.Core.Common.DeviceData;
|
|
using Aitex.Core.RT.Device;
|
|
using Aitex.Core.RT.Device.Unit;
|
|
using Aitex.Core.RT.Event;
|
|
using Aitex.Core.RT.Log;
|
|
using Aitex.Core.RT.OperationCenter;
|
|
using Aitex.Core.RT.SCCore;
|
|
using Aitex.Core.Util;
|
|
using MECF.Framework.Common.Communications;
|
|
using MECF.Framework.Common.Device.Bases;
|
|
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Common;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.SMIFs.Brooks
|
|
{
|
|
|
|
public class BrooksSMIF : SerialPortDevice, IConnection
|
|
{
|
|
public string Address { get { return _address; } }
|
|
public bool IsConnected { get; }
|
|
public bool Connect()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public bool Disconnect()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public string PortStatus { get; set; } = "Closed";
|
|
|
|
private BrooksSMIFConnection _connection;
|
|
public BrooksSMIFConnection Connection
|
|
{
|
|
get { return _connection; }
|
|
}
|
|
|
|
public List<IOResponse> IOResponseList { get; set; } = new List<IOResponse>();
|
|
public int Axis { get; private set; }
|
|
public bool IsIdle { get; private set; }
|
|
public bool IsHomed { get; private set; }
|
|
public bool IsPodPresent { get; private set; }
|
|
public bool IsArmRetract { get; private set; }
|
|
public bool IsAlarm { get; private set; }
|
|
|
|
private R_TRIG _trigError = new R_TRIG();
|
|
|
|
private R_TRIG _trigCommunicationError = new R_TRIG();
|
|
private R_TRIG _trigRetryConnect = new R_TRIG();
|
|
|
|
private PeriodicJob _thread;
|
|
|
|
private LinkedList<HandlerBase> _lstHandler = new LinkedList<HandlerBase>();
|
|
private LinkedList<HandlerBase> _lstMonitorHandler = new LinkedList<HandlerBase>();
|
|
|
|
private object _locker = new object();
|
|
|
|
private bool _enableLog;
|
|
private string _errorCode="";
|
|
private DeviceTimer _setStatusTimer = new DeviceTimer();
|
|
private int SetStatusTime = 800;
|
|
|
|
private string _scRoot;
|
|
public BrooksSMIF(string module, string name, string scRoot) : base(module, name)
|
|
{
|
|
_scRoot = scRoot;
|
|
}
|
|
private void ResetPropertiesAndResponses()
|
|
{
|
|
Connected = null;
|
|
|
|
RobotStatus = null;
|
|
IsOnLine = null;
|
|
IsManual = null;
|
|
IsES = null;
|
|
MovingCompleted = null;
|
|
ACalCompleted = null;
|
|
AddressOutSide = null;
|
|
PositionOutSide = null;
|
|
EmergencyStop = null;
|
|
XLowerSide = null;
|
|
XUpperSide = null;
|
|
YLowerSide = null;
|
|
YUpperSide = null;
|
|
ZLowerSide = null;
|
|
ZUpperSide = null;
|
|
|
|
|
|
foreach (var ioResponse in IOResponseList)
|
|
{
|
|
ioResponse.ResonseContent = null;
|
|
ioResponse.ResonseRecievedTime = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
internal void OnEventArrived(string eventData)
|
|
{
|
|
if (eventData == "POD_ARRIVED")
|
|
{
|
|
PodArrived = true;
|
|
}
|
|
else if (eventData == "POD_REMOVED")
|
|
{
|
|
PodRemoved = true;
|
|
}
|
|
else if (eventData == "BEGIN_FETCH")
|
|
{
|
|
FetchBegun = true;
|
|
}
|
|
else if (eventData == "CMPL_FETCH")
|
|
{
|
|
FetchCompleted = true;
|
|
}
|
|
else if (eventData == "BEGIN_LOAD")
|
|
{
|
|
LoadBegun = true;
|
|
}
|
|
else if (eventData == "ABORT_LOAD")
|
|
{
|
|
LoadAbort = true;
|
|
}
|
|
else if (eventData == "CMPL_LOAD")
|
|
{
|
|
LoadCompleted = true;
|
|
}
|
|
else if (eventData == "BEGIN_RECV_CASSETTE")
|
|
{
|
|
UnloadBegun = true;
|
|
}
|
|
else if (eventData == "ABORT_UNLOAD")
|
|
{
|
|
UnloadAbort = true;
|
|
}
|
|
else if (eventData == "RECV_CASSETTE")
|
|
{
|
|
UnloadCompleted = true;
|
|
}
|
|
else if (eventData == "BEGIN_HOME")
|
|
{
|
|
HomeBegun = true;
|
|
}
|
|
else if (eventData == "REACH_HOME")
|
|
{
|
|
HomeCompleted = true;
|
|
}
|
|
else if (eventData == "BEGIN_OPEN")
|
|
{
|
|
OpenBegun = true;
|
|
}
|
|
else if (eventData == "CMPL_OPEN")
|
|
{
|
|
OpenCompleted = true;
|
|
}
|
|
else if (eventData == "BEGIN_UNLOAD")
|
|
{
|
|
CloseBegun = true;
|
|
}
|
|
else if (eventData == "CMPL_UNLOAD")
|
|
{
|
|
CloseCompleted = true;
|
|
}
|
|
}
|
|
|
|
private static Dictionary<string, string> _RealyMessageDict = new Dictionary<string, string>()
|
|
{
|
|
{"OK","Comment accepted" },
|
|
{"BUSY","Command rejected, LPI is busy" },
|
|
{"ALARM","Command rejected, LPI in alarm state" },
|
|
{"NO_POD","Command rejected, Pod not on LPI" },
|
|
{"NOT_READY","Command rejected, Host interlock not enabled" },
|
|
{"INVALID_ARG","Command rejected, at least one invalid parameter" },
|
|
{"CANNOT_PERFORM","LPI not in the proper state to perform the Host command" },
|
|
{"DENIED","Command rejected for other reason" },
|
|
};
|
|
|
|
private static Dictionary<string, string> _AlarmTimeCodeDict = new Dictionary<string, string>()
|
|
{
|
|
{"00","No alarm" },
|
|
{"41","Alarm occurred during a fetch or open operation" },
|
|
{"42","Alarm occurred during a cassette placement on the process tool" },
|
|
{"43","Alarm occurred during a returning of the minienvironment to Home" },
|
|
{"44","Alarm occurred during a retrieval of the cassette from the Tool" },
|
|
{"45","Alarm occurred during a placement of the cassette on the Pod door" },
|
|
{"46","Non-recoverable fatal error" }
|
|
};
|
|
|
|
private static Dictionary<string, string> _ErrorCodeDict = new Dictionary<string, string>()
|
|
{
|
|
{"00","No error" },
|
|
{"01","Position following error" },
|
|
{"02","LPI not Home" },
|
|
{"03","LPI busy" },
|
|
{"04","Pod removed/missing elevator door" },
|
|
{"05","Aborted by user" },
|
|
{"07","Protrusion sensor failure" },
|
|
{"08","Slot sensor failure" },
|
|
{"09","Wafer presence sensor failure" },
|
|
{"10","Flash sensor failure" },
|
|
{"11"," Elevator over-travel limit trip" },
|
|
{"13","Excessive wafer protrusion" },
|
|
{"14","System internal time-out" },
|
|
{"15","Servo command error" },
|
|
{"16","Pod door open time-out" },
|
|
{"17","Pod door close time-out" },
|
|
{"18","Pod hold-down open time-out" },
|
|
{"19","Pod hold-down close time-out" },
|
|
{"20","Wafer seater failed to move toward wafer" },
|
|
{"21","Wafer seater failed to return to Home" },
|
|
{"22","Elevator failed to reach target position" },
|
|
{"24","System error" },
|
|
{"27","Loss of configuration data" },
|
|
{"28","Cassette not present" },
|
|
{"29","Loss of air flow" },
|
|
{"31","Gripper open time out" },
|
|
{"32","Gripper close time out" },
|
|
{"33","Interprocessor communication error" },
|
|
{"34","Gripper overtravel" },
|
|
{"35","Cassette found during unload" },
|
|
};
|
|
|
|
internal void OnAlarmArrived(string alarmData)
|
|
{
|
|
var alarmArray = alarmData.Split(' ');
|
|
if (alarmArray.Count() != 2)
|
|
return;
|
|
|
|
string alarmTimeCode = alarmArray[0].Substring(0, 2);
|
|
string alarmInfoCode = alarmArray[0].Substring(2, 2);
|
|
|
|
AlarmOccurTime = alarmTimeCode + "=" + _AlarmTimeCodeDict[alarmTimeCode];
|
|
AlarmInfo = alarmInfoCode + "=" + alarmArray[1];
|
|
IsAlarm = true;
|
|
}
|
|
|
|
public void SetError(string errorCode)
|
|
{
|
|
string alarmTimeCode = errorCode.Substring(0, 2);
|
|
string alarmInfoCode = errorCode.Substring(2, 2);
|
|
if (_AlarmTimeCodeDict.ContainsKey(alarmTimeCode))
|
|
AlarmOccurTime = _AlarmTimeCodeDict[alarmTimeCode];
|
|
else
|
|
AlarmOccurTime = alarmTimeCode;
|
|
|
|
if (_ErrorCodeDict.ContainsKey(alarmInfoCode))
|
|
AlarmInfo = _ErrorCodeDict[alarmInfoCode];
|
|
else
|
|
AlarmInfo = alarmInfoCode;
|
|
|
|
if(_errorCode != errorCode)
|
|
{
|
|
EV.PostAlarmLog(Module, $"{Module} {AlarmOccurTime}, for {AlarmInfo}");
|
|
}
|
|
|
|
_errorCode = errorCode;
|
|
IsAlarm = true;
|
|
}
|
|
|
|
public void SetStatus(bool isReady, bool isHomed, bool isPodPresent, bool isArmRetract)
|
|
{
|
|
if(_setStatusTimer.IsIdle() || _setStatusTimer.GetElapseTime() > SetStatusTime)
|
|
{
|
|
IsIdle = isReady;
|
|
IsHomed = isHomed;
|
|
IsPodPresent = isPodPresent;
|
|
IsArmRetract = isArmRetract;
|
|
}
|
|
}
|
|
|
|
private string _address = "";
|
|
public override bool Initialize()
|
|
{
|
|
ResetPropertiesAndResponses();
|
|
|
|
if (_connection != null && _connection.IsConnected)
|
|
return true;
|
|
|
|
if(string.IsNullOrEmpty(_scRoot))
|
|
{
|
|
PortName = SC.GetStringValue($"{Module}.DeviceAddress");
|
|
_enableLog = SC.GetValue<bool>($"{Module}.EnableLogMessage");
|
|
}
|
|
else
|
|
{
|
|
PortName = SC.GetStringValue($"{_scRoot}.{Module}.{Name}.DeviceAddress");
|
|
_enableLog = SC.GetValue<bool>($"{_scRoot}.{Module}.{Name}.EnableLogMessage");
|
|
}
|
|
|
|
_connection = new BrooksSMIFConnection(this, PortName);
|
|
_connection.EnableLog(_enableLog);
|
|
|
|
base.Initialize(PortName);
|
|
|
|
if (_connection.Connect())
|
|
{
|
|
PortStatus = "Open";
|
|
EV.PostInfoLog(Module, $"{Module}.{Name} connected");
|
|
}
|
|
|
|
_thread = new PeriodicJob(400, OnTimer, $"{Module}.{Name} MonitorHandler", true);
|
|
RequestStatus();
|
|
|
|
OP.Subscribe($"{Module}.Home", (string cmd, object[] args) =>
|
|
{
|
|
HomeSmif(out _);
|
|
return true;
|
|
});
|
|
|
|
OP.Subscribe($"{Module}.Abort", (string cmd, object[] args) =>
|
|
{
|
|
Stop();
|
|
return true;
|
|
});
|
|
|
|
OP.Subscribe($"{Module}.Reset", (string cmd, object[] args) =>
|
|
{
|
|
Reset();
|
|
return true;
|
|
});
|
|
|
|
OP.Subscribe($"{Module}.Unload", (string cmd, object[] args) =>
|
|
{
|
|
UnloadCassette(out _);
|
|
return true;
|
|
});
|
|
|
|
OP.Subscribe($"{Module}.Load", (string cmd, object[] args) =>
|
|
{
|
|
LoadCassette(out _);
|
|
return true;
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
internal void NoteConstant(string constantResult)
|
|
{
|
|
var constantResultArray = constantResult.Split('=');
|
|
if(constantResultArray.Count() != 2)
|
|
{
|
|
return;
|
|
}
|
|
if(constantResultArray[0] == "P13")
|
|
{
|
|
MSCInterlockMode = constantResultArray[1];
|
|
}
|
|
//else if....
|
|
}
|
|
|
|
private bool OnTimer()
|
|
{
|
|
try
|
|
{
|
|
//return true;
|
|
_connection.MonitorTimeout();
|
|
|
|
if (!_connection.IsConnected || _connection.IsCommunicationError)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
_lstHandler.Clear();
|
|
}
|
|
|
|
_trigRetryConnect.CLK = !_connection.IsConnected;
|
|
if (_trigRetryConnect.Q)
|
|
{
|
|
if (string.IsNullOrEmpty(_scRoot))
|
|
{
|
|
_connection.SetPortAddress(SC.GetStringValue($"{Module}.DeviceAddress"));
|
|
}
|
|
else
|
|
{
|
|
_connection.SetPortAddress(SC.GetStringValue($"{_scRoot}.{Module}.{Name}.DeviceAddress"));
|
|
}
|
|
if (!_connection.Connect())
|
|
{
|
|
EV.PostAlarmLog(Module, $"Can not connect with {_connection.Address}, {Module}");
|
|
}
|
|
else
|
|
{
|
|
//_lstHandler.AddLast(new BrooksSMIFQueryPinHandler(this, _deviceAddress));
|
|
//_lstHandler.AddLast(new BrooksSMIFSetCommModeHandler(this, _deviceAddress, EnumRfPowerCommunicationMode.Host));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
HandlerBase handler = null;
|
|
if (!_connection.IsBusy)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
if (_lstHandler.Count == 0)
|
|
{
|
|
foreach (var monitorHandler in _lstMonitorHandler)
|
|
{
|
|
_lstHandler.AddLast(monitorHandler);
|
|
}
|
|
|
|
}
|
|
|
|
if (_lstHandler.Count > 0)
|
|
{
|
|
handler = _lstHandler.First.Value;
|
|
|
|
_lstHandler.RemoveFirst();
|
|
}
|
|
}
|
|
|
|
if (handler != null)
|
|
{
|
|
_connection.Execute(handler);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LOG.Write(ex);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
internal void NoteStatus(string formCode, string status)
|
|
{
|
|
if(formCode == "FSD0")
|
|
{
|
|
SmifStatus = status;
|
|
}
|
|
else if (formCode == "FSD2")
|
|
{
|
|
CassetteMapInfo = status;
|
|
}
|
|
}
|
|
|
|
internal void NoteEnable(string parameter, bool isEnable)
|
|
{
|
|
if(parameter == "FETCH")
|
|
{
|
|
FetchEnable = isEnable;
|
|
}
|
|
else if (parameter == "LOAD")
|
|
{
|
|
LoadEnable = isEnable;
|
|
}
|
|
else if (parameter == "HOME")
|
|
{
|
|
HomeEnable = isEnable;
|
|
}
|
|
else if (parameter == "OPEN")
|
|
{
|
|
OpenEnable = isEnable;
|
|
}
|
|
else if (parameter == "UNLOAD")
|
|
{
|
|
UnloadEnable = isEnable;
|
|
}
|
|
else if (parameter == "CLOSE")
|
|
{
|
|
CloseEnable = isEnable;
|
|
}
|
|
}
|
|
|
|
public override void Monitor()
|
|
{
|
|
try
|
|
{
|
|
//_connection.EnableLog(_enableLog);
|
|
|
|
|
|
_trigCommunicationError.CLK = _connection.IsCommunicationError;
|
|
if (_trigCommunicationError.Q)
|
|
{
|
|
EV.PostAlarmLog(Module, $"{Module}.{Name} communication error, {_connection.LastCommunicationError}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LOG.Write(ex);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override void Reset()
|
|
{
|
|
_trigError.RST = true;
|
|
|
|
_connection.SetCommunicationError(false, "");
|
|
_trigCommunicationError.RST = true;
|
|
|
|
//_enableLog = SC.GetValue<bool>($"{ScBasePath}.{Name}.EnableLogMessage");
|
|
|
|
_trigRetryConnect.RST = true;
|
|
|
|
if(IsAlarm)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
_lstHandler.AddFirst(new BrooksSMIFResetHandler(this));
|
|
}
|
|
}
|
|
|
|
IsAlarm = false;
|
|
|
|
base.Reset();
|
|
}
|
|
|
|
public override bool Home(out string reason)
|
|
{
|
|
return base.Home(out reason);
|
|
}
|
|
|
|
|
|
#region Command Functions
|
|
public void PerformRawCommand(string commandType,string command, string completeEvent, string comandArgument)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
_lstHandler.AddLast(new BrooksSMIFRawCommandHandler(this, commandType, command, completeEvent, comandArgument));
|
|
}
|
|
}
|
|
|
|
public void EnableAction(string action, string isEnable)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
_lstHandler.AddLast(new BrooksSMIFEnableActionHandler(this, action, bool.Parse(isEnable)));
|
|
}
|
|
}
|
|
|
|
public void FetchCassette()
|
|
{
|
|
lock (_locker)
|
|
{
|
|
if(!PodArrived || !FetchEnable )
|
|
{
|
|
EV.PostAlarmLog(Module, $"{Module}.{Name} Fetch Cassette conditon error");
|
|
return;
|
|
}
|
|
_lstHandler.AddFirst(new BrooksSMIFFetchCassetteHandler(this));
|
|
}
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
}
|
|
public bool LoadCassette(out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
if (!IsIdle)
|
|
{
|
|
reason = $"{Module} is busy";
|
|
return false;
|
|
}
|
|
lock (_locker)
|
|
{
|
|
//if (!LoadEnable)
|
|
//{
|
|
// EV.PostAlarmLog(Module, $"{Module}.{Name} Load Cassette conditon error");
|
|
// return;
|
|
//}
|
|
_lstHandler.AddFirst(new BrooksSMIFLoadCassetteHandler(this));
|
|
}
|
|
|
|
IsIdle = false;
|
|
IsArmRetract = false;
|
|
IsPodPresent = false;
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool HomeSmif(out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
if(!IsIdle)
|
|
{
|
|
reason = $"{Module} is busy";
|
|
return false;
|
|
}
|
|
lock (_locker)
|
|
{
|
|
//if (!HomeEnable)
|
|
//{
|
|
// EV.PostAlarmLog(Module, $"{Module}.{Name} Home conditon error");
|
|
// return;
|
|
//}
|
|
//_lstHandler.AddLast(new BrooksSMIFHomeHandler(this));
|
|
_lstHandler.AddFirst(new BrooksSMIFRecoveryHandler(this));
|
|
}
|
|
|
|
IsIdle = false;
|
|
IsArmRetract = false;
|
|
IsHomed = false;
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
|
|
return true;
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
lock (_locker)
|
|
{
|
|
_lstHandler.AddFirst(new BrooksSMIFStopHandler(this));
|
|
}
|
|
|
|
IsIdle = false;
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
}
|
|
|
|
public void OpenPod()
|
|
{
|
|
lock (_locker)
|
|
{
|
|
if (!PodArrived || !OpenEnable)
|
|
{
|
|
EV.PostAlarmLog(Module, $"{Module}.{Name} OpenPod conditon error");
|
|
return;
|
|
}
|
|
_lstHandler.AddFirst(new BrooksSMIFOpenPodHandler(this));
|
|
}
|
|
|
|
IsIdle = false;
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
}
|
|
|
|
public bool UnloadCassette(out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
if (!IsIdle)
|
|
{
|
|
reason = $"{Module} is busy";
|
|
return false;
|
|
}
|
|
lock (_locker)
|
|
{
|
|
//if (!UnloadEnable)
|
|
//{
|
|
// EV.PostAlarmLog(Module, $"{Module}.{Name} Unload Cassette conditon error");
|
|
// return;
|
|
//}
|
|
_lstHandler.AddFirst(new BrooksSMIFUnloadCassetteHandler(this));
|
|
}
|
|
|
|
IsIdle = false;
|
|
IsArmRetract = false;
|
|
IsPodPresent = false;
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
|
|
return true;
|
|
}
|
|
|
|
public void ClosePod()
|
|
{
|
|
lock (_locker)
|
|
{
|
|
if (!CloseEnable)
|
|
{
|
|
EV.PostAlarmLog(Module, $"{Module}.{Name} ClosePod conditon error");
|
|
return;
|
|
}
|
|
_lstHandler.AddFirst(new BrooksSMIFClosePodHandler(this));
|
|
}
|
|
|
|
IsIdle = false;
|
|
|
|
if (!_setStatusTimer.IsIdle())
|
|
_setStatusTimer.Stop();
|
|
_setStatusTimer.Start(0);
|
|
}
|
|
public void SendEvent(string command)
|
|
{
|
|
_connection.SendMessage("AERS " + command + "\r\n");
|
|
}
|
|
|
|
public void MonitorRawCommand(bool isSelected, string commandType, string command, string commandArgument)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
var existHandlers = _lstMonitorHandler.Where(handler => handler.GetType() == typeof(BrooksSMIFRawCommandHandler)
|
|
&& ((BrooksSMIFRawCommandHandler)handler)._commandType == commandType
|
|
&& ((BrooksSMIFRawCommandHandler)handler)._command == command
|
|
);
|
|
if (isSelected)
|
|
{
|
|
if (!existHandlers.Any())
|
|
_lstMonitorHandler.AddFirst(new BrooksSMIFRawCommandHandler(this, commandType, command, commandArgument));
|
|
}
|
|
else
|
|
{
|
|
if (existHandlers.Any())
|
|
{
|
|
_lstMonitorHandler.Remove(existHandlers.First());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RequestConstant(bool isSelected, string constantId)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
var existHandlers = _lstMonitorHandler.Where(handler => handler.GetType() == typeof(BrooksSMIFRequestConstantHandler));
|
|
if (isSelected)
|
|
{
|
|
if (!existHandlers.Any())
|
|
_lstMonitorHandler.AddFirst(new BrooksSMIFRequestConstantHandler(this, constantId));
|
|
}
|
|
else
|
|
{
|
|
if (existHandlers.Any())
|
|
{
|
|
_lstMonitorHandler.Remove(existHandlers.First());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public void RequestStatus(bool isSelected = true)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
var existHandlers = _lstMonitorHandler.Where(handler => handler.GetType() == typeof(BrooksSMIFRequestStatusHandler)
|
|
&& ((BrooksSMIFRequestStatusHandler)handler)._parameter.Contains("0"));
|
|
if (isSelected)
|
|
{
|
|
if (!existHandlers.Any())
|
|
_lstMonitorHandler.AddFirst(new BrooksSMIFRequestStatusHandler(this, 0));
|
|
}
|
|
else
|
|
{
|
|
if (existHandlers.Any())
|
|
{
|
|
_lstMonitorHandler.Remove(existHandlers.First());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void RequestCassetteMap(bool isSelected)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
var existHandlers = _lstMonitorHandler.Where(handler => handler.GetType() == typeof(BrooksSMIFRequestStatusHandler)
|
|
&& ((BrooksSMIFRequestStatusHandler)handler)._parameter.Contains("2"));
|
|
if (isSelected)
|
|
{
|
|
if (!existHandlers.Any())
|
|
_lstMonitorHandler.AddFirst(new BrooksSMIFRequestStatusHandler(this, 2));
|
|
}
|
|
else
|
|
{
|
|
if (existHandlers.Any())
|
|
{
|
|
_lstMonitorHandler.Remove(existHandlers.First());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public string Connected { get; private set; }
|
|
|
|
public string RobotStatus { get; private set; }
|
|
public string IsOnLine { get; private set; }
|
|
public string IsManual { get; private set; }
|
|
public string IsStop { get; private set; }
|
|
public string IsES { get; private set; }
|
|
public string MovingCompleted { get; private set; }
|
|
public string ACalCompleted { get; private set; }
|
|
public string AddressOutSide { get; private set; }
|
|
public string PositionOutSide { get; private set; }
|
|
public string EmergencyStop { get; private set; }
|
|
public string XLowerSide { get; private set; }
|
|
public string XUpperSide { get; private set; }
|
|
public string YLowerSide { get; private set; }
|
|
public string YUpperSide { get; private set; }
|
|
public string ZLowerSide { get; private set; }
|
|
public string ZUpperSide { get; private set; }
|
|
|
|
public bool PodArrived { get; private set; }
|
|
public bool PodRemoved { get; private set; }
|
|
public bool FetchBegun { get; private set; }
|
|
public bool FetchCompleted { get; private set; }
|
|
public bool FetchEnable { get; private set; }
|
|
public bool LoadEnable { get; private set; }
|
|
public bool LoadBegun { get; private set; }
|
|
public bool LoadAbort { get; private set; }
|
|
public bool LoadCompleted { get; private set; }
|
|
public bool UnloadEnable { get; private set; }
|
|
public bool UnloadBegun { get; private set; }
|
|
public bool UnloadAbort { get; private set; }
|
|
public bool UnloadCompleted { get; private set; }
|
|
|
|
public bool HomeEnable { get; private set; }
|
|
public bool HomeBegun { get; private set; }
|
|
public bool HomeCompleted { get; private set; }
|
|
|
|
public bool OpenEnable { get; private set; }
|
|
public bool OpenBegun { get; private set; }
|
|
public bool OpenCompleted { get; private set; }
|
|
|
|
public bool CloseEnable { get; private set; }
|
|
public bool CloseBegun { get; private set; }
|
|
public bool CloseCompleted { get; private set; }
|
|
public string AlarmOccurTime { get; private set; }
|
|
public string AlarmInfo { get; private set; }
|
|
public string MSCInterlockMode { get; private set; }
|
|
public string SmifStatus { get; private set; }
|
|
public string CassetteMapInfo { get; private set; }
|
|
|
|
#endregion
|
|
|
|
|
|
#region Note Functions
|
|
private R_TRIG _trigWarningMessage = new R_TRIG();
|
|
|
|
|
|
public void NoteError(string errorData)
|
|
{
|
|
if (errorData != null)
|
|
{
|
|
_trigWarningMessage.CLK = true;
|
|
if (_trigWarningMessage.Q)
|
|
{
|
|
EV.PostWarningLog(Module, $"{Module} error, {(_RealyMessageDict.ContainsKey(errorData) ? _RealyMessageDict[errorData] : errorData)}");
|
|
}
|
|
if (errorData.ToUpper() == "ALARM")
|
|
IsAlarm = true;
|
|
}
|
|
}
|
|
|
|
internal void NoteRawCommandInfo(string commandType, string command, string data, bool isAck)
|
|
{
|
|
var curIOResponse = IOResponseList.Find(res => res.SourceCommandType == commandType && res.SourceCommand == command);
|
|
if (curIOResponse != null)
|
|
{
|
|
IOResponseList.Remove(curIOResponse);
|
|
}
|
|
IOResponseList.Add(new IOResponse() { SourceCommandType = commandType, SourceCommand = command, ResonseContent = data, IsAck = isAck, ResonseRecievedTime = DateTime.Now });
|
|
}
|
|
|
|
|
|
#endregion
|
|
}
|
|
|
|
}
|