Sic-Software
/
Sic.Framework
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Sic.Framework/MECF.Framework.RT.Equipment.../HardwareUnits/Robots/Aligner.cs

627 lines
20 KiB
C#
Raw Normal View History

Add project files.
2023-04-13 11:51:03 +08:00
using System;
using System.Text.RegularExpressions;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Core.RT.Device;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot.NX100.AL;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot.SR100.AL;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot
{
public class Aligner : BaseDevice, IDevice,IConnection
{
public string Address
{
get { return _addr; }
}
public virtual bool IsConnected
{
get { return _socket.IsConnected; }
}
public virtual bool Disconnect()
{
return true;
}
public virtual bool Connect()
{
return true;
}
public const string delimiter = "\r";
public int LastErrorCode { get; set; }
public int Status { get; set; }
public int ErrorCode { get; set; }
public int ElapseTime { get; set; }
public int Notch { get; set; }
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 >= Convert.ToInt32("2EB0",16)|| _commErr;
}
}
//public string ErrorMessage
//{
// get
// {
// return _factory.GetError(LastErrorCode);
// }
//}
public DeviceState State
{
get
{
if (!Initalized)
{
return DeviceState.Unknown;
}
if (Error)
{
return DeviceState.Error;
}
if (Busy)
return DeviceState.Busy;
return DeviceState.Idle;
}
}
public virtual bool WaferOnAligner
{
get
{
return (Status & ((int)StateBit.WaferOnGrip | (int)StateBit.WaferOnCCD)) > 0;
}
}
public bool StateWaferHold { get; set; }
private static Object _locker = new Object();
private AsyncSocket _socket;
private IHandler _eventHandler = null;
private IHandler _backgroundHandler = null; //moving
private IHandler _foregroundHandler = null; //current handler
private IAlignerHandlerFactory _factory = null;
private bool _commErr = false;
//private bool _exceuteErr = false;
private string _addr;
private DeviceTimer _timerQuery = new DeviceTimer();
//private int _queryPeriod = 5000; //ms
//private bool _queryState = true;
private RobotType _type = RobotType.SR100;
private string AlarmAlignerMotionError = "AlignerMotionError";
public Aligner(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;
_commErr = false;
WaferManager.Instance.SubscribeLocation(name, 1);
}
public virtual bool Initialize()
{
switch (_type)
{
case RobotType.NX100:
_factory = new NX100AlignerHandlerFactory(this);
break;
default:
_factory = new SR100AlignerHandlerFactory(this);
break;
}
_eventHandler = _factory.Event();
ConnectionManager.Instance.Subscribe(Name, this);
if(!string.IsNullOrEmpty(_addr))
_socket.Connect(this._addr);
DEVICE.Register(String.Format("{0}.{1}", Name, "Init"), (out string reason, int time, object[] param) =>
{
bool ret = Init(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Init");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerInit"), (out string reason, int time, object[] param) =>
{
bool ret = Init(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Init");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "Home"), (out string reason, int time, object[] param) =>
{
bool ret = Home(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Home");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerHome"), (out string reason, int time, object[] param) =>
{
bool ret = Home(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Home");
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 Error");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerReset"), (out string reason, int time, object[] param) =>
{
bool ret = Clear(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Reset Error");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "Grip"), (out string reason, int time, object[] param) =>
{
bool ret = Grip(0,out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Hold Wafer");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerGrip"), (out string reason, int time, object[] param) =>
{
bool ret = Grip(0, out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Hold Wafer");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "Release"), (out string reason, int time, object[] param) =>
{
bool ret = Release(0, out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Release Wafer");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerRelease"), (out string reason, int time, object[] param) =>
{
bool ret = Release(0, out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Release Wafer");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "LiftUp"), (out string reason, int time, object[] param) =>
{
bool ret = LiftUp(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Lifter Up");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerLiftUp"), (out string reason, int time, object[] param) =>
{
bool ret = LiftUp(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Lifter Up");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "LiftDown"), (out string reason, int time, object[] param) =>
{
bool ret = LiftDown(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Lifter Down");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerLiftDown"), (out string reason, int time, object[] param) =>
{
bool ret = LiftDown(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Lifter Down");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "Stop"), (out string reason, int time, object[] param) =>
{
bool ret = Stop(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Stop Align");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerStop"), (out string reason, int time, object[] param) =>
{
bool ret = Stop(out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "Stop Align");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "Align"), (out string reason, int time, object[] param) =>
{
double angle = double.Parse((string)param[0]);
bool ret = Align(angle, out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "PreAlign");
return true;
}
return false;
});
DEVICE.Register(String.Format("{0}.{1}", Name, "AlignerAlign"), (out string reason, int time, object[] param) =>
{
double angle = double.Parse((string)param[0]);
bool ret = Align(angle, out reason);
if (ret)
{
reason = string.Format("{0} {1}", Name, "PreAlign");
return true;
}
return false;
});
DATA.Subscribe($"{Name}.State", () => State);
DATA.Subscribe($"{Name}.AlignerState", () => State.ToString());
DATA.Subscribe($"{Name}.Busy", () => Busy);
DATA.Subscribe($"{Name}.ErrorCode", () => ErrorCode);
DATA.Subscribe($"{Name}.Error", () => Error);
DATA.Subscribe($"{Name}.ElapseTime", () => ElapseTime);
DATA.Subscribe($"{Name}.Notch", () => Notch);
DATA.Subscribe($"{Name}.WaferOnAligner", () => WaferOnAligner);
// string str = string.Empty;
EV.Subscribe(new EventItem(0,"Event", AlarmAlignerMotionError, "Aligner error", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));
// _timerQuery.Start(_queryPeriod);
return true;
}
public virtual void Terminate()
{
_socket.Dispose();
}
public virtual void Reset()
{
lock (_locker)
{
_foregroundHandler = null;
_backgroundHandler = null;
}
//_exceuteErr = false;
if (_commErr)
{
_commErr = false;
_socket.Connect(this._addr);
}
}
#region Command
public virtual bool Init(out string reason)
{
reason = string.Empty;
return execute(_factory.Init(), out reason);
}
public virtual bool Home(out string reason)
{
reason = string.Empty;
return execute(_factory.Home(), out reason);
}
public virtual bool Clear(out string reason)
{
reason = string.Empty;
return execute(_factory.Clear(), 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 LiftUp(out string reason)
{
reason = string.Empty;
return execute(_factory.LiftUp(), out reason);
}
public virtual bool LiftDown(out string reason)
{
reason = string.Empty;
return execute(_factory.LiftDown(), out reason);
}
public virtual bool MoveToReady(out string reason)
{
reason = string.Empty;
return execute(_factory.MoveToReadyPostion(), out reason);
}
public virtual bool Stop(out string reason)
{
reason = string.Empty;
lock (_locker)
{
_foregroundHandler = null;
_backgroundHandler = null;
}
return execute(_factory.Stop(), out reason);
}
public virtual bool Align(double angle, out string reason)
{
reason = string.Empty;
return execute(_factory.Align(angle), out reason);
}
public virtual bool QueryState(out string reason)
{
reason = string.Empty;
return execute(_factory.QueryState(), out reason);
}
#endregion
private 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));
return false;
}
[Common] 优化BaseDevice对象，新增用于解析Xml配置的构造函数，修正其子类的ScBasePath中如果定义了{module}，没有自动替换为Module名称的问题。 移除ErrorDetectableBaseDevice构造函数中解析Xml并初始化相关属性的代码。 新增SicMath命名空间，并新增时域信号算数平均滤波器。 [EquipmentLibrary] 新增IoSensorAnalog对象，用于监测模拟信号并产生警告和报警事件。 新增IoSensorWaterFlowTemp对象，用于自动监测水温并输出用于互锁的DO信号。 移除IoInterLock对象中监测水温并设置相关DO的代码。 移除IoSensor构造函数中解析Xml并初始化相关属性的代码。 移除IoPressureMeter构造函数中解析Xml并初始化相关属性的代码。
2023-04-19 15:38:04 +08:00
handler.Unit = (int)RobotUnit.Aligner;
Add project files.
2023-04-13 11:51:03 +08:00
if(!handler.Execute(ref _socket))
{
reason = "Communication error,please check it.";
return false;
}
if (handler.IsBackground)
_backgroundHandler = handler;
else
_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 > 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;
}
}
else
{
if (_eventHandler != null)
{
if (_eventHandler.OnMessage(ref _socket, resp, out completed))
{
if (completed)
{
EV.PostMessage("Aligner", EventEnum.DefaultWarning, string.Format(" has error. {0:X}", ErrorCode));
OnError(string.Format(" has error. {0:X}", ErrorCode));//_exceuteErr = true;
}
}
}
}
}
}
}
}
catch (ExcuteFailedException e)
{
EV.PostMessage("Aligner", EventEnum.DefaultWarning, string.Format("executed failed. {0}", e.Message));
OnError(string.Format("executed failed. {0}", e.Message));
}
catch (InvalidPackageException e)
{
EV.PostMessage("Aligner", 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("Aligner failed：" + ex.ToString());
}
}
private void OnErrorHandler(ErrorEventArgs args)
{
Initalized = false;
_commErr = true;
EV.PostMessage(Module, EventEnum.CommunicationError, Display, args.Reason);
OnError("Communciation Error");
//LOG.Error(string.Format("{0} Communication failed, {1}", Name, args.Reason));
}
//private bool checkslot(int min, int max, int slot)
//{
// return slot >= min && slot < max;
//}
private void OnError(string errortext)
{
EV.Notify(AlarmAlignerMotionError,new SerializableDictionary<string, object> {
{"AlarmText",errortext }
});
}
}
}