JET-EFEM/athos/athosRT/Devices/LoadLockDevice.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using athosRT.Modules.EFEMs;
using athosRT.tool;

namespace athosRT.Devices
{
    public class LoadLockDevice : BaseDevice, IDevice
    {
        private IoSensor _sensorDoorOpen;
        private IoSensor _sensorArmExtendEnable;
        private IoTrigger _triggerSafetytoPM;
        private IoTrigger _triggerRBNotExtendPM;
        private static DOAccessor _openAtmDoorSignal;
        private static DOAccessor _closeAtmDoorSignal;
        private static DIAccessor _openAtmDoorFeedback;
        private static DIAccessor _closeAtmDoorFeedback;
        private static DOAccessor _openVtmDoorSignal;
        private static DOAccessor _closeVtmDoorSignal;
        private static DIAccessor _openVtmDoorFeedback;
        private static DIAccessor _closeVtmDoorFeedback;
        private bool _isDoorControledByStation;
        private static RD_TRIG atmDoorTrig = new RD_TRIG();
        private static RD_TRIG vtmDoorTrig = new RD_TRIG();
        private static LoadLockDoorState atmDoorState = LoadLockDoorState.Unknown;
        private static LoadLockDoorState vtmDoorState = LoadLockDoorState.Unknown;
        private static bool isIdle;
        private static bool isSimulator = SC.GetValue<bool>("System.IsSimulatorMode");
        private static bool isDoorAlwaysOpen = SC.GetValue<bool>("System.IsLoadLockDoorAlwaysOpen");

        public bool IsDoorOpen => !this._sensorDoorOpen.Value && this._sensorArmExtendEnable.Value;

        public static bool IsDoorOpenedByStation => LoadLockDevice._openAtmDoorFeedback.Value && !LoadLockDevice._closeAtmDoorFeedback.Value;

        public static bool IsDoorClosedByStation => LoadLockDevice._closeAtmDoorFeedback.Value && !LoadLockDevice._openAtmDoorFeedback.Value;

        public static bool IsOuterDoorOpenedByStation => LoadLockDevice._openVtmDoorFeedback.Value && !LoadLockDevice._closeVtmDoorFeedback.Value;

        public static bool IsOuterDoorClosedByStation => LoadLockDevice._closeVtmDoorFeedback.Value && !LoadLockDevice._openVtmDoorFeedback.Value;

        public static bool IsIdle => LoadLockDevice.isIdle;

        public static RD_TRIG AtmDoorTrig => LoadLockDevice.atmDoorTrig;

        public static RD_TRIG VtmDoorTrig => LoadLockDevice.vtmDoorTrig;

        public static LoadLockDoorState LoadLockAtmDoorState
        {
            get
            {
                if (LoadLockDevice.isDoorAlwaysOpen)
                    return LoadLockDoorState.Opened;
                if (LoadLockDevice.isSimulator)
                {
                    if (LoadLockDevice._openAtmDoorSignal != null && LoadLockDevice._openAtmDoorSignal.Value && LoadLockDevice._closeAtmDoorSignal != null && !LoadLockDevice._closeAtmDoorSignal.Value)
                        return LoadLockDoorState.Opened;
                    return LoadLockDevice._closeAtmDoorSignal != null && LoadLockDevice._closeAtmDoorSignal.Value && LoadLockDevice._openAtmDoorSignal != null && !LoadLockDevice._openAtmDoorSignal.Value ? LoadLockDoorState.Closed : LoadLockDoorState.Unknown;
                }
                if (LoadLockDevice._openAtmDoorFeedback != null && LoadLockDevice._openAtmDoorFeedback.Value && LoadLockDevice._closeAtmDoorFeedback != null && !LoadLockDevice._closeAtmDoorFeedback.Value)
                    return LoadLockDoorState.Opened;
                return LoadLockDevice._closeAtmDoorFeedback != null && LoadLockDevice._closeAtmDoorFeedback.Value && LoadLockDevice._openAtmDoorFeedback != null && !LoadLockDevice._openAtmDoorFeedback.Value ? LoadLockDoorState.Closed : LoadLockDoorState.Unknown;
            }
        }
        public LoadLockDevice() { }

        public static LoadLockDoorState LoadLockVtmDoorState
        {
            get
            {
                if (LoadLockDevice.isDoorAlwaysOpen)
                    return LoadLockDoorState.Opened;
                if (LoadLockDevice.isSimulator)
                {
                    if (LoadLockDevice._openVtmDoorSignal != null && LoadLockDevice._openVtmDoorSignal.Value && LoadLockDevice._closeVtmDoorSignal != null && !LoadLockDevice._closeVtmDoorSignal.Value)
                        return LoadLockDoorState.Opened;
                    return LoadLockDevice._closeVtmDoorSignal != null && LoadLockDevice._closeVtmDoorSignal.Value && LoadLockDevice._openVtmDoorSignal != null && !LoadLockDevice._openVtmDoorSignal.Value ? LoadLockDoorState.Closed : LoadLockDoorState.Unknown;
                }
                if (LoadLockDevice._openVtmDoorFeedback != null && LoadLockDevice._openVtmDoorFeedback.Value && LoadLockDevice._closeVtmDoorFeedback != null && !LoadLockDevice._closeVtmDoorFeedback.Value)
                    return LoadLockDoorState.Opened;
                return LoadLockDevice._closeVtmDoorFeedback != null && LoadLockDevice._closeVtmDoorFeedback.Value && LoadLockDevice._openVtmDoorFeedback != null && !LoadLockDevice._openVtmDoorFeedback.Value ? LoadLockDoorState.Closed : LoadLockDoorState.Unknown;
            }
        }

        public LoadLockDevice(
          string module,
          string name,
          int slotNumber,
          IoSensor sensorDoorOpen,
          IoSensor sensorArmExtendEnable,
          DOAccessor openAtmDoorSignal,
          DOAccessor closeAtmDoorSignal,
          DIAccessor openAtmDoorFeedback,
          DIAccessor closeAtmDoorFeedback,
          DOAccessor openVtmDoorSignal,
          DOAccessor closeVtmDoorSignal,
          DIAccessor openVtmDoorFeedback,
          DIAccessor closeVtmDoorFeedback)
        {
            this.Module = module;
            this.Name = name;
            this._sensorDoorOpen = sensorDoorOpen;
            this._sensorArmExtendEnable = sensorArmExtendEnable;
            LoadLockDevice._openAtmDoorSignal = openAtmDoorSignal;
            LoadLockDevice._closeAtmDoorSignal = closeAtmDoorSignal;
            LoadLockDevice._openAtmDoorFeedback = openAtmDoorFeedback;
            LoadLockDevice._closeAtmDoorFeedback = closeAtmDoorFeedback;
            LoadLockDevice._openVtmDoorSignal = openVtmDoorSignal;
            LoadLockDevice._closeVtmDoorSignal = closeVtmDoorSignal;
            LoadLockDevice._openVtmDoorFeedback = openVtmDoorFeedback;
            LoadLockDevice._closeVtmDoorFeedback = closeVtmDoorFeedback;
            Singleton<WaferManager>.Instance.SubscribeLocation(name, slotNumber);
            this._isDoorControledByStation = true;
        }

        public LoadLockDevice(
          string module,
          string name,
          int slotNumber,
          IoSensor sensorDoorOpen,
          IoSensor sensorArmExtendEnable,
          IoTrigger triggerSafetytoPM,
          IoTrigger triggerRBNotExtendPM)
        {
            this.Module = module;
            this.Name = name;
            this._sensorDoorOpen = sensorDoorOpen;
            this._sensorArmExtendEnable = sensorArmExtendEnable;
            this._triggerRBNotExtendPM = triggerRBNotExtendPM;
            this._triggerSafetytoPM = triggerSafetytoPM;
            Singleton<WaferManager>.Instance.SubscribeLocation(name, slotNumber);
            this._isDoorControledByStation = false;
        }

        public bool Initialize()
        {
            LoadLockDevice.isIdle = true;
            DATA.Subscribe(this.Name + ".WaferSize", (Func<object>)(() => (object)Singleton<WaferManager>.Instance.GetWafer(ModuleHelper.Converter(this.Name), 0).Size.ToString()), SubscriptionAttribute.FLAG.SaveDB);
            return true;
        }

        public void Monitor()
        {
            LoadLockDevice.atmDoorTrig.CLK = LoadLockDevice.LoadLockAtmDoorState == LoadLockDoorState.Closed;
            LoadLockDevice.vtmDoorTrig.CLK = LoadLockDevice.LoadLockVtmDoorState == LoadLockDoorState.Closed;
            //if (!LoadLockDevice.atmDoorTrig.R && !LoadLockDevice.atmDoorTrig.T && !LoadLockDevice.vtmDoorTrig.R && !LoadLockDevice.vtmDoorTrig.T || !Singleton<DeviceDefineManager>.Instance.GetValue<bool>("LLDoorControlByStation").GetValueOrDefault() || !Singleton<EfemEntity>.Instance.IsOnlineMode)
            //    return;
            //Singleton<EfemEntity>.Instance.SendSigStatEvent(ModuleName.LL1);
        }

        public void Terminate()
        {
        }

        public void Reset()
        {
        }

        public static bool OpenAtmDoor(out string reason)
        {
            LoadLockDevice.isIdle = false;
            reason = string.Empty;
            EV.PostInfoLog(GetName.GetCurrentName(), "LoadLock", "Open Atm Door");
            if (LoadLockDevice._openAtmDoorSignal.Value && !LoadLockDevice._closeAtmDoorSignal.Value)
            {
                reason = "Atm door opened, can't open again";
                LoadLockDevice.isIdle = true;
                return true;
            }
            string reason1;
            LoadLockDevice._closeAtmDoorSignal.SetValue(false, out reason1);
            LoadLockDevice._openAtmDoorSignal.SetValue(true, out reason1);
            LoadLockDevice.isIdle = true;
            return true;
        }

        public static bool CloseAtmDoor(out string reason)
        {
            LoadLockDevice.isIdle = false;
            reason = string.Empty;
            EV.PostInfoLog(GetName.GetCurrentName(), "LoadLock", "Close Atm Door");
            if (LoadLockDevice._closeAtmDoorSignal.Value && !LoadLockDevice._openAtmDoorSignal.Value)
            {
                reason = "Atm door closed, can't open again";
                LoadLockDevice.isIdle = true;
                return true;
            }
            string reason1;
            LoadLockDevice._openAtmDoorSignal.SetValue(false, out reason1);
            LoadLockDevice._closeAtmDoorSignal.SetValue(true, out reason1);
            LoadLockDevice.isIdle = true;
            return true;
        }

        public static bool OpenVtmDoor(out string reason)
        {
            LoadLockDevice.isIdle = false;
            reason = string.Empty;
            EV.PostInfoLog(GetName.GetCurrentName(), "LoadLock", "Open Vtm Door");
            if (LoadLockDevice._openVtmDoorSignal.Value && !LoadLockDevice._closeVtmDoorSignal.Value)
            {
                reason = "Vtm door opened, can't open again";
                LoadLockDevice.isIdle = true;
                return true;
            }
            string reason1;
            LoadLockDevice._closeVtmDoorSignal.SetValue(false, out reason1);
            LoadLockDevice._openVtmDoorSignal.SetValue(true, out reason1);
            LoadLockDevice.isIdle = true;
            return true;
        }

        public static bool CloseVtmDoor(out string reason)
        {
            LoadLockDevice.isIdle = false;
            reason = string.Empty;
            EV.PostInfoLog(GetName.GetCurrentName(), "LoadLock", "Close Vtm Door");
            if (LoadLockDevice._closeVtmDoorSignal.Value && !LoadLockDevice._openVtmDoorSignal.Value)
            {
                reason = "Vtm door closed, can't open again";
                LoadLockDevice.isIdle = true;
                return true;
            }
            string reason1;
            LoadLockDevice._openVtmDoorSignal.SetValue(false, out reason1);
            LoadLockDevice._closeVtmDoorSignal.SetValue(true, out reason1);
            LoadLockDevice.isIdle = true;
            return true;
        }

        public void SafeytoPm(bool value)
        {
            LoadLockDevice.isIdle = false;
            EV.PostInfoLog(GetName.GetCurrentName(), "LoadLock", string.Format("set SafeytoPm{0}", (object)value));
            this._triggerSafetytoPM.SetTrigger(value, out string _);
            LoadLockDevice.isIdle = true;
        }

        public void NotExtendtoPm(bool value)
        {
            LoadLockDevice.isIdle = false;
            EV.PostInfoLog(GetName.GetCurrentName(), "LoadLock", string.Format("set NotExtendtoPm {0}", (object)value));
            this._triggerSafetytoPM.SetTrigger(value, out string _);
            LoadLockDevice.isIdle = true;
        }

        public bool IsEnableTransferWafer(out string reason)
        {
            reason = string.Empty;
            if (this._isDoorControledByStation)
                return LoadLockDevice.LoadLockAtmDoorState == LoadLockDoorState.Opened;
            if (!LoadLockDevice.isDoorAlwaysOpen && this._sensorDoorOpen != null && !this._sensorDoorOpen.Value)
            {
                reason = this.Name + " is not ready for transfer";
                return false;
            }
            reason = "";
            return true;
        }
    }
}