Kepler-Release/Venus/Venus_RT/Devices/EFEM/JetEfem.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
using Venus_Core;
using Venus_RT.Modules;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using Aitex.Sorter.Common;
using Aitex.Core.Common;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Log;
using Aitex.Core.Util;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot;
using Venus_RT.Devices.YASKAWA;

namespace Venus_RT.Devices.EFEM
{
    class JetEfem : EfemBase
    {
        private RState _status;
        private bool _IsHomed;
        private string _waferPresence;
        private bool _bIsUnloadClamp;
        private RobotMoveInfo _robotMoveInfo = new RobotMoveInfo();
        private readonly Loadport[] _LPMs = new Loadport[3];
        private readonly SignalTower _signalT = new SignalTower();
        private readonly AsyncSocket _socket;
        private EfemMessage _currentMsg;
        private EfemMessage _backroundMsg;
        private EfemMessage _revMsg;
        private bool _LiftIsUp = false;
        private bool _LiftIsDown = false;

        public override RState Status { get { return _status; } }
        public override bool IsHomed { get { return _IsHomed; } }
        public override RobotMoveInfo TMRobotMoveInfo { get { return _robotMoveInfo; } }
        public override ILoadport this[ModuleName mod]
        {
            get
            {
                if (!ModuleHelper.IsLoadPort(mod))
                    throw new ApplicationException($"{mod} is NOT Loadport");

                return _LPMs[mod - ModuleName.LP1];
            }
        }

        public override bool LiftIsUp { get { return _LiftIsUp; } }
        public override bool LiftIsDown { get { return _LiftIsDown; } }



        public JetEfem()
        {
            _socket = new AsyncSocket("");
            _socket.Connect(SC.GetStringValue($"EFEM.IPAddress"));
            _socket.OnDataChanged += OnReceiveMessage;
            _socket.OnErrorHappened += OnErrorHappen;

            _status = RState.Init;
            _IsHomed = false;

            _LPMs[0] = new Loadport(ModuleName.LP1, this);
            _LPMs[1] = new Loadport(ModuleName.LP2, this);
            _LPMs[2] = new Loadport(ModuleName.LP3, this);


            CarrierManager.Instance.SubscribeLocation(ModuleName.LP1.ToString(), 1);
            CarrierManager.Instance.SubscribeLocation(ModuleName.LP2.ToString(), 1);
            CarrierManager.Instance.SubscribeLocation(ModuleName.LP3.ToString(), 1);


            Action<ModuleName, int> _subscribeLoc = (ModuleName module, int waferCount) => {
                if (ModuleHelper.IsInstalled(module))
                {
                    WaferManager.Instance.SubscribeLocation(module, waferCount);
                }
            };
            WaferManager.Instance.SubscribeLocation(ModuleName.EfemRobot, 2);
            WaferManager.Instance.SubscribeLocation(ModuleName.Aligner1, 1);

            // _subscribeLoc(ModuleName.EfemRobot, 2);
            //_subscribeLoc(ModuleName.Aligner1, 1);
            _subscribeLoc(ModuleName.Aligner2, 1);
            _subscribeLoc(ModuleName.Cooling1, 1);
            _subscribeLoc(ModuleName.Cooling2, 1);
            _subscribeLoc(ModuleName.LP1, SC.GetValue<int>("EFEM.LoadPort.SlotNumber"));
            _subscribeLoc(ModuleName.LP2, SC.GetValue<int>("EFEM.LoadPort.SlotNumber"));
            _subscribeLoc(ModuleName.LP3, SC.GetValue<int>("EFEM.LoadPort.SlotNumber"));

        }

        public override void Monitor()
        {
        }
        public override void Terminate()
        {

        }
        public override void Reset()
        {
            _status = RState.End;
        }
        public override void SetOnline(bool online)
        {

        }
        public override void SetOnline(ModuleName mod, bool online)
        {

        }

        public override void SetBusy(ModuleName mod, bool online)
        {
            _status = RState.Running;
        }

        public override bool HomeAll()
        {
            _currentMsg = new EfemMessage
            {
                Port = ModuleName.EFEM,
                Operation = EfemOperation.Home,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[ModuleName.EFEM] }
            };

            _status = RState.Running;
            string data = _currentMsg.ToString();
            return _socket.Write(data);
        }
        public override bool Home(ModuleName mod)
        {
            if(ModuleHelper.IsLoadPort(mod))
            {
                _backroundMsg = new EfemMessage
                {
                    Port = mod,
                    Operation = EfemOperation.Home,
                    Head = EfemMessage.MsgHead.MOV,
                    Parameters = new List<string> { Constant.ModuleString[mod] }
                };

                return _socket.Write(_backroundMsg.ToString());
            }
            else
            {
                _currentMsg = new EfemMessage
                {
                    Operation = EfemOperation.Home,
                    Head = EfemMessage.MsgHead.MOV,
                    Parameters = new List<string> { Constant.ModuleString[mod] }
                };

                _status = RState.Running;
                return _socket.Write(_currentMsg.ToString());
            }
            
        }

        public override bool OriginalSearch(ModuleName mod)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Orgsh,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    Constant.ModuleString[mod] 
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }

        public override bool CheckWaferPresence()
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.StateTrack,
                Head = EfemMessage.MsgHead.GET,
                Parameters = new List<string> { "TRACK" }
            };

            _waferPresence = string.Empty;
            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }

        public override string GetWaferPresence()
        {
            return _waferPresence;
        }

        public override bool Halt()
        {
            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.EmsStop,
                Head = EfemMessage.MsgHead.MOV,
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }

        public override bool ClearError()
        {

            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.ClearError,
                Head = EfemMessage.MsgHead.SET,
                Parameters = new List<string> { "CLEAR" }
            };

            _status = RState.Running;
            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool PickExtend(ModuleName chamber, int slot, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Extend,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    chamber.ToHWString(),
                    ExtendPos.GB.ToString(),
                    Constant.ArmString[hand],
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool PickRetract(ModuleName chamber, int slot, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Extend,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    chamber.ToHWString(),
                    ExtendPos.G4.ToString(),
                    Constant.ArmString[hand],
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool PlaceExtend(ModuleName chamber, int slot, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Extend,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    chamber.ToHWString(),
                    ExtendPos.PB.ToString(),
                    Constant.ArmString[hand],
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool PlaceRetract(ModuleName chamber, int slot, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Extend,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    chamber.ToHWString(),
                    ExtendPos.P4.ToString(),
                    Constant.ArmString[hand],
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool Pick(ModuleName station, int slot, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            Position SrcPos = new Position {  Module= station,Slot= (byte)slot };
            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Pick,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    SrcPos.ToHWString(),
                    Constant.ArmString[hand],
                    //WaferSize.WS12.ToString()
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool Place(ModuleName station, int slot, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            Position DestPos = new Position { Module = station, Slot = (byte)slot };
            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Place,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    DestPos.ToHWString(),
                    Constant.ArmString[hand],
                    //WaferSize.WS12.ToString()
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool Goto(ModuleName station, Hand hand)
        {
            if (!CheckEfemStatus())
                return false;

            Position DestPos = new Position { Module = station, Slot = (byte)0 };
            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Goto,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string>
                {
                    DestPos.ToHWString(),
                    Constant.ArmString[hand],
                    WaferSize.WS12.ToString()
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool Grip(Hand blade, bool isGrip)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Grip,
                Head = EfemMessage.MsgHead.SET,
                Parameters = new List<string>
                {
                    isGrip ? "ON":"OFF",
                    Constant.ArmString[blade]
                }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool Map(ModuleName mod)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Map,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool SetPinUp(ModuleName mod)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Lift,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod], "UP" }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool SetPinDown(ModuleName mod)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation = EfemOperation.Lift,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod], "DOWN" }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        }
        public override bool Align(ModuleName mod, double angle, float delayTime, WaferSize size)
        {
            if (!CheckEfemStatus())
                return false;

            _currentMsg = new EfemMessage
            {
                Operation =  EfemOperation.Align,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { $"A{angle.ToString("000.00")}" }
            };

            _status = RState.Running;
            return _socket.Write(_currentMsg.ToString());
        } 
        public override bool SetLamp(LightType light, LightStatus status)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Light,
                Head = EfemMessage.MsgHead.SET,
                Parameters = new List<string> { Constant.STOWER, light.ToString(), status.ToString() }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool Load(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Load,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool Unload(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Unload,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool ReadCarrierId(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.CarrierId,
                Head = EfemMessage.MsgHead.GET,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool WriteCarrierId(ModuleName mod, string id)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.CarrierId,
                Head = EfemMessage.MsgHead.SET,
                Parameters = new List<string> { Constant.ModuleString[mod], id }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool ReadTagData(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.CarrierId,
                Head = EfemMessage.MsgHead.GET,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool WriteTagData(ModuleName mod, string tagData)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.CarrierId,
                Head = EfemMessage.MsgHead.SET,
                Parameters = new List<string> { Constant.ModuleString[mod], tagData }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool Dock(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Dock,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod]}
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool Undock(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Undock,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod]}
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool Clamp(ModuleName mod, bool isUnloadClamp)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Clamp,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            _bIsUnloadClamp = isUnloadClamp;
            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool Unclamp(ModuleName mod)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.Unclamp,
                Head = EfemMessage.MsgHead.MOV,
                Parameters = new List<string> { Constant.ModuleString[mod] }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override bool SetThickness(ModuleName mod, string thickness)
        {
            _backroundMsg = new EfemMessage
            {
                Operation = EfemOperation.SetThickness,
                Head = EfemMessage.MsgHead.SET,
                Parameters = new List<string> { Constant.ModuleString[mod], thickness.ToUpper() }
            };

            return _socket.Write(_backroundMsg.ToString());
        }
        public override void SetRobotMovingInfo(RobotAction action, Hand hand, ModuleName target)
        {

        }

        private void OnReceiveMessage(string RevMsg)
        {
            string[] msgs = RevMsg.Split('\r');

            foreach (var msg in msgs)
            {
                if (string.IsNullOrWhiteSpace(msg)) continue;

                EfemMessage rec_msg = msg.ToMessage();

                switch (rec_msg.Head)
                {
                    case EfemMessage.MsgHead.ACK:
                        if (msg.Contains("ERROR"))
                        {
                            _status = RState.End;
                            _revMsg = rec_msg;
                        }
                        
                        break;

                    case EfemMessage.MsgHead.INF:

                        // 收到INF之后发送ACK确认
                        string strACK = rec_msg.RawString.Replace("INF", "ACK");

                        SendBack(strACK);
                        EfemMessage ack_msg = strACK.ToMessage();
                        ack_msg.Direct = MsgDirection.To;
                        _revMsg = rec_msg;

                        OnCommandUpdated(rec_msg);
                        break;

                    case EfemMessage.MsgHead.EVT:
                        OnEventUpdated(new EfemEventArgs
                        {
                            EvtStr = rec_msg.ToParamString(),
                            Module = rec_msg.Port,
                            CommandType = rec_msg.Operation,
                            DataList = rec_msg.Data
                        });
                        break;

                    case EfemMessage.MsgHead.NAK:
                    case EfemMessage.MsgHead.CAN:
                    case EfemMessage.MsgHead.ABS:
                        OnErrorOccurred(rec_msg);
                        break;
                }
            }
        }

        private void OnErrorHappen(ErrorEventArgs args)
        {
            _status = RState.Failed;
            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
        }

        private void OnErrorOccurred(EfemMessage message)
        {
            string description = string.Empty;
            switch(message.Head)
            {
                case EfemMessage.MsgHead.NAK:
                    description = Constant.FactorString[message.Factor];
                    break;
                case EfemMessage.MsgHead.CAN:
                    description = Constant.FactorString.ContainsKey(message.Factor) ? Constant.FactorString[message.Factor] : message.Factor;
                    break;
                case EfemMessage.MsgHead.ABS:
                    description = $"{message.Data[0]}, {message.Data[1]}";
                    break;
            }

            _status = RState.Failed;
            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, $"{description}, [{message.Data[0]}], [{message.Factor}]");
        }

        private void OnEventUpdated(EfemEventArgs eArg)
        {

            switch (eArg.CommandType)
            {
                case EfemOperation.SigStatus:
                    // EVT:SIGSTAT/Parameter/DATA1/DATA2;
                    string sParam = eArg.DataList[0];           // "SYSTEM" or "Pn"

                    // DATA1 & DATA2
                    int nData1 = Convert.ToInt32(eArg.DataList[1], 16);
                    int nData2 = Convert.ToInt32(eArg.DataList[2], 16);

                    BitArray baData1 = new BitArray(new int[] { nData1 });
                    BitArray baData2 = new BitArray(new int[] { nData2 });

                    if (0 == string.Compare(sParam, Constant.SYS, true))
                    {
                        // EVT:SIGSTAT/System/00000000/00000004;
                        // DATA1

                        // Post warning and alarm
                        if (!baData1[0])   // Bit[0] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMVacuumPressureError);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM System vacuum source pressure low");

                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[1])   // Bit[1] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMIonizerAlarm);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM Ionizer compressed air error");
                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[2])   // Bit[2] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMCDAError);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM System compressed air pressure low");
                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[4])   // Bit[4] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMFlowGaugeSensorError);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM Flow gauge sensor error");
                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[5])   // Bit[5] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMLeakageAlarm);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM Leakage alarm");
                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[10])   // Bit[10] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMIonizerAlarm);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM Ionizer alarm");
                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[11])   // Bit[11] ON=Normal, OFF=Abnormal
                        {
                            //EV.Notify(EFEMFFUAlarm);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "FFU alarm");
                            Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.Error);
                        }
                        if (!baData1[13])   // Bit[13] ON=RUN, OFF=Maintain
                        {
                            //EV.Notify(EFEMOffline);
                            LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EFEM, "EFEM switch to Maintain mode, HomeAll to recover");
                        }
                        // DATA2
                        _signalT.ChangeLightStatus(LightType.RED, baData2[0] ? LightStatus.ON : baData2[5] ? LightStatus.BLINK : LightStatus.OFF);
                        _signalT.ChangeLightStatus(LightType.GREEN, baData2[1] ? LightStatus.ON : baData2[6] ? LightStatus.BLINK : LightStatus.OFF);
                        _signalT.ChangeLightStatus(LightType.YELLOW, baData2[2] ? LightStatus.ON : baData2[7] ? LightStatus.BLINK : LightStatus.OFF);
                        _signalT.ChangeLightStatus(LightType.BLUE, baData2[3] ? LightStatus.ON : baData2[8] ? LightStatus.BLINK : LightStatus.OFF);
                        _signalT.ChangeLightStatus(LightType.WHITE, baData2[4] ? LightStatus.ON : baData2[9] ? LightStatus.BLINK : LightStatus.OFF);
                        _signalT.ChangeLightStatus(LightType.BUZZER1, baData2[10] ? LightStatus.ON : LightStatus.OFF);

                        /* EFEM 程序中目前没有实现
                        _RobotErr.CLK = baData2[27]; // bit 27

                        bool bArmNotExtendLLA            = baData2[30]; // bit 30
                        bool bArmNotExtendLLB            = baData2[31]; // bit 31
                        */
                    } // system event
                    else
                    {
                        _LPMs[eArg.Module - ModuleName.LP1].HandleEvent(eArg);
                    } // FOUP EVENT
                    break;
                case EfemOperation.GetWaferInfo:
                    _LPMs[eArg.Module - ModuleName.LP1].HandleEvent(eArg);
                    break;
                default:
                    break;
            }
        }

        private void OnCommandUpdated(EfemMessage message)
        {
            if(message.Operation != EfemOperation.ClearError && message.Operation != EfemOperation.Ready && _currentMsg.Operation != message.Operation && _backroundMsg.Operation != message.Operation)
            {
                LOG.Write(eEvent.ERR_EFEM_COMMON_FAILED, ModuleName.EfemRobot, $"OnCommandUpdated() unexpected return: {message.Operation}, backround: {_backroundMsg.Operation}");
                return;
            }

            switch(message.Operation)
            {
                case EfemOperation.ClearError:
                case EfemOperation.Align:
                case EfemOperation.Map:
                case EfemOperation.Pick:
                case EfemOperation.Place:
                case EfemOperation.Extend:
                case EfemOperation.Goto:
                case EfemOperation.Orgsh:
                case EfemOperation.EmsStop:
                    _status = RState.End;
                    break;
                case EfemOperation.StateTrack:
                    {
                        _waferPresence = message.Data.Count >= 1 ? message.Data.First() : string.Empty;
                        _IsHomed = true;
                        _status = RState.End;
                    }
                    break;
                case EfemOperation.Home:
                    {
                        if(_currentMsg.Port == ModuleName.EFEM)
                        {
                            _LPMs[0].OnHomed();
                            _LPMs[1].OnHomed();
                        }
                        else if(ModuleHelper.IsLoadPort(_currentMsg.Port))
                        {
                            _LPMs[_currentMsg.Port - ModuleName.LP1].OnHomed();
                        }

                        _status = RState.End;
                    }
                    break;
                case EfemOperation.Load:
                    {
                        _LPMs[message.Port - ModuleName.LP1].OnLoaded();
                    }
                    break;
                case EfemOperation.Unload:
                    {
                        _LPMs[message.Port - ModuleName.LP1].OnUnloaded();
                    }
                    break;
                case EfemOperation.CarrierId:
                    {
                        if(message.Head == EfemMessage.MsgHead.GET)
                        {
                            _LPMs[message.Port - ModuleName.LP1].OnCarrierIDRead(message.Data.First());
                        }
                        else
                        {
                            _LPMs[message.Port - ModuleName.LP1].OnCarrierIDWrite(message.Data.First());
                        }
                    }
                    break;
                case EfemOperation.Clamp:
                    {
                        _LPMs[message.Port - ModuleName.LP1].OnClamped(_bIsUnloadClamp);
                    }
                    break;
                case EfemOperation.Unclamp:
                    {
                        _LPMs[message.Port - ModuleName.LP1].OnUnclamped();
                    }
                    break;
                case EfemOperation.Grip:
                    {
                        if (_currentMsg.Parameters[1] == "ARM2")
                        {
                            GripStateBlade1 = _currentMsg.Parameters[0];
                        }
                        else
                        {
                            GripStateBlade2 = _currentMsg.Parameters[0];
                        }
                    }
                    break;
                case EfemOperation.Ready:
                    {
                        Singleton<RouteManager>.Instance.EFEM.PostMsg(EfemEntity.MSG.CommReady);
                    }
                    break;

                case EfemOperation.Lift:
                    {
                        if (_currentMsg.Parameters[1] == "UP")
                        {
                            _LiftIsUp = true;
                            _LiftIsDown = false;
                            _status = RState.End;

                        }
                        else if (_currentMsg.Parameters[1] == "DOWN")
                        {
                            _LiftIsUp = false;
                            _LiftIsDown = true;
                            _status = RState.End;
                        }
                    }
                    break;
            }
        }

        async void SendBack(string data)
        {
            await Task.Run(()=> _socket.Write(data + '\r'));
        }
    }
}