ZZ-EFEM/Framework/AitexSorterRT/Device/RFID/Reader.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using Aitex.Sorter.RT.Device.Robot;
using System;
using System.Text.RegularExpressions;
using DeviceState = Aitex.Sorter.Common.DeviceState;
using TSC = Aitex.Sorter.Common;
using Aitex.Core.RT.Event;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.Equipment;


namespace Aitex.Sorter.RT.Device.RFID
{

    public class RIDReader : BaseDevice, IDevice, IConnection
    {
        public string Address => _addr;
        public bool IsConnected => _socket.IsConnected;
        public bool Connect()
        {
            _socket.Connect(this._addr);
            return true;
        }

        public bool Disconnect()
        {
            _socket.Dispose();
            return true;
        }
        public event Action<ModuleName, string> OnCarrierIdRead;
        public event Action<ModuleName> OnCarrierIdReadFailed;
        public event Action<ModuleName, string> OnCarrierIdWrite;
        public event Action<ModuleName> OnCarrierIdWriteFailed;

        public DeviceState State
        {
            get
            {
                if (!Initalized)
                {
                    return DeviceState.Unknown;
                }
                if (Error)
                {
                    return DeviceState.Error;
                }

                if (Busy)
                    return DeviceState.Busy;

                return DeviceState.Idle;
            }
        }

        public bool Initalized { get; set; }
        public bool Busy
        {
            get { return _foregroundHandler != null; }
        }

        public bool Error
        {
            get{return _commErr;}
        }

        private string _rfId;

        public string RfID
        {
            get
            {
                return _rfId;
            }
            set
            {
                //FAManager.Instance.ChangeFoupId(Name, value);
                _rfId = value;
            }
        }

        public string LoadPortName
        {
            get
            {
                return _loadPort;
            }
 
        }

        private static Object _locker = new Object();  
        private AsyncSocket _socket;

        private IHandler _foregroundHandler = null;  //current handler

        public const string delimiter = "\r";

        private bool _commErr = false;

        private string page;

        private string _addr;

        private int startpage;
        private int length { get; set; } = 16;

        private string _loadPort ;

        public RIDReader(string module, string name, string display, string deviceId, string address, string page, string loadport )
            : base(module, name, display, deviceId)
        {
            this.page = page;
            _addr = address;
            _loadPort = loadport;

            _socket = new AsyncSocket(address);
            _socket.OnDataChanged += new AsyncSocket.MessageHandler(OnDataChanged);
            _socket.OnErrorHappened += new AsyncSocket.ErrorHandler(OnErrorHandler);

            Initalized = false;
        }
        public RIDReader(string module, string name, string display, string deviceId, string address, int Startpage, int Length,string loadport)
            : base(module, name, display, deviceId)
        {
            //this.page = page;

            this.startpage = Startpage;
            this.length = Length;
            double dpage = 0;
            for (int i = 0; i < Length; i++)
            {
                dpage = dpage + Math.Pow(2, 18 - Startpage- i);
            }
            this.page = String.Format("{0:X}", Convert.ToInt32(dpage)); 

            for(int j=page.Length;j<8;j++)
            {
                page = "0" + page;
            }
            _addr = address;
            _loadPort = loadport;

            _socket = new AsyncSocket(address);
            _socket.OnDataChanged += new AsyncSocket.MessageHandler(OnDataChanged);
            _socket.OnErrorHappened += new AsyncSocket.ErrorHandler(OnErrorHandler);

            Initalized = false;
        }

        public bool Initialize()
        {
            ConnectionManager.Instance.Subscribe(Name, this);
            _socket.Connect(this._addr);

            DEVICE.Register(String.Format("{0}.{1}", Name, TSC.DeviceOperationName.ReadRFID), (out string reason, int time, object[] param) =>
            {
                bool ret = Read(out reason);
                if (ret)
                {
                    reason = string.Format("{0}{1}", Name, "Reading ID");
                    return true;
                }

                return false;
            });

            DEVICE.Register(String.Format("{0}.{1}", Name, TSC.DeviceOperationName.WriteRFID), (out string reason, int time, object[] param) =>
            {
                string id = (string)param[0];
                bool ret = Write(id, out reason);
                if (ret)
                {
                    reason = string.Format("{0}{1}", Name, "Writing ID");
                    return true;
                }

                return false;
            });
            

            DATA.Subscribe(Name, ParamName.RIDReaderBusy, () => Busy);
            DATA.Subscribe(Name, ParamName.RfID, () => RfID);
            DATA.Subscribe(Name, ParamName.RIDReaderState, () => State);

            DATA.Subscribe(string.Format("Device.{0}.{1}", Module , Name), 
                () =>
                {
                    AITRfidReaderData data = new AITRfidReaderData()
                                        {
                                            DeviceName = Name,
                                            DeviceSchematicId = DeviceID,
                                            DisplayName = Display,
                                            IsBusy = Busy,
                                            IsError = Error,
                                            IsInitalized = Initalized,
                                            State = State.ToString(),
                    };

                    return data;
                }, SubscriptionAttribute.FLAG.IgnoreSaveDB);


            Initalized = true;
            return true;
        }

        public void Terminate()
        {
        }

        public void Monitor()
        {
        }

        public void Reset()
        {
            lock (_locker)
            {
                _foregroundHandler = null;
            }

            if (_commErr)
            {
                _commErr = false;
                _socket.Connect(this._addr);
            }

        }


        #region Command

        public bool Read(out string reason)
        {
            reason = string.Empty;
            return execute(new RfidHandler<ReadHandler>(this.DeviceID, this.page), out reason);
        }
        public bool Read_E99(int startpage, int length,out string reason)
        {
            reason = string.Empty;
            return execute(new RfidHandler<E99ReadHandler>(this.DeviceID,startpage,length), out reason);
        }

        public bool Write(string id, out string reason)
        {
            reason = string.Empty;

            return execute(new RfidHandler<WriteHandler>(this.DeviceID, this.page,id, length), out reason);
        }
        public bool Write_E99(int startpage,int length, string id,out string reason)
        {
            reason = string.Empty;

            return execute(new RfidHandler<E99WriteHandler>(this.DeviceID, startpage, length,id ), out reason);
        }

        #endregion


        private bool execute(IHandler handler, out string reason)
        {
            reason = string.Empty;
            lock (_locker)
            {
                if (_foregroundHandler != null)
                {
                    reason = string.Format("Busy,can not execute");
                    return false;
                }

                if(!handler.Execute(ref _socket))
                {
                    reason = "Communication error, please re-connect";
                    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 > 0)
                    {
                        bool completed = false;
                        string resp = msg;

                        lock (_locker)
                        {
                            if (_foregroundHandler != null && _foregroundHandler.OnMessage(ref _socket, resp, out completed))
                            {
                                _foregroundHandler = null;
                            }
                        }
                    }
                }
            }
            catch (ExcuteFailedException ex)
            {
                EV.PostMessage(DeviceID, EventEnum.DefaultWarning, ex.Message);
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(_loadPort, out name))
                {
                    var t = _foregroundHandler as RfidHandler<ReadHandler>;
                    if (t != null)
                    {
                        if (OnCarrierIdReadFailed != null)
                            OnCarrierIdReadFailed(name);
                    }
                    else
                    {
                        if (OnCarrierIdWriteFailed != null)
                            OnCarrierIdWriteFailed(name);
                    }
                }

                _foregroundHandler = null;
            }
            catch (InvalidPackageException ex)
            {
                EV.PostMessage(DeviceID, EventEnum.DefaultWarning, ex.Message);
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(_loadPort, out name))
                {
                    var t = _foregroundHandler as RfidHandler<ReadHandler>;
                    if (t != null)
                    {
                        if (OnCarrierIdReadFailed != null)
                            OnCarrierIdReadFailed(name);
                    }
                    else
                    {
                        if (OnCarrierIdWriteFailed != null)
                            OnCarrierIdWriteFailed(name);
                    }
                }

                _foregroundHandler = null;
            }
            catch (System.Exception ex)
            {
                EV.PostMessage(Name, EventEnum.DefaultWarning, "【RFID】has exception：" + ex.ToString());
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(_loadPort, out name))
                {
                    var t = _foregroundHandler as RfidHandler<ReadHandler>;
                    if (t != null)
                    {
                        if (OnCarrierIdReadFailed != null)
                            OnCarrierIdReadFailed(name);
                    }
                    else
                    {
                        if (OnCarrierIdWriteFailed != null)
                            OnCarrierIdWriteFailed(name);
                    }
                }

                _foregroundHandler = null;
            }
        }


        private void OnErrorHandler(ErrorEventArgs args)
        {
            if (OnCarrierIdReadFailed != null)
            {
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(Module, out name))
                    OnCarrierIdReadFailed(name);
            }

            if (OnCarrierIdWriteFailed != null)
            {
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(Module, out name))
                    OnCarrierIdWriteFailed(name);
            }
            _commErr = true;
            Initalized = false;
            EV.PostMessage(Module, EventEnum.CommunicationError, Display, args.Reason);
        }

        public void SetCarrierIdReadResult(string carrierId)
        {

            RfID = carrierId;

            if (OnCarrierIdRead != null)
            {
                OnCarrierIdRead((ModuleName)Enum.Parse(typeof(ModuleName), LoadPortName), carrierId);
            }
        }

        public void SetCarrierIdWriteResult(string carrierId)
        {

            RfID = carrierId;

            if (OnCarrierIdWrite != null)
            {
                OnCarrierIdWrite((ModuleName)Enum.Parse(typeof(ModuleName), LoadPortName), carrierId);
            }
        }
        
    }

    public class VirtualRIDReader : BaseDevice, IDevice, IConnection
    {
        public string Address => _addr;
        public bool IsConnected => true;
        public bool Connect()
        {
            
            return true;
        }

        public bool Disconnect()
        {
            
            return true;
        }
        public event Action<ModuleName, string> OnCarrierIdRead;
        public event Action<ModuleName> OnCarrierIdReadFailed;
        public event Action<ModuleName, string> OnCarrierIdWrite;
        public event Action<ModuleName> OnCarrierIdWriteFailed;

        public DeviceState State
        {
            get
            {
                if (!Initalized)
                {
                    return DeviceState.Unknown;
                }
                if (Error)
                {
                    return DeviceState.Error;
                }

                if (Busy)
                    return DeviceState.Busy;

                return DeviceState.Idle;
            }
        }

        public bool Initalized { get; set; }
        public bool Busy
        {
            get { return _foregroundHandler != null; }
        }

        public bool Error
        {
            get { return _commErr; }
        }

        private string _rfId;

        public string RfID
        {
            get
            {
                return _rfId;
            }
            set
            {
                //FAManager.Instance.ChangeFoupId(Name, value);
                _rfId = value;
            }
        }

        public string LoadPortName
        {
            get
            {
                return _loadPort;
            }

        }

        private static Object _locker = new Object();
        private AsyncSocket _socket;

        private IHandler _foregroundHandler = null;  //current handler

        public const string delimiter = "\r";

        private bool _commErr = false;

        private string page;

        private string _addr;

        private int startpage;
        private int length { get; set; } = 16;

        private string _loadPort;

        public VirtualRIDReader(string module, string name, string display, string deviceId, string address, string page, string loadport)
            : base(module, name, display, deviceId)
        {
            this.page = page;
            _addr = address;
            _loadPort = loadport;

           

            Initalized = false;
        }
        public VirtualRIDReader(string module, string name, string display, string deviceId, string address, int Startpage, int Length, string loadport)
            : base(module, name, display, deviceId)
        {
            //this.page = page;

            this.startpage = Startpage;
            this.length = Length;
            double dpage = 0;
            for (int i = 0; i < Length; i++)
            {
                dpage = dpage + Math.Pow(2, 18 - Startpage - i);
            }
            this.page = String.Format("{0:X}", Convert.ToInt32(dpage));

            for (int j = page.Length; j < 8; j++)
            {
                page = "0" + page;
            }
            _addr = address;
            _loadPort = loadport;

           

            Initalized = false;
        }

        public bool Initialize()
        {
            ConnectionManager.Instance.Subscribe(Name, this);
            //_socket.Connect(this._addr);

            DEVICE.Register(String.Format("{0}.{1}", Name, TSC.DeviceOperationName.ReadRFID), (out string reason, int time, object[] param) =>
            {
                bool ret = Read(out reason);
                if (ret)
                {
                    reason = string.Format("{0}{1}", Name, "Reading ID");
                    return true;
                }

                return false;
            });

            DEVICE.Register(String.Format("{0}.{1}", Name, TSC.DeviceOperationName.WriteRFID), (out string reason, int time, object[] param) =>
            {
                string id = (string)param[0];
                bool ret = Write(id, out reason);
                if (ret)
                {
                    reason = string.Format("{0}{1}", Name, "Writing ID");
                    return true;
                }

                return false;
            });


            DATA.Subscribe(Name, ParamName.RIDReaderBusy, () => Busy);
            DATA.Subscribe(Name, ParamName.RfID, () => RfID);
            DATA.Subscribe(Name, ParamName.RIDReaderState, () => State);

            DATA.Subscribe(string.Format("Device.{0}.{1}", Module, Name),
                () =>
                {
                    AITRfidReaderData data = new AITRfidReaderData()
                    {
                        DeviceName = Name,
                        DeviceSchematicId = DeviceID,
                        DisplayName = Display,
                        IsBusy = Busy,
                        IsError = Error,
                        IsInitalized = Initalized,
                        State = State.ToString(),
                    };

                    return data;
                }, SubscriptionAttribute.FLAG.IgnoreSaveDB);


            Initalized = true;
            return true;
        }

        public void Terminate()
        {
        }

        public void Monitor()
        {
        }

        public void Reset()
        {
            lock (_locker)
            {
                _foregroundHandler = null;
            }

            if (_commErr)
            {
                _commErr = false;
                //_socket.Connect(this._addr);
            }

        }


        #region Command

        public bool Read(out string reason)
        {
            reason = string.Empty;
            return execute(new RfidHandler<ReadHandler>(this.DeviceID, this.page), out reason);
        }

        public bool Write(string id, out string reason)
        {
            reason = string.Empty;

            return execute(new RfidHandler<WriteHandler>(this.DeviceID, this.page, id, length), out reason);
        }

        #endregion


        private bool execute(IHandler handler, out string reason)
        {
            reason = string.Empty;
            
            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;
                            }
                        }
                    }
                }
            }
            catch (ExcuteFailedException ex)
            {
                EV.PostMessage(DeviceID, EventEnum.DefaultWarning, ex.Message);
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(_loadPort, out name))
                {
                    var t = _foregroundHandler as RfidHandler<ReadHandler>;
                    if (t != null)
                    {
                        if (OnCarrierIdReadFailed != null)
                            OnCarrierIdReadFailed(name);
                    }
                    else
                    {
                        if (OnCarrierIdWriteFailed != null)
                            OnCarrierIdWriteFailed(name);
                    }
                }

                _foregroundHandler = null;
            }
            catch (InvalidPackageException ex)
            {
                EV.PostMessage(DeviceID, EventEnum.DefaultWarning, ex.Message);
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(_loadPort, out name))
                {
                    var t = _foregroundHandler as RfidHandler<ReadHandler>;
                    if (t != null)
                    {
                        if (OnCarrierIdReadFailed != null)
                            OnCarrierIdReadFailed(name);
                    }
                    else
                    {
                        if (OnCarrierIdWriteFailed != null)
                            OnCarrierIdWriteFailed(name);
                    }
                }

                _foregroundHandler = null;
            }
            catch (System.Exception ex)
            {
                EV.PostMessage(Name, EventEnum.DefaultWarning, "【RFID】has exception：" + ex.ToString());
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(_loadPort, out name))
                {
                    var t = _foregroundHandler as RfidHandler<ReadHandler>;
                    if (t != null)
                    {
                        if (OnCarrierIdReadFailed != null)
                            OnCarrierIdReadFailed(name);
                    }
                    else
                    {
                        if (OnCarrierIdWriteFailed != null)
                            OnCarrierIdWriteFailed(name);
                    }
                }

                _foregroundHandler = null;
            }
        }


        private void OnErrorHandler(ErrorEventArgs args)
        {
            if (OnCarrierIdReadFailed != null)
            {
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(Module, out name))
                    OnCarrierIdReadFailed(name);
            }

            if (OnCarrierIdWriteFailed != null)
            {
                ModuleName name = ModuleName.System;
                if (Enum.TryParse(Module, out name))
                    OnCarrierIdWriteFailed(name);
            }
            _commErr = true;
            Initalized = false;
            EV.PostMessage(Module, EventEnum.CommunicationError, Display, args.Reason);
        }

        public void SetCarrierIdReadResult(string carrierId)
        {

            RfID = carrierId;

            if (OnCarrierIdRead != null)
            {
                OnCarrierIdRead((ModuleName)Enum.Parse(typeof(ModuleName), LoadPortName), carrierId);
            }
        }

        public void SetCarrierIdWriteResult(string carrierId)
        {

            RfID = carrierId;

            if (OnCarrierIdWrite != null)
            {
                OnCarrierIdWrite((ModuleName)Enum.Parse(typeof(ModuleName), LoadPortName), carrierId);
            }
        }

    }
}