using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Threading;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using athosRT.tool;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.BufferStations;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.LoadPortBase;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots.RobotBase;
using HandlerBase = athosRT.tool.Comm.HandlerBase;
using EV = athosRT.tool.EV;
using DATA = Common.DataCenter.DATA;
using OP = Common.OP.OP;
using athosCore;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using Aitex.Sorter.Common;
using athosRT.tool.Comm;

namespace athosRT.Modules.Robot
{
    public class RorzeRobot751 : RobotBaseDevice, IConnection
    {
        private bool isSimulatorMode;

        private string _scRoot;

        public string PortName;

        private string _address;

        private bool _enableLog;

        private RorzeRobot751Connection _connection;

        private R_TRIG _trigError = new R_TRIG();

        private R_TRIG _trigCommunicationError = new R_TRIG();

        private R_TRIG _trigRetryConnect = new R_TRIG();

        private PeriodicJob _thread;

        private object _locker = new object();

        private LinkedList<HandlerBase> _lstHandlers = new LinkedList<HandlerBase>();

        private IoSensor _diRobotReady = null;

        private IoSensor _diRobotBlade1WaferOn = null;

        private IoSensor _diRobotBlade2WaferOn = null;

        private IoSensor _diRobotError = null;

        private IoSensor _diTPinUse = null;

        private IoTrigger _doRobotHold = null;

        private DateTime _dtActionStart;

        public bool ParseComplete;

        private string _setParameter;

        private RobotArmEnum _setSizeArm;

        private WaferSize _setSize;

        private BlockingCollection<JetRobotMoveInfo> _blockingCollection = new BlockingCollection<JetRobotMoveInfo>();
        /// <summary>
        /// Robot MoveInfo
        /// </summary>
        private JetRobotMoveInfo _robotMoveInfo = new JetRobotMoveInfo();

        public JetRobotMoveInfo RobotMoveInfo
        {
            get { return _robotMoveInfo; }
            set { _robotMoveInfo = value; }
        }

        public RROpModeEnum CurrentOpMode { get; set; }

        public bool IsOrgshCompleted { get; set; }

        public bool IsCmdProcessing { get; set; }

        public RROpStatusEnum CurrentOpStatus { get; set; }

        public int CurrentOperationSpeed { get; set; }

        public string CurrentIdCodeForErrorController { get; set; }

        public bool IsEnableMultiWaferSize
        {
            get
            {
                if (SC.ContainsItem("System.IsEnableMultiWaferSize"))
                {
                    return SC.GetValue<bool>("System.IsEnableMultiWaferSize");
                }
                return false;
            }
        }

        public ModuleName GripFrom { get; set; }
        public ModuleName UnGripTo { get; set; }

        public bool _diEms { get; set; }

        public bool _diTempStop { get; set; }

        public bool _diVacuumPressure { get; set; }

        public bool _diAirSourcePressure { get; set; }

        public bool _diZaxisFan { get; set; }

        public bool _diUpperArmFan { get; set; }

        public bool _diLowerArmFan { get; set; }

        public bool _diUpperFinger1ArmWaferExistence1 { get; set; }

        public bool _diUpperFinger1ArmWaferExistence2 { get; set; }

        public bool _diLowerArmWaferExistence1 { get; set; }

        public bool _diLowerArmWaferExistence2 { get; set; }

        public bool _diTPEms { get; set; }

        public bool _diDeadmanSwitch { get; set; }

        public bool _diModeKey { get; set; }

        public bool IsEnableSeqNo { get; private set; }

        public bool IsEnableCheckSum { get; private set; }

        public int CurrentSeqNo { get; set; }

        public string Address => _address;

        public ModuleName CurrentInteractiveModule { get; private set; }

        public bool IsConnected
        {
            get
            {
                throw new NotImplementedException();
            }
        }

        public bool IsGrippedBlade1 { get; private set; }

        public bool IsGrippedBlade2 { get; private set; }

        public bool IsPermittedInterlock1 { get; private set; }

        public bool IsPermittedInterlock2 { get; private set; }

        public bool IsPermittedInterlock3 { get; private set; }

        public bool IsPermittedInterlock4 { get; private set; }

        public bool IsPermittedInterlock5 { get; private set; }

        public bool IsPermittedInterlock6 { get; private set; }

        public bool IsPermittedInterlock7 { get; private set; }

        public bool IsPermittedInterlock8 { get; private set; }

        public float CurrentThetaPosition { get; private set; }

        public float CurrentExtensionPosition { get; private set; }

        public float CurrentArm1Position { get; private set; }

        public float CurrentArm2Position { get; private set; }

        public float CurrentZPosition { get; private set; }

        public float CommandThetaPosition { get; private set; }

        public float CommandExtensionPosition { get; private set; }

        public float CommandArm1Position { get; private set; }

        public float CommandArm2Position { get; private set; }

        public float CommandZPosition { get; private set; }

        public int SpeedLevel { get; private set; }

        public int SpeedLevelSetting { get; private set; }

        public string ReadMemorySpec { get; private set; }

        public string ReadTransferStation { get; private set; }

        public int ReadSlotNumber { get; private set; }

        public string ReadArmPosture { get; private set; }

        public RobotArmEnum ReadBladeNo { get; private set; }

        public float ReadThetaPosition { get; private set; }

        public float ReadExtensionPosition { get; private set; }

        public float ReadArm1Position { get; private set; }

        public float ReadArm2Position { get; private set; }

        public float ReadZPosition { get; private set; }

        public Dictionary<string, string> ReadStationItemValues { get; private set; } = new Dictionary<string, string>();


        public Dictionary<string, string> ReadStationItemContents { get; private set; } = new Dictionary<string, string>();


        public string ReadParameterType { get; private set; }

        public string ReadParameterNo { get; private set; }

        public string ReadParameterValue { get; private set; }

        public bool IsManipulatorBatteryLow { get; private set; }

        public bool IsCommandExecutionReady { get; private set; }

        public bool IsServoON { get; private set; }

        public bool IsErrorOccurred { get; private set; }

        public bool IsControllerBatteryLow { get; private set; }

        public bool IsCheckInterlockWaferPresenceOnBlade1 { get; private set; }

        public bool IsCheckInterlockWaferPresenceOnBlade2 { get; private set; }

        public bool IsCheckInterlockPAOp { get; private set; }

        public bool IsCheckInterlockPAWaferStatus { get; private set; }

        public bool IsCheckInterlockPAWaferStatusByCCD { get; private set; }

        public string RobotSystemVersion { get; private set; }

        public string RobotSoftwareVersion { get; private set; }

        public string ReadMappingTransferStation { get; private set; }

        public int ReadMappingSlotNumbers { get; private set; }

        public string ReadSlotMap { get; private set; }

        public int RobotBodyNumber { get; private set; }

        public RobotArmEnum chcekingArm { get; set; }

        public Dictionary<string, float> ReadMappingCalibrationResult { get; private set; }

        public bool IsEnableIdentifyThickness => SC.GetValue<bool>("System.IsEnableIdentifyThickness");

        
        public bool IsSlotShowOpposite
        {
            get
            {
                if (SC.ContainsItem("System.IsSlotShowOpposite"))
                {
                    return SC.GetValue<bool>("System.IsSlotShowOpposite");
                }
                return false;
            }
        }

        private bool _isNeedMappignData
        {
            get
            {
                if (SC.ContainsItem($"Robot.{base.RobotModuleName}.NeedReadMapData"))
                {
                    return SC.GetValue<bool>($"Robot.{base.RobotModuleName}.NeedReadMapData");
                }
                return true;
            }
        }

        internal void OnEventReceived(string rawMessage)
        {
            try
            {
                string text = rawMessage.Split('.')[1].Split(':')[0];
                string[] array = rawMessage.Split('.')[1].Split(':')[1].Split('/');
                string text2 = text;
                string text3 = text2;
                if (!(text3 == "STAT"))
                {
                    if (text3 == "GPIO")
                    {
                        ParseDioStatus(array);
                    }
                }
                else
                {
                    ParseSTATStatus(array);
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "OnEventReceived", 92);
            }
        }


        public RorzeRobot751(string module, string name, string scRoot, IoSensor[] dis, IoTrigger[] dos)
            : base(module, name)
        {
            base.Module = module;
            base.Name = name;
            isSimulatorMode = SC.ContainsItem("System.IsSimulatorMode") && SC.GetValue<bool>("System.IsSimulatorMode");
            _scRoot = scRoot;
            _address = SC.GetStringValue(_scRoot + ".Address");
            //Trace.WriteLine($"即将连接的地址{_address}");
            _enableLog = SC.GetValue<bool>(_scRoot + "." + base.Name + ".EnableLogMessage");
            RobotBodyNumber = SC.GetValue<int>(_scRoot + "." + base.Name + ".BodyNumber");
            SpeedLevelSetting = SC.GetValue<int>(_scRoot + "." + base.Name + ".SpeedLevel");
            _connection = new RorzeRobot751Connection(this, _address);
            _connection.EnableLog(_enableLog);
            if (dis != null && dis.Length >= 5)
            {
                _diRobotReady = dis[0];
                _diRobotBlade1WaferOn = dis[1];
                _diRobotBlade2WaferOn = dis[2];
                _diRobotError = dis[3];
                _diTPinUse = dis[4];
                _diRobotError.OnSignalChanged += _diRobotError_OnSignalChanged;
                _diTPinUse.OnSignalChanged += _diTPinUse_OnSignalChanged;
            }
            if (dos != null && dos.Length >= 1)
            {
                _doRobotHold = dos[0];
            }
            Singleton<ConnectionManager>.Instance.Subscribe(base.Name ?? "", _connection);
            _thread = new PeriodicJob(1000, OnTimer, _scRoot + "." + base.Name + " MonitorHandler", isStartNow: true);
            ResetPropertiesAndResponses();
            RegisterSpecialData();
            RegisterAlarm();

            Task.Run(() =>
            {
                foreach (var data in _blockingCollection.GetConsumingEnumerable())
                {
                    _robotMoveInfo.Action = data.Action;
                    _robotMoveInfo.HandTarget = data.HandTarget == Hand.Blade1 ? Hand.Blade1 : (data.HandTarget == Hand.Both ? Hand.Both : Hand.Blade2);
                    _robotMoveInfo.TargetModule = data.TargetModule;
                    System.Threading.Thread.Sleep(600);
                }
            });
        }
        public void SetJetRobotMovingInfo(RobotAction action, Hand hand, ModuleName target, int slot)
        {
            _blockingCollection.Add(new JetRobotMoveInfo(action, hand, target, slot));
        }
        public void HandlerMotion(string command, string[] pdata)
        {
            if (!(command == "MMAP"))
            {
                return;
            }
            try
            {
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = 6; i < pdata.Length; i++)
                {
                    switch (pdata[i].Substring(3))
                    {
                        case "--":
                            stringBuilder.Append("0");
                            break;
                        case "OK":
                            stringBuilder.Append("1");
                            break;
                        case "CW":
                            stringBuilder.Append("2");
                            break;
                        case "DW":
                            stringBuilder.Append("W");
                            break;
                    }
                }
                ReadSlotMap = stringBuilder.ToString();
                NotifySlotMapResult(CurrentInteractiveModule, ReadSlotMap);
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "HandlerMotion", 276);
            }
        }

        private void RegisterAlarm()
        {
        }

        public void NotifyAlarmByErrorCode(string errorcode)
        {
            EV.Notify(base.Name + "Error" + errorcode);
        }

        private void _diTPinUse_OnSignalChanged(IoSensor arg1, bool arg2)
        {
            SetMaintenanceMode(!arg1.Value);
        }

        private void _diRobotError_OnSignalChanged(IoSensor arg1, bool arg2)
        {
            if (!arg1.Value)
            {
                lock (_locker)
                {
                    _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "STAT"));
                }
                OnError("RobotError");
            }
        }

        public override int RobotCommandTimeout
        {
            get
            {
                if (SC.ContainsItem($"Robot.{RobotModuleName}.TimeLimitRobotCommand"))
                {
                    return SC.GetValue<int>($"Robot.{RobotModuleName}.TimeLimitRobotCommand");
                }
                return 60;
            }
        }

        private void ResetPropertiesAndResponses()
        {
        }

        private void RegisterSpecialData()
        {
            //System.Robot
            DATA.Subscribe(base.Module + "." + base.Name + ".CurrentArm1Position"       , () => CurrentArm1Position);
            DATA.Subscribe(base.Module + "." + base.Name + ".CurrentArm2Position"       , () => CurrentArm2Position);
            DATA.Subscribe(base.Module + "." + base.Name + ".CurrentExtensionPosition"  , () => CurrentExtensionPosition);
            DATA.Subscribe(base.Module + "." + base.Name + ".CurrentThetaPosition"      , () => CurrentThetaPosition);
            DATA.Subscribe(base.Module + "." + base.Name + ".CurrentZPosition"          , () => CurrentZPosition);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsManipulatorBatteryLow"   , () => IsManipulatorBatteryLow);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsCommandExecutionReady"   , () => IsCommandExecutionReady);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsServoON"                 , () => IsServoON);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsErrorOccurred"           , () => IsErrorOccurred);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsControllerBatteryLow"    , () => IsControllerBatteryLow);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsWaferPresenceOnBlade1"   , () => IsWaferPresenceOnBlade1);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsWaferPresenceOnBlade2"   , () => IsWaferPresenceOnBlade2);
            DATA.Subscribe(base.Module + "." + base.Name + ".ErrorCode"                 , () => base.ErrorCode);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsGrippedBlade1"           , () => IsGrippedBlade1);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsGrippedBlade2"           , () => IsGrippedBlade2);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock1"     , () => IsPermittedInterlock1);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock2"     , () => IsPermittedInterlock2);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock3"     , () => IsPermittedInterlock3);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock4"     , () => IsPermittedInterlock4);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock5"     , () => IsPermittedInterlock5);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock6"     , () => IsPermittedInterlock6);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock7"     , () => IsPermittedInterlock7);
            DATA.Subscribe(base.Module + "." + base.Name + ".IsPermittedInterlock8"     , () => IsPermittedInterlock8);
            DATA.Subscribe(base.Module + "." + base.Name + ".RobotSpeed"                , () => SpeedLevelSetting.ToString());
            DATA.Subscribe(base.Name + ".RobotSpeed", () => SpeedLevelSetting.ToString());
            DATA.Subscribe($"{base.Name}.RobotMoveInfo", () => (this.RobotMoveInfo));

            OP.Subscribe(base.Name+".SetSpeed", InvokeSetSpeed);

            OP.Subscribe($"Robot.Home",     (cmd, args) => { PostMsg(RobotMsg.StartInit); return true; });
            OP.Subscribe($"Robot.Reset",    (cmd, args) => { PostMsg(RobotMsg.Reset); return true; });
            OP.Subscribe($"Robot.Stop",     (cmd, args) => { PostMsg(RobotMsg.Stop); return true; });
            OP.Subscribe($"Robot.Hold",     (cmd, args) => { PostMsg(RobotMsg.Grip); return true; });
            OP.Subscribe($"Robot.Release",  (cmd, args) => { PostMsg(RobotMsg.UnGrip); return true; });
        }
        /// <summary>
        /// 定时会处理任务的模块 用来对数据进行发送
        /// </summary>
        /// <returns></returns>
        private bool OnTimer()
        {
            //Trace.WriteLine("=================="+ RobotState + "==================");
            try
            {
                if (!_connection.IsConnected || _connection.IsCommunicationError)
                {
                    lock (_locker)
                    {
                        _lstHandlers.Clear();
                    }
                    _trigRetryConnect.CLK = !_connection.IsConnected;
                    if (_trigRetryConnect.Q && !_connection.Connect())
                    {
                        EV.PostAlarmLog(base.Module, "Can not connect with " + _connection.Address + ", " + base.Module + "." + base.Name);
                    }
                    return true;
                }
                HandlerBase handlerBase = null;
                lock (_locker)
                {
                    if (!_connection.IsBusy)
                    {
                        //此处若不循环会导致只执行一次的情况 导致转不出去
                        if (_lstHandlers.Count > 0)
                        {
                            handlerBase = _lstHandlers.First.Value;
                            ExecuteHandler(handlerBase);//在这个位置进行了通讯下发
                            //LogObject.Info("Robot", $"Communication {_connection.Address} Send {handlerBase.SendText.Replace("\r", "")}");
                            _lstHandlers.RemoveFirst();
                        }
                    }
                    else
                    {
                        _connection.MonitorTimeout();
                        _trigCommunicationError.CLK = _connection.IsCommunicationError;
                        if (_trigCommunicationError.Q)
                        {
                            _lstHandlers.Clear();
                            Trace.WriteLine(base.Module + "." + base.Name + " communication error, " + _connection.LastCommunicationError);
                            LogObject.Error("Robot", base.Module + "." + base.Name + " communication error, " + _connection.LastCommunicationError);
                            OnError(base.Module + "." + base.Name + " communication error, " + _connection.LastCommunicationError);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "OnTimer", 413);
            }
            return true;
        }

        public bool Connect()
        {
            return _connection.Connect();
        }

        public bool Disconnect()
        {
            return _connection.Disconnect();
        }

        public override bool IsReady()
        {
            if (_diRobotError != null && !_diRobotError.Value)
            {
                return false;
            }
            if (_diTPinUse != null && !_diTPinUse.Value)
            {
                return false;
            }
            return base.RobotState == RobotStateEnum.Idle && !base.IsBusy && fsm.CheckExecuted();
        }

        public bool ParseReadData(string _command, string[] rdata)
        {
            try
            {
                switch (_command)
                {
                    case "STAT":
                        rdata[0] = rdata[0].Split(':')[1];
                        ParseSTATStatus(rdata);
                        break;
                    case "GPIO":
                        rdata[0] = rdata[0].Split(':')[1];
                        ParseDioStatus(rdata);
                        break;
                    case "GMAP":
                        ParseSlotMap(rdata);
                        break;
                    case "GCHK":
                        ParseWaferPresence(rdata);
                        break;
                    case "EXST":
                        ParseWaferIsPresence(rdata);
                        break;
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseReadData", 524);
                return true;
            }
        }

        private void ParseDioStatus(string[] rdata)
        {
            byte b = Convert.ToByte(rdata[0].Substring(12, 2), 16);
            byte b2 = Convert.ToByte(rdata[0].Substring(10, 2), 16);
            IsWaferPresenceOnBlade1 = ((b2 >> 2) & 1) == 1 && ((b2 >> 3) & 1) == 1;
            IsWaferPresenceOnBlade2 = (b & 1) == 1 && ((b >> 1) & 1) == 1;
        }

        public bool ParseSTATStatus(string[] status)
        {
            try
            {
                CurrentOpMode = (RROpModeEnum)int.Parse(status[0].Substring(0, 1));
                IsOrgshCompleted = status[0][1] == '1';
                IsCmdProcessing = status[0][2] == '1';
                CurrentOpStatus = (RROpStatusEnum)int.Parse(status[0].Substring(3, 1));
                CurrentIdCodeForErrorController = status[1].Substring(0, 2);
                CurrentIdCodeForErrorController = status[1].Substring(2, 2);
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseSTATStatus", 558);
                return true;
            }
        }

        public bool ParseWaferPresence(string[] data)
        {
            try
            {
                string text = data[0].Split(':')[1];
                IsWaferPresenceOnBlade2 = ((int.Parse(text.Substring(0, 1)) != 0) ? true : false);
                IsWaferPresenceOnBlade1 = ((int.Parse(text.Substring(1, 1)) != 0) ? true : false);
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseWaferPresence", 576);
                return true;
            }
        }

        public bool ParseWaferIsPresence(string[] data)
        {
            try
            {
                string text = data[0].Split(':')[1];
                if (chcekingArm == RobotArmEnum.Lower)
                {
                    IsWaferPresenceOnBlade1 = int.Parse(text.Substring(0, 1)) == 1;
                }
                else if (chcekingArm == RobotArmEnum.Upper)
                {
                    IsWaferPresenceOnBlade2 = int.Parse(text.Substring(0, 1)) == 1;
                }
                ParseComplete = true;
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseWaferIsPresence", 599);
                return true;
            }
        }

        public bool ParseSpeedLevel(string speedlevel)
        {
            try
            {
                int num = Convert.ToInt32(speedlevel);
                if (num < 1 || num > 3)
                {
                    return false;
                }
                SpeedLevel = num;
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseSpeedLevel", 615);
                return false;
            }
        }

        public bool ParsePositionData(string[] pdata)
        {
            try
            {
                if (pdata[0] == "R")
                {
                    CommandThetaPosition = Convert.ToSingle(pdata[1]) / 1000f;
                    CommandExtensionPosition = Convert.ToSingle(pdata[2]) / 1000f;
                    CommandArm1Position = Convert.ToSingle(pdata[3]) / 1000f;
                    CommandArm2Position = Convert.ToSingle(pdata[4]) / 1000f;
                    CommandZPosition = Convert.ToSingle(pdata[5]) / 1000f;
                    return true;
                }
                if (pdata[0] == "F")
                {
                    CurrentThetaPosition = Convert.ToSingle(pdata[1]) / 1000f;
                    base.PositionAxis1 = CurrentThetaPosition;
                    CurrentExtensionPosition = Convert.ToSingle(pdata[2]) / 1000f;
                    base.PositionAxis2 = CurrentExtensionPosition;
                    CurrentArm1Position = Convert.ToSingle(pdata[3]) / 1000f;
                    base.PositionAxis3 = CurrentArm1Position;
                    CurrentArm2Position = Convert.ToSingle(pdata[4]) / 1000f;
                    base.PositionAxis4 = CurrentArm2Position;
                    CurrentZPosition = Convert.ToSingle(pdata[5]) / 1000f;
                    base.PositionAxis5 = CurrentZPosition;
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParsePositionData", 651);
                return false;
            }
        }

        public bool ParseRegisteredPositionData(string[] pdata)
        {
            return true;
        }

        public bool ParseStationData(string[] pdata)
        {
            try
            {
                ReadMemorySpec = pdata[0];
                ReadTransferStation = pdata[1];
                if (ReadStationItemValues.ContainsKey(pdata[2]))
                {
                    ReadStationItemValues.Remove(pdata[2]);
                }
                ReadStationItemValues.Add(pdata[2], pdata[3]);
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseStationData", 674);
                return false;
            }
        }

        public bool ParseParameterData(string[] pdata)
        {
            try
            {
                ReadParameterType = pdata[0];
                ReadParameterNo = pdata[1];
                ReadParameterValue = pdata[2];
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseParameterData", 689);
                return false;
            }
        }

        public bool ParseInterlockInfo(string[] pdata)
        {
            try
            {
                int num = Convert.ToInt16(pdata[0]);
                IsCheckInterlockWaferPresenceOnBlade1 = (num & 1) == 0;
                IsCheckInterlockWaferPresenceOnBlade2 = (num & 2) == 0;
                IsCheckInterlockPAOp = (num & 0x10) == 0;
                IsCheckInterlockPAWaferStatus = (num & 0x20) == 0;
                IsCheckInterlockPAWaferStatusByCCD = (num & 0x40) == 0;
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseInterlockInfo", 707);
                return false;
            }
        }

        public bool ParseSoftwareVersion(string[] pdata)
        {
            try
            {
                RobotSystemVersion = pdata[0];
                RobotSoftwareVersion = pdata[1];
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseSoftwareVersion", 721);
                return false;
            }
        }

        public bool ParseSlotMap(string[] pdata)
        {
            try
            {
                ReadSlotMap = pdata[0].Split(':')[1].Replace("2", "W").Replace("3", "2").Replace("4", "?")
                    .Replace("7", "W")
                    .Replace("8", "?")
                    .Replace("9", "?")
                    .Replace("\r", "");
                NotifySlotMapResult(CurrentInteractiveModule, ReadSlotMap);
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseSlotMap", 743);
                return false;
            }
        }

        public bool ParseMappingData(string[] pdata)
        {
            try
            {
                ReadMappingTransferStation = pdata[0];
                List<string> list = new List<string>();
                List<string> list2 = new List<string>();
                for (int i = 0; i < (pdata.Length - 1) / 2; i++)
                {
                    list.Add(pdata[2 * i + 1].Remove(0, 3));
                    list2.Add(pdata[2 * i + 2]);
                }
                base.ReadMappingDownData = list2.ToArray();
                base.ReadMappingUpData = list.ToArray();
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseMappingData", 767);
                return false;
            }
        }

        public bool ParseMappingCalibrationResult(string[] pdata)
        {
            try
            {
                ReadMappingTransferStation = pdata[0];
                ReadMappingCalibrationResult.Clear();
                ReadMappingCalibrationResult.Add("LowestLaySlotPosition", Convert.ToInt32(pdata[1]) / 1000);
                ReadMappingCalibrationResult.Add("HighestLaySlotPosition", Convert.ToInt32(pdata[2]) / 1000);
                ReadMappingCalibrationResult.Add("WaferWidth", Convert.ToInt32(pdata[3]) / 1000);
                ReadMappingCalibrationResult.Add("ThreshhholdValueofDoubleInsertion", Convert.ToInt32(pdata[4]) / 1000);
                ReadMappingCalibrationResult.Add("ThreshhholdValueofSlantingInsertion1", Convert.ToInt32(pdata[5]) / 1000);
                ReadMappingCalibrationResult.Add("ThreshhholdValueofSlantingInsertion2", Convert.ToInt32(pdata[6]) / 1000);
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "ParseMappingCalibrationResult", 787);
                return false;
            }
        }

        protected override bool fClear(object[] param)
        {
            lock (_locker)
            {
                _lstHandlers.Clear();
                _connection.ForceClear();
                _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "CCLR", "E"));
                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "STAT"));
            }
            return true;
        }

        protected override bool fStartReadData(object[] param)
        {
            if (param.Length < 1)
            {
                return false;
            }
            switch (param[0].ToString())
            {
                case "CurrentStatus":
                    lock (_locker)
                    {
                        _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "STAT"));
                    }
                    break;
                case "SignalStatus":
                    lock (_locker)
                    {
                        _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "GPIO"));
                    }
                    break;
                case "CheckWaferIsPresence":
                    lock (_locker)
                    {
                        _dtActionStart = DateTime.Now;
                        ParseComplete = false;
                        base.IsBusy = true;
                        RobotArmEnum robotArmEnum3 = (chcekingArm = (RobotArmEnum)param[1]);
                        RobotArmEnum robotArmEnum4 = robotArmEnum3;
                        int num = Convert.ToInt16(param[2]);
                        switch (robotArmEnum4)
                        {
                            case RobotArmEnum.Lower:
                                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "EXST", $"(2,{num})"));
                                break;
                            case RobotArmEnum.Upper:
                                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "EXST", $"(1,{num})"));
                                break;
                        }
                    }
                    break;
                case "CheckWaferPresence":
                    lock (_locker)
                    {
                        switch (chcekingArm = (RobotArmEnum)param[1])
                        {
                            case RobotArmEnum.Lower:
                                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "GCHK", "(2)"));
                                break;
                            case RobotArmEnum.Upper:
                                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "GCHK", "(1)"));
                                break;
                            case RobotArmEnum.Both:
                                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "GCHK", "(3)"));
                                break;
                        }
                    }
                    break;
            }
            return true;
        }

        protected override bool fMonitorReadData(object[] param)
        {
            switch (base.CurrentParamter[0].ToString())
            {
                case "CurrentStatus":
                    base.IsBusy = false;
                    break;
                case "SignalStatus":
                    base.IsBusy = false;
                    break;
                case "CheckWaferPresence":
                    base.IsBusy = false;
                    break;
                case "WaferSize":
                    base.IsBusy = false;
                    if (_setSizeArm == RobotArmEnum.Lower || _setSizeArm == RobotArmEnum.Blade1)
                    {
                        Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 0, _setSize);
                    }
                    if (_setSizeArm == RobotArmEnum.Upper || _setSizeArm == RobotArmEnum.Upper)
                    {
                        Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 1, _setSize);
                    }
                    if (_setSizeArm == RobotArmEnum.Both)
                    {
                        Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 0, _setSize);
                        Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 1, _setSize);
                    }
                    base.Size = _setSize;
                    break;
                case "CheckWaferIsPresence":
                    if (!ParseComplete)
                    {
                        if (DateTime.Now - _dtActionStart < TimeSpan.FromSeconds(30.0))
                        {
                            return false;
                        }
                        OnError("CheckWaferIsPresence timeout");
                        return true;
                    }
                    base.IsBusy = false;
                    break;
            }
            return true;
        }

        private void ExecuteHandler(HandlerBase handler)
        {
            if (handler != null)
            {
                LogObject.Info("Robot", $"Communication {_connection.Address} Send {handler.SendText.Replace("\r", "")}");
                _connection.Execute(handler);
            }
        }

        private string Checksum(byte[] bytes)
        {
            int num = 0;
            foreach (byte b in bytes)
            {
                num += b;
            }
            return $"{num % 256:X2}";
        }
        public new bool InvokeSetSpeed(string arg1, object[] arg2)
        {
            int result =(int) arg2[0];

            if (result > 20 && result < 1)
            {
                    EV.PostWarningLog(ModuleName.Robot.ToString(), "Error Parameter,speed should be range in 1, 20");
             }

            return SetSpeed(new object[1] { result });
        

       
        }


        protected override bool fStartSetParameters(object[] param)
        {
            try
            {
                string text = (_setParameter = param[0].ToString());
                switch (text)
                {
                    case "RobotSpeed":
                        {
                            int num2 = Convert.ToInt32(param[2]);
                            lock (_locker)
                            {
                                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "SSPD", $"(0,{num2})"));
                            }
                            if (SC.ContainsItem(_scRoot + "." + base.Name + ".SpeedLevel"))
                            {
                                SC.SetItemValue(_scRoot + "." + base.Name + ".SpeedLevel", Convert.ToInt32(num2));
                                SpeedLevelSetting = SC.GetValue<int>(_scRoot + "." + base.Name + ".SpeedLevel");
                            }
                            break;
                        }
                    case "TransferSpeedLevel":
                        {
                            //string text2 = param[1].ToString();
                            //int num = 100;
                            //if (text2 == "1")
                            //{
                            //    num = 100;
                            //}
                            //if (text2 == "2")
                            //{
                            //    num = 50;
                            //}
                            //if (text2 == "3")
                            //{
                            //    num = 10;
                            //}
                            //if (!"123".Contains(text2))
                            //{
                            //    EV.PostAlarmLog(base.Name, "Set " + text + " with invalid parameter:" + text2);
                            //    return false;
                            //}

                            int num = (int)param[1];
                            lock (_locker)
                            {
                                //_lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "SSPD", $"(0,{num})"));
                                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "SSPD", $"({num})"));
                            }
                            if (SC.ContainsItem(_scRoot + "." + base.Name + ".SpeedLevel"))
                            {
                                SC.SetItemValue(_scRoot + "." + base.Name + ".SpeedLevel", num);
                                SpeedLevelSetting = SC.GetValue<int>(_scRoot + "." + base.Name + ".SpeedLevel");
                            }
                            break;
                        }
                    case "WaferSize":
                        _setSizeArm = (RobotArmEnum)param[1];
                        _setSize = (WaferSize)param[2];
                        break;
                }
            }
            catch (Exception)
            {
                string text3 = "";
                if (param != null)
                {
                    foreach (object obj in param)
                    {
                        text3 = text3 + obj.ToString() + ",";
                    }
                }
                EV.PostAlarmLog(base.Name, "Set command parameter invalid:" + text3);
                return false;
            }
            return true;
        }

        protected override bool fMonitorSetParamter(object[] param)
        {
            base.IsBusy = false;
            string setParameter = _setParameter;
            string text = setParameter;
            if (text == "WaferSize")
            {
                if (_setSizeArm == RobotArmEnum.Lower || _setSizeArm == RobotArmEnum.Blade1)
                {
                    Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 0, _setSize);
                }
                if (_setSizeArm == RobotArmEnum.Upper || _setSizeArm == RobotArmEnum.Upper)
                {
                    Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 1, _setSize);
                }
                if (_setSizeArm == RobotArmEnum.Both)
                {
                    Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 0, _setSize);
                    Singleton<WaferManager>.Instance.UpdateWaferSize(base.RobotModuleName, 1, _setSize);
                }
                base.Size = _setSize;
            }
            return true;
        }

        protected override bool fStartTransferWafer(object[] param)
        {
            return false;
        }

        protected override bool fStartUnGrip(object[] param)
        {
            lock (_locker)
            {
                switch ((RobotArmEnum)param[0])
                {
                    case RobotArmEnum.Lower:
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "UCLM", "(2)"));
                        break;
                    case RobotArmEnum.Upper:
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "UCLM", "(1)"));
                        break;
                    case RobotArmEnum.Both:
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "UCLM", "(3)"));
                        break;
                }
            }
            return true;
        }

        protected override bool fStartGrip(object[] param)
        {
            lock (_locker)
            {
                switch ((RobotArmEnum)param[0])
                {
                    case RobotArmEnum.Lower:
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "CLMP", "(2)"));
                        break;
                    case RobotArmEnum.Upper:
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "CLMP", "(1)"));
                        break;
                    case RobotArmEnum.Both:
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "CLMP", "(3)"));
                        break;
                }
            }
            return true;
        }

        //protected override bool fMonitorGrip(object[] param)
        //{
        //    return false;
        //}

        //protected override bool fGripComplete(object[] param)
        //{
        //    if (param[0] == "ActionDone")
        //    {
        //        RobotArmEnum robotArmEnum = (RobotArmEnum)base.CurrentParamter[0];
        //        ModuleName moduleNameFrom = (ModuleName)base.CurrentParamter[1]; ;
        //        ModuleName moduleNameTo = base.RobotModuleName;

        //        if (robotArmEnum == RobotArmEnum.Lower)
        //        {
        //            Singleton<WaferManager>.Instance.WaferMoved(moduleNameFrom, 0, moduleNameTo, 0);
        //            UpdateThicknessType(moduleNameFrom, 0, base.RobotModuleName, 0);
        //        }
        //        if (robotArmEnum == RobotArmEnum.Upper)
        //        {
        //            Singleton<WaferManager>.Instance.WaferMoved(moduleNameFrom, 0, moduleNameTo, 1);
        //            UpdateThicknessType(moduleNameFrom, 0, base.RobotModuleName, 1);
        //        }

                
        //        IsBusy = false;
        //        return true;
        //    }
        //    else
        //    {
        //        return false;
        //    }
        //}



        protected override bool fStartInit(object[] param)
        {
            SpeedLevelSetting = SC.GetValue<int>(_scRoot + "." + base.Name + ".SpeedLevel");
            //LogObject.Info("Robot State", $"Busy:{IsBusy},Robot State:{RobotState}");
            lock (_locker)
            {
                if (_doRobotHold != null)
                {
                    _doRobotHold.SetTrigger(value: true, out var _);
                    Thread.Sleep(100);//原本就有
                }
                SetJetRobotMovingInfo(RobotAction.Retracting, Hand.Both, ModuleName.PMA, 0);
                //_lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "EVNT", "(0,1)"));
                _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "INIT"));
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "MODE", "(1,0)"));
                _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "ORGN", "(2,0)"));
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "SSPD", $"({SpeedLevelSetting})"));

            }
            return true;
        }

        protected override bool fStartHome(object[] param)
        {
            SpeedLevelSetting = SC.GetValue<int>(_scRoot + "." + base.Name + ".SpeedLevel");
            EV.PostInfoLog(base.Name, "Home robot speed:" + SpeedLevelSetting);
            lock (_locker)
            {
                if (_doRobotHold != null)
                {
                    _doRobotHold.SetTrigger(value: true, out var _);
                    Thread.Sleep(100);//原本就有
                }
                SetJetRobotMovingInfo(RobotAction.Retracting, Hand.Both, ModuleName.PMA, 0);
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "EVNT", "(0,1)"));
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "INIT"));
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "MODE", "(1,0)"));
                _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "ORGN", "(2,0)"));
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "SSPD", $"({SpeedLevelSetting})"));
            }
            return true;
        }

        protected override bool fStartGoTo(object[] param)
        {
            try
            {
                RobotArmEnum robotArmEnum = (RobotArmEnum)param[0];
                ModuleName moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), param[1].ToString());
                if (ModuleHelper.IsLoadPort(moduleName))
                {
                    DEVICE.GetDevice<LoadPortBaseDevice>(moduleName.ToString())?.NoteTransferStart();
                }
                base.BladeTarget = moduleName;
                base.Blade1Target = moduleName;
                base.Blade2Target = moduleName;
                int num = (int)param[2] + 1;
                RobotPostionEnum robotPostionEnum = (RobotPostionEnum)param[3];
                string text = null;
                if (IsEnableMultiWaferSize)
                {
                    if (robotPostionEnum.ToString().Contains("Pick"))
                    {
                        WaferSize waferSize = Singleton<WaferManager>.Instance.GetWaferSize(moduleName, (int)param[2]);
                        text = GetStationsName(moduleName, waferSize).ToString();
                    }
                    else if (robotPostionEnum.ToString().Contains("Place"))
                    {
                        WaferSize waferSize2 = Singleton<WaferManager>.Instance.GetWaferSize(base.RobotModuleName, (int)robotArmEnum);
                        text = GetStationsName(moduleName, waferSize2).ToString();
                    }
                }
                else
                {
                    text = GetStationsName(moduleName).ToString();
                }
                if (string.IsNullOrEmpty(text) || text == "0")
                {
                    EV.PostAlarmLog("Robot", "Invalid Parameter.");
                    return false;
                }
                int num2 = 0;
                if (robotArmEnum == RobotArmEnum.Lower)
                {
                    num2 = 2;
                }
                if (robotArmEnum == RobotArmEnum.Upper)
                {
                    num2 = 1;
                }
                if (robotArmEnum == RobotArmEnum.Both)
                {
                    num2 = 3;
                }
                if (num2 == 0)
                {
                    return false;
                }
                string command = string.Empty;
                int num3 = 1;
                if (robotPostionEnum == RobotPostionEnum.PickExtend)
                {
                    num3 = 1;
                    command = "EXTD";
                    base.MoveInfo = new RobotMoveInfo
                    {
                        ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                        BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + moduleName
                    };
                }
                if (robotPostionEnum == RobotPostionEnum.PickRetracted)
                {
                    num3 = 1;
                    command = "HOME";
                }
                if (robotPostionEnum == RobotPostionEnum.PlaceExtend)
                {
                    num3 = 3;
                    command = "EXTD";
                    base.MoveInfo = new RobotMoveInfo
                    {
                        ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                        BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + moduleName
                    };
                }
                if (robotPostionEnum == RobotPostionEnum.PlaceRetract)
                {
                    num3 = 1;
                    command = "HOME";
                }
                if (robotPostionEnum == RobotPostionEnum.PickReady)
                {
                    num3 = 1;
                    command = "HOME";
                }
                if (robotPostionEnum == RobotPostionEnum.PlaceReady)
                {
                    num3 = 2;
                    command = "HOME";
                }
                string text2 = $"{num3},{num2},{text},{num}";
                lock (_locker)
                {
                    lock (_locker)
                    {
                        if (_lstHandlers.Count == 0 && !_connection.IsBusy)
                        {
                            ExecuteHandler(new RorzeRobot751MotionHandler(this, command, "(" + text2 + ")"));
                        }
                        else
                        {
                            _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, command, "(" + text2 + ")"));
                        }
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fStartGoTo", 1275);
                return false;
            }
        }

        protected override bool fGoToComplete(object[] param)
        {
            try
            {
                RobotArmEnum robotArmEnum = (RobotArmEnum)base.CurrentParamter[0];
                ModuleName moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), base.CurrentParamter[1].ToString());
                int num = (int)base.CurrentParamter[2];
                switch ((RobotPostionEnum)base.CurrentParamter[3])
                {
                    case RobotPostionEnum.PickRetracted:
                        base.BladeTarget = ModuleName.System;
                        base.Blade1Target = ModuleName.System;
                        base.Blade2Target = ModuleName.System;
                        base.MoveInfo = new RobotMoveInfo
                        {
                            ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                            BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + ModuleName.System
                        };
                        if (robotArmEnum == RobotArmEnum.Lower)
                        {
                            Singleton<WaferManager>.Instance.WaferMoved(moduleName, num, base.RobotModuleName, 0);
                            UpdateThicknessType(moduleName, num, base.RobotModuleName, 0);
                        }
                        if (robotArmEnum == RobotArmEnum.Upper)
                        {
                            Singleton<WaferManager>.Instance.WaferMoved(moduleName, num, base.RobotModuleName, 1);
                            UpdateThicknessType(moduleName, num, base.RobotModuleName, 1);
                        }
                        if (robotArmEnum == RobotArmEnum.Both)
                        {
                            Singleton<WaferManager>.Instance.WaferMoved(moduleName, num, base.RobotModuleName, 0);
                            UpdateThicknessType(moduleName, num, base.RobotModuleName, 0);
                            Singleton<WaferManager>.Instance.WaferMoved(moduleName, num, base.RobotModuleName, 1);
                            UpdateThicknessType(moduleName, num, base.RobotModuleName, 1);
                        }
                        break;
                    case RobotPostionEnum.PlaceRetract:
                        base.BladeTarget = ModuleName.System;
                        base.Blade1Target = ModuleName.System;
                        base.Blade2Target = ModuleName.System;
                        base.MoveInfo = new RobotMoveInfo
                        {
                            ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                            BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + ModuleName.System
                        };
                        if (robotArmEnum == RobotArmEnum.Lower)
                        {
                            Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 0, moduleName, num);
                            UpdateThicknessType(base.RobotModuleName, 0, moduleName, num);
                        }
                        if (robotArmEnum == RobotArmEnum.Upper)
                        {
                            Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 1, moduleName, num);
                            UpdateThicknessType(base.RobotModuleName, 1, moduleName, num);
                        }
                        if (robotArmEnum == RobotArmEnum.Both)
                        {
                            Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 0, moduleName, num);
                            UpdateThicknessType(base.RobotModuleName, 0, moduleName, num);
                            Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 1, moduleName, num);
                            UpdateThicknessType(base.RobotModuleName, 1, moduleName, num);
                        }
                        break;
                    case RobotPostionEnum.PickReady:
                    case RobotPostionEnum.PlaceReady:
                        base.BladeTarget = ModuleName.System;
                        base.Blade1Target = ModuleName.System;
                        base.Blade2Target = ModuleName.System;
                        if (robotArmEnum == RobotArmEnum.Lower)
                        {
                            base.MoveInfo = new RobotMoveInfo
                            {
                                ArmTarget = RobotArm.ArmA,
                                BladeTarget = RobotArm.ArmA.ToString() + "." + ModuleName.System
                            };
                        }
                        if (robotArmEnum == RobotArmEnum.Upper)
                        {
                            base.MoveInfo = new RobotMoveInfo
                            {
                                ArmTarget = RobotArm.ArmB,
                                BladeTarget = RobotArm.ArmB.ToString() + "." + ModuleName.System
                            };
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fGoToComplete", 1406);
            }
            return base.fGoToComplete(param);
        }


        //protected override bool fMonitorGoTo(object[] param)
        //{
        //    if (CheckToPostMessage((int)RobotMsg.MoveComplete))
        //    {
        //        return true;
        //    }
        //    else
        //    {
        //        return false;
        //    }
        //}

        

        protected override bool fStop(object[] param)
        {
            lock (_locker)
            {
                if (_doRobotHold != null)
                {
                    _doRobotHold.SetTrigger(value: false, out var _);
                }
                _lstHandlers.Clear();
                _connection.ForceClear();
            }
            return true;
        }

        protected override bool fStartMove(object[] param)
        {
            try
            {
                string text = param[0].ToString();
                string text2 = string.Empty;
                for (int i = 1; i < param.Length; i++)
                {
                    text2 = ((i != 1) ? (text2 + "," + param[i].ToString()) : (text2 + param[i].ToString()));
                }
                lock (_locker)
                {
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fStartMove", 1446);
                return false;
            }
        }

        private int GetStationsName(ModuleName module)
        {
            try
            {
                if (ModuleHelper.IsLoadPort(module))
                {
                    if (SC.GetValue<bool>("System.IsEnableIdentifyThickness"))
                    {
                        if (SC.GetValue<int>($"LoadPort.{module}.SlotsNumber") == 25)
                        {
                            string arg = ((SC.GetStringValue($"CarrierInfo.{module}ThicknessType") == "THICK") ? "0" : "1");
                            return SC.GetValue<int>($"CarrierInfo.{module}Station{arg}");
                        }
                        if (SC.GetValue<int>($"LoadPort.{module}.SlotsNumber") == 13)
                        {
                            string arg2 = ((SC.GetStringValue($"CarrierInfo.{module}ThicknessType") == "THICK") ? "0" : "1");
                            return SC.GetValue<int>($"CarrierInfo.{module}Station{arg2}13");
                        }
                        EV.PostAlarmLog("Robot", $"SlotsNumber of {module} is not 13 or 25");
                        OnError($"SlotsNumber of {module} is not 13 or 25");
                        return 0;
                    }
                    return SC.GetValue<int>($"CarrierInfo.{module}Station");
                }
                return SC.GetValue<int>($"CarrierInfo.{module}Station");
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "GetStationsName", 1488);
                return 0;
            }
        }



        private int GetStationsName(ModuleName module, WaferSize wz)
        {
            try
            {
                int num = 0;
                int result = 0;
                if (ModuleHelper.IsLoadPort(module))
                {
                    LoadPortBaseDevice device = DEVICE.GetDevice<LoadPortBaseDevice>(module.ToString());
                    if (device != null)
                    {
                        num = device.InfoPadCarrierIndex;
                    }
                    else
                    {
                        LoadPort device2 = DEVICE.GetDevice<LoadPort>(module.ToString());
                        num = device.InfoPadCarrierIndex;
                    }
                    if (SC.ContainsItem($"CarrierInfo.Carrier{num}.{module}Station"))
                    {
                        //result = int.Parse(SC.GetStringValue($"CarrierInfo.Carrier{num}.{module}Station"));
                        //=====为了过检====
                        result = module.ToString() == "LP1" ? 3 : 6;
                        //=================
                    }
                    else if (SC.ContainsItem($"CarrierInfo.{module}Station{num}"))
                    {
                        result = SC.GetValue<int>($"CarrierInfo.{module}Station{num}");
                    }
                    else if (SC.ContainsItem($"CarrierInfo.{module}CassetteNumber{num}"))
                    {
                        result = SC.GetValue<int>($"CarrierInfo.{module}CassetteNumber{num}");
                    }
                    else if (SC.ContainsItem($"CarrierInfo.Carrier{num}.{module}CassetteNumber"))
                    {
                        result = SC.GetValue<int>($"CarrierInfo.Carrier{num}.{module}CassetteNumber");
                    }
                    else
                    {
                        EV.PostAlarmLog("Robot", $"Can not find CassetteNum of {module}");
                        OnError($"Can not find CassetteNum of {module}");
                    }
                    return result;
                }
                if (wz == WaferSize.WS12)
                {
                    num = 12;
                }
                if (wz == WaferSize.WS8)
                {
                    num = 8;
                }
                if (wz == WaferSize.WS6)
                {
                    num = 6;
                }
                if (wz == WaferSize.WS4)
                {
                    num = 4;
                }
                if (wz == WaferSize.WS3)
                {
                    num = 3;
                }
                if (SC.ContainsItem($"CarrierInfo.{module}Station{num}"))
                {
                    result = SC.GetValue<int>($"CarrierInfo.{module}Station{num}");
                }
                else
                {
                    EV.PostAlarmLog("Robot", $"Can not find CassetteNum:CarrierInfo.{module}Station{num}");
                    OnError($"Can not find CassetteNum of {module}");
                }
                return result;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "GetStationsName", 1560);
                return 0;
            }
        }

        private bool UpdateThicknessType(ModuleName moduleform, int moduleformslot, ModuleName moduleto, int moduletoslot)
        {
            try
            {
                lock (this)
                {
                    if (!IsEnableIdentifyThickness)
                    {
                        return true;
                    }
                    if (!ModuleHelper.IsLoadPort(moduleto))
                    {
                        string text = null;
                        if (ModuleHelper.IsRobot(moduleform))
                        {
                            SC.SetItemValueFromString(value: (moduleformslot != 0) ? SC.GetStringValue("CarrierInfo.UpperThicknessType") : SC.GetStringValue("CarrierInfo.LowerThicknessType"), name: $"CarrierInfo.{moduleto}ThicknessType");
                        }
                        else
                        {
                            text = SC.GetStringValue($"CarrierInfo.{moduleform}ThicknessType");
                            if (ModuleHelper.IsRobot(moduleto))
                            {
                                if (moduletoslot == 0)
                                {
                                    SC.SetItemValueFromString("CarrierInfo.LowerThicknessType", text);
                                }
                                else
                                {
                                    SC.SetItemValueFromString("CarrierInfo.UpperThicknessType", text);
                                }
                            }
                            else
                            {
                                SC.SetItemValueFromString($"CarrierInfo.{moduleto}ThicknessType", text);
                            }
                        }
                    }
                    if (!ModuleHelper.IsLoadPort(moduleform))
                    {
                        if (ModuleHelper.IsRobot(moduleform))
                        {
                            if (moduleformslot == 0)
                            {
                                SC.SetItemValueFromString("CarrierInfo.LowerThicknessType", "NONE");
                            }
                            else
                            {
                                SC.SetItemValueFromString("CarrierInfo.UpperThicknessType", "NONE");
                            }
                        }
                        else
                        {
                            SC.SetItemValueFromString($"CarrierInfo.{moduleform}ThicknessType", "NONE");
                        }
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "UpdateThicknessType", 1609);
                return false;
            }
        }

        private int GetSlotsNumber(ModuleName module)
        {
            try
            {
                if (ModuleHelper.IsLoadPort(module))
                {
                    return DEVICE.GetDevice<LoadPortBaseDevice>(module.ToString()).ValidSlotsNumber;
                }
                if (ModuleHelper.IsBuffer(module))
                {
                    //return DEVICE.GetDevice<BufferStation>(module.ToString()).ValidSlotsNumber;
                }
                return SC.GetValue<int>($"CarrierInfo.{module}SlotsNumber");
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "GetSlotsNumber", 1630);
                return -1;
            }
        }

        protected override bool fStartMapWafer(object[] param)
        {
            try
            {
                ModuleName moduleName4 = (base.Blade2Target = (base.Blade1Target = (base.BladeTarget = (ModuleName)Enum.Parse(typeof(ModuleName), param[0].ToString()))));
                int slotsNumber = GetSlotsNumber(moduleName4);
                if (slotsNumber == -1)
                {
                    EV.PostAlarmLog("Robot", "Invalid mapping paramter slots number");
                    return false;
                }
                string parameter = $"({GetStationsName(moduleName4)},0,0)";
                lock (_locker)
                {
                    CurrentInteractiveModule = moduleName4;
                    _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "WMAP", parameter));
                    _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "GMAP"));
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fStartMapWafer", 1670);
                return false;
            }
        }

        protected override bool fMonitorMap(object[] param)
        {
            if (_lstHandlers.Count == 0 && !_connection.IsBusy)
            {
                return true;
            }
            return false;
        }

        protected override bool fStartSwapWafer(object[] param)
        {
            try
            {
                RobotArmEnum robotArmEnum = (RobotArmEnum)param[0];
                ModuleName moduleName4 = (base.Blade2Target = (base.Blade1Target = (base.BladeTarget = (ModuleName)Enum.Parse(typeof(ModuleName), param[1].ToString()))));
                base.MoveInfo = new RobotMoveInfo
                {
                    ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                    BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + moduleName4
                };
                int num = (int)param[2] + 1;
                if (ModuleHelper.IsLoadPort(moduleName4))
                {
                    LoadPortBaseDevice device = DEVICE.GetDevice<LoadPortBaseDevice>(moduleName4.ToString());
                    device?.NoteTransferStart();
                    if (IsSlotShowOpposite)
                    {
                        num = device.ValidSlotsNumber - num + 1;
                    }
                }
                string text = null;
                if (IsEnableMultiWaferSize)
                {
                    WaferSize waferSize = Singleton<WaferManager>.Instance.GetWaferSize(moduleName4, (int)param[2]);
                    text = GetStationsName(moduleName4, waferSize).ToString();
                }
                else
                {
                    text = GetStationsName(moduleName4).ToString();
                }
                if (string.IsNullOrEmpty(text) || text == "0")
                {
                    EV.PostAlarmLog("Robot", "Invalid Parameter.");
                    return false;
                }
                int num2 = 0;
                if (robotArmEnum == RobotArmEnum.Lower)
                {
                    num2 = 2;
                }
                if (robotArmEnum == RobotArmEnum.Upper)
                {
                    num2 = 1;
                }
                if (num2 == 0)
                {
                    return false;
                }
                string parameter = $"({num2},{text},{num})";
                lock (_locker)
                {
                    SetJetRobotMovingInfo(RobotAction.Extending, (Hand)robotArmEnum, moduleName4, (int)param[2]);
                    if (_lstHandlers.Count == 0 && !_connection.IsBusy)
                    {
                        ExecuteHandler(new RorzeRobot751MotionHandler(this, "EXCH", parameter));
                    }
                    else
                    {
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "EXCH", parameter));
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fStartSwapWafer", 1748);
                return false;
            }
        }

        protected override bool fSwapComplete(object[] param)
        {
            RobotArmEnum robotArmEnum = (RobotArmEnum)base.CurrentParamter[0];
            if (!Enum.TryParse<ModuleName>(base.CurrentParamter[1].ToString(), out var result))
            {
                return false;
            }
            if (!int.TryParse(base.CurrentParamter[2].ToString(), out var result2))
            {
                return false;
            }
            base.BladeTarget = ModuleName.System;
            base.Blade1Target = ModuleName.System;
            base.Blade2Target = ModuleName.System;
            base.MoveInfo = new RobotMoveInfo
            {
                ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + ModuleName.System
            };
            if (robotArmEnum == RobotArmEnum.Lower)
            {
                Singleton<WaferManager>.Instance.WaferMoved(result, result2, base.RobotModuleName, 0);
                UpdateThicknessType(result, result2, base.RobotModuleName, 0);
                Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 1, result, result2);
                UpdateThicknessType(base.RobotModuleName, 1, result, result2);
            }
            if (robotArmEnum == RobotArmEnum.Upper)
            {
                Singleton<WaferManager>.Instance.WaferMoved(result, result2, base.RobotModuleName, 1);
                UpdateThicknessType(result, result2, base.RobotModuleName, 1);
                Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 0, result, result2);
                UpdateThicknessType(base.RobotModuleName, 0, result, result2);
            }
            return base.fSwapComplete(param);
        }

        protected override bool fStartPlaceWafer(object[] param)
        {
            try
            {
                RobotArmEnum robotArmEnum = (RobotArmEnum)param[0];
                ModuleName moduleName4 = (base.Blade2Target = (base.Blade1Target = (base.BladeTarget = (ModuleName)Enum.Parse(typeof(ModuleName), param[1].ToString()))));
                base.MoveInfo = new RobotMoveInfo
                {
                    ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                    BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + moduleName4
                };
                int num = (int)param[2] + 1;
                if (ModuleHelper.IsLoadPort(moduleName4))
                {
                    LoadPortBaseDevice device = DEVICE.GetDevice<LoadPortBaseDevice>(moduleName4.ToString());
                    device?.NoteTransferStart();
                    if (IsSlotShowOpposite)
                    {
                        num = device.ValidSlotsNumber - num + 1;
                    }
                }
                string text = null;
                if (IsEnableMultiWaferSize)
                {
                    WaferSize waferSize = Singleton<WaferManager>.Instance.GetWaferSize(base.RobotModuleName, (int)robotArmEnum);
                    text = GetStationsName(moduleName4, waferSize).ToString();
                }
                else
                {
                    text = GetStationsName(moduleName4).ToString();
                }
                if (string.IsNullOrEmpty(text) || text == "0")
                {
                    EV.PostAlarmLog("Robot", "Invalid Parameter.");
                    return false;
                }
                int num2 = 0;
                if (robotArmEnum == RobotArmEnum.Lower)
                {
                    num2 = 2;
                }
                if (robotArmEnum == RobotArmEnum.Upper)
                {
                    num2 = 1;
                }
                if (robotArmEnum == RobotArmEnum.Both)
                {
                    num2 = 3;
                }
                if (num2 == 0)
                {
                    return false;
                }
                string text2 = $"{num2},{text},{num}";
                lock (_locker)
                {
                    SetJetRobotMovingInfo(RobotAction.Placing, (Hand)robotArmEnum, moduleName4, (int)param[2]);
                    if (_lstHandlers.Count == 0 && !_connection.IsBusy)
                    {                       
                        ExecuteHandler(new RorzeRobot751MotionHandler(this, "UNLD", "(" + text2 + ")"));
                    }
                    else
                    {
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "UNLD", "(" + text2 + ")"));
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fStartPlaceWafer", 1886);
                return false;
            }
        }

        protected override bool fPlaceComplete(object[] param)
        {
            RobotArmEnum robotArmEnum = (RobotArmEnum)base.CurrentParamter[0];
            if (!Enum.TryParse<ModuleName>(base.CurrentParamter[1].ToString(), out var result))
            {
                return false;
            }
            if (!int.TryParse(base.CurrentParamter[2].ToString(), out var result2))
            {
                return false;
            }
            base.BladeTarget = ModuleName.System;
            base.Blade1Target = ModuleName.System;
            base.Blade2Target = ModuleName.System;
            base.MoveInfo = new RobotMoveInfo
            {
                ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + ModuleName.System
            };
            if (robotArmEnum == RobotArmEnum.Lower)
            {
                Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 0, result, result2);
                UpdateThicknessType(base.RobotModuleName, 0, result, result2);
            }
            if (robotArmEnum == RobotArmEnum.Upper)
            {
                Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 1, result, result2);
                UpdateThicknessType(base.RobotModuleName, 1, result, result2);
            }
            if (robotArmEnum == RobotArmEnum.Both)
            {
                Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 0, result, result2);
                UpdateThicknessType(base.RobotModuleName, 0, result, result2);
                Singleton<WaferManager>.Instance.WaferMoved(base.RobotModuleName, 1, result, result2 + 1);
                UpdateThicknessType(base.RobotModuleName, 1, result, result2 + 1);
            }
            return true;
        }

        protected override bool fStartPickWafer(object[] param)
        {
            try
            {
                RobotArmEnum robotArmEnum = (RobotArmEnum)param[0];
                ModuleName moduleName4 = (base.Blade2Target = (base.Blade1Target = (base.BladeTarget = (ModuleName)Enum.Parse(typeof(ModuleName), param[1].ToString()))));
                base.MoveInfo = new RobotMoveInfo
                {
                    ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                    BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + moduleName4
                };
                int num = (int)param[2] + 1;
                if (ModuleHelper.IsLoadPort(moduleName4))
                {
                    LoadPortBaseDevice device = DEVICE.GetDevice<LoadPortBaseDevice>(moduleName4.ToString());
                    device?.NoteTransferStart();
                    if (IsSlotShowOpposite)
                    {
                        num = device.ValidSlotsNumber - num + 1;
                    }
                }
                string text = null;
                if (IsEnableMultiWaferSize)
                {
                    WaferSize waferSize = Singleton<WaferManager>.Instance.GetWaferSize(moduleName4, (int)param[2]);
                    text = GetStationsName(moduleName4, waferSize).ToString();
                }
                else
                {
                    text = GetStationsName(moduleName4).ToString();
                }
                if (string.IsNullOrEmpty(text) || text == "0")
                {
                    EV.PostAlarmLog("Robot", "Invalid Parameter.");
                    return false;
                }
                int num2 = 0;
                if (robotArmEnum == RobotArmEnum.Lower)
                {
                    num2 = 2;
                }
                if (robotArmEnum == RobotArmEnum.Upper)
                {
                    num2 = 1;
                }
                if (robotArmEnum == RobotArmEnum.Both)
                {
                    num2 = 3;
                }
                if (num2 == 0)
                {
                    return false;
                }
                string text2 = $"{num2},{text},{num}";
                lock (_locker)
                {
                    SetJetRobotMovingInfo(RobotAction.Picking, (Hand)robotArmEnum, moduleName4, (int)param[2]);
                    if (_lstHandlers.Count == 0 && !_connection.IsBusy)
                    {                        
                        ExecuteHandler(new RorzeRobot751MotionHandler(this, "LOAD", "(" + text2 + ")"));
                    }
                    else
                    {
                        _lstHandlers.AddLast(new RorzeRobot751MotionHandler(this, "LOAD", "(" + text2 + ")"));
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "fStartPickWafer", 1997);
                return false;
            }
        }

        protected override bool fPickComplete(object[] param)
        {
            RobotArmEnum robotArmEnum = (RobotArmEnum)base.CurrentParamter[0];
            ModuleName moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), base.CurrentParamter[1].ToString());
            if (!Enum.TryParse<ModuleName>(base.CurrentParamter[1].ToString(), out var result))
            {
                return false;
            }
            if (!int.TryParse(base.CurrentParamter[2].ToString(), out var result2))
            {
                return false;
            }
            base.BladeTarget = ModuleName.System;
            base.Blade1Target = ModuleName.System;
            base.Blade2Target = ModuleName.System;
            base.MoveInfo = new RobotMoveInfo
            {
                ArmTarget = ((robotArmEnum != 0) ? RobotArm.ArmB : RobotArm.ArmA),
                BladeTarget = ((robotArmEnum == RobotArmEnum.Lower) ? RobotArm.ArmA.ToString() : RobotArm.ArmB.ToString()) + "." + ModuleName.System
            };
            if (robotArmEnum == RobotArmEnum.Lower)
            {
                Singleton<WaferManager>.Instance.WaferMoved(result, result2, base.RobotModuleName, 0);
                UpdateThicknessType(result, result2, base.RobotModuleName, 0);
            }
            if (robotArmEnum == RobotArmEnum.Upper)
            {
                Singleton<WaferManager>.Instance.WaferMoved(result, result2, base.RobotModuleName, 1);
                UpdateThicknessType(result, result2, base.RobotModuleName, 1);
            }
            if (robotArmEnum == RobotArmEnum.Both)
            {
                Singleton<WaferManager>.Instance.WaferMoved(result, result2, base.RobotModuleName, 0);
                UpdateThicknessType(result, result2, base.RobotModuleName, 0);
                Singleton<WaferManager>.Instance.WaferMoved(result, result2 + 1, base.RobotModuleName, 1);
                UpdateThicknessType(result, result2 + 1, base.RobotModuleName, 1);
            }
            return true;
        }

        protected override bool fResetToReady(object[] param)
        {
            if (_doRobotHold != null)
            {
                _doRobotHold.SetTrigger(value: true, out var _);
            }
            return true;
        }

        protected override bool fReset(object[] param)
        {
            base.IsBusy = true;

            if (!_connection.IsConnected)
            {
                _address = SC.GetStringValue(_scRoot + "." + base.Name + ".Address");
                _enableLog = SC.GetValue<bool>(_scRoot + "." + base.Name + ".EnableLogMessage");
                _connection = new RorzeRobot751Connection(this, _address);
                _connection.EnableLog(_enableLog);
                _connection.Connect();
            }
            lock (_locker)
            {
                if (_doRobotHold != null)
                {
                    _doRobotHold.SetTrigger(value: true, out var _);
                }
                _lstHandlers.Clear();
                _connection.ForceClear();
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "RSTA", "(1)"));
                _lstHandlers.AddLast(new RorzeRobot751SetHandler(this, "EVNT", "(0,1)"));
                _lstHandlers.AddLast(new RorzeRobot751ReadHandler(this, "STAT"));
            }
            return true;
        }

        protected override bool fMonitorReset(object[] param)
        {
            if (_lstHandlers.Count > 0)
            {
                return false;
            }
            if (IsCmdProcessing)
            {
                return false;
            }
            IsBusy = false;
            return true;
        }

        protected override bool fError(object[] param)
        {
            return true;
        }

        protected override bool fStartExtendForPick(object[] param)
        {
            return false;
        }

        protected override bool fStartExtendForPlace(object[] param)
        {
            return false;
        }

        protected override bool fStartRetractFromPick(object[] param)
        {
            return false;
        }

        protected override bool fStartRetractFromPlace(object[] param)
        {
            return false;
        }

        public override RobotArmWaferStateEnum GetWaferState(RobotArmEnum arm)
        {
            switch (arm)
            {
                case RobotArmEnum.Lower:
                    if (_diRobotBlade1WaferOn != null)
                    {
                        if (_diRobotBlade1WaferOn.Value)
                        {
                            return RobotArmWaferStateEnum.Absent;
                        }
                        return RobotArmWaferStateEnum.Present;
                    }
                    return IsWaferPresenceOnBlade1 ? RobotArmWaferStateEnum.Present : RobotArmWaferStateEnum.Absent;
                case RobotArmEnum.Upper:
                    if (_diRobotBlade2WaferOn != null)
                    {
                        if (_diRobotBlade2WaferOn.Value)
                        {
                            return RobotArmWaferStateEnum.Absent;
                        }
                        return RobotArmWaferStateEnum.Present;
                    }
                    return IsWaferPresenceOnBlade2 ? RobotArmWaferStateEnum.Present : RobotArmWaferStateEnum.Absent;
                case RobotArmEnum.Both:
                    if (_diRobotBlade1WaferOn != null && _diRobotBlade2WaferOn != null)
                    {
                        if (_diRobotBlade2WaferOn.Value && _diRobotBlade1WaferOn.Value)
                        {
                            return RobotArmWaferStateEnum.Absent;
                        }
                        if (!_diRobotBlade2WaferOn.Value && !_diRobotBlade1WaferOn.Value)
                        {
                            return RobotArmWaferStateEnum.Present;
                        }
                        return RobotArmWaferStateEnum.Unknown;
                    }
                    if (IsWaferPresenceOnBlade1 && IsWaferPresenceOnBlade2)
                    {
                        return RobotArmWaferStateEnum.Present;
                    }
                    if (!IsWaferPresenceOnBlade1 && !IsWaferPresenceOnBlade2)
                    {
                        return RobotArmWaferStateEnum.Absent;
                    }
                    break;
            }
            return RobotArmWaferStateEnum.Unknown;
        }

        public void NoteError(string errortext)
        {
            OnError(errortext);
        }

        public override bool OnActionDone(object[] param)
        {
            base.IsBusy = false;
            if (base.CurrentParamter != null && base.CurrentParamter.Length > 2 && Enum.TryParse<ModuleName>(base.CurrentParamter[1].ToString(), out var result) && ModuleHelper.IsLoadPort(result))
            {
                DEVICE.GetDevice<LoadPortBaseDevice>(result.ToString())?.NoteTransferStop();
            }
            if (_lstHandlers.Count == 0)
            {
                base.IsBusy = false;
                return base.OnActionDone(param);
            }
            return true;
        }

        public override void Terminate()
        {
            _thread.Stop();
            if (!SC.ContainsItem(_scRoot + "." + base.Name + ".CloseConnectionOnShutDown") || SC.GetValue<bool>(_scRoot + "." + base.Name + ".CloseConnectionOnShutDown"))
            {
                LOG.Write("Close connection for" + base.RobotModuleName, 2, "D:\\sorter\\trunk\\Efem\\Jet\\Jet_001_2P_Jet\\EfemRT\\Devices\\Rorze751\\RorzeRobot751.cs", "Terminate", 2190);
                _connection.Disconnect();
            }
            base.Terminate();
        }
    }
}