1991 lines
72 KiB
C#
1991 lines
72 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Text.RegularExpressions;
|
||
using Aitex.Core.Common;
|
||
using Aitex.Core.RT.Log;
|
||
using Aitex.Core.RT.Event;
|
||
using Aitex.Core.RT.DataCenter;
|
||
using Aitex.Core.Util;
|
||
using Aitex.Sorter.Common;
|
||
using TSC = Aitex.Sorter.Common;
|
||
using Aitex.Core.RT.Device;
|
||
using Aitex.Core.RT.SCCore;
|
||
using MECF.Framework.Common.Equipment;
|
||
using MECF.Framework.Common.SubstrateTrackings;
|
||
using Aitex.Core.RT.OperationCenter;
|
||
using MECF.Framework.Common.CommonData;
|
||
using MECF.Framework.Common.Communications;
|
||
|
||
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot
|
||
{
|
||
public enum RobotType
|
||
{
|
||
SR100,
|
||
NX100,
|
||
MAG7,
|
||
DAIHEN,
|
||
HAtm,
|
||
HIRATA_R4
|
||
}
|
||
|
||
public class Robot : BaseDevice, IDevice, IConnection
|
||
{
|
||
public event Action<ModuleName, string> OnSlotMapRead;
|
||
|
||
public event Action<bool> ActionDone;
|
||
|
||
public string Address
|
||
{
|
||
get { return _addr; }
|
||
}
|
||
|
||
public virtual bool IsConnected
|
||
{
|
||
get { return _socket.IsConnected; }
|
||
}
|
||
|
||
public bool Disconnect()
|
||
{
|
||
_commErr = true;
|
||
_socket.Dispose();
|
||
return true;
|
||
}
|
||
|
||
public bool IsOnline
|
||
{
|
||
get { return _isOnline; }
|
||
}
|
||
|
||
public const string delimiter = "\r";
|
||
|
||
private bool _isOnline;
|
||
|
||
public int LastErrorCode { get; set; }
|
||
public int Status { get; set; }
|
||
public int ErrorCode { get; set; }
|
||
|
||
public int ElapseTime { get; set; }
|
||
public int Speed { get; set; }
|
||
|
||
public int Rotation { get; set; }
|
||
public int Extension { get; set; }
|
||
public int Wrist1 { get; set; }
|
||
public int Wrist2 { get; set; }
|
||
public int Evevation { get; set; }
|
||
|
||
public bool StateWaferOnBlade1 { get; set; }
|
||
public bool StateWaferOnBlade2 { get; set; }
|
||
public bool StateBlade1Gripped { get; set; }
|
||
public bool StateBlade2Gripped { get; set; }
|
||
|
||
public bool StateInterlock1 { get; set; }
|
||
public bool StateInterlock2 { get; set; }
|
||
public bool StateInterlock3 { get; set; }
|
||
public bool StateInterlock4 { get; set; }
|
||
public bool StateInterlock5 { get; set; }
|
||
public bool StateInterlock6 { get; set; }
|
||
public bool StateInterlock7 { get; set; }
|
||
public bool StateInterlock8 { get; set; }
|
||
|
||
public bool Swap { get; set; }
|
||
public Hand PlaceBalde { get; set; }
|
||
|
||
public ModuleName Blade1Target
|
||
{
|
||
get;
|
||
set;
|
||
}
|
||
public ModuleName Blade2Target { get; set; }
|
||
|
||
public RobotMoveInfo MoveInfo { get; set; }
|
||
|
||
//naming follow PM1.A LL1.A PM2.B
|
||
public string CmdBladeTarget { get; set; }
|
||
|
||
//naming follow 0 1
|
||
public string CmdBlade1Extend { get; set; }
|
||
|
||
//naming follow 0 1
|
||
public string CmdBlade2Extend { get; set; }
|
||
|
||
public bool Blade1Enable
|
||
{
|
||
get
|
||
{
|
||
if (SC.ContainsItem($"{Name}.Blade1Enable"))
|
||
{
|
||
return SC.GetValue<bool>($"{Name}.Blade1Enable");
|
||
}
|
||
|
||
return SC.GetValue<bool>($"Robot.Blade1Enable");
|
||
}
|
||
set
|
||
{
|
||
if (SC.ContainsItem($"{Name}.Blade1Enable"))
|
||
{
|
||
SC.SetItemValue($"{Name}.Blade1Enable", value);
|
||
}else if (SC.ContainsItem($"Robot.Blade1Enable"))
|
||
{
|
||
SC.SetItemValue($"Robot.Blade1Enable", value);
|
||
}
|
||
}
|
||
}
|
||
public bool Blade2Enable
|
||
{
|
||
get
|
||
{
|
||
if (SC.ContainsItem($"{Name}.Blade2Enable"))
|
||
{
|
||
return SC.GetValue<bool>($"{Name}.Blade2Enable");
|
||
}
|
||
|
||
return SC.GetValue<bool>($"Robot.Blade2Enable");
|
||
}
|
||
set
|
||
{
|
||
if (SC.ContainsItem($"{Name}.Blade2Enable"))
|
||
{
|
||
SC.SetItemValue($"{Name}.Blade2Enable", value);
|
||
}
|
||
else if (SC.ContainsItem($"Robot.Blade2Enable"))
|
||
{
|
||
SC.SetItemValue($"Robot.Blade2Enable", value);
|
||
}
|
||
}
|
||
}
|
||
|
||
public int Blade2Slots
|
||
{
|
||
get
|
||
{
|
||
if (SC.ContainsItem($"{Name}.Blade2Slots"))
|
||
{
|
||
return Math.Max(SC.GetValue<int>($"{Name}.Blade2Slots"), 1);
|
||
}
|
||
|
||
if (SC.ContainsItem($"Robot.Blade2Slots"))
|
||
{
|
||
return Math.Max(SC.GetValue<int>($"Robot.Blade2Slots"), 1);
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
public bool Initalized { get; set; }
|
||
|
||
public bool Communication
|
||
{
|
||
get
|
||
{
|
||
return !_commErr;
|
||
}
|
||
}
|
||
|
||
|
||
public virtual bool Busy
|
||
{
|
||
get { return _backgroundHandler != null || _foregroundHandler != null; }
|
||
}
|
||
|
||
public virtual bool Moving
|
||
{
|
||
get { return _backgroundHandler != null; }
|
||
}
|
||
|
||
public virtual bool Error
|
||
{
|
||
get
|
||
{
|
||
return ErrorCode > 0 || _commErr || _exceuteErr;
|
||
}
|
||
}
|
||
|
||
public DeviceState State
|
||
{
|
||
get
|
||
{
|
||
if (!Initalized)
|
||
{
|
||
return DeviceState.Unknown;
|
||
}
|
||
if (Error)
|
||
{
|
||
return DeviceState.Error;
|
||
}
|
||
|
||
if (Busy)
|
||
return DeviceState.Busy;
|
||
|
||
return DeviceState.Idle;
|
||
}
|
||
}
|
||
|
||
//public string ErrorMessage
|
||
//{
|
||
// get
|
||
// {
|
||
// return _factory.GetError(LastErrorCode);
|
||
// }
|
||
//}
|
||
|
||
|
||
public virtual bool WaferOnBlade1 { get { return (Status & (int)StateBit.WaferOnBlade1) > 0; } }
|
||
public virtual bool WaferOnBlade2 { get { return (Status & (int)StateBit.WaferOnBlade2) > 0; } }
|
||
|
||
public bool WaferPresentOnBlade1 { get; set; }
|
||
public bool WaferPresentOnBlade2 { get; set; }
|
||
|
||
public Hand TransferBlade {
|
||
get
|
||
{
|
||
if (!Blade1Enable) return Hand.Blade2;
|
||
if (!Blade2Enable) return Hand.Blade1;
|
||
return Hand.Both;
|
||
}
|
||
}
|
||
|
||
|
||
protected static Object _locker = new Object();
|
||
protected AsyncSocket _socket;
|
||
|
||
|
||
protected IHandler _eventHandler = null;
|
||
protected IHandler _backgroundHandler = null; //moving
|
||
protected IHandler _foregroundHandler = null; //current handler
|
||
|
||
private IRobotHandlerFactory _factory = null;
|
||
|
||
private DeviceTimer _timerQuery = new DeviceTimer();
|
||
//private int _queryPeriod = 5000; //ms
|
||
//private bool _queryState = true;
|
||
protected bool _exceuteErr = false;
|
||
protected bool _commErr = false;
|
||
|
||
protected string _addr;
|
||
protected RobotType _type = RobotType.SR100;
|
||
private string AlarmRobotError = "RobotMotionError";
|
||
|
||
//Active wafer Center finder Data R
|
||
public int CenterOffsetR { get; private set; }
|
||
|
||
//Active wafer Center finder Data T
|
||
public int CenterOffsetT { get; private set; }
|
||
|
||
private int _bufferMaxSlot = 6;
|
||
public int BufferMaxSlot
|
||
{
|
||
set
|
||
{
|
||
_bufferMaxSlot = value;
|
||
}
|
||
get
|
||
{
|
||
return _bufferMaxSlot;
|
||
}
|
||
}
|
||
|
||
public Robot(string module, string name, string display, string deviceId, string address, RobotType type = RobotType.SR100)
|
||
: base(module, name, display, deviceId)
|
||
{
|
||
_addr = address;
|
||
if (!string.IsNullOrEmpty(_addr))
|
||
{
|
||
_socket = new AsyncSocket(address);
|
||
_socket.OnDataChanged += new AsyncSocket.MessageHandler(OnDataChanged);
|
||
_socket.OnErrorHappened += new AsyncSocket.ErrorHandler(OnErrorHandler);
|
||
}
|
||
_type = type;
|
||
|
||
Initalized = false;
|
||
|
||
MoveInfo = new RobotMoveInfo()
|
||
{
|
||
Action = RobotAction.Moving,
|
||
ArmTarget = RobotArm.Both,
|
||
BladeTarget = "ArmA.System",
|
||
};
|
||
|
||
WaferManager.Instance.SubscribeLocation(name, 1+ Blade2Slots);
|
||
|
||
}
|
||
|
||
public Robot(string module, string name, string address, RobotType type = RobotType.SR100, int bufferMaxSlot = 6)
|
||
: this(module, name, name, name, address, type)
|
||
{
|
||
}
|
||
|
||
public virtual bool Initialize()
|
||
{
|
||
switch (_type)
|
||
{
|
||
case RobotType.NX100:
|
||
_factory = new NX100.NX100RobotHandlerFactory(this);
|
||
break;
|
||
case RobotType.SR100:
|
||
_factory = new SR100.SR100RobotHandlerFactory(this);
|
||
break;
|
||
case RobotType.MAG7:
|
||
_factory = new MAG7.Mag7RobotHandlerFactory(this);
|
||
break;
|
||
//case RobotType.DAIHEN:
|
||
// _factory = new Daihen.DaihenRobotHandlerFactory(this);
|
||
// break;
|
||
}
|
||
|
||
|
||
ConnectionManager.Instance.Subscribe(Name, this);
|
||
|
||
if (!string.IsNullOrEmpty(_addr))
|
||
Connect();
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", ModuleName.Robot.ToString(), "Init"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Init(out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Initializing");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", ModuleName.Robot.ToString(), "Home"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Home(out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Homing");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", ModuleName.Robot.ToString(), "RobotHome"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Home(out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Homing");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Reset"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Clear(out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Reset");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotReset"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Clear(out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Reset");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Grip"), (out string reason, int time, object[] param) =>
|
||
{
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[0], true);
|
||
bool ret = Grip(hand,out reason);
|
||
//bool ret = WaferMapping(ModuleName.LP1, out reason);
|
||
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Grip");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotGrip"), (out string reason, int time, object[] param) =>
|
||
{
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[0], true);
|
||
bool ret = Grip(hand, out reason);
|
||
//bool ret = WaferMapping(ModuleName.LP1, out reason);
|
||
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Grip");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Release"), (out string reason, int time, object[] param) =>
|
||
{
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[0], true);
|
||
bool ret = Release(hand, out reason);
|
||
//bool ret = QueryWaferMap(ModuleName.LP1, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Release");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotRelease"), (out string reason, int time, object[] param) =>
|
||
{
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[0], true);
|
||
bool ret = Release(hand, out reason);
|
||
//bool ret = QueryWaferMap(ModuleName.LP1, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Release");
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Stop"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Stop(false, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Stopping");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotStop"), (out string reason, int time, object[] param) =>
|
||
{
|
||
bool ret = Stop(false, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Stopping");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Pick"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
bool ret = Pick(chamber, slot, hand, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Pick wafer");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotPick"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
bool ret = Pick(chamber, slot, hand, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Pick wafer");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Place"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
bool ret = Place(chamber, slot, hand, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Place wafer");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotPlace"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
bool ret = Place(chamber, slot, hand, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Place wafer");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Exchange"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
bool ret = Exchange(chamber, slot, hand, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Swap wafer");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotExchange"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
bool ret = Exchange(chamber, slot, hand, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0} {1}", Name, "Swap wafer");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "Goto"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
Motion next = (Motion)Enum.Parse(typeof(Motion), (string)param[3], true);
|
||
|
||
int x = int.Parse((string)param[4]);
|
||
int y = int.Parse((string)param[5]);
|
||
int z = int.Parse((string)param[6]);
|
||
|
||
bool ret = Goto(chamber, slot, next, hand, x,y,z, out reason);
|
||
|
||
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0}{1}", Name, "Goto");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotGoto"), (out string reason, int time, object[] param) =>
|
||
{
|
||
ModuleName chamber = (ModuleName)Enum.Parse(typeof(ModuleName), (string)param[0], true);
|
||
int slot = int.Parse((string)param[1]);
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[2], true);
|
||
Motion next = (Motion)Enum.Parse(typeof(Motion), (string)param[3], true);
|
||
|
||
int x = int.Parse((string)param[4]);
|
||
int y = int.Parse((string)param[5]);
|
||
int z = int.Parse((string)param[6]);
|
||
|
||
bool ret = Goto(chamber, slot, next, hand, x, y, z, out reason);
|
||
|
||
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0}{1}", Name, "Goto");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "BladeEnable"), (out string reason, int time, object[] param) =>
|
||
{
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[0], true);
|
||
bool bEnable = bool.Parse((string)param[1]);
|
||
bool ret = Enable(hand, bEnable, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0}{1}", Name, "Disable robot arm");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
DEVICE.Register(String.Format("{0}.{1}", Name, "RobotBladeEnable"), (out string reason, int time, object[] param) =>
|
||
{
|
||
Hand hand = (Hand)Enum.Parse(typeof(Hand), (string)param[0], true);
|
||
bool bEnable = bool.Parse((string)param[1]);
|
||
bool ret = Enable(hand, bEnable, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0}{1}", Name, "Disable robot arm");
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
|
||
OP.Subscribe($"{Name}.Reconnect", (string cmd, object[] args) =>
|
||
{
|
||
return Connect();
|
||
});
|
||
|
||
OP.Subscribe($"{Name}.TestRobotPosition", (string cmd, object[] param) =>
|
||
{
|
||
//int setValue = 0;
|
||
Hand _hand = Hand.Blade1;
|
||
Axis axis;
|
||
if (param == null || param.Length < 2) return false;
|
||
int moveValue = (int)(double.Parse(param[1].ToString()));
|
||
switch (param[0].ToString())
|
||
{
|
||
case "TestRobotUp":
|
||
axis = Axis.Z;
|
||
break;
|
||
case "TestRobotDown":
|
||
moveValue = -moveValue;
|
||
axis = Axis.Z;
|
||
break;
|
||
case "TestRobotArmLeft":
|
||
moveValue = -moveValue;
|
||
axis = Axis.S;// Axis.H;//H1
|
||
break;
|
||
case "TestRobotArmRight":
|
||
axis = Axis.S;
|
||
break;
|
||
case "TestRobotArmUp":
|
||
axis = Axis.A;// Axis.I;//H2
|
||
break;
|
||
case "TestRobotArmDown":
|
||
moveValue = -moveValue;
|
||
axis = Axis.A;
|
||
break;
|
||
case "TestRobotBlade1Left":
|
||
_hand = Hand.Blade1;
|
||
axis = Axis.H;
|
||
break;
|
||
case "TestRobotBlade1Right":
|
||
moveValue = -moveValue;
|
||
_hand = Hand.Blade1;
|
||
axis = Axis.H;//TH
|
||
break;
|
||
case "TestRobotBlade2Left":
|
||
_hand = Hand.Blade2;
|
||
axis = Axis.I;
|
||
break;
|
||
case "TestRobotBlade2Right":
|
||
moveValue = -moveValue;
|
||
_hand = Hand.Blade2;
|
||
axis = Axis.I;
|
||
break;
|
||
default:
|
||
axis = Axis.A;
|
||
break;
|
||
}
|
||
string reason;
|
||
bool ret = PositionAdjustment(axis,_hand, moveValue, out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0}{1}", Name, reason);
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
OP.Subscribe($"{Name}.QueryPosition", (string cmd, object[] args) =>
|
||
{
|
||
string reason;
|
||
bool ret = QueryPosition(out reason);
|
||
if (ret)
|
||
{
|
||
reason = string.Format("{0}.QueryPosition,{1}", Name, reason);
|
||
return true;
|
||
}
|
||
return false;
|
||
});
|
||
|
||
DATA.Subscribe($"{Name}.State", () => State);
|
||
|
||
DATA.Subscribe($"{Name}.Busy", () => Busy);
|
||
DATA.Subscribe($"{Name}.ErrorCode", () => ErrorCode);
|
||
|
||
DATA.Subscribe($"{Name}.Blade1Target", () => Blade1Target);
|
||
DATA.Subscribe($"{Name}.Blade2Target", () => Blade2Target);
|
||
|
||
DATA.Subscribe($"{Name}.Blade1Enable", () => Blade1Enable);
|
||
DATA.Subscribe($"{Name}.Blade2Enable", () => Blade2Enable);
|
||
|
||
DATA.Subscribe($"{Name}.Swap", () => Swap);
|
||
DATA.Subscribe($"{Name}.PlaceBalde", () => PlaceBalde);
|
||
|
||
|
||
DATA.Subscribe($"{Name}.Speed", () => Speed);
|
||
DATA.Subscribe($"{Name}.RobotSpeed", () => Speed.ToString());
|
||
DATA.Subscribe($"{Name}.RobotState", () => State.ToString());
|
||
|
||
DATA.Subscribe($"{Name}.Rotation", () => Rotation);
|
||
DATA.Subscribe($"{Name}.Extension", () => Extension);
|
||
DATA.Subscribe($"{Name}.Wrist1", () => Wrist1);
|
||
DATA.Subscribe($"{Name}.Wrist2", () => Wrist2);
|
||
DATA.Subscribe($"{Name}.Evevation", () => Evevation);
|
||
|
||
DATA.Subscribe($"{Name}.CmdBladeTarget", () => CmdBladeTarget);
|
||
DATA.Subscribe($"{Name}.CmdBlade1Extend", () => CmdBlade1Extend);
|
||
DATA.Subscribe($"{Name}.CmdBlade2Extend", () => CmdBlade2Extend);
|
||
|
||
DATA.Subscribe($"{Name}.RobotMoveInfo", () => MoveInfo);
|
||
|
||
|
||
DATA.Subscribe($"{Name}.RobotBusy", () => Busy);
|
||
DATA.Subscribe($"{Name}.RobotError", () => ErrorCode);
|
||
DATA.Subscribe($"{Name}.RobotBlade1Traget", () => Blade1Target);
|
||
DATA.Subscribe($"{Name}.RobotBlade2Traget", () => Blade2Target);
|
||
DATA.Subscribe($"{Name}.RobotBlade1Enabled", () => Blade1Enable);
|
||
DATA.Subscribe($"{Name}.RobotBlade2Enabled", () => Blade2Enable);
|
||
DATA.Subscribe($"{Name}.RobotSwap", () => Swap);
|
||
DATA.Subscribe($"{Name}.RobotSwapPlaceBlade", () => PlaceBalde);
|
||
|
||
DATA.Subscribe($"{Name}.RobotPosRotationAxis", () => Rotation);
|
||
DATA.Subscribe($"{Name}.RobotPosExtensionAxis", () => Extension);
|
||
DATA.Subscribe($"{Name}.RobotPosWrist1Axis", () => Wrist1);
|
||
DATA.Subscribe($"{Name}.RobotPosWrist2Axis", () => Wrist2);
|
||
DATA.Subscribe($"{Name}.RobotPosEvevationAxis", () => Evevation);
|
||
|
||
DATA.Subscribe($"{Name}.CenterOffsetR", () => CenterOffsetR);
|
||
DATA.Subscribe($"{Name}.CenterOffsetT", () => CenterOffsetT);
|
||
|
||
DATA.Subscribe($"{Name}.CommunicationStatus", () => _socket == null ? false : _socket.IsConnected);
|
||
|
||
DATA.Subscribe($"{Name}.IsOnline", () => _isOnline);
|
||
|
||
EV.Subscribe(new EventItem(60014,"Event", AlarmRobotError, "Robot error", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
|
||
|
||
Reset();
|
||
string str = string.Empty;
|
||
|
||
if(_factory != null)
|
||
_eventHandler = _factory.Event();
|
||
return true;
|
||
}
|
||
|
||
public virtual void Terminate()
|
||
{
|
||
if (SC.ContainsItem("Robot.CloseSocketOnShutDown") && SC.GetValue<bool>("Robot.CloseSocketOnShutDown"))
|
||
{
|
||
LOG.Write($"Robot {Name} termination process: close socket");
|
||
_socket.Dispose();
|
||
}
|
||
}
|
||
|
||
public virtual void Monitor()
|
||
{
|
||
}
|
||
|
||
public virtual void Reset()
|
||
{
|
||
|
||
if (Error)
|
||
{
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
}
|
||
|
||
_exceuteErr = false;
|
||
if (_commErr)
|
||
{
|
||
Connect();
|
||
}
|
||
Swap = false;
|
||
}
|
||
|
||
public void SetOnline(bool online)
|
||
{
|
||
_isOnline = online;
|
||
}
|
||
|
||
public bool Enable(Hand hand, bool bEnable, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
|
||
if (hand == Hand.Blade1)
|
||
{
|
||
Blade2Enable = bEnable;
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
Blade2Enable = bEnable;
|
||
}
|
||
else
|
||
{
|
||
reason = "Can't disable all blade";
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
public virtual bool Connect()
|
||
{
|
||
_commErr = false;
|
||
_socket.Connect(this._addr);
|
||
return true;
|
||
}
|
||
|
||
|
||
#region Command
|
||
|
||
public virtual bool Init(out string reason)
|
||
{
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
reason = string.Empty;
|
||
return execute(_factory.Init(), out reason);
|
||
}
|
||
|
||
|
||
public virtual bool Home(out string reason)
|
||
{
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
reason = string.Empty;
|
||
return execute(_factory.Home(), out reason);
|
||
}
|
||
|
||
public virtual bool ArmHome(out string reason)
|
||
{
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
reason = string.Empty;
|
||
return execute(_factory.ArmHome(), out reason);
|
||
}
|
||
|
||
public virtual bool Grip(Hand hand,out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.Grip(hand), out reason);
|
||
}
|
||
|
||
public virtual bool Release(Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.Release(hand), out reason);
|
||
}
|
||
|
||
public virtual bool WaferMapping(ModuleName loadport, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.WaferMapping(loadport), out reason);
|
||
}
|
||
|
||
|
||
public virtual bool QueryWaferMap(ModuleName loadport, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.QueryWaferMap(loadport), out reason);
|
||
}
|
||
|
||
public virtual bool QueryState(out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.QueryState(), out reason);
|
||
}
|
||
|
||
public virtual bool QueryPosition(out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
|
||
return execute(_factory.QueryPosition(), out reason);
|
||
}
|
||
|
||
public virtual bool Clear(out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.Clear(), out reason);
|
||
}
|
||
|
||
|
||
public virtual bool Stop(bool isEmergency, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
return execute(_factory.Stop(isEmergency), out reason);
|
||
}
|
||
public virtual bool Resume( out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
|
||
return execute(_factory.Resume(), out reason);
|
||
}
|
||
|
||
public virtual bool SetSpeed(int speed, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.SetSpeed(speed), out reason);
|
||
}
|
||
|
||
public virtual bool SetCommunication( out string reason)
|
||
{
|
||
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
|
||
reason = string.Empty;
|
||
return execute(_factory.SetCommunication(), out reason);
|
||
}
|
||
|
||
|
||
public virtual bool SetLoad(Hand hand, out string reason)
|
||
{
|
||
|
||
lock (_locker)
|
||
{
|
||
_foregroundHandler = null;
|
||
_backgroundHandler = null;
|
||
}
|
||
|
||
reason = string.Empty;
|
||
return execute(_factory.SetLoad(hand), out reason);
|
||
}
|
||
|
||
|
||
public virtual bool CheckLoad(ModuleName chamber, int slot, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.CheckLoad(chamber, slot), out reason);
|
||
}
|
||
|
||
public virtual bool RequestWaferAWCData(out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.RequestAWCData(), out reason);
|
||
}
|
||
|
||
public virtual bool RequestWaferPresent( out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.RequestWaferPresent(), out reason);
|
||
}
|
||
|
||
public virtual bool Goto(ModuleName chamber, int slot, Motion motion,Hand hand, int x, int y, int z,out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if(hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, double pick,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.Goto( chamber, slot, motion, hand, x,y,z), out reason);
|
||
}
|
||
|
||
public virtual bool MoveTo(ModuleName chamber, int slot, Hand hand, bool isPick, int x, int y, int z,out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if(hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, double pick,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.MoveTo( chamber, slot, hand, isPick, x,y,z), out reason);
|
||
}
|
||
|
||
public virtual bool Extend(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Extend invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Extend invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Extend invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Extend invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Extend invalid parameter, double pick,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.Extend(chamber, slot, hand), out reason);
|
||
|
||
}
|
||
|
||
public virtual bool Retract(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Retract invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Retract invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Retract invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Retract invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Retract invalid parameter, double pick,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.Retract(chamber, slot, hand), out reason);
|
||
|
||
}
|
||
|
||
public virtual bool PickExtend(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber.ToString() == Name || chamber == ModuleName.System || ModuleHelper.IsLoadPort(chamber) || ModuleHelper.IsBuffer(chamber))
|
||
{
|
||
reason = $"Pick extend target not support, chamber is {chamber.ToString()}, slot is {slot}";
|
||
return false;
|
||
}
|
||
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Pick extend invalid parameter, do not support double arm extend ,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
return execute(_factory.PickExtend(chamber, slot, hand), out reason);
|
||
}
|
||
|
||
public virtual bool PickRetract(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber.ToString() == Name || chamber == ModuleName.System || ModuleHelper.IsLoadPort(chamber) || ModuleHelper.IsBuffer(chamber))
|
||
{
|
||
reason = $"Pick retract target not support, chamber is {chamber.ToString()}, slot is {slot}";
|
||
return false;
|
||
}
|
||
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Pick retract invalid parameter, do not support double arm retract ,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
return execute(_factory.PickRetract(chamber, slot, hand), out reason);
|
||
}
|
||
|
||
public virtual bool Pick(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else if(ModuleHelper.IsBuffer(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, _bufferMaxSlot - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, _bufferMaxSlot - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, _bufferMaxSlot, slot))
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, double pick,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.Pick(chamber, slot, hand), out reason);
|
||
|
||
}
|
||
|
||
public virtual bool PickReadyPosition(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
return execute(_factory.PickReadyPosition(chamber, slot, hand), out reason);
|
||
|
||
}
|
||
|
||
public virtual bool Place(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Place invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Place invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Place invalid parameter,place, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else if (ModuleHelper.IsBuffer(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, _bufferMaxSlot - Blade2Slots, slot)) //0-6
|
||
{
|
||
reason = string.Format("Place invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, _bufferMaxSlot - Blade2Slots + 1, slot)) //0 - 6
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, _bufferMaxSlot, slot))
|
||
{
|
||
reason = string.Format("Place invalid parameter,place, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Place invalid parameter, double place,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.Place(chamber, slot, hand), out reason);
|
||
}
|
||
|
||
public virtual bool PlaceReadyPosition(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Place invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
return execute(_factory.PlaceReadyPosition(chamber, slot, hand), out reason);
|
||
|
||
}
|
||
|
||
public virtual bool PlaceExtend(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber.ToString() == Name || chamber == ModuleName.System || ModuleHelper.IsLoadPort(chamber) || ModuleHelper.IsBuffer(chamber))
|
||
{
|
||
reason = $"Place extend target not support, chamber is {chamber.ToString()}, slot is {slot}";
|
||
return false;
|
||
}
|
||
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason =
|
||
$"Place extend invalid parameter, do not support double arm extend ,chamber is {chamber.ToString()}, slot is {slot}";
|
||
return false;
|
||
}
|
||
|
||
return execute(_factory.PlaceExtend(chamber, slot, hand), out reason);
|
||
}
|
||
|
||
public virtual bool PlaceRetract(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber.ToString() == Name || chamber == ModuleName.System || ModuleHelper.IsLoadPort(chamber) ||ModuleHelper.IsBuffer(chamber) )
|
||
{
|
||
reason = $"Place retract target not support, chamber is {chamber.ToString()}, slot is {slot}";
|
||
return false;
|
||
}
|
||
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason =
|
||
$"Place retract invalid parameter, do not support double arm extend ,chamber is {chamber.ToString()}, slot is {slot}";
|
||
return false;
|
||
}
|
||
|
||
return execute(_factory.PlaceRetract(chamber, slot, hand), out reason);
|
||
}
|
||
|
||
public virtual bool Exchange(ModuleName chamber, int slot, Hand hand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Exchange invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Exchange invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Exchange invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.Exchange(chamber, slot, hand), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangeReadyPosition(ModuleName chamber, int slot, Hand pickHand, Hand placeHand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (pickHand == Hand.Both || placeHand == Hand.Both)
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangeReadyPosition(chamber, slot, pickHand, placeHand), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangeReadyPositionExtend(ModuleName chamber, int slot, Hand pickHand, Hand placeHand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (pickHand == Hand.Both || placeHand == Hand.Both)
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangeReadyExtend(chamber, slot, pickHand, placeHand), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangeAfterReadyPositionExtend(ModuleName chamber, int slot, Hand pickHand, Hand placeHand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (pickHand == Hand.Both || placeHand == Hand.Both)
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("ExchangeReadyPosition invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangeAfterReadyExtend(chamber, slot, pickHand, placeHand), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangePickExtend(ModuleName chamber, int slot, Hand pickHand, Hand placeHand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("ExchangePickExtend invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (pickHand == Hand.Both || placeHand == Hand.Both)
|
||
{
|
||
reason = string.Format("ExchangePickExtend invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("ExchangePickExtend invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangePickExtend(chamber, slot, pickHand, placeHand), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangePlaceExtend(ModuleName chamber, int slot, Hand pickHand, Hand placeHand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("ExchangePlaceExtend invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (pickHand == Hand.Both || placeHand == Hand.Both)
|
||
{
|
||
reason = string.Format("ExchangePlaceExtend invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("ExchangePlaceExtend invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangePlaceExtend(chamber, slot, pickHand, placeHand), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangePlaceRetract(ModuleName chamber, int slot, Hand pickHand, Hand placeHand, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("ExchangePlaceRetract invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (pickHand == Hand.Both || placeHand == Hand.Both)
|
||
{
|
||
reason = string.Format("ExchangePlaceRetract invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("ExchangePlaceRetract invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangePlaceRetract(chamber, slot, pickHand, placeHand), out reason);
|
||
}
|
||
public virtual bool SetWaferSize(int cmd, WaferSize size, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.SetWaferSize(cmd, size), out reason);
|
||
}
|
||
|
||
public virtual bool QueryParameter(int parameter, string parameterType, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.QueryParameter(parameter, parameterType), out reason);
|
||
}
|
||
public virtual bool SetServoOnOff(bool trueForOnFalseForOff, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.SetServoOnOff(trueForOnFalseForOff), out reason);
|
||
}
|
||
public virtual bool PickEx(ModuleName chamber, int slot, Hand hand, int x, int y, int z, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Pick invalid parameter, double pick,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.PickEx(chamber, slot, hand, x,y,z), out reason);
|
||
|
||
}
|
||
|
||
public virtual bool PlaceEx(ModuleName chamber, int slot, Hand hand, int x, int y, int z, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Place invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots, slot)) //0-20 | 20,21,22,23,24
|
||
{
|
||
reason = string.Format("Place invalid parameter,double hand, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else if (hand == Hand.Blade2)
|
||
{
|
||
if (!checkslot(0, 25 - Blade2Slots + 1, slot)) //0 - 21| 21,22,23,24
|
||
{
|
||
reason = string.Format("Pick invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Place invalid parameter,place, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Place invalid parameter, double place,chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return execute(_factory.PlaceEx(chamber, slot, hand,x,y,z), out reason);
|
||
}
|
||
|
||
public virtual bool ExchangeEx(ModuleName chamber, int slot, Hand hand, int x, int y, int z, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
if (chamber == ModuleName.Robot)
|
||
{
|
||
reason = string.Format("Exchange invalid parameter, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
|
||
if (Blade2Slots > 1)
|
||
{
|
||
reason = string.Format("this robot don't support exchange operation.");
|
||
return false;
|
||
}
|
||
|
||
if (hand == Hand.Both)
|
||
{
|
||
reason = string.Format("Exchange invalid parameter,double hand");
|
||
return false;
|
||
}
|
||
|
||
if (ModuleHelper.IsLoadPort(chamber))
|
||
{
|
||
if (!checkslot(0, 25, slot))
|
||
{
|
||
reason = string.Format("Exchange invalid parameter,pick, chamber is {0}, slot is {1}", chamber.ToString(), slot);
|
||
return false;
|
||
}
|
||
}
|
||
return execute(_factory.ExchangeEx(chamber, slot, hand, x, y, z), out reason);
|
||
}
|
||
#endregion
|
||
|
||
public virtual bool PositionAdjustment( Axis axis, Hand hand, int value, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
return execute(_factory.PositionAdjustment( axis,hand,value), out reason);
|
||
}
|
||
|
||
public virtual bool execute(IHandler handler, out string reason)
|
||
{
|
||
reason = string.Empty;
|
||
lock (_locker)
|
||
{
|
||
if (_foregroundHandler != null)
|
||
{
|
||
reason = "System busy, please wait or reset system.";
|
||
EV.PostMessage(Name, EventEnum.DefaultWarning, string.Format("{0} {1} {2}", this.DeviceID, handler.ToString(), reason));
|
||
|
||
return false;
|
||
}
|
||
|
||
if (_backgroundHandler != null && handler.IsBackground)
|
||
{
|
||
reason = "System busy，one background command is running, please wait or reset system.";
|
||
EV.PostMessage(Name, EventEnum.DefaultWarning, string.Format("{0} {1} {2}", this.DeviceID, handler.ToString(), reason));
|
||
//reason = "系统忙，后台命令正在处理,暂时不能处理新的后台命令";
|
||
return false;
|
||
}
|
||
|
||
handler.Unit = (int)Unit.Robot;
|
||
if(!handler.Execute(ref _socket))
|
||
{
|
||
reason = "Communication error,please check it.";
|
||
OnError(reason);
|
||
return false;
|
||
}
|
||
|
||
if (handler.IsBackground)
|
||
_backgroundHandler = handler;
|
||
else
|
||
_foregroundHandler = handler;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
public virtual void OnDataChanged(string package)
|
||
{
|
||
try
|
||
{
|
||
if (!package.Contains("Gb") && !package.Contains("Pb"))
|
||
package = package.ToUpper();
|
||
string[] msgs = Regex.Split(package, delimiter);
|
||
|
||
foreach (string msg in msgs)
|
||
{
|
||
if (msg.Length > 0)
|
||
{
|
||
bool completed = false;
|
||
string resp = msg;
|
||
|
||
lock (_locker)
|
||
{
|
||
if (_foregroundHandler != null && _foregroundHandler.OnMessage(ref _socket, resp, out completed))
|
||
{
|
||
_foregroundHandler = null;
|
||
}
|
||
else if (_backgroundHandler != null && _backgroundHandler.OnMessage(ref _socket, resp, out completed))
|
||
{
|
||
if (completed)
|
||
{
|
||
//string reason = string.Empty;
|
||
//QueryState(out reason);
|
||
_backgroundHandler = null;
|
||
|
||
if (ActionDone != null)
|
||
ActionDone(true);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (_eventHandler != null)
|
||
{
|
||
if (_eventHandler.OnMessage(ref _socket, resp, out completed))
|
||
{
|
||
if (completed)
|
||
{
|
||
EV.PostMessage("Robot", EventEnum.DefaultWarning, string.Format(" has error. {0:X}", ErrorCode));
|
||
OnError(string.Format("has error. {0:X}", ErrorCode));
|
||
_exceuteErr = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (ExcuteFailedException e)
|
||
{
|
||
EV.PostMessage("Robot", EventEnum.DefaultWarning, string.Format("executed failed. {0}",e.Message));
|
||
OnError(string.Format("executed failed. {0}", e.Message));
|
||
_exceuteErr = false;
|
||
}
|
||
catch (InvalidPackageException e)
|
||
{
|
||
EV.PostMessage("Robot", EventEnum.DefaultWarning, string.Format("receive invalid package. {0}", e.Message));
|
||
OnError(string.Format("receive invalid package. {0}", e.Message));
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
_commErr = true;
|
||
LOG.Write("Robot failed：" + ex.ToString());
|
||
}
|
||
}
|
||
|
||
private void OnErrorHandler(ErrorEventArgs args)
|
||
{
|
||
_commErr = true;
|
||
Initalized = false;
|
||
EV.PostMessage(Module, EventEnum.CommunicationError, Display, args.Reason);
|
||
|
||
OnError("CommunicationError");
|
||
}
|
||
|
||
private bool checkslot(int min, int max, int slot)
|
||
{
|
||
return slot >= min && slot < max;
|
||
}
|
||
|
||
public void NotifySlotMapResult(ModuleName module, string slotMap)
|
||
{
|
||
if (OnSlotMapRead != null)
|
||
{
|
||
OnSlotMapRead(module, slotMap);
|
||
}
|
||
}
|
||
public void OnError(string errorcode)
|
||
{
|
||
EV.Notify(AlarmRobotError,new SerializableDictionary<string, object> {
|
||
{
|
||
"AlarmText",errorcode
|
||
}
|
||
});
|
||
|
||
if (ActionDone != null)
|
||
ActionDone(false);
|
||
}
|
||
|
||
public void NotifyWaferPresent(Hand hand, WaferStatus status)
|
||
{
|
||
if (status == WaferStatus.Empty)
|
||
{
|
||
if (hand == Hand.Blade1)
|
||
{
|
||
WaferPresentOnBlade1 = status == WaferStatus.Empty;
|
||
}
|
||
|
||
if (hand == Hand.Blade2)
|
||
{
|
||
WaferPresentOnBlade2 = status == WaferStatus.Empty;
|
||
}
|
||
}
|
||
if (status == WaferStatus.Unknown)
|
||
{
|
||
EV.PostWarningLog(Module, "Wafer present unknown");
|
||
return;
|
||
}
|
||
|
||
if (hand == Hand.Blade1)
|
||
{
|
||
WaferPresentOnBlade1 = status == WaferStatus.Normal;
|
||
}
|
||
|
||
if (hand == Hand.Blade2)
|
||
{
|
||
WaferPresentOnBlade2 = status == WaferStatus.Normal;
|
||
}
|
||
}
|
||
|
||
//Active wafer Center finder Data
|
||
public void NotifyAWCData(int rOffset, int tOffset)
|
||
{
|
||
CenterOffsetR = rOffset;
|
||
CenterOffsetT = tOffset;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|