首次上传

This commit is contained in:
hanqiangqiang
2026-06-15 10:56:30 +08:00
commit b0213b94d6
4160 changed files with 736101 additions and 0 deletions
@@ -0,0 +1,177 @@
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public class SetEventHandler : IMsg //common move
{
public bool background { get; private set;}
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public SetEventHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = args[0].ToString();
return string.Format("EVT:{0}", _cmd);
}
public string retry()
{
return string.Format("RFN:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("ACK"))
return false;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
public class OnEventHandler : IMsg //common move
{
public bool background { get; private set; }
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public OnEventHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = args[0].ToString();
return "";
}
public string retry()
{
return "";
}
public bool unpackage(string type, string[] items)
{
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
if (type.Equals("INF") || type.Equals("RIF") )
{
string name = items[0];
switch (name)
{
case "PODON": // PODON The FOUP is moved from no load to the normal position.
{
device.OnCarrierPresent();
device.OnCarrierPlaced();
string reason = string.Empty;
device.OnEvent(out reason);
}
break;
case "PODOF": //PODOF The FOUP is moved from normal position to no load.
{
device.OnCarrierNotPlaced();
device.OnCarrierNotPresent();
string reason = string.Empty;
device.OnEvent(out reason);
}
break;
case "ABNST": //PODOF The FOUP is moved from normal position to no load.
{
device.OnCarrierNotPlaced();
//device.OnCarrierPresent();
string reason = string.Empty;
device.OnEvent(out reason);
}
break;
case "SMTON":
{
device.OnCarrierNotPlaced();
//device.OnCarrierPresent();
string reason = string.Empty;
device.OnEvent(out reason);
}
break;
case "FANST":
device.FFUIsOK = false;
break;
case "MANSW":
EV.PostMessage(device.Module, EventEnum.ManualOpAccess, device.Display);
device.OnSwitchKey1();
break;
case "MA2SW":
device.OnSwitchKey2();
break;
case "MANOF":
device.OffSwitchKey1();
break;
case "MA2OF":
device.OffSwitchKey2();
break;
case "ITLOF":
device.UnlockKey = false;
break;
case "ITLON":
device.UnlockKey = true;
break;
case "IPAON":
device.IsInfoPadAOn = true;
break;
case "IPBON":
device.IsInfoPadBOn = true;
break;
case "IPCON":
device.IsInfoPadCOn = true;
break;
case "IPDON":
device.IsInfoPadDOn = true;
break;
case "IPAOF":
device.IsInfoPadAOn = false;
break;
case "IPBOF":
device.IsInfoPadBOn = false;
break;
case "IPCOF":
device.IsInfoPadCOn = false;
break;
case "IPDOF":
device.IsInfoPadDOn = false;
break;
default:
LOG.Write(string.Format("Not handled event {0} from LP {1}", name, device.DeviceID));
break;
}
return true;
}
else if (type.Equals("ABS") || type.Equals("RAS"))
{
LOG.Write(string.Format("Received {0} event from {1}", type, device.DeviceID));
}
return false;
}
public bool canhandle(string id)
{
return true;
}
}
}
@@ -0,0 +1,394 @@
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using System;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public class QueryStateHandler : IMsg
{
/// <summary>
/// / (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20)
/// (1) Equipment status 0 = Normal A = Recoverable error E = Fatal error
///(5)Error code Error code(upper)
///(6)Error code Error code(lower)
///(7)Cassette presence 0 = None 1 = Normal position 2 = Error load
///(8)FOUP clamp status 0 = Open 1 = Close? = Not defined
///(11)Door position 0 = Open position 1 = Close position ? = Not defined
/// </summary>
public bool background { get; private set; }
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public QueryStateHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = QueryType.STATE.ToString();
return string.Format("GET:{0}", _cmd);
}
public string retry()
{
return string.Format("RFN:{0}", _cmd);
}
public bool unpackage(string type, string[] items)
{
if (!type.Equals("ACK"))
return false;
string state = items[1];
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
device.ErrorCode = state.Substring(4, 2);
if (state[0] != '0')
{
device.Error = true;
device.ErrorCode = state.Substring(4,2);
string error = Singleton<ErrorCode>.Instance.Code2Msg(device.ErrorCode);
EV.PostMessage(deviceID, EventEnum.DefaultWarning, string.Format("{0} has error, error is {1}", deviceID, error));
EV.Notify(device.AlarmLoadPortError, new SerializableDictionary<string, object> {
{"AlarmText",string.Format(error)}
});
}
else
{
device.Error = false;
}
device.ClampState = getClampState(state[7]);
device.DoorState = getDoorState(state[10]);
device.DockPOS = GetDockPos(state[13]);
device.DockState = GetFoupDockPos(state[13]);
device.DoorPOS = GetDoorPos(state[12]);
LOG.Write($"Get State:{state}");
if (SC.ContainsItem("CarrierInfo.InfoPadType") && (SC.GetValue<int>("CarrierInfo.InfoPadType") == 0)) //0 is TDK sensor, 1 is for external sensors.
{
int infopadstatus = Convert.ToInt16($"0x{state[19]}", 16);
if ((infopadstatus & 1) != 0) device.IsInfoPadAOn = true;
else device.IsInfoPadAOn = false;
if ((infopadstatus & 2) != 0) device.IsInfoPadBOn = true;
else device.IsInfoPadBOn = false;
if ((infopadstatus & 4) != 0) device.IsInfoPadCOn = true;
else device.IsInfoPadCOn = false;
if ((infopadstatus & 8) != 0) device.IsInfoPadDOn = true;
else device.IsInfoPadDOn = false;
int cindex = (device.IsInfoPadAOn ? 8 : 0) + (device.IsInfoPadBOn ? 4 : 0) + (device.IsInfoPadCOn ? 2 : 0) + (device.IsInfoPadDOn ? 1 : 0);
device.InfoPadCarrierIndex = cindex;
if (getCassetteState(state[6]) == LoadportCassetteState.Normal)
{
if (SC.ContainsItem($"CarrierInfo.CarrierName{cindex}"))
device.InfoPadCarrierType = SC.GetStringValue($"CarrierInfo.CarrierName{cindex}");
}
else
device.InfoPadCarrierType = "";
if (SC.ContainsItem($"CarrierInfo.{device.Name}CarrierIndex"))
SC.SetItemValue($"CarrierInfo.{device.Name}CarrierIndex", cindex);
if (SC.ContainsItem($"CarrierInfo.CarrierFosbMode{cindex}"))
{
int fosbmode = SC.GetValue<int>($"CarrierInfo.CarrierFosbMode{cindex}");
if (fosbmode >= 0 && fosbmode <= 1)
device.CasstleType = (CasstleType)fosbmode;
}
LOG.Write($"{device.Name} detect carrier Type:{device.InfoPadCarrierType}");
}
if (SC.ContainsItem("CarrierInfo.InfoPadType") && (SC.GetValue<int>("CarrierInfo.InfoPadType") == 2)) //0 is TDK sensor, 1 is for external sensors.
{
int cindex = SC.GetValue<int>($"CarrierInfo.{device.Name}CarrierIndex");
device.InfoPadCarrierIndex = cindex;
if (SC.ContainsItem($"CarrierInfo.CarrierName{cindex}"))
device.InfoPadCarrierType = SC.GetStringValue($"CarrierInfo.CarrierName{cindex}");
if (SC.ContainsItem($"CarrierInfo.CarrierFosbMode{cindex}"))
{
int fosbmode = SC.GetValue<int>($"CarrierInfo.CarrierFosbMode{cindex}");
if (fosbmode >= 0 && fosbmode <= 1)
device.CasstleType = (CasstleType)fosbmode;
if(device.CasstleType == CasstleType.FOSB)
device.IsMapWaferByLoadPort = false;
else
device.IsMapWaferByLoadPort = true;
}
LOG.Write($"{device.Name} detect carrier Type:{device.InfoPadCarrierType}");
}
device.SetCassetteState(getCassetteState(state[6]));
string reason = string.Empty;
device.OnStateUpdated();
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
//(7) Cassette presence 0 = None 1 = Normal position 2 = Error load
private LoadportCassetteState getCassetteState(char x)
{
if (x == '0')
return LoadportCassetteState.Absent;
if (x == '1')
return LoadportCassetteState.Normal;
return LoadportCassetteState.Absent;
}
// (8) FOUP clamp status 0 = Open 1 = Close ? = Not defined
private FoupClampState getClampState(char x)
{
if (x == '0')
return FoupClampState.Open;
if (x == '1')
return FoupClampState.Close;
return FoupClampState.Unknown;
}
private TDKY_AxisPos GetDockPos(char x)
{
if (x == '0')
return TDKY_AxisPos.Undock;
if (x == '1')
return TDKY_AxisPos.Dock;
return TDKY_AxisPos.Unknown;
}
private FoupDockState GetFoupDockPos(char x)
{
if (x == '0')
return FoupDockState.Undocked;
if (x == '1')
return FoupDockState.Docked;
return FoupDockState.Unknown;
}
private TDKZ_AxisPos GetDoorPos(char x)
{
if (x == '0')
return TDKZ_AxisPos.Up;
if (x == '1')
return TDKZ_AxisPos.Down;
if (x == '2')
return TDKZ_AxisPos.Start;
if (x == '3')
return TDKZ_AxisPos.End;
return TDKZ_AxisPos.Unknown;
}
//(11) Door position 0 = Open position 1 = Close position ? = Not defined
private FoupDoorState getDoorState(char x)
{
if (x == '0')
return FoupDoorState.Open;
if (x == '1')
return FoupDoorState.Close;
return FoupDoorState.Unknown;
}
}
public class QueryIndicatorHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public QueryIndicatorHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = QueryType.LEDST.ToString();
return string.Format("GET:{0}", _cmd);
}
public string retry()
{
return string.Format("RFN:{0}", _cmd);
}
public bool unpackage(string type, string[] items)
{
if (!type.Equals("ACK"))
return false;
string state = items[1];
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
if (state.Length == 7)
{
device.IndicatiorPresence = getIndicatorState(state[0]);
device.IndicatiorPlacement = getIndicatorState(state[1]);
device.IndicatorAlarm = getIndicatorState(state[2]);
device.IndicatiorLoad = getIndicatorState(state[3]);
device.IndicatiorUnload = getIndicatorState(state[4]);
device.IndicatiorOpAccess = getIndicatorState(state[5]);
device.IndicatiorStatus1 = getIndicatorState(state[6]);
}
else
{
device.IndicatiorLoad = getIndicatorState(state[0]);
device.IndicatiorUnload = getIndicatorState(state[1]);
device.IndicatiorAccessManual = getIndicatorState(state[2]);
device.IndicatiorPresence = getIndicatorState(state[3]);
device.IndicatiorPlacement = getIndicatorState(state[4]);
device.IndicatiorAccessAuto = getIndicatorState(state[5]);
device.IndicatorAlarm = getIndicatorState(state[7]);
device.IndicatiorStatus1 = getIndicatorState(state[6]);
device.IndicatiorStatus2 = getIndicatorState(state[8]);
}
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
private IndicatorState getIndicatorState(char x)
{
if (x == '0')
return IndicatorState.OFF;
if (x == '1')
return IndicatorState.ON;
return IndicatorState.BLINK;
}
}
public class QueryWaferMappingHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public QueryWaferMappingHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = QueryType.MAPRD.ToString();
return string.Format("GET:{0}", _cmd);
}
public string retry()
{
return string.Format("RFN:{0}", _cmd);
}
public bool unpackage(string type, string[] items)
{
if (!type.Equals("ACK"))
return false;
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
device.OnSlotMapRead(items[1]);
string reason = string.Empty;
device.QueryState(out reason);
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 查询FOSB模式是否激活
/// </summary>
public class QueryFOSBModeHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public QueryFOSBModeHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = QueryType.FSBxx.ToString();
return string.Format("GET:{0}", _cmd);
}
public string retry()
{
return string.Format("RFN:{0}", _cmd);
}
public bool unpackage(string type, string[] items)
{
if (!type.Equals("ACK"))
return false;
string modeState = items[1];
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
switch (modeState)
{
case "ON":
device.IsFOSBMode = true;
break;
case "OF":
device.IsFOSBMode = false;
break;
default:
device.IsFOSBMode = false;
break;
}
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
}
@@ -0,0 +1,132 @@
using System;
using System.Text.RegularExpressions;
using Aitex.Core.RT.Log;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public interface IMsg
{
string deviceID { set; }
bool background { get; }
string package(params object[] args);
string retry();
/// </summary>
/// return value, completed
/// <param name="type"></param>
/// <param name="cmd"></param>
/// <returns></returns>
bool unpackage(string type, string[] cmd);
bool canhandle(string id);
}
public class handler<T> : IHandler where T : IMsg, new()
{
private static int retry_time = 3;
private int retry_count = retry_time;
private T _imp = new T();
public int ID { get; set; }
public int Unit { get; set; }
public bool IsBackground { get { return _imp.background; } }
private object[] _objs = null;
private string _deviceID = string.Empty;
private LoadPort _lpdevice;
public handler(LoadPort lp, string deviceID, params object[] objs)
{
_deviceID = deviceID;
_imp.deviceID = _deviceID;
this._objs = objs;
_lpdevice = lp;
}
public bool Execute<TPort>(ref TPort port) where TPort : ICommunication
{
//_lpdevice.ExecuteError = false;
retry_count = retry_time;
return port.Write(string.Format("s00{0};\r", _imp.package(this._objs)));
}
/// <summary>
/// return value: bhandle
/// </summary>
/// <typeparam name="TPort"></typeparam>
/// <param name="port"></param>
/// <param name="msg"></param>
/// <param name="completed"></param>
/// <returns></returns>
public bool OnMessage<TPort>(ref TPort port, string message, out bool completed) where TPort : ICommunication
{
// message = "ACK:STATE/A000A400101000101000;";
completed = false;
try
{
string msg = message.TrimEnd(';');
string[] words = Regex.Split(msg, ":");
string type = words[0];
string data = words[1];
string[] items = Regex.Split(data, "/");
if (!_imp.canhandle(items[0]))
return false;
if (type == "ABS")
{
_lpdevice.ExecuteError = true;
throw (new ExcuteFailedException(message));
}
else if (type == "NAK") //process retry
{
if (items.Length > 1)
{
string cause = items[1];
if (cause != "CKSUM" || cause != "CMDER")
{
string warning = string.Format("can't excute retry, failed cause is {0}", cause);
LOG.Warning(warning);
throw (new ExcuteFailedException(warning));
}
if (retry_count-- <= 0)
{
string warning = string.Format("retry over {0} times", retry_time);
LOG.Warning(warning);
throw (new ExcuteFailedException(warning));
}
port.Write(_imp.retry());
return true;
}
}
else
{
//_lpdevice.ExecuteError = false;
completed = _imp.unpackage(type, items);
return true;
}
}
catch (ExcuteFailedException e)
{
throw (e);
}
catch (Exception ex)
{
LOG.Write(ex);
throw (new InvalidPackageException(message));
}
return false;
}
}
}
@@ -0,0 +1,38 @@
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public class ModHandler : IMsg //common move
{
public bool background { get; private set; }
public string deviceID { private get; set; }
private string _cmd = string.Empty;
public ModHandler()
{
background = false;
}
public string package(params object[] args)
{
_cmd = args[0].ToString();
return string.Format("MOD:{0}", _cmd);
}
public string retry()
{
return string.Format("RFN:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("ACK"))
return false;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
}
@@ -0,0 +1,379 @@
using Aitex.Core.RT.Device;
using Aitex.Sorter.Common;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public class MovHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
public string _cmd = string.Empty;
TDKLoadPort _device = null;
public MovHandler()
{
background = true;
}
public string package(params object[] args)
{
MovType type = (MovType)args[0];
_cmd = type.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
if (_cmd == MovType.CULOD.ToString() || _cmd == MovType.CULDK.ToString())
_device.OnUnloaded();
if (_cmd == MovType.CLDDK.ToString() || _cmd == MovType.CLDMP.ToString() || _cmd == MovType.CLOAD.ToString())
_device.OnLoaded();
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
public class HomeHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
TDKLoadPort _device = null;
private string _cmd = string.Empty;
public HomeHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.ORGSH.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
_device.Initalized = true;
_device.OnHomed();
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
public class ForceHomeHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
TDKLoadPort _device = null;
private string _cmd = string.Empty;
public ForceHomeHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.ABORG.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
_device.Initalized = true;
_device.OnHomed();
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 单步移动到Dock位置动作 指令为YDOOR
/// </summary>
public class DockPosHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
TDKLoadPort _device = null;
private string _cmd = string.Empty;
public DockPosHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.YDOOR.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
_device.ClampState = FoupClampState.Close;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 单步移动到Un Dock位置动作 指令为YWAIT
/// </summary>
public class UnDockPosHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
TDKLoadPort _device = null;
private string _cmd = string.Empty;
public UnDockPosHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.YWAIT.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
_device.DockPOS = TDKY_AxisPos.Undock;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 单步开门动作 指令为DORBK
/// </summary>
public class DoorOpenHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
//TDKLoadPort _device = null;
private string _cmd = string.Empty;
public DoorOpenHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.DORBK.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 单步关门动作 指令为DORFW
/// </summary>
public class DoorCloseHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
//TDKLoadPort _device = null;
private string _cmd = string.Empty;
public DoorCloseHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.DORFW.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 单步门下降动作 指令为ZDRDW
/// </summary>
public class DoorDownHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
TDKLoadPort _device = null;
private string _cmd = string.Empty;
public DoorDownHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.ZDRDW.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
_device.DoorState = FoupDoorState.Open;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
/// <summary>
/// 单步门上升动作 指令为ZDRUP
/// </summary>
public class DoorUpHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
TDKLoadPort _device = null;
private string _cmd = string.Empty;
public DoorUpHandler()
{
background = true;
}
public string package(params object[] args)
{
_cmd = MovType.ZDRUP.ToString();
return string.Format("MOV:{0}", _cmd);
}
public string retry()
{
return string.Format("RMV:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (!type.Equals("INF"))
return false;
_device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
_device.DoorState = FoupDoorState.Close;
return true;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
}
}
@@ -0,0 +1,187 @@
using Aitex.Core.RT.Device;
using Aitex.Sorter.Common;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public class ResetHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
public ResetHandler()
{
background = true;
}
public string package(params object[] args)
{
return "SET:RESET";
}
public string retry()
{
return "RST:RESET";
}
public bool unpackage(string type, string[] cmds)
{
if (type.Equals("INF"))
return true;
return false;
}
public bool canhandle(string id)
{
return id.Equals("RESET");
}
}
/// <summary>
/// 将LoadPort切换为FOSB模式
/// </summary>
public class FOSBModeHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
public FOSBModeHandler()
{
background = true;
}
public string package(params object[] args)
{
return "SET:FSBON";
}
public string retry()
{
return "RST:FSBON";
}
public bool unpackage(string type, string[] cmds)
{
if (type.Equals("ACK"))
return true;
return false;
}
public bool canhandle(string id)
{
return id.Equals("FSBON");
}
}
/// <summary>
/// 将LoadPort切换为FOUP模式
/// </summary>
public class FOUPModeHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
public FOUPModeHandler()
{
background = true;
}
public string package(params object[] args)
{
return "SET:FSBOF";
}
public string retry()
{
return "RST:FSBOF";
}
public bool unpackage(string type, string[] cmds)
{
if (type.Equals("ACK"))
return true;
return false;
}
public bool canhandle(string id)
{
return id.Equals("FSBOF");
}
}
public class IndicatorHandler : IMsg
{
public bool background { get; private set; }
public string deviceID { private get; set; }
private string[] _opstring = { "LON", "LBL", "LOF" };
private string _cmd =" ";
Indicator light;
IndicatorState func;
public IndicatorHandler()
{
background = true;
}
public string package(params object[] args)
{
light = (Indicator)args[0];
func = (IndicatorState)args[1];
_cmd = indicator(light,func);
return string.Format("SET:{0}", _cmd);
}
public string retry()
{
return string.Format("RST:{0}", _cmd);
}
public bool unpackage(string type, string[] cmds)
{
if (type.Equals("INF"))
{
SetLight(light,func);
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
string reason = string.Empty;
// device.QueryIndicator(out reason);
return true;
}
return false;
}
public bool canhandle(string id)
{
return id.Equals(_cmd);
}
private string indicator(Indicator light, IndicatorState op)
{
return string.Format("{0}{1:D2}", _opstring[(int)op-1], (int)light);
}
private void SetLight(Indicator light, IndicatorState op)
{
TDKLoadPort device = DEVICE.GetDevice<TDKLoadPort>(deviceID);
switch (light)
{
case Indicator.LOAD:
device.IndicatiorLoad = op;
break;
case Indicator.UNLOAD:
device.IndicatiorUnload = op;
break;
case Indicator.ACCESSAUTO:
device.IndicatiorAccessAuto = op;
break;
case Indicator.ACCESSMANUL:
device.IndicatiorAccessManual = op;
break;
case Indicator.PLACEMENT:
device.IndicatiorPlacement = op;
break;
case Indicator.PRESENCE:
device.IndicatiorPresence = op;
break;
}
}
}
}
@@ -0,0 +1,950 @@
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Communications;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.Device.Devices;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
/// <summary>
/// 代码说明:
///
/// </summary>
///
public enum CarrierOnLPState
{
Unknow=0,
On,
Off,
}
public class TDKLoadPort : LoadPort,IConnection
{
public string Address { get; set; }
public bool IsConnected
{
get { return _port.IsOpen(); }
}
public bool UnlockKey
{
set
{
}
}
public bool Enable
{
set
{
if (_enableTrigger != null)
{
_enableTrigger.SetTrigger(value, out _);
}
}
}
public bool FFUIsOK { get; set; }
private LoadportCassetteState _cassetteState = LoadportCassetteState.None;
public override LoadportCassetteState CassetteState
{
get { return _cassetteState; }
set
{
_cassetteState = value;
}
}
public bool Processed { get; set; }
public bool Communication
{
get
{
return _port == null ? !_commErr : !_commErr && _port.IsOpen();
}
}
//
public override bool IsBusy
{
get { return _foregroundHandler != null || _handlers.Count > 0 ; }
}
public override bool IsMoving
{
get { return _foregroundHandler != null && _handlers.Count > 0; }
}
public const string delimiter = "\r";
public const int min_len = 3; //S00
private static Object _locker = new Object();
private AsyncSerial _port;
private bool _commErr = false;
private IHandler _eventHandler = null;
private IHandler _foregroundHandler = null; //moving
private Queue<IHandler> _handlers = new Queue<IHandler>();
private IoSensor _sensorEnable = null;
private IoTrigger _enableTrigger = null;
public TDKLoadPort(string module, string name, string port, IoSensor sensorEnable, IoTrigger triggerEnable,
EnumLoadPortType portType =EnumLoadPortType.LoadPort)
: base(module, name )
{
_port = new AsyncSerial(port, 9600, 8);
_port.OnDataChanged += (OnDataChanged);
_port.OnErrorHappened += (OnErrorHandler);
_eventHandler = new handler<OnEventHandler>(this, Name);
_sensorEnable = sensorEnable;
_enableTrigger = triggerEnable;
Initalized = false;
IsMapWaferByLoadPort = portType== EnumLoadPortType.LoadPort;
PortType = portType;
IndicatiorLoad = IndicatorState.UNKNOW;
IndicatiorUnload = IndicatorState.UNKNOW;
IndicatiorPresence = IndicatorState.UNKNOW;
IndicatorAlarm = IndicatorState.UNKNOW;
IndicatiorPlacement = IndicatorState.UNKNOW;
IndicatiorOpAccess = IndicatorState.UNKNOW;
IndicatiorStatus1 = IndicatorState.UNKNOW;
IndicatiorStatus2 = IndicatorState.UNKNOW;
IndicatiorAccessAuto = IndicatorState.UNKNOW;
IndicatiorAccessManual = IndicatorState.UNKNOW;
DoorState = FoupDoorState.Unknown;
ClampState = FoupClampState.Unknown;
CassetteState = LoadportCassetteState.Unknown;
//if (!this.QueryState(out string reason))
//{
// EV.PostAlarmLog(module,$"Query state error.{reason}");
//}
Enable = true;
Address = port;
}
public void SetCassetteState(LoadportCassetteState state)
{
_cassetteState = state;
if (state == LoadportCassetteState.Normal)
{
_isPlaced = true;
_isPresent = true;
ConfirmAddCarrier();
}
else if(state == LoadportCassetteState.Absent)
{
_isPlaced = false;
_isPresent = false;
ConfirmRemoveCarrier();
}
else
{
_isPlaced = false;
ConfirmRemoveCarrier();
}
}
public override bool ReadRfId(out string reason)
{
OP.DoOperation("ReadCarrierId", Name);
reason = "";
return true;
}
public override bool Initialize()
{
base.Initialize();
_commErr = true;
ConnectionManager.Instance.Subscribe($"{Name}", this);
Connect();
//if (!RetryInstance.Instance().Execute<bool>(
// ()=> _port.Open(),
// SC.GetValue<int>("System.ComPortRetryDelayTime"),
// SC.GetValue<int>("System.ComPortRetryCount"),
// true
//))
//{
// return false;
//}
return true;
}
public override bool Connect()
{
_commErr = false;
Task.Factory.StartNew(() =>
{
int count = SC.ContainsItem("System.ComPortRetryCount") ? SC.GetValue<int>("System.ComPortRetryCount") : 5;
int sleep = SC.ContainsItem("System.ComPortRetryDelayTime") ? SC.GetValue<int>("System.ComPortRetryDelayTime") : 2;
if (sleep <= 0 || sleep > 10)
sleep = 2;
int retry = 0;
do
{
_port.Close();
Thread.Sleep(sleep * 1000);
if (_port.Open())
{
//LOG.Write($"Connected with {Module}.{Name} .");
EV.PostInfoLog(Module, $"Connected with {Module}.{Name} .");
break;
}
if (count > 0 && retry++ > count)
{
LOG.Write($"Retry connect {Module}.{Name} stop retry.");
EV.PostAlarmLog(Module, $"Can't connect to {Module}.{Name}.");
break;
}
Thread.Sleep(sleep * 1000);
LOG.Write($"Retry connect {Module}.{Name} for the {retry + 1} time.");
} while (true);
});
return true;
}
public bool Disconnect()
{
return true;
}
public override void Terminate()
{
_port.Close();
}
public override bool IsEnableMapWafer()
{
if (IsIdle
&& _isPresent
&& _isPlaced
&& DoorState == FoupDoorState.Open
&& CassetteState == LoadportCassetteState.Normal
)
return true;
return false;
}
public override bool IsEnableTransferWafer()
{
return IsEnableTransferWafer(out _);
}
public override bool IsEnableTransferWafer(out string reason)
{
reason = "";
if (_isPlaced
&& _isPresent
&& _isMapped
&& IsIdle
&& DoorState==FoupDoorState.Open
&& CassetteState==LoadportCassetteState.Normal
&& IsWaferEnableTransfer()
) return true;
return false;
}
public override void Monitor()
{
base.Monitor();
}
/// <summary>
///The Indicator is for EAP/Operator
/// LOAD READY: LoadPort Ready to receive FOUP
/// UNLOAD READY: FOUP ready to remove
///
/// </summary>
public void OnStateUpdated()
{
//if (!SC.ContainsItem("Process.OptionLoadportMonitor") || !SC.GetValue<bool>("Process.OptionLoadportMonitor"))
// return;
//if (_isPresent && _isPlaced && this.ClampState == FoupClampState.Open &&this.DockPOS == TDKY_AxisPos.Undock)
//{
// if (IndicatiorUnload != IndicatorState.ON)
// SetIndicator(Indicator.UNLOAD, IndicatorState.ON);
// if (IndicatiorLoad != IndicatorState.OFF)
// SetIndicator(Indicator.LOAD, IndicatorState.OFF);
// return;
//}
//if (!_isPresent || !_isPlaced)
//{
// if (IndicatiorUnload != IndicatorState.OFF)
// SetIndicator(Indicator.UNLOAD, IndicatorState.OFF);
// if (IndicatiorLoad != IndicatorState.ON)
// SetIndicator(Indicator.LOAD, IndicatorState.ON);
// return;
//}
//if (IndicatiorUnload != IndicatorState.OFF)
// SetIndicator(Indicator.UNLOAD, IndicatorState.OFF);
//if (IndicatiorLoad != IndicatorState.OFF)
// SetIndicator(Indicator.LOAD, IndicatorState.OFF);
}
public void OnAccessButtonPushed()
{
if (_isPresent && _isPlaced)
{
}
}
/// <summary>
///reset load port error
///
/// </summary>
public override void Reset()
{
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
FFUIsOK = true;
_commErr = false;
Enable = true;
Error = false;
base.Reset();
}
public override bool Home(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<HomeHandler>(this, Name), out reason);
}
public override bool ForceHome(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<ForceHomeHandler>(this, Name), out reason);
}
public override bool FOSBMode(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<FOSBModeHandler>(this, Name), out reason);
}
public override bool FOUPMode(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<FOUPModeHandler>(this, Name), out reason);
}
public override bool FOSBDock(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<DockPosHandler>(this, Name), out reason);
}
public override bool FOSBUnDock(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<UnDockPosHandler>(this, Name), out reason);
}
public override bool FOSBDoorOpen(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<DoorOpenHandler>(this, Name), out reason);
}
public override bool FOSBDoorClose(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<DoorCloseHandler>(this, Name), out reason);
}
public override bool FOSBDoorUp(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<DoorUpHandler>(this, Name), out reason);
}
public override bool FOSBDoorDown(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<DoorDownHandler>(this, Name), out reason);
}
/// <summary>
/// Clear LP error
/// </summary>
public override bool ClearError(out string reason)
{
reason = string.Empty;
Error = false;
ExecuteError = false;
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<ResetHandler>(this, Name), out reason);
}
public override bool Stop(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_handlers.Clear();
}
return execute(new handler<MovHandler>(this, Name, MovType.STOP_), out reason);
}
public override bool FALoad(out string reason) //map and loads
{
reason = "";
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
OP.DoOperation("LoadFoup", Name);
return true;
}
public override bool Load(out string reason) //map and loads
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CLDMP, out reason);
}
public override bool LoadWithoutMap(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CLOAD, out reason);
}
public override bool Unload(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CULOD, out reason);
}
public override bool Clamp(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.PODCL, out reason);
}
public override bool Unclamp(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.PODOP, out reason);
}
public override bool Dock(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CLDDK, out reason);
}
public override bool Undock(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CULFC, out reason); //????
}
public override bool OpenDoor(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CLMPO, out reason);
}
public override bool OpenDoorNoMap(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CLDOP, out reason);
}
public override bool CloseDoor(out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
return Move(MovType.CULDK, out reason);
}
public override bool SetIndicator(Indicator light, IndicatorState op, out string reason)
{
reason = string.Empty;
return execute(new handler<IndicatorHandler>(this,Name, light, op), out reason);
}
public bool SetOnlineMode(out string reason)
{
reason = string.Empty;
return execute(new handler<ModHandler>(this, Name, Mode.ONMGV), out reason);
}
public override bool QueryState(out string reason)
{
reason = string.Empty;
return execute(new handler<QueryStateHandler>(this, Name), out reason);
}
public override bool QueryIndicator(out string reason)
{
reason = string.Empty;
return execute(new handler<QueryIndicatorHandler>(this, Name), out reason);
}
public override bool QueryWaferMap(out string reason)
{
reason = string.Empty;
return execute(new handler<QueryWaferMappingHandler>(this, DeviceID), out reason);
}
public override bool QueryFOSBMode(out string reason)
{
reason = string.Empty;
return execute(new handler<QueryFOSBModeHandler>(this, DeviceID), out reason);
}
public bool Move(MovType fun, out string reason)
{
if (State != DeviceState.Idle)
{
reason = $"LoadPort is in {State}";
return false;
}
reason = string.Empty;
return execute(new handler<MovHandler>(this, Name, fun), out reason);
}
//public bool Query(QueryType type, out string reason)
//{
// reason = string.Empty;
// return execute(new handler<QueryWaferMappingHandler>(Name), out reason);
//}
public bool SetEvent(EvtType fun, out string reason)
{
reason = string.Empty;
return execute(new handler<SetEventHandler>(this, Name, fun), out reason);
}
public bool OnEvent(out string reason)
{
reason = string.Empty;
lock (_locker)
{
if (!execute(new handler<QueryStateHandler>(this, Name), out reason))
return false;
return execute(new handler<QueryIndicatorHandler>(this, Name), out reason);
}
}
private bool execute(IHandler handler1, out string reason)
{
reason = string.Empty;
lock (_locker)
{
if (_foregroundHandler == null)
{
if (!handler1.Execute(ref _port))
{
reason = "Communication failed, please recovery it.";
return false;
}
_foregroundHandler = handler1;
}
else
{
var type = handler1.GetType();
string name = type.Name;
if (type.GenericTypeArguments.Length > 0)
name = type.GenericTypeArguments[0].Name;
LOG.Info(string.Format("Add command {0}", name));
_handlers.Enqueue(handler1);
}
}
return true;
}
private bool execute(out string reason)
{
reason = string.Empty;
lock(_locker)
{
if (_handlers.Count > 0)
{
IHandler handler = _handlers.Dequeue();
if (!handler.Execute(ref _port))
{
reason = " communication failed, please recovery it.";
LOG.Error(reason);
EV.PostMessage(Name, EventEnum.DefaultWarning, "【Reader】" + reason);
return false;
}
_foregroundHandler = handler;
}
}
return true;
}
private void OnDataChanged(string package)
{
try
{
package = package.ToUpper();
string[] msgs = Regex.Split(package, delimiter);
foreach (string msg in msgs)
{
if (msg.Length > min_len)
{
bool completed = false;
string resp = msg.Substring(3, msg.Length - min_len);
lock (_locker)
{
if (_foregroundHandler != null && _foregroundHandler.OnMessage(ref _port, resp, out completed))
{
string reason = string.Empty;
if (!_foregroundHandler.IsBackground)
{
_foregroundHandler = null;
execute(out reason);
OnActionDone(true);
}
else
{
if (completed)
{
_foregroundHandler = null;
QueryState(out reason);
if (_foregroundHandler is handler<HomeHandler>)
{
QueryIndicator(out reason);
}
}
}
}
else
{
_eventHandler.OnMessage(ref _port, resp, out completed); //process event
}
}
}
}
}
catch (ExcuteFailedException ex)
{
EV.PostWarningLog(Module, $"{Name} action failed, "+ex.Message);
_foregroundHandler = null;
OnError( $"{ Name} action failed");
}
catch (InvalidPackageException ex)
{
EV.PostWarningLog(Module, $"{Name} received unprocessed message, {ex.Message}" );
OnError($"{Name} received unprocessed message");
}
catch (Exception ex)
{
LOG.Write($" {Name} has exception:" + ex.Message);
}
}
private void OnErrorHandler(ErrorEventArgs args)
{
_commErr = true;
Initalized = false;
EV.PostAlarmLog(Module, $"{Display} Communication error, {args.Reason}");
OnError($"{Display} Communication error");
}
public void OnCarrierNotPlaced()
{
_isPlaced = false;
}
public void OnCarrierNotPresent()
{
_isPresent = false;
}
public void OnCarrierPlaced()
{
//if (SC.ContainsItem("CarrierInfo.InfoPadType") && (SC.GetValue<int>("CarrierInfo.InfoPadType") == 0)) //0 is TDK sensor
//{
// int cindex = (IsInfoPadAOn ? 8 : 0) + (IsInfoPadBOn ? 4 : 0) + (IsInfoPadCOn ? 2 : 0) + (IsInfoPadDOn ? 1 : 0);
// InfoPadCarrierIndex = cindex;
// if (SC.ContainsItem($"CarrierInfo.CarrierName{cindex}"))
// InfoPadCarrierType = SC.GetStringValue($"CarrierInfo.CarrierName{cindex}");
// if (SC.ContainsItem($"CarrierInfo.{Name}CarrierIndex"))
// SC.SetItemValue($"CarrierInfo.{Name}CarrierIndex", cindex);
// LOG.Write($"{Name} detect carrier Type:{InfoPadCarrierType}");
//}
_isPlaced = true;
_isPresent = true;
}
public void OnCarrierPresent()
{
_isPresent = true;
}
public void OnSwitchKey1()
{
_isAccessSwPressed = true;
}
public void OnSwitchKey2()
{
}
public void OffSwitchKey1()
{
_isAccessSwPressed = false;
}
public void OffSwitchKey2()
{
}
public void SetIndicator(Indicator led, IndicatorState state)
{
SetIndicator(led, state, out string reason);
}
//impment E84 interface
public bool ReadyForLoad()
{
return CassetteState == LoadportCassetteState.Absent;
}
public bool ReadyForUnload()
{
return CassetteState == LoadportCassetteState.Normal;
}
public bool FoupArrirved()
{
return CassetteState == LoadportCassetteState.Normal;
}
public bool FoupRemoved()
{
return CassetteState == LoadportCassetteState.Absent;
}
public LPTransferState GetTransferState()
{
return LPTransferState.IN_SERVICE;
}
public LPAccessMode GetAccessMode()
{
return LPAccessMode.AUTO;
}
public LPReservedState GetReservedState()
{
return LPReservedState.NOT_RESERVED;
}
public void LPTSTrans(LPTransferState lpts)
{
return;
}
public bool IsSystemAutoMode()
{
return false;
}
public void SetAccessMode(bool isauto)
{
return;
}
public void E84Retry()
{
throw new NotImplementedException();
}
public void SetCompleted()
{
return;
}
}
}
@@ -0,0 +1,213 @@
using System.Collections.Generic;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK
{
public enum CommandType
{
SET, // Initialization setting command
MOD, // Operation mode setting command
GET, // Status acquisition command
FIN, // Normal reception command
MOV, // Operation command
EVT, // Start/Stop event report command
RST, // Resend initialization setting command comman
RFN, // Resend normal reception command
RMV, // Resend operation command
}
public enum RespType
{
NAK, // Initialization setting command
ACK, // Operation mode setting command
INF, // Status acquisition command
ABS, // Normal reception command
}
//顺序不能变!!!
public enum Indicator
{
LOAD = 0x01,
UNLOAD = 0x02,
ACCESSMANUL = 0x03,
PRESENCE = 0x04,
PLACEMENT = 0x05,
ACCESSAUTO = 0x06,
RESERVE1 = 0x07,
ALARM = 0x08,
RESERVE2 = 0x9,
CLAMP,
DOCK,
ACCESS_SW,
}
//public enum IndicatorState
//{
// ON,
// BLINK,
// OFF,
//}
public enum Mode
{
ONMGV, //Changes to the online mode
MENTE,
}
public enum QueryType
{
STATE, //Checks the status.
VERSN, //Checks the version.
LEDST, //Reports the indicator status.
MAPDT, //Wafer search data (descending order)
MAPRD, //Wafer search data (ascending order)
WFCNT, //Wafer quantity check
FSBxx //Checks whether the FOSB Mode is ON/OFF
}
public enum EvtType
{
EVTON, //Starts reporting all events.(FOUP events is excluded)
EVTOF, //Stops reporting all events. (FOUP events is excluded)
FPEON, //Starts reporting FOUP events.
FPEOF, //Stops reporting FOUP events.
}
public enum MovType
{
ORGSH, //Moves the FOUP to the initial position.
ABORG, //Aborts the operation and moves the FOUP to the initial position.
CLOAD, //Loads the FOUP (transfers the FOUP to the process unit).
CLDDK, //Loads the FOUP (same as CLOAD) to the point where the system is ready to open the door.
CLDYD, //Clamps the FOUP and moves the FOUP to the Y-axis docking position.
CLDOP, //Continues loading the FOUP after CLDDK.
CLDMP, //Maps and loads the FOUP.
CLMPO, //Continues mapping and loading the FOUP after CLDDK.
CULOD, //Unloads the FOUP (at the ejection position).
CULDK, //Closes the door (same as CULOD).
CUDCL, //Undocks the FOUP (while being clamped) after CULDK.
CUDNC, //Unloads the FOUP after CULDK.
CULYD, //Unloads the FOUP to the docking status.
CULFC, //Unloads the FOUP to the point where the system can release (unclamp) the FOUP.
CUDMP, //Maps and unloads the FOUP from the loaded status.
CUMDK, //Maps the FOUP and closes the door from the loaded status.
CUMFC, //Maps the FOUP to the before-unclamp status from the loaded status.
MAPDO, //Maps the FOUP while being loaded.
REMAP, //Resumes the interrupted mapping.
PODOP, //FOUP clamp: Open
PODCL, //FOUP clamp: Close
VACON, //Vacuum on
VACOF, //Vacuum off
DOROP, //Latch key: Open (Unlatches the FOUP door.)
DORCL, //Latch key: Close (Latches the FOUP door.)
MAPOP, //Mapper arm: Open
MAPCL, //Mapper arm: Close
ZDRUP, //Move to Z-axis up position (door open position)
ZDRDW, //Move to Z-axis down position (transport unit handover possible position)
ZDRMP, //Lower to Z-axis mapping end position and conduct mapping
ZMPST, //Move the mapper to the start position
YWAIT, //Move to Y-axis undock position
YDOOR, //Move to Y-axis dock position
DORBK, //Move to door open position
DORFW, //Move to door close position
RETRY, //Retry during recoverable error
STOP_, //Immediate stop and command abort
PAUSE, //Immediate stop
ABORT, //Command abort
RESUM, //Resume operation
}
public class ErrorCode
{
private Dictionary<string, string> dict = new Dictionary<string, string>
{
{"02","Z-axis position: NG (Down)"},
{"42","Z-axis position: NG (Up)"},
{"04","Y-axis position: NG (Dock)"},
{"44","Y-axis position: NG (Undock)"},
{"07","Wafer protrusion"},
{"47","Grass wafer protrusion (Option)"},
{"08","Door forward/backward position: NG(Open)"},
{"48","Door forward/backward position: NG(Close)"},
{"F2","FOUP door close error."},
{"09","Mapper arm position: NG (Open)"},
{"49","Mapper arm position: NG (Close)"},
{"11","Mapper stopper position: NG (On)"},
{"51","Mapper stopper position: NG (Off)"},
{"12","Mapping end position: NG"},
{"61","FOUP clamp open error (Up)"},
{"21","FOUP clamp open error (Back)"},
{"62","FOUP clamp open error (Down)"},
{"22","FOUP clamp close error (Front)"},
{"63","FOUP clamp close error (Middle)"},
{"23","Latch key open error"},
{"24","Latch key close error"},
{"25","Vacuum on error"},
{"26","Vacuum off error"},
{"27","Main air error "},
{"A1","Normal position error at FOUP open"},
{"A2","Normal position error at FOUP close"},
{"A3","Mapper storage error when Z-axis lowered"},
{"A4","Parallel signal error from upper machine"},
{"FD","Interlock relay failure"},
{"FE","Communication failure"},
{"FF","Obstacle detection sensor failure"},
{"FC","Fan operation error"},
{"EE","Mapping mechanical(Adjustment) error"},
{"EF","Mapping mechanical(Sensor) error"},
{"F1","Door detection error during dock"},
{"31","Door detection error except dock"},
};
public ErrorCode()
{
}
public string Code2Msg(string code)
{
if (dict.ContainsKey(code))
{
return string.Format("Code:{0},Message:{1}", code, dict[code]);
}
return code;
}
}
/*
public enum LoadportCassetteState
{
None, //Load sensor/Position sensor: All OFF
Normal, //Load sensor/Position sensor: All ON
Absent, //Load sensor: ON, Position sensor: 1 or 2: ON
Unknown,//Load sensor: ON, Position sensor: All OFF
//or Load sensor: OFF, Except Position sensor: All OFF
}
public enum FoupDoorState
{
Open,
Close,
Unknown,
}
public enum FoupClampState
{
Open,
Close,
Unknown,
}
*/
}