ZZ-EFEM/Framework/AitexSorterRT/Device/Robot/Aligner.cs

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 TSC = Aitex.Sorter.Common;
using Aitex.Core.RT.Device;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;

namespace Aitex.Sorter.RT.Device.Robot
{
  
    public class Aligner : BaseDevice, IDevice
    {
        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 bool Busy
        {
            get { return _backgroundHandler != null || _foregroundHandler != null; }
        }
        public bool Moving
        {
            get { return _backgroundHandler != null; }
        }
        
        public bool Error
        {
            get
            {
                return ErrorCode > 0 || _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 bool WaferOnAligner
        {   
            get
            {
                return (Status & ((int)StateBit.WaferOnGrip | (int)StateBit.WaferOnCCD)) > 0; 
            } 
        }

        public bool StateVacuumGripStatus { get; internal set; }
        public bool StateWaferPresent { get; internal set; }
        public bool StateWaferHold { get; internal 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 string AlignerMotionError = "AlignerMotionError";

        public Aligner(string module, string name, string display, string deviceId, string address, RobotType type = RobotType.SR100)
            : base(module, name, display, deviceId)
        {
            _addr = address;
            _socket = new AsyncSocket(address);
            _socket.OnDataChanged += new AsyncSocket.MessageHandler(OnDataChanged); 
            _socket.OnErrorHappened += new AsyncSocket.ErrorHandler(OnErrorHandler);

            switch (type)
            {
                case RobotType.NX100:
                    _factory = new NX100.AL.HandlerFactory();
                    break;
                default:
                    _factory = new SR100.AL.HandlerFactory();
                    break;
            }

            _eventHandler = _factory.Event();

            Initalized = false;
            _commErr = false;

            WaferManager.Instance.SubscribeLocation(name, 1);
        }

        public bool Initialize()
        {
            _socket.Connect(this._addr);

            DEVICE.Register(String.Format("{0}.{1}", Name, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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, TSC.DeviceOperationName.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(ModuleName.Aligner.ToString(), ParamName.AlignerState, () => State);

            DATA.Subscribe(ModuleName.Aligner.ToString(), ParamName.AlignerBusy, () => Busy);

            DATA.Subscribe(ModuleName.Aligner.ToString(), ParamName.AlignerError, () => ErrorCode);

            DATA.Subscribe(ModuleName.Aligner.ToString(), ParamName.AlignerElapseTime, () => ElapseTime);

            DATA.Subscribe(ModuleName.Aligner.ToString(), ParamName.AlignerNotch, () => Notch);

            DATA.Subscribe(ModuleName.Aligner.ToString(), ParamName.WaferOnAligner, () => WaferOnAligner);

            EV.Subscribe(new EventItem("Event", AlignerMotionError, "Aligner error", EventLevel.Alarm, Aitex.Core.RT.Event.EventType.HostNotification));


            return true;
        }

        public void Terminate()
        {
            _socket.Dispose();
        }

        public void Monitor()
        {
            object maintenance = DATA.Poll(ModuleName.System.ToString(), ParamName.IsMaintenanceMode);
            
            bool bTrigger = maintenance==null || (bool)maintenance;

            if (bTrigger && _timerQuery.IsTimeout())
            {
                if (!Busy)
                {
                    string reason = string.Empty;
                    if (_queryState)
                        QueryState(out reason);
    
                    _queryState = !_queryState;
                    _timerQuery.Start(_queryPeriod);
                }
            }

        }

        public void Reset()
        {
            lock (_locker)
            {
                _foregroundHandler = null;
                _backgroundHandler = null;
            }
            
            //_exceuteErr = false;
            if (_commErr)
            {
                _commErr = false;
                _socket.Connect(this._addr);
            }
        }


        #region Command
        public bool Init(out string reason)
        {
            reason = string.Empty;
            return execute(_factory.Init(), out reason);
        }
        public bool Home(out string reason)
        {
            reason = string.Empty;
            return execute(_factory.Home(), out reason);
        }

        public bool Clear(out string reason)
        {
            reason = string.Empty;
            return execute(_factory.Clear(), out reason);
        }

        public bool Grip(Hand hand, out string reason)
        {
            reason = string.Empty;
            return execute(_factory.Grip(hand), out reason);
        }

        public bool Release(Hand hand, out string reason)
        {
            reason = string.Empty;
            return execute(_factory.Release(hand), out reason);
        }


        public bool LiftUp(out string reason)
        {
            reason = string.Empty;
            return execute(_factory.LiftUp(), out reason);
        }

        public bool LiftDown(out string reason)
        {
            reason = string.Empty;
            return execute(_factory.LiftDown(), out reason);
        }



        public bool Stop(out string reason)
        {
            reason = string.Empty;

            lock (_locker)
            {
                _foregroundHandler = null;
                _backgroundHandler = null;
            }
            return execute(_factory.Stop(), out reason);
        }

        public bool Align(double angle, out string reason)
        {
            reason = string.Empty;
            return execute(_factory.Align(angle), out reason);
        }

        
        public 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;
                }
                handler.Unit = (int)Unit.Aligner;
                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($"Aligner occurred error code {ErrorCode}.");
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (ExcuteFailedException e)
            {
                EV.PostMessage("Aligner", EventEnum.DefaultWarning, string.Format("executed failed. {0}", e.Message));
                OnError("Aligner Execution failure.");
            }
            catch (InvalidPackageException e)
            {
                EV.PostMessage("Aligner", EventEnum.DefaultWarning, string.Format("receive invalid package. {0}", e.Message));
                OnError("Received invilid message from Aligner.");
            }
            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("Aligner communication 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 error)
        {
            EV.Notify(AlignerMotionError,new SerializableDictionary<string, object> 
            {
                {"AlarmText",error }
            });
        }
    }
}