Kepler-Release/Venus/Venus_RT/Devices/TM/JetTM.cs

using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.Util;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using System;
using System.Collections.Generic;
using Venus_Core;
using Venus_RT.Modules;
using Venus_RT.Devices.IODevices;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.OperationCenter;
using IoMfc = Venus_RT.Devices.IODevices.IoMfc;

namespace Venus_RT.Devices
{
    class JetTM : MECF.Framework.RT.EquipmentLibrary.HardwareUnits.TMs.TM
    {
        private readonly IoLid _TMLid;
        private readonly IoLid _LLALid;
        private readonly IoLid _LLBLid;

        private readonly IoLid _PMALid;
        private readonly IoLid _PMBLid;
        private readonly IoLid _PMCLid;
        private readonly IoLid _PMDLid;


        private readonly IoCylinder _LLATSlitDoor;
        private readonly IoCylinder _LLBTSlitDoor;


        private readonly IoCylinder _PMASlitDoor;
        private readonly IoCylinder _PMBSlitDoor;
        private readonly IoCylinder _PMCSlitDoor;
        private readonly IoCylinder _PMDSlitDoor;



        private readonly IoCylinder _LLAESlitDoor;
        private readonly IoCylinder _LLBESlitDoor;

        private readonly IoValve _TMN2Valve;
        private readonly IoValve _TMSoftPumpValve;
        private readonly IoValve _TMFastPumpValve;
        private readonly IoValve _TMPurgeValve;
        private readonly IoValve _TMVentValve;
        //private readonly IoValve _TMSoftVentValve;
        //private readonly IoValve _TMFastVentValve;

        private readonly IoValve _LLASoftPumpValve;
        private readonly IoValve _LLAFastPumpValve;
        private readonly IoValve _LLAPurgeValve;
        private readonly IoValve _LLAVentValve;

        private readonly IoValve _LLASoftVentValve;
        private readonly IoValve _LLAFastVentValve;
        private readonly IoValve _LLBSoftVentValve;
        private readonly IoValve _LLBFastVentValve;

        private readonly IoValve _LLBSoftPumpValve;
        private readonly IoValve _LLBFastPumpValve;
        private readonly IoValve _LLBPurgeValve;
        private readonly IoValve _LLBVentValve;
        private readonly IoValve _WaferRelayValve;

        private readonly IoValve _TMVacAtmMode;

        private readonly IoValve _TMVentExhaustValve;
        private readonly IoValve _LLAVentExhaustValve;
        private readonly IoValve _LLBVentExhaustValve;


        private readonly IoSensor _TMPowerOn;
        private readonly IoSensor _TMInSafty;
        private readonly IoSensor _WaferLeakSensor;
        private readonly IoSensor _EFEMSideDoorClosed;
        private readonly IoSensor _TMPCWFlowSwitch;
        private readonly IoSensor _LLAPCWFlowSwitch;
        private readonly IoSensor _LLBPCWFlowSwitch;
        private readonly IoSensor _TMLidClosed;

        private readonly IoSensor _CDAPressureSwitch;
        private readonly IoSensor _VaccumPressureSwitch;
        private readonly IoSensor _N2PressureSwitch;

        private readonly IoSensor _TMRobotNotExtendPMA;
        private readonly IoSensor _TMRobotNotExtendPMB;
        private readonly IoSensor _TMRobotNotExtendPMC;
        private readonly IoSensor _TMRobotNotExtendPMD;
        private readonly IoSensor _TMRobotNotExtendLLA;
        private readonly IoSensor _TMRobotNotExtendLLB;
        private readonly IoSensor _EfemRobotNotExtendLLA;
        private readonly IoSensor _EfemRobotNotExtendLLB;
        private readonly IoSensor _TMVacSwitch;
        private readonly IoSensor _LLAVacSwitch;
        private readonly IoSensor _LLBVacSwitch;
        private readonly IoSensor _TMATMSwitch;
        private readonly IoSensor _LLAATMSwitch;
        private readonly IoSensor _LLBATMSwitch;

        //private readonly IoSwitch _LLAWaferSizeCheck;
        //private readonly IoSwitch _LLBWaferSizeCheck;
        //private readonly IoSwitch _PMAWaferSizeCheck;
        //private readonly IoSwitch _PMBWaferSizeCheck;
        //private readonly IoSwitch _PMCWaferSizeCheck;
        //private readonly IoSwitch _PMDWaferSizeCheck;
        private readonly IoSwitch _TM_PressureMode_Switch;
        private readonly IoSwitch _LLA_PressureMode_Switch;
        private readonly IoSwitch _LLB_PressureMode_Switch;



        private readonly IoMfc _TMMfc;
        private readonly IoMfc _LLAMfc;
        private readonly IoMfc _LLBMfc;



        private readonly PumpBase _TMPump;
        private readonly PumpBase _LLAPump;
        private readonly PumpBase _LLBPump;


        private readonly IoTMPressureCtrl _presureCtrl;

        public bool TMLidClosed => _TMLid.OFFFeedback;
        public bool LLALidClosed => _LLALid.OFFFeedback;
        public bool LLBLidClosed => _LLBLid.OFFFeedback;

        public bool PMALidClosed => _PMALid.OFFFeedback;
        public bool PMBLidClosed => _PMBLid.OFFFeedback;
        public bool PMCLidClosed => _PMCLid.OFFFeedback;
        public bool PMDLidClosed => _PMDLid.OFFFeedback;


        public bool IsLLASlitDoorClosed => _LLATSlitDoor.State == CylinderState.Close;
        public bool IsLLASlitDoorOpen => _LLATSlitDoor.State == CylinderState.Open;
        public bool IsLLAESlitDoorClosed => _LLAESlitDoor.State == CylinderState.Close;
        public bool IsLLAESlitDoorOpen => _LLAESlitDoor.State == CylinderState.Open;
        public bool IsLLBSlitDoorClosed => _LLBTSlitDoor.State == CylinderState.Close;
        public bool IsLLBSlitDoorOpen => _LLBTSlitDoor.State == CylinderState.Open;
        public bool IsLLBESlitDoorClosed => _LLBESlitDoor.State == CylinderState.Close;
        public bool IsLLBESlitDoorOpen => _LLBESlitDoor.State == CylinderState.Open;


        public bool IsTMVac => _TMVacSwitch.Value;
        public bool IsLLAVac => _LLAVacSwitch.Value;
        public bool IsLLBVac => _LLBVacSwitch.Value;
        public bool IsTMATM => _TMATMSwitch.Value;
        public bool IsLLAATM => _LLAATMSwitch.Value;
        public bool IsLLBATM => _LLBATMSwitch.Value;
        public bool IsTMPowerOn => _TMPowerOn.Value;
        public bool IsTMInSafty => _TMInSafty.Value;
        public bool IsLLAFastPumpOpen => _LLAFastPumpValve.Status;
        public bool IsLLASoftPumpOpen => _LLASoftPumpValve.Status;
        public bool IsLLBFastPumpOpen => _LLBFastPumpValve.Status;
        public bool IsLLBSoftPumpOpen => _LLBSoftPumpValve.Status;
        public bool IsLLAVentValveOpen => _LLAVentValve.Status;
        public bool IsLLAPurgeValveOpen => _LLAPurgeValve.Status;
        public bool IsLLBVentValveOpen => _LLBVentValve.Status;
        public bool IsLLBPurgeValveOpen => _LLBPurgeValve.Status;

        public bool IsTMVentValveOpen => _TMVentValve.Status;

        // public bool IsTMFastVentValveOpen => _TMFastVentValve.Status;

        public bool IsTMPurgeValveOpen => _TMPurgeValve.Status;
        public bool IsTMFastPumpOpen => _TMFastPumpValve.Status;
        public bool IsTMSoftPumpOpen => _TMSoftPumpValve.Status;
        public bool TMRobotNotExtendToPMA => _TMRobotNotExtendPMA.Value;
        public bool TMRobotNotExtendToPMB => _TMRobotNotExtendPMB.Value;
        public bool TMRobotNotExtendToPMC => _TMRobotNotExtendPMC.Value;
        public bool TMRobotNotExtendToPMD => _TMRobotNotExtendPMD.Value;
        public bool TMRobotNotExtendToLLA => _TMRobotNotExtendLLA.Value;
        public bool TMRobotNotExtendToLLB => _TMRobotNotExtendLLB.Value;
        public bool EfemRobotNotExtendToLLA => _EfemRobotNotExtendLLA.Value;
        public bool EfemRobotNotExtendToLLB => _EfemRobotNotExtendLLB.Value;

        public override double ChamberPressure => _presureCtrl.TMPressureGauge.Value;
        public double LLAPressure => _presureCtrl.LLAPressureGauge.Value;
        public double LLBPressure => _presureCtrl.LLBPressureGauge.Value;
        public override double ForelinePressure => _presureCtrl.MFForelineGauge.Value;
        public double LLAForelinePressure => _presureCtrl.LLAForelineGauge.Value;
        public double LLBForelinePressure => _presureCtrl.LLBForelineGauge.Value;


        public bool TMPumpIsRunning => _TMPump != null ? _TMPump.IsRunning : false;
        public bool LLAPumpIsRunning => _LLAPump != null ? _LLAPump.IsRunning : false;
        public bool LLBPumpIsRunning => _LLBPump != null ? _LLBPump.IsRunning : false;


        public double PMAPressure { get { return Singleton<RouteManager>.Instance.PMA.ChamberPressure; } }
        //public bool PMAIsVAC { get { return Singleton<RouteManager>.Instance.PMA.IsVac; } }
        public double PMBPressure { get { return Singleton<RouteManager>.Instance.PMB.ChamberPressure; } }
        //public bool PMBIsATM { get { return Singleton<RouteManager>.Instance.PMB.IsAtm; } }
        public double PMCPressure { get { return Singleton<RouteManager>.Instance.PMC.ChamberPressure; } }
        //public bool PMCIsATM { get { return Singleton<RouteManager>.Instance.PMC.IsAtm; } }
        public double PMDPressure { get { return Singleton<RouteManager>.Instance.PMD.ChamberPressure; } }
        //public bool PMDIsATM { get { return Singleton<RouteManager>.Instance.PMD.IsAtm; } }



        public enum LLPumpState
        {
            Idle,
            LLAUsing,
            LLBUsing,
        }

        LLPumpState _llPumpingState = LLPumpState.Idle;

        public LLPumpState LLPumpStatus { get { return _llPumpingState; } }

        public bool PMASlitDoorClosed => _PMASlitDoor.State == CylinderState.Close;
        public bool PMASlitDoorOpened => _PMASlitDoor.State == CylinderState.Open;
        public bool PMBSlitDoorClosed => _PMBSlitDoor.State == CylinderState.Close;
        public bool PMBSlitDoorOpened => _PMBSlitDoor.State == CylinderState.Open;
        public bool PMCSlitDoorClosed => _PMCSlitDoor.State == CylinderState.Close;
        public bool PMCSlitDoorOpened => _PMCSlitDoor.State == CylinderState.Open;
        public bool PMDSlitDoorClosed => _PMDSlitDoor.State == CylinderState.Close;
        public bool PMDSlitDoorOpened => _PMDSlitDoor.State == CylinderState.Open;

        public bool AllPMSlitDoorClosed
        {
            get
            {
                if (PMASlitDoorClosed == true && PMBSlitDoorClosed == true && PMCSlitDoorClosed == true && PMDSlitDoorClosed == true)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public Dictionary<ModuleName, ModuleName> PreRotateModules { get; private set; }

        public JetTM() : base("TM")
        {
            _TMLid = DEVICE.GetDevice<IoLid>($"TM.{VenusDevice.TMLid}");
            _LLALid = DEVICE.GetDevice<IoLid>($"TM.{VenusDevice.LLALid}");
            _LLBLid = DEVICE.GetDevice<IoLid>($"TM.{VenusDevice.LLBLid}");

            _PMALid = DEVICE.GetDevice<IoLid>($"TM.PMALid");
            _PMBLid = DEVICE.GetDevice<IoLid>($"TM.PMBLid");
            _PMCLid = DEVICE.GetDevice<IoLid>($"TM.PMCLid");
            _PMDLid = DEVICE.GetDevice<IoLid>($"TM.PMDLid");


            _LLATSlitDoor = DEVICE.GetDevice<IoCylinder>($"TM.{VenusDevice.LLATSlitDoor}");
            _LLBTSlitDoor = DEVICE.GetDevice<IoCylinder>($"TM.{VenusDevice.LLBTSlitDoor}");
            _LLAESlitDoor = DEVICE.GetDevice<IoCylinder>($"TM.{VenusDevice.LLAESlitDoor}");
            _LLBESlitDoor = DEVICE.GetDevice<IoCylinder>($"TM.{VenusDevice.LLBESlitDoor}");


            _PMASlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.PMASlitDoor");
            _PMBSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.PMBSlitDoor");
            _PMCSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.PMCSlitDoor");
            _PMDSlitDoor = DEVICE.GetDevice<IoCylinder>($"{Module}.PMDSlitDoor");

            _TMN2Valve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMValveN2}");
            _TMSoftPumpValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMSoftPumpValve}");
            _TMFastPumpValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMFastPumpValve}");
            _TMPurgeValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMPurgeValve}");
            _TMVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMVentValve}");
            //_TMSoftVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMSoftVentValve}");
            //_TMFastVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMFastVentValve}");

            _LLASoftPumpValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLASoftPumpValve}");
            _LLAFastPumpValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLAFastPumpValve}");
            _LLAPurgeValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLAPurgeValve}");
            _LLAVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLAVentValve}");

            _LLASoftVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLASoftVentValve}");
            _LLAFastVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLAFastVentValve}");
            _LLBSoftVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBSoftVentValve}");
            _LLBFastVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBFastVentValve}");

            _TMVacAtmMode = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMVacAtmMode}");

            _TMVentExhaustValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.TMVentExhaustValve}");
            _LLAVentExhaustValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLAVentExhaustValve}");
            _LLBVentExhaustValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBVentExhaustValve}");


            _LLBSoftPumpValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBSoftPumpValve}");
            _LLBFastPumpValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBFastPumpValve}");
            _LLBPurgeValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBPurgeValve}");
            _LLBVentValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.LLBVentValve}");
            _WaferRelayValve = DEVICE.GetDevice<IoValve>($"TM.{VenusDevice.ValveWaterRelay}");

            _TMPowerOn = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMPowerOn}");
            _TMInSafty = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMInSafty}");
            _WaferLeakSensor = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.WaferLeakSensor}");
            _EFEMSideDoorClosed = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.EFEMSideDoorClosed}");
            _TMPCWFlowSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMPCWFlowSwitch}");
            _LLAPCWFlowSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.LLAPCWFlowSwitch}");
            _LLBPCWFlowSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.LLBPCWFlowSwitch}");
            _TMLidClosed = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMLidClosed}");

            _CDAPressureSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.CDAPressureSwitch}");
            _VaccumPressureSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.VaccumPressureSwitch}");
            _N2PressureSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.N2PressureSwitch}");

            _TMRobotNotExtendPMA = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMRobotNotExtendPMA}");
            _TMRobotNotExtendPMB = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMRobotNotExtendPMB}");
            _TMRobotNotExtendPMC = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMRobotNotExtendPMC}");
            _TMRobotNotExtendPMD = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMRobotNotExtendPMD}");
            _TMRobotNotExtendLLA = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMRobotNotExtendLLA}");
            _TMRobotNotExtendLLB = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMRobotNotExtendLLB}");
            _EfemRobotNotExtendLLA = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.EfemRobotNotExtendLLA}");
            _EfemRobotNotExtendLLB = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.EfemRobotNotExtendLLB}");

            _TMVacSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMVacSwitch}");
            _LLAVacSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.LLAVacSwitch}");
            _LLBVacSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.LLBVacSwitch}");
            _TMATMSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.TMATMSwitch}");
            _LLAATMSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.LLAATMSwitch}");
            _LLBATMSwitch = DEVICE.GetDevice<IoSensor>($"TM.{VenusDevice.LLBATMSwitch}");

            //_LLAWaferSizeCheck = DEVICE.GetDevice<IoSwitch>($"TM.{VenusDevice.LLAWaferSizeCheckSwitch}");
            //_LLBWaferSizeCheck = DEVICE.GetDevice<IoSwitch>($"TM.{VenusDevice.LLBWaferSizeCheckSwitch}");
            //_PMAWaferSizeCheck = DEVICE.GetDevice<IoSwitch>($"TM.{VenusDevice.PMAWaferSizeCheckSwitch}");
            //_PMBWaferSizeCheck = DEVICE.GetDevice<IoSwitch>($"TM.{VenusDevice.PMBWaferSizeCheckSwitch}");
            //_PMCWaferSizeCheck = DEVICE.GetDevice<IoSwitch>($"TM.{VenusDevice.PMCWaferSizeCheckSwitch}");
            //_PMDWaferSizeCheck = DEVICE.GetDevice<IoSwitch>($"TM.{VenusDevice.PMDWaferSizeCheckSwitch}");
            _TM_PressureMode_Switch = DEVICE.GetDevice<IoSwitch>("TM.TMPressureModeSwitch");
            _LLA_PressureMode_Switch = DEVICE.GetDevice<IoSwitch>("TM.LLAPressureModeSwitch");
            _LLB_PressureMode_Switch = DEVICE.GetDevice<IoSwitch>("TM.LLBPressureModeSwitch");


            _TMMfc = DEVICE.GetDevice<IoMfc>($"{Module}.TM_MFC1");
            _LLAMfc = DEVICE.GetDevice<IoMfc>($"{Module}.LLA_MFC1");
            _LLBMfc = DEVICE.GetDevice<IoMfc>($"{Module}.LLB_MFC1");


            _presureCtrl = DEVICE.GetDevice<IoTMPressureCtrl>($"TM.{VenusDevice.TMPressureCtrl}");

            if (SC.GetValue<int>($"TM.DryPump.CommunicationType") == (int)CommunicationType.RS232)
            {
                if (SC.GetValue<int>($"TM.DryPump.MFG") == (int)DryPumpMFG.SKY)
                {
                    _TMPump = DEVICE.GetDevice<SkyPump>($"TM.{VenusDevice.MainPump}");
                }
                else if (SC.GetValue<int>($"TM.DryPump.MFG") == (int)DryPumpMFG.Edwards)
                {
                    _TMPump = DEVICE.GetDevice<EdwardsPump>($"TM.{VenusDevice.MainPump}");
                }
            }
            if (SC.GetValue<int>($"LLA.DryPump.CommunicationType") == (int)CommunicationType.RS232)
            {
                if (SC.GetValue<int>($"LLA.DryPump.MFG") == (int)DryPumpMFG.SKY)
                {
                    _LLAPump = DEVICE.GetDevice<SkyPump>($"LLA.{VenusDevice.MainPump}");
                }
                else if (SC.GetValue<int>($"LLA.DryPump.MFG") == (int)DryPumpMFG.Edwards)
                {
                    _LLAPump = DEVICE.GetDevice<EdwardsPump>($"LLA.{VenusDevice.MainPump}");
                }
            }
            if (SC.GetValue<int>($"LLB.DryPump.CommunicationType") == (int)CommunicationType.RS232)
            {
                if (SC.GetValue<int>($"LLB.DryPump.MFG") == (int)DryPumpMFG.SKY)
                {
                    _LLBPump = DEVICE.GetDevice<SkyPump>($"LLB.{VenusDevice.MainPump}");
                }
                else if (SC.GetValue<int>($"LLB.DryPump.MFG") == (int)DryPumpMFG.Edwards)
                {
                    _LLBPump = DEVICE.GetDevice<EdwardsPump>($"LLB.{VenusDevice.MainPump}");
                }
            }
            PreRotateModules = new Dictionary<ModuleName, ModuleName>();
            foreach (var mod in new List<ModuleName> { ModuleName.LLA, ModuleName.LLB, ModuleName.PMA, ModuleName.PMB, ModuleName.PMC, ModuleName.PMD })
            {
                string rotateModule = SC.GetStringValue($"TM.PreRotation.{mod}");
                if (rotateModule.Length == 3)
                {
                    ModuleName rotModule = ModuleHelper.Converter(rotateModule);
                    if ((ModuleHelper.IsPm(rotModule) || ModuleHelper.IsLoadLock(rotModule)) && rotModule != mod)
                    {
                        PreRotateModules.Add(mod, rotModule);
                    }
                }
            }

            DATA.Subscribe("TM.PumpIsRunning", () => TMPumpIsRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("TM.TMLidClosed", () => TMLidClosed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("TM.LLALidClosed", () => LLALidClosed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("TM.LLBLidClosed", () => LLBLidClosed, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("LLA.PumpIsRunning", () => LLAPumpIsRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe("LLB.PumpIsRunning", () => LLBPumpIsRunning, SubscriptionAttribute.FLAG.IgnoreSaveDB);


            DATA.Subscribe($"{Name}.LLAPressure", () => LLAPressure);
            DATA.Subscribe($"{Name}.LLBPressure", () => LLBPressure);

            DATA.Subscribe($"{Name}.PV.CDA_PRES",     () => GetAiValue($"{Module}.AI_CDA_PRES_PV"));
            DATA.Subscribe($"{Name}.PV.N2_PRES",      () => GetAiValue($"{Module}.AI_N2_PRES_PV"));
            DATA.Subscribe($"{Name}.PV.TMWATER_FLOW", () => GetAiValue($"{Module}.AI_TM_WATER_FLOW_PV"));
            DATA.Subscribe($"{Name}.PV.LLAWATER_FLOW",() => GetAiValue($"{Module}.AI_LLA_WATER_FLOW_PV"));
            DATA.Subscribe($"{Name}.PV.LLBWATER_FLOW",() => GetAiValue($"{Module}.AI_LLB_WATER_FLOW_PV"));



            OP.Subscribe("TM.ControlPump", (cmd, args) =>
            {
                _TMPump.SetPumpOnOff((bool)args[0]);
                return true;
            });
            OP.Subscribe("LLA.ControlPump", (cmd, args) =>
            {
                _LLAPump.SetPumpOnOff((bool)args[0]);
                return true;
            });
            OP.Subscribe("LLB.ControlPump", (cmd, args) =>
            {
                _LLBPump.SetPumpOnOff((bool)args[0]);
                return true;
            });
            OP.Subscribe("TM.SetChamberPressure", (cmd, args) =>
            {
                _presureCtrl.SetTMPressure((int)(args[0]));
                return true;
            });
            OP.Subscribe("TM.SetChamberFlow", (cmd, args) =>
            {
                _TMMfc.SetPoint = (int)(args[0]);
                return true;
            });
            OP.Subscribe($"TM.SetMFSlitDoor", (cmd, args) =>
            {
                var module = (ModuleName)Enum.Parse(typeof(ModuleName), args[0].ToString());
                TurnMFSlitDoor(module, (bool)args[1], out _);
                return true;
            });
            OP.Subscribe($"TM.SetEFEMSlitDoor", (cmd, args) =>
            {
                var module = (ModuleName)Enum.Parse(typeof(ModuleName), args[0].ToString());
                TurnEFEMSlitDoor(module, (bool)args[1], out _);
                return true;
            });
            _TMVacAtmMode.TurnValve(RouteManager.IsATMMode, out string _);

        }

        public override void Monitor()
        {
            //if (_WaferLeakSensor.Value && _WaferRelayValve.Status == false)
            //{
            //    _WaferRelayValve.TurnValve(true, out string _);

            //}
            //else if (_WaferLeakSensor.Value == false && _WaferRelayValve.Status == true)
            //{
            //    _WaferRelayValve.TurnValve(false, out string _);

            //}
        }


        public void TurnSoftPumpValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMSoftPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLA:
                    _LLASoftPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLB:
                    _LLBSoftPumpValve.TurnValve(bOn, out string _);
                    break;

            }
        }

        public void TurnFastPumpValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMFastPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLA:
                    _LLAFastPumpValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLB:
                    _LLBFastPumpValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public void TurnVentValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLA:
                    _LLAVentValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLB:
                    _LLBVentValve.TurnValve(bOn, out string _);
                    break;
            }
        }





        public void TurnPurgeValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMPurgeValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLA:
                    _LLAPurgeValve.TurnValve(bOn, out string _);
                    break;
                case ModuleName.LLB:
                    _LLBPurgeValve.TurnValve(bOn, out string _);
                    break;
            }
        }

        public void TurnN2Valve(bool bOn)
        {
            _TMN2Valve.TurnValve(bOn, out string _);
        }

        public void CloseModuleAllValves(ModuleName mod)
        {
            TurnFastPumpValve(mod, false);
            TurnSoftPumpValve(mod, false);
            TurnVentValve(mod, false);
            TurnPurgeValve(mod, false);

            if (mod == ModuleName.TM)
                TurnN2Valve(false);
        }


        public double GetModulePressure(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    return ChamberPressure;
                case ModuleName.LLA:
                    return LLAPressure;
                case ModuleName.LLB:
                    return LLBPressure;
                case ModuleName.PMA:
                    return PMAPressure;
                case ModuleName.PMB:
                    return PMBPressure;
                case ModuleName.PMC:
                    return PMCPressure;
                case ModuleName.PMD:
                    return PMDPressure;
            }

            return 0;
        }


        public double GetModuleForelinePressure(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    return ForelinePressure;
                case ModuleName.LLA:
                    return LLAForelinePressure;
                case ModuleName.LLB:
                    return LLBForelinePressure;
            }

            return 0;
        }


        public bool IsModuleATM(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    return IsTMATM;
                case ModuleName.LLA:
                    return IsLLAATM;
                case ModuleName.LLB:
                    return IsLLBATM;
                case ModuleName.PMA:
                    return Singleton<RouteManager>.Instance.PMA.IsAtm;
                case ModuleName.PMB:
                    return Singleton<RouteManager>.Instance.PMB.IsAtm;
                case ModuleName.PMC:
                    return Singleton<RouteManager>.Instance.PMC.IsAtm;
                case ModuleName.PMD:
                    return Singleton<RouteManager>.Instance.PMD.IsAtm;
            }

            return false;
        }

        public bool IsModuleVaccum(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    return IsTMVac;
                case ModuleName.LLA:
                    return IsLLAVac;
                case ModuleName.LLB:
                    return IsLLBVac;
                case ModuleName.PMA:
                    return Singleton<RouteManager>.Instance.PMA.IsVac;
                case ModuleName.PMB:
                    return Singleton<RouteManager>.Instance.PMB.IsVac;
                case ModuleName.PMC:
                    return Singleton<RouteManager>.Instance.PMC.IsVac;
                case ModuleName.PMD:
                    return Singleton<RouteManager>.Instance.PMD.IsVac;
            }

            return false;
        }

        public bool IsPMSlitdoorOpened(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.PMA:
                    return PMASlitDoorOpened;
                case ModuleName.PMB:
                    return PMBSlitDoorOpened;
                case ModuleName.PMC:
                    return PMCSlitDoorOpened;
                case ModuleName.PMD:
                    return PMDSlitDoorOpened;
            }
            return false;
        }

        public bool IsPMSlitdoorClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.PMA:
                    return PMASlitDoorClosed;
                case ModuleName.PMB:
                    return PMBSlitDoorClosed;
                case ModuleName.PMC:
                    return PMCSlitDoorClosed;
                case ModuleName.PMD:
                    return PMDSlitDoorClosed;
            }
            return false;
        }

        public bool TurnExhaustValve(ModuleName mod, bool bOn)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    _TMVentExhaustValve.TurnValve(bOn, out _);
                    return true;
                case ModuleName.LLA:
                    _LLAVentExhaustValve.TurnValve(bOn, out _);
                    return true;
                case ModuleName.LLB:
                    _LLBVentExhaustValve.TurnValve(bOn, out _);
                    return true;
                default:
                    return false;
            }
        }
        public bool CheckLidClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    if (!TMLidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, "TM Lid not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLA:
                    if (!LLALidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLA, "LLA Lid not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLB:
                    if (!LLBLidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLB, "LLB Lid not closed");
                        return false;
                    }
                    break;
                case ModuleName.PMA:
                    if (!PMALidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.PMA, "PMA Lid not closed");
                        return false;
                    }
                    break;
                case ModuleName.PMB:
                    if (!PMBLidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.PMB, "PMB Lid not closed");
                        return false;
                    }
                    break;
                case ModuleName.PMC:
                    if (!PMCLidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.PMC, "PMC Lid not closed");
                        return false;
                    }
                    break;
                case ModuleName.PMD:
                    if (!PMDLidClosed)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.PMD, "PMD Lid not closed");
                        return false;
                    }
                    break;
            }

            return true;
        }

        public bool CheckVentValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    if (IsTMVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, "TM Vent Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLA:
                    if (IsLLAVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLA, "LLA Vent Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLB:
                    if (IsLLBVentValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLB, "LLB Vent Valve not closed");
                        return false;
                    }
                    break;
            }

            return true;
        }

        public bool CheckPurgeValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    if (IsTMPurgeValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, "TM Purge Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLA:
                    if (IsLLAPurgeValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLA, "LLA Purge Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLB:
                    if (IsLLBPurgeValveOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLB, "LLB Purge Valve not closed");
                        return false;
                    }
                    break;
            }

            return true;
        }

        public bool CheckPumpValveClosed(ModuleName mod)
        {
            switch (mod)
            {
                case ModuleName.TM:
                    if (IsTMFastPumpOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, "TM Fast Pump Valve not closed");
                        return false;
                    }
                    else if (IsTMSoftPumpOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.TM, "TM Soft Pump Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLA:
                    if (IsLLAFastPumpOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLA, "LLA Fast Pump Valve not closed");
                        return false;
                    }
                    else if (IsLLASoftPumpOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLA, "LLA Soft Pump Valve not closed");
                        return false;
                    }
                    break;
                case ModuleName.LLB:
                    if (IsLLBFastPumpOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLB, "LLB Fast Pump Valve not closed");
                        return false;
                    }
                    else if (IsLLBSoftPumpOpen)
                    {
                        LOG.Write(eEvent.ERR_TM, ModuleName.LLB, "LLB Soft Pump Valve not closed");
                        return false;
                    }
                    break;
            }

            return true;
        }
        //private bool CheckRobotNotExtendSensor(ModuleName ll, bool open, bool bTMDoor, out string reason)
        //{
        //    string action = open ? "Open" : "Close";
        //    string doorName = bTMDoor ? "TM" : "EFEM";
        //    if (ll == ModuleName.LLA)
        //    {
        //        if (!_TMRobotNotExtendLLA.Value)
        //        {
        //            reason = $"TM Robot Not Extend to {ll} is false, can not {action} {doorName} slit door";
        //            LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
        //            return false;
        //        }

        //        if (!_EfemRobotNotExtendLLA.Value)
        //        {
        //            reason = $"EFEM Robot Not Extend to {ll} is false, can not {action} {doorName} slit door";
        //            LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
        //            return false;
        //        }
        //    }
        //    else
        //    {
        //        if (!_TMRobotNotExtendLLB.Value)
        //        {
        //            reason = $"TM Robot Not Extend to {ll} is false, can not {action} {doorName} slit door";
        //            LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
        //            return false;
        //        }

        //        if (!_EfemRobotNotExtendLLB.Value)
        //        {
        //            reason = $"EFEM Robot Not Extend to {ll} is false, can not {action} {doorName} slit door";
        //            LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
        //            return false;
        //        }
        //    }

        //    reason = "";
        //    return true;
        //}
        public bool TurnMFSlitDoor(ModuleName moduleName, bool open, out string reason)
        {
            //if (!CheckRobotNotExtendSensor(loadlock, open, true, out reason))

            //    return false;

            if (open)
            {
                if (RouteManager.IsATMMode)
                {
                    if (!IsTMATM)
                    {
                        reason = $"TM is not ATM, can not open slit door";
                        LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
                        return false;
                    }

                    if (!IsModuleATM(moduleName))
                    {
                        reason = $"{moduleName} is not ATM, can not open slit door";
                        LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
                        return false;
                    }
                }
                else
                {
                    if (!IsModuleVaccum(moduleName))
                    {
                        reason = $"{moduleName} is notVacuum, can not open slit door";
                        LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
                        return false;
                    }
                    double maxPressureDifference;
                    switch (moduleName)
                    {
                        case ModuleName.LLA:
                        case ModuleName.LLB:
                            maxPressureDifference = SC.GetValue<double>("System.TMLLMaxPressureDifference");
                            break;
                        case ModuleName.PMA:
                        case ModuleName.PMB:
                        case ModuleName.PMC:
                        case ModuleName.PMD:
                            maxPressureDifference = SC.GetValue<double>("System.PMTMMaxPressureDifference");
                            break;
                        default:
                            maxPressureDifference = SC.GetValue<double>("System.PMTMMaxPressureDifference");
                            break;
                    }
                    if (Math.Abs(GetModulePressure(moduleName) - GetModulePressure(ModuleName.TM)) > maxPressureDifference)
                    {
                        reason = $"{moduleName}:{GetModulePressure(moduleName)} and TM : {GetModulePressure(ModuleName.TM)} pressure difference exceeds the max limit {maxPressureDifference}";
                        LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
                        return false;
                    }
                }

            }

            switch (moduleName)
            {
                case ModuleName.LLA:
                    return _LLATSlitDoor.SetCylinder(open, out reason);
                case ModuleName.LLB:
                    return _LLBTSlitDoor.SetCylinder(open, out reason);
                case ModuleName.PMA:
                    return _PMASlitDoor.SetCylinder(open, out reason);
                case ModuleName.PMB:
                    return _PMBSlitDoor.SetCylinder(open, out reason);
                case ModuleName.PMC:
                    return _PMCSlitDoor.SetCylinder(open, out reason);
                case ModuleName.PMD:
                    return _PMDSlitDoor.SetCylinder(open, out reason);

            }

            reason = $"Invalid module {moduleName}";
            LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
            return false;
        }

        public bool TurnEFEMSlitDoor(ModuleName loadlock, bool open, out string reason)
        {
            //if (!CheckRobotNotExtendSensor(loadlock, open, false, out reason))

            //    return false;

            if (open && !IsModuleATM(loadlock))
            {
                reason = $"{loadlock} is not ATM, can not open EFEM side slit door";
                LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
                return false;
            }

            switch (loadlock)
            {
                case ModuleName.LLA:
                    return _LLAESlitDoor.SetCylinder(open, out reason);
                case ModuleName.LLB:
                    return _LLBESlitDoor.SetCylinder(open, out reason);

            }

            reason = $"Invalid module {loadlock}";
            LOG.Write(eEvent.ERR_DEVICE_INFO, Module, reason);
            return false;
        }
        //public bool ControlTMPump(bool ison)
        //{
        //    _TMPump.SetPumpOnOff(ison);
        //    return true;
        //}
        public void SwitchTMPressureMode(bool isPressureMode)
        {
            if (isPressureMode == true)
            {
                _TM_PressureMode_Switch.TurnOn();
            }
            else
            {
                _TM_PressureMode_Switch.TurnOff();
            }
        }
        public void SwitchLLAPressureMode(bool isPressureMode)
        {
            if (isPressureMode == true)
            {
                _LLA_PressureMode_Switch.TurnOn();
            }
            else
            {
                _LLA_PressureMode_Switch.TurnOff();
            }
        }

        public void SwitchLLBPressureMode(bool isPressureMode)
        {
            if (isPressureMode == true)
            {
                _LLB_PressureMode_Switch.TurnOn();
            }
            else
            {
                _LLB_PressureMode_Switch.TurnOff();
            }
        }
        public void SetTMPressure(int pressureValue)
        {
            _presureCtrl.SetTMPressure(pressureValue);
        }
        public void SetLLAPressure(int pressureValue)
        {
            _presureCtrl.SetLLAPressure(pressureValue);
        }
        public void SetLLBPressure(int pressureValue)
        {
            _presureCtrl.SetLLBPressure(pressureValue);
        }
        public void SetTMFlow(int flowValue)
        {
            SwitchTMPressureMode(false);
            _TMMfc.SetPoint = (flowValue);
        }
        public void SetLLAFlow(double flowValue)
        {
            SwitchLLAPressureMode(false);
            _LLAMfc.SetPoint = (flowValue);
        }
        public void SetLLBFlow(double flowValue)
        {
            SwitchLLBPressureMode(false);
            _LLBMfc.SetPoint = (flowValue);
        }
        public bool CloseAllSlitDoor()
        {

            TurnMFSlitDoor(ModuleName.LLA, false, out _);
            TurnMFSlitDoor(ModuleName.LLB, false, out _);
            TurnMFSlitDoor(ModuleName.PMA, false, out _);
            TurnMFSlitDoor(ModuleName.PMB, false, out _);
            TurnMFSlitDoor(ModuleName.PMC, false, out _);
            TurnMFSlitDoor(ModuleName.PMD, false, out _);

            return true;
        }
        public bool TurnTMPump(bool ison)
        {
            _TMPump.SetPumpOnOff(ison);
            return true;
        }

        public bool TryGetLLPump(ModuleName LLname)
        {
            //Self
            if ((LLname == ModuleName.LLA && _llPumpingState == LLPumpState.LLAUsing) || (LLname == ModuleName.LLB && _llPumpingState == LLPumpState.LLBUsing))
                return true;

            //Idle
            if (LLname == ModuleName.LLA && !IsLLBFastPumpOpen && !IsLLBSoftPumpOpen && _llPumpingState == LLPumpState.Idle)
            {
                _llPumpingState = LLPumpState.LLAUsing;
                return true;
            }

            if (LLname == ModuleName.LLB && !IsLLAFastPumpOpen && !IsLLASoftPumpOpen && _llPumpingState == LLPumpState.Idle)
            {
                _llPumpingState = LLPumpState.LLBUsing;
                return true;
            }

            //LOG.Write(eEvent.WARN_DEFAULT_WARN, LLname, "无法打开，另一个泵正在用！");
            //locked
            return false;
        }

        public void ReleasePump(ModuleName Module)
        {
            //release pump (must do it by user)
            if ((Module == ModuleName.LLA && _llPumpingState == LLPumpState.LLAUsing) || (Module == ModuleName.LLB && _llPumpingState == LLPumpState.LLBUsing))
                _llPumpingState = LLPumpState.Idle;
        }
        public void HomeSlitDoor()
        {
            if (IsLLASlitDoorClosed == true)
            {
                _LLATSlitDoor.SetCylinder(false, out _);
            }
            else if (IsLLASlitDoorOpen == true)
            {
                _LLATSlitDoor.SetCylinder(true, out _);
            }

            if (IsLLBSlitDoorClosed == true)
            {
                _LLBTSlitDoor.SetCylinder(false, out _);
            }
            else if (IsLLBSlitDoorOpen == true)
            {
                _LLBTSlitDoor.SetCylinder(true, out _);
            }

            if (IsLLAESlitDoorClosed == true)
            {
                _LLAESlitDoor.SetCylinder(false, out _);
            }
            else if (IsLLAESlitDoorOpen == true)
            {
                _LLAESlitDoor.SetCylinder(true, out _);
            }

            if (IsLLBESlitDoorClosed == true)
            {
                _LLBESlitDoor.SetCylinder(false, out _);
            }
            else if (IsLLBESlitDoorOpen == true)
            {
                _LLBESlitDoor.SetCylinder(true, out _);
            }
        }

        public bool CheckPumpIsRunning(ModuleName moduleName)
        {
            switch (moduleName)
            {
                case ModuleName.LLA:
                    return LLAPumpIsRunning;
                case ModuleName.LLB:
                    return LLBPumpIsRunning;
                case ModuleName.TM:
                    return TMPumpIsRunning;

                default:
                    return false;
            }
        }

        public bool LLDoorAllClosed(ModuleName moduleName)
        {
            if (moduleName == ModuleName.LLA)
            {
                return IsLLASlitDoorClosed && IsLLAESlitDoorClosed;
            }
            else if (moduleName == ModuleName.LLB)
            {
                return IsLLBSlitDoorClosed && IsLLBESlitDoorClosed;
            }
            return false;
        }


        public bool TMRobotNotExtendModule(ModuleName moduleName)
        {
            switch (moduleName)
            {
                case ModuleName.PMA:
                    return TMRobotNotExtendToPMA;
                case ModuleName.PMB:
                    return TMRobotNotExtendToPMB;
                case ModuleName.PMC:
                    return TMRobotNotExtendToPMC;
                case ModuleName.PMD:
                    return TMRobotNotExtendToPMD;
                case ModuleName.LLA:
                    return TMRobotNotExtendToLLA;
                case ModuleName.LLB:
                    return TMRobotNotExtendToLLB;
                default: return false;
            }
        }
        public bool EFEMRobotNotExtendModule(ModuleName moduleName)
        {
            switch (moduleName)
            {
                case ModuleName.LLA:
                    return EfemRobotNotExtendToLLA;
                case ModuleName.LLB:
                    return EfemRobotNotExtendToLLB;
                default: return false;
            }
        }
    }
}