FurnaceELK/Furnace/FurnaceRT/Equipments/PMs/PMN2Purge.cs

using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
using FurnaceRT.Devices;
using FurnaceRT.Equipments.PMs.Devices;
using FurnaceRT.Extraction;
using MECF.Framework.Common.CommonData.SorterDefines;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Tolerance;
using MECF.Framework.Common.Utilities;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.TDK;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace FurnaceRT.Equipments.PMs
{
    /// <summary>
    /// 分布类 定义N2Purge的执行逻辑
    /// </summary>
    public partial class PMModule
    {
        private R_TRIG _trigN2UpRD = new R_TRIG();
        private R_TRIG _trigN2DownRD = new R_TRIG();
        private R_TRIG _trigN2AirUpRD = new R_TRIG();
        private R_TRIG _trigN2AirDownRD = new R_TRIG();
        private R_TRIG _trigN2AirDownTwoRD = new R_TRIG();
        private R_TRIG _trigSelectN2PurgeModeD = new R_TRIG();
        private FilterChecker _filterChecker = new FilterChecker();
        private R_TRIG tank1_TRIG = new R_TRIG();
        private R_TRIG tank2_TRIG = new R_TRIG();
        private Dictionary<string, Tuple<R_TRIG, List<Tuple<IDevice, string>>>> _n2PurgeSequenceAction;
        private Dictionary<string, Func<bool>> _n2PurgeSequenceStatus;
        private Dictionary<string, R_TRIG> _rTrigDict;
        private N2PurgeModeEnum _N2PurgeMode = N2PurgeModeEnum.Auto;
        private double _n2PurgeData = 20;
        private double _n2ToAirData = 185000;
        private N2PurgeModeEnum _currentPhase;
        private double _manualPhase2StabilityTime = 0;
        private double _manualPhase4StabilityTime = 0;

        private bool _enableAbortN2purge = true;

        private int _phase1CycleCount = 0;
        private int _phase1CycleCountSC = 0;
        private bool _canSwitchToPhase2 = true;

        private Dictionary<string, Stopwatch> _allTimeDict = new Dictionary<string, Stopwatch>();
        private void InitN2PurgeData()
        {
            DATA.Subscribe($"{Module}.N2PurgeLimitData", () => GetN2PurgeLimitData());
            DATA.Subscribe($"{Module}.O2DensityData", () => ConcentrationO2.Value.ToString("f3"), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.CheckO2Location", () => GetCheckO2Location(), SubscriptionAttribute.FLAG.IgnoreSaveDB);
            DATA.Subscribe($"{Module}.O2SetCheckSetPoint", () => GetO2SetCheckSetPoint(), SubscriptionAttribute.FLAG.IgnoreSaveDB);

            DATA.Subscribe($"{Module}.N2PurgeMode", () => SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : "");




            var selectN2PurgeMode = SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : "";
            if (!string.IsNullOrEmpty(selectN2PurgeMode))
            {
                if (selectN2PurgeMode != _N2PurgeMode.ToString())
                {
                    SetN2PurgeModeAction(selectN2PurgeMode);
                }
            }

            var currentPhase = SC.ContainsItem("PM1.SelectN2PurgeModePhase") ? SC.GetStringValue("PM1.SelectN2PurgeModePhase") : "";
            if (!string.IsNullOrEmpty(currentPhase))
            {
                var enumCurrentPhase = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), currentPhase);
                _currentPhase = enumCurrentPhase;
            }
        }

        private void InitN2PurgeConfigData()
        {
            _n2PurgeData = SC.ContainsItem($"System.N2PurgeData") ? SC.GetValue<double>("System.N2PurgeData") : 20;
            _n2ToAirData = SC.ContainsItem($"System.N2PurgeData") ? SC.GetValue<double>("System.N2ToAirData") : 185000;

            _enableAbortN2purge = SC.ContainsItem($"PM1.N2Purge.EnableAbortN2purge") ? SC.GetValue<bool>("PM1.N2Purge.EnableAbortN2purge") : false;

            _manualPhase2StabilityTime = SC.ContainsItem($"PM1.N2Purge.Manual_phase2.StabilityTime") ? SC.GetValue<double>("PM1.N2Purge.Manual_phase2.StabilityTime") : 0;
            _manualPhase4StabilityTime = SC.ContainsItem($"PM1.N2Purge.Manual_phase4.StabilityTime") ? SC.GetValue<double>("PM1.N2Purge.Manual_phase4.StabilityTime") : 0;

            _phase1CycleCountSC = SC.ContainsItem($"PM1.N2Purge.Manual_phase1.CycleCount") ? SC.GetValue<int>("PM1.N2Purge.Manual_phase1.CycleCount") : 0;


            _n2PurgeSequenceAction = ExtractionMethods.GetN2PurgeSequenceAction();
            _n2PurgeSequenceStatus = new Dictionary<string, Func<bool>>()
            {
                {"N2PurgeAIRTo20PPM",()=> GetN2PurgeAIRTo20PPMStatus()},
                {"N2PurgeUnder20PPM",()=> GetN2PurgeUnder20PPMStatus()},
                {"AIR",()=> GetN2PurgeAIRStatus()},
                {"DoorOpen",()=> GetN2PurgeDoorOpenStatus()},
                {"Foup1",()=> GetN2PurgeFoup1Status()},
                {"Foup2",()=> GetN2PurgeFoup2Status()},

                {N2PurgeModeEnum.Manual_phase1.ToString(),()=>  CheckN2PurgePhase1() },
                {N2PurgeModeEnum.Manual_phase2.ToString(),()=>  CheckN2PurgePhase2()},
                {N2PurgeModeEnum.Manual_phase3.ToString(),()=>  CheckN2PurgePhase3() },
                {N2PurgeModeEnum.Manual_phase4.ToString(),()=>  CheckN2PurgePhase4() },
                {N2PurgeModeEnum.Manual_phase5.ToString(),()=>  CheckN2PurgePhase5() },

            };
            _allTimeDict = new Dictionary<string, Stopwatch>()
            {
                {N2PurgeModeEnum.Manual_phase1.ToString(),new Stopwatch() },
                {N2PurgeModeEnum.Manual_phase2.ToString(),new Stopwatch()},
                {N2PurgeModeEnum.Manual_phase3.ToString(),new Stopwatch()},
                {N2PurgeModeEnum.Manual_phase4.ToString(),new Stopwatch() },
                {N2PurgeModeEnum.Manual_phase5.ToString(),new Stopwatch() }
            };
            _rTrigDict = new Dictionary<string, R_TRIG>();
        }

        private void MonitorN2Purge()
        {
            var selectN2PurgeMode = SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : "";
            if (string.IsNullOrEmpty(selectN2PurgeMode))
            {
                return;
            }
            SetN2PurgeModeAction(selectN2PurgeMode);
        }
        private void MonitorTank1LeakAgeExec()
        {

            tank1_TRIG.CLK = SensorHCDTANKH != null && SensorHCDTANKH.Value;
            if (tank1_TRIG.Q)
            {
                SetHREFEnable(new object[1] { false });
                ValveAV113?.TurnValve(false, out _);

            }

        }

        public bool SetHREFEnable(object[] param)
        {
            if (param == null || param.Length <= 0)
                return true;

            bool.TryParse(param[0].ToString(), out bool isEnable);

            if (isEnable)
            {
                if (SensorHREFILK != null && SensorHREFILK.Value)
                {
                    TrigSIREFON?.CheckAndSet(isEnable, out _);

                }
            }
            else
            {
                TrigSIREFON?.CheckAndSet(isEnable, out _);
            }
            return true;
        }
        private void MonitorTank2LeakAgeExec()
        {

            tank2_TRIG.CLK = SensorCSOURCETANKH != null && SensorCSOURCETANKH.Value;
            if (tank2_TRIG.Q)
            {
                SetCREFEnable(new object[1] { false });
                ValveAV121?.TurnValve(false, out _);

            }

        }
        public bool SetCREFEnable(object[] param)
        {
            if (param == null || param.Length <= 0)
                return true;

            bool.TryParse(param[0].ToString(), out bool isEnable);
            if (isEnable)
            {
                if (SensorCREFILK != null && SensorCREFILK.Value)
                {
                    TrigCREFON?.CheckAndSet(isEnable, out _);

                }
            }
            else
            {
                TrigCREFON?.CheckAndSet(isEnable, out _);
            }
            return true;
        }
        /// <summary>
        /// TODO:这里展示数据的逻辑 不正确，待明确逻辑
        /// </summary>
        /// <returns></returns>
        private double GetN2PurgeLimitData()
        {
            if (_N2PurgeMode == N2PurgeModeEnum.N2PurgeMode)
            {
                if ((SensorO2DetectSideFIMS1 != null && SensorO2DetectSideFIMS1.Value) || (SensorO2DetectSideFIMS2 != null && SensorO2DetectSideFIMS2.Value))
                {
                    return (float)SC.GetValue<double>("PM1.N2Purge.N2PurgeFOUPO2CheckSV");

                }
                return _n2PurgeData;
            }
            if (_N2PurgeMode == N2PurgeModeEnum.ATMMode)
            {
                return _n2ToAirData;
            }

            return ConcentrationO2.Value;
        }
        private void SetN2PurgeModeAction(string selectN2PurgeMode)
        {

            _N2PurgeMode = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), selectN2PurgeMode);

            if (_N2PurgeMode == N2PurgeModeEnum.N2PurgeMode)
            {
                if (_currentPhase == N2PurgeModeEnum.Manual_phase1)
                {
                    _filterChecker.CheckInterval = 3;
                    _filterChecker.Monitor(CheckN2PurgePhase2());

                    if (_filterChecker.Trig && _canSwitchToPhase2)
                    {
                        LOG.Info($" N2PurgeMode Trigger from Manual_phase1 to Manual_phase2,O2：{ConcentrationO2.Value}");
                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase2.ToString());
                    }
                }
                else if (_currentPhase == N2PurgeModeEnum.Manual_phase2)
                {
                    if (!_allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].IsRunning && _canSwitchToPhase2)
                    {
                        _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Restart();
                    }
                    var second = _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Elapsed.TotalSeconds;
                    if (second >= _manualPhase2StabilityTime)
                    {
                        if (CheckN2PurgePhase1())
                        {
                            LOG.Info($"N2PurgeMode Trigger Manual_phase1 was triggered {second} seconds later,O2：{ConcentrationO2.Value}");
                            N2PurgeFaileAlarm.Set();

                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Restart();
                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Stop();
                            _canSwitchToPhase2 = false;

                            SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase1.ToString());

                        }
                        if (CheckN2PurgePhase2())
                        {
                            LOG.Info($"N2PurgeMode Trigger Hold Manual_phase2 was triggered {second} seconds later,O2：{ConcentrationO2.Value}");
                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Restart();
                            _allTimeDict[N2PurgeModeEnum.Manual_phase2.ToString()].Stop();
                            _canSwitchToPhase2 = false;
                        }
                    }

                }
                else
                {
                    if (CheckN2PurgePhase1())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase1,O2：{ConcentrationO2.Value}");
                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase1.ToString());
                    }
                    else if (CheckN2PurgePhase2())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase2,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase2.ToString());

                    }
                }
            }
            if (_N2PurgeMode == N2PurgeModeEnum.ATMMode)
            {

                if (_currentPhase == N2PurgeModeEnum.Manual_phase3)
                {
                    var checkResult = CheckN2PurgePhase4();

                    if (!_allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].IsRunning)
                    {
                        _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Restart();
                    }
                    var second = _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Elapsed.TotalSeconds;

                    if (second >= _manualPhase4StabilityTime && checkResult)
                    {
                        LOG.Info($"N2PurgeMode Trigger from  Manual_phase3 to Manual_phase4 is triggered {second} seconds later,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase4.ToString());
                        _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Restart();
                        _allTimeDict[N2PurgeModeEnum.Manual_phase4.ToString()].Stop();
                    }

                }
                else if (_currentPhase == N2PurgeModeEnum.Manual_phase4)
                {
                    if (CheckN2PurgePhase5())
                    {
                        LOG.Info($"N2PurgeMode Trigger from Manual_phase4 to Manual_phase5,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase5.ToString());
                    }
                    //if (CheckN2PurgePhase3( ))
                    //{
                    //    LOG.Info($"N2PurgeMode Trigger from Manual_phase4 to Manual_phase3,O2：{o2Value}");

                    //    SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase3.ToString());
                    //}

                }
                else if (_currentPhase == N2PurgeModeEnum.Manual_phase5)
                {
                    if (CheckN2PurgePhase4())
                    {
                        LOG.Info($"N2PurgeMode Trigger from Manual_phase5 to Manual_phase4,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase4.ToString());
                    }
                    //if (CheckN2PurgePhase3( ))
                    //{
                    //    LOG.Info($"N2PurgeMode Trigger from Manual_phase5 to Manual_phase3,O2：{o2Value}");

                    //    SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase3.ToString());
                    //}
                }
                else
                {
                    if (CheckN2PurgePhase3())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase3,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase3.ToString());
                        return;
                    }
                    if (CheckN2PurgePhase5())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase5,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase5.ToString());
                        return;
                    }
                    if (CheckN2PurgePhase4())
                    {
                        LOG.Info($"N2PurgeMode Trigger Directly  triggered Manual_phase4,O2：{ConcentrationO2.Value}");

                        SetN2PurgeValveData(N2PurgeModeEnum.Manual_phase4.ToString());
                        return;
                    }
                }
            }
            if (_N2PurgeMode == N2PurgeModeEnum.ManualMode || _N2PurgeMode == N2PurgeModeEnum.Auto)
            {
                _currentPhase = _N2PurgeMode;
            }
            //switch (_N2PurgeMode)
            //{
            //    case N2PurgeModeEnum.Auto:
            //        // 自动模式下的操作
            //        break;
            //    case N2PurgeModeEnum.ManualMode:
            //        break;
            //    case N2PurgeModeEnum.N2PurgeMode:

            //        ProcessPhase(_trigN2UpRD, N2PurgeModeEnum.Manual_phase1.ToString());
            //        ProcessPhase(_trigN2DownRD, N2PurgeModeEnum.Manual_phase2.ToString(), _manualPhase2NeedCheck, (int)(_manualPhase2StabilityTime * 1000));
            //        break;
            //    case N2PurgeModeEnum.ATMMode:

            //        ProcessPhase(_trigN2AirDownRD, N2PurgeModeEnum.Manual_phase3.ToString());
            //        ProcessPhase(_trigN2AirUpRD, N2PurgeModeEnum.Manual_phase4.ToString(), _manualPhase4NeedCheck, (int)(_manualPhase4StabilityTime * 1000));
            //        ProcessPhase(_trigN2AirDownTwoRD, N2PurgeModeEnum.Manual_phase5.ToString());
            //        break;
            //}

        }
        bool CheckConditionInTime(string modeKey, int millisecondsTimeout, Func<bool> condition)
        {
            var stopwatch = _allTimeDict[modeKey];
            if (!_allTimeDict[modeKey].IsRunning)
            {
                _allTimeDict[modeKey].Restart();
            }
            while (stopwatch.ElapsedMilliseconds < millisecondsTimeout)
            {
                if (!_allTimeDict[modeKey].IsRunning)
                {
                    return true;
                }
                if (!condition())
                {
                    _allTimeDict[modeKey].Stop();
                    _allTimeDict[modeKey].Reset();
                    return false;
                }
            }
            if (stopwatch.ElapsedMilliseconds > millisecondsTimeout)
            {
                _allTimeDict[modeKey].Stop();
                _allTimeDict[modeKey].Reset();
            }
            return true;
        }
        private void ProcessPhase(R_TRIG r_TRIG, string modeKey, bool needCheck = false, int time = 0)
        {
            r_TRIG.CLK = needCheck ? (CheckConditionInTime(modeKey, time, () => _n2PurgeSequenceStatus[modeKey].Invoke())) : _n2PurgeSequenceStatus[modeKey].Invoke();
            if (r_TRIG.Q)
            {
                LOG.Info($"N2PurgeMode Trigger {modeKey}!,O2：{ConcentrationO2.Value},time:{_allTimeDict[modeKey].ElapsedMilliseconds}");
                SetN2PurgeValveData(modeKey);
                _allTimeDict[modeKey].Stop();
                _allTimeDict[modeKey].Reset();
            }
        }
        public void RestAllN2PrugeRD()
        {
            _trigN2AirDownRD.RST = false;
            _trigN2AirUpRD.RST = false;
            _trigN2DownRD.RST = false;
            _trigN2UpRD.RST = false;

            foreach (var item in _allTimeDict)
            {
                item.Value.Stop();
                item.Value.Reset();
            }
            _canSwitchToPhase2 = true;
        }
        private void SetN2PurgeValveData(string mode, string msg = "")
        {

            var value = _n2PurgeSequenceAction[mode];

            _currentPhase = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), mode);

            if (SC.ContainsItem("PM1.SelectN2PurgeModePhase"))
            {
                SC.SetItemValue("PM1.SelectN2PurgeModePhase", mode);
            }
            foreach (var operateItem in value.Item2)
            {
                if (operateItem.Item1 is IoMFC)
                {
                    var ioMFc = (operateItem.Item1 as IoMFC);
                    { ioMFc.SetMfcValue(out _, 0, new object[] { float.Parse(operateItem.Item2.ToString()) }); }
                }

                if (operateItem.Item1 is IoValve)
                {
                    var ioValve = (operateItem.Item1 as IoValve);

                    ioValve.TurnValve(bool.Parse(operateItem.Item2), out _);
                }
                if (operateItem.Item1 is IoTrigger)
                {
                    var ioTrigger = (operateItem.Item1 as IoTrigger);

                    ioTrigger.CheckAndSet(bool.Parse(operateItem.Item2), out _);
                }
            }


        }

        private bool SetN2PurgeMode(out string reason, int time, object[] param)
        {
            reason = string.Empty;
            var mode = param[0].ToString();
            _N2PurgeMode = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), mode);

            if (SC.ContainsItem("PM1.SelectN2PurgeMode"))
            {
                SC.SetItemValue("PM1.SelectN2PurgeMode", mode);
            }
            RestAllN2PrugeRD();
            return true;
        }

        /// <summary>
        /// 获取当前O2检测位置的设定值
        /// TODO:这里展示数据的逻辑也不正确，待明确逻辑
        /// </summary>
        /// <returns></returns>
        private string GetO2SetCheckSetPoint()
        {
            if (SensorO2DetectSideLA != null && SensorO2DetectSideLA.Value)
            {
                var key = "PM1.N2Purge.N2PurgeLAO2CheckSV";
                if (SC.ContainsItem(key))
                    return SC.GetValue<double>(key).ToString("f3");
            }

            if ((SensorO2DetectSideFIMS1 != null && SensorO2DetectSideFIMS1.Value) || (SensorO2DetectSideFIMS2 != null && SensorO2DetectSideFIMS2.Value))
            {
                var key = "PM1.N2Purge.N2PurgeFOUPO2CheckSV";
                if (SC.ContainsItem(key))
                    return SC.GetValue<double>(key).ToString("f3");
            }
            return "";
        }
        /// <summary>
        /// 获取当前O2检测位置
        /// </summary>
        /// <returns></returns>
        private string GetCheckO2Location()
        {
            if (SensorO2DetectSideLA != null && SensorO2DetectSideLA.Value)
                return SensorO2DetectSideLA.Display;

            if (SensorO2DetectSideFIMS1 != null && SensorO2DetectSideFIMS1.Value)
                return SensorO2DetectSideFIMS1.Display;

            if (SensorO2DetectSideFIMS2 != null && SensorO2DetectSideFIMS2.Value)
                return SensorO2DetectSideFIMS2.Display;

            return "";
        }
        /// <summary>
        /// 获取当前O2浓度
        /// </summary>
        /// <returns></returns>


        private bool CheckN2PurgePhase1()
        {
            return ((int)ConcentrationO2.Value >= _n2PurgeData) && GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase2()
        {
            return ((int)ConcentrationO2.Value < _n2PurgeData) && GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase3()
        {
            return ((int)ConcentrationO2.Value) < _n2ToAirData && GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase5()
        {
            return ((int)ConcentrationO2.Value) >= _n2ToAirData && !GetLADoorOpenStatus();
        }
        private bool CheckN2PurgePhase4()
        {

            return (((int)ConcentrationO2.Value)) >= _n2ToAirData && GetLADoorOpenStatus();
        }
        private bool GetN2PurgeAIRTo20PPMStatus()
        {
            return ValveAV202.DOOpen.Value;
        }
        public bool GetN2PurgeUnder20PPMStatus(double value = 20)
        {
            return ConcentrationO2.Value < value;
        }
        private bool GetN2PurgeAIRStatus()
        {
            return ValveAV202.DOClose.Value && (AlarmSignalFilterBox1DoorSwitch != null ? !AlarmSignalFilterBox1DoorSwitch.Value : false);
        }
        private bool GetLADoorOpenStatus()
        {
            return (bool)(SensorLADoorSw1?.Value);
        }
        private bool GetN2PurgeDoorOpenStatus()
        {
            return ValveAV202.DOClose.Value && (AlarmSignalFilterBox1DoorSwitch != null ? !AlarmSignalFilterBox1DoorSwitch.Value : false);
        }
        private bool GetN2PurgeFoup1Status()
        {
            return GetN2PurgeAIRTo20PPMStatus() && GetN2PurgeUnder20PPMStatus() && FIMS1.IsFoupExist && FIMS1.CollisionAvoidanceUpDownStatus == DeviceStatus.Down;
        }
        private bool GetN2PurgeFoup2Status()
        {
            return GetN2PurgeAIRTo20PPMStatus() && GetN2PurgeUnder20PPMStatus() && FIMS2.IsFoupExist && FIMS2.CollisionAvoidanceUpDownStatus == DeviceStatus.Down; ;
        }
        public bool IsAbortN2purge()
        {
            if (!_enableAbortN2purge)
            {
                return false;
            }

            if (SensorSL02001gasboxdoorsw11.Value || SensorSL02001gasboxdoorsw12.Value || SensorSL02002gasboxdoorsw11.Value || SensorSL02002gasboxdoorsw12.Value || SensorSL05002LAdoorsw2.Value || SensorSL05004LAfurnacedoorsw.Value)
            {
                return true;
            }


            return false;

        }

        public void SetN2PurgeLAO2CheckFirstEnable(bool isEable)
        {
            if (TrigN2PurgeLAO2CheckFirstEnable != null && TrigN2PurgeLAO2CheckFirstEnable.Value != isEable)
            {
                TrigN2PurgeLAO2CheckFirstEnable.SetTrigger(isEable, out _);
            }
        }
        public void SetN2PurgeFIMS1O2CheckEnable(ModuleName fims, bool isEable)
        {
            if (fims == ModuleName.FIMS1 && TrigN2PurgeFIMS1O2CheckEnable != null && TrigN2PurgeFIMS1O2CheckEnable.Value != isEable)
            {
                TrigN2PurgeFIMS1O2CheckEnable.SetTrigger(isEable, out _);
            }

            if (fims == ModuleName.FIMS2 && TrigN2PurgeFIMS2O2CheckEnable != null && TrigN2PurgeFIMS2O2CheckEnable.Value != isEable)
            {
                TrigN2PurgeFIMS2O2CheckEnable.SetTrigger(isEable, out _);

            }
        }
        public void SetN2PurgeProcess(bool isEable)
        {
            if (TrigN2PurgeProcess != null && TrigN2PurgeProcess.Value != isEable)
            {
                TrigN2PurgeProcess.SetTrigger(isEable, out _);
            }
        }
        public void SetN2PurgeLAO2CheckSV(float value)
        {
            if (TrigN2PurgeLAO2CheckSV != null)
                TrigN2PurgeLAO2CheckSV?.SetAOTrigger(value, out _);
        }
        public void SetN2PurgeFOUPO2CheckSV(float value)
        {
            if (TrigN2PurgeFOUPO2CheckSV != null)
                TrigN2PurgeFOUPO2CheckSV?.SetAOTrigger(value, out _);
        }

        /// <summary>
        /// N2Purge相关时间参数，电气要求设定为秒，实际下发按照毫秒
        /// </summary>
        public void SetN2PurgeParameters(string n2PurgeModeEnum)
        {
            if (SC.ContainsItem("PM1.N2Purge.TransferRoomArrivalWaitTime") && TrigN2PurgeLAO2CheckTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.TransferRoomArrivalWaitTime");
                TrigN2PurgeLAO2CheckTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.TransferRoomStableWaitTime") && TrigN2PurgeLAO2OverTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.TransferRoomStableWaitTime");
                TrigN2PurgeLAO2OverTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.FOUPOpenerArrivalWaitTime") && TrigN2PurgeFOUPO2CheckTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.FOUPOpenerArrivalWaitTime");
                TrigN2PurgeFOUPO2CheckTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.FOUPOpenerStableWaitTime") && TrigN2PurgeFOUPO2OverTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.FOUPOpenerStableWaitTime");
                TrigN2PurgeFOUPO2OverTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.O2DetectorTransferRoomToFOUPTime") && TrigN2PurgeExchangeLATOFOUPWaitTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.O2DetectorTransferRoomToFOUPTime");
                TrigN2PurgeExchangeLATOFOUPWaitTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.O2DetectorFOUPToTransferRoomTime") && TrigN2PurgeExchangeFOUPTOLAWaitTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.O2DetectorFOUPToTransferRoomTime");
                TrigN2PurgeExchangeFOUPTOLAWaitTime.SetAOTrigger(time, out _);
            }

            if (SC.ContainsItem("PM1.N2Purge.O2DetectorFOUPToFOUPTime") && TrigN2PurgeExchangeFOUPTOFOUPWaitTime != null)
            {
                var time = (float)SC.GetValue<double>("PM1.N2Purge.O2DetectorFOUPToFOUPTime");
                TrigN2PurgeExchangeFOUPTOFOUPWaitTime.SetAOTrigger(time, out _);
            }
            //这2个SV下发值应该根据什么阶段下发什么值
            if (n2PurgeModeEnum == N2PurgeModeEnum.WaferCharge.ToString())
            {
                SetN2PurgeFOUPO2CheckSV((float)GetWaferChargeFOUPO2CheckSV());
                SetN2PurgeLAO2CheckSV((float)GetWaferChargeLAO2CheckSV());
            }
            if (n2PurgeModeEnum == N2PurgeModeEnum.FoupEnter.ToString())
            {
                SetN2PurgeFOUPO2CheckSV((float)GetFoupEnterFOUPO2CheckSV());
                SetN2PurgeLAO2CheckSV((float)GetFoupEnterLAO2CheckSV());
            }
            if (n2PurgeModeEnum == N2PurgeModeEnum.WaferDisCharge.ToString())
            {
                SetN2PurgeFOUPO2CheckSV((float)GetWaferDisChargeFOUPO2CheckSV());
                SetN2PurgeLAO2CheckSV((float)GetWaferDisChargeLAO2CheckSV());
            }
        }

        /// <summary>
        /// Job start的时候，就根据Process的配置判定是否需要进行LA压氧
        /// </summary>
        /// <param name="n2PurgeModeStr"></param>
        public void InitN2PurgeMode(string n2PurgeModeStr)
        {


            if (string.IsNullOrEmpty(n2PurgeModeStr))
                return;

            if (n2PurgeModeStr.ToLower() == "none")
                return;


            if (SC.ContainsItem("PM1.RecipeRelevancyN2Purge") && SC.GetValue<bool>("PM1.RecipeRelevancyN2Purge") && SC.ContainsItem("PM1.SelectN2PurgeMode"))
            {

                var setValue = GetN2PurgeModeEnumByStr(n2PurgeModeStr);
                SC.SetItemValueFromString("PM1.SelectN2PurgeMode", setValue);
                RestAllN2PrugeRD();
            }
        }

        public bool CheckFimsIsNeedOxygenPressure(bool fimsN2PurgeConfig, string recipeN2PurgeModeStr, out bool isCheckO2, bool isCheckRecipeHeader = true)
        {
            isCheckO2 = false;
            var currectN2PurgeModel = GetLACurrectN2purgeMode();

            if (isCheckRecipeHeader)
            {
                if (string.IsNullOrEmpty(recipeN2PurgeModeStr))
                    return false;

                if (recipeN2PurgeModeStr.ToLower().Equals("n2 purge"))
                {
                    recipeN2PurgeModeStr = N2PurgeModeEnum.N2PurgeMode.ToString();
                }
                if (recipeN2PurgeModeStr.ToLower().Contains("atm"))
                {
                    recipeN2PurgeModeStr = IsATMMode(recipeN2PurgeModeStr);
                }


                var n2PurgeEnum = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), recipeN2PurgeModeStr);

                if (n2PurgeEnum == N2PurgeModeEnum.ATMMode)
                    return false;

                if (n2PurgeEnum == N2PurgeModeEnum.N2PurgeMode)
                {

                    if (currectN2PurgeModel == N2PurgeModeEnum.N2PurgeMode.ToString() || currectN2PurgeModel == N2PurgeModeEnum.ATMMode.ToString() || currectN2PurgeModel == N2PurgeModeEnum.ManualMode.ToString())
                    {
                        if (fimsN2PurgeConfig)
                        {
                            isCheckO2 = true;
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }

                }
                if (n2PurgeEnum == N2PurgeModeEnum.None)
                {

                    if (currectN2PurgeModel == N2PurgeModeEnum.ATMMode.ToString() || currectN2PurgeModel == N2PurgeModeEnum.ManualMode.ToString())
                    {
                        return false;
                    }
                    if (currectN2PurgeModel == N2PurgeModeEnum.N2PurgeMode.ToString())
                    {
                        if (fimsN2PurgeConfig)
                        {
                            isCheckO2 = true;
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }


                }
            }
            else
            {

                if (currectN2PurgeModel == N2PurgeModeEnum.N2PurgeMode.ToString() || currectN2PurgeModel == N2PurgeModeEnum.ManualMode.ToString())
                {
                    if (fimsN2PurgeConfig)
                    {
                        isCheckO2 = true;
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                if (currectN2PurgeModel == N2PurgeModeEnum.ATMMode.ToString())
                {
                    return false;
                }
            }


            return false;
        }
        public bool CheckLAIsNeedOxygenPressure(string recipeN2PurgeModeStr)
        {
            if (string.IsNullOrEmpty(recipeN2PurgeModeStr))
                return false;

            if (recipeN2PurgeModeStr.ToLower() == "none")
                return false;

            if (recipeN2PurgeModeStr.ToLower() == "atm")
            {
                recipeN2PurgeModeStr = N2PurgeModeEnum.ATMMode.ToString();

            }
            if (recipeN2PurgeModeStr.ToLower().Contains("n2"))
            {
                recipeN2PurgeModeStr = N2PurgeModeEnum.N2PurgeMode.ToString();

            }
            var n2PurgeEnum = (N2PurgeModeEnum)Enum.Parse(typeof(N2PurgeModeEnum), recipeN2PurgeModeStr);

            if (n2PurgeEnum == N2PurgeModeEnum.N2PurgeMode || n2PurgeEnum == N2PurgeModeEnum.ATMMode)
                return true;


            return false;
        }





        public string GetN2PurgeModeEnumByStr(string str)
        {
            if ((str == N2PurgeModeEnum.ATMMode.ToString()) || (str == N2PurgeModeEnum.ATMMode.ToDescription()) || (str.StartsWith("ATM")))
            {
                return N2PurgeModeEnum.ATMMode.ToString();
            }
            else if ((str == N2PurgeModeEnum.N2PurgeMode.ToString()) || (str == N2PurgeModeEnum.N2PurgeMode.ToDescription()) || (str.StartsWith("N2")))
            {
                return N2PurgeModeEnum.N2PurgeMode.ToString();
            }
            else
            {
                return GetLACurrectN2purgeMode();
            }
        }
        public string IsATMMode(string str)
        {
            if ((str == N2PurgeModeEnum.ATMMode.ToString()) || (str == N2PurgeModeEnum.ATMMode.ToDescription()) || (str.StartsWith("ATM")))
            {
                return N2PurgeModeEnum.ATMMode.ToString();
            }
            return str;
        }
        public double GetFoupEnterLAO2CheckSV()
        {
            return SC.ContainsItem("PM1.N2Purge.FoupEnter.LAO2CheckSV") ? SC.GetValue<double>("PM1.N2Purge.FoupEnter.LAO2CheckSV") : 20;
        }
        public double GetFoupEnterFOUPO2CheckSV()
        {
            return SC.ContainsItem("PM1.N2Purge.FoupEnter.FOUPO2CheckSV") ? SC.GetValue<double>("PM1.N2Purge.FoupEnter.FOUPO2CheckSV") : 20;
        }
        public bool GetFoupEnterFIMSN2purgeConfig()
        {
            return SC.ContainsItem("PM1.N2Purge.FoupEnter.FOUPN2PurgeEnable") ? SC.GetValue<bool>("PM1.N2Purge.FoupEnter.FOUPN2PurgeEnable") : false;

        }
        public double GetWaferChargeLAO2CheckSV()
        {
            return SC.ContainsItem("PM1.N2Purge.WaferCharge.LAO2CheckSV") ? SC.GetValue<double>("PM1.N2Purge.WaferCharge.LAO2CheckSV") : 20;
        }
        public double GetWaferChargeFOUPO2CheckSV()
        {
            return SC.ContainsItem("PM1.N2Purge.WaferCharge.FOUPO2CheckSV") ? SC.GetValue<double>("PM1.N2Purge.WaferCharge.FOUPO2CheckSV") : 20;
        }

        public bool GetWaferChargeFIMSN2purgeConfig()
        {
            return SC.ContainsItem("PM1.N2Purge.WaferCharge.FOUPN2PurgeEnable") ? SC.GetValue<bool>("PM1.N2Purge.WaferCharge.FOUPN2PurgeEnable") : false;
        }
        public double GetWaferDisChargeLAO2CheckSV()
        {
            return SC.ContainsItem("PM1.N2Purge.WaferDisCharge.LAO2CheckSV") ? SC.GetValue<double>("PM1.N2Purge.WaferDisCharge.LAO2CheckSV") : 20;
        }
        public double GetWaferDisChargeFOUPO2CheckSV()
        {
            return SC.ContainsItem("PM1.N2Purge.WaferDisCharge.FOUPO2CheckSV") ? SC.GetValue<double>("PM1.N2Purge.WaferDisCharge.FOUPO2CheckSV") : 20;
        }

        public bool GetWaferDisChargeFIMSN2purgeConfig()
        {
            return SC.ContainsItem("PM1.N2Purge.WaferDisCharge.FOUPN2PurgeEnable") ? SC.GetValue<bool>("PM1.N2Purge.WaferDisCharge.FOUPN2PurgeEnable") : false;
        }
        public string GetLACurrectN2purgeMode()
        {
            return SC.ContainsItem("PM1.SelectN2PurgeMode") ? SC.GetStringValue("PM1.SelectN2PurgeMode") : N2PurgeModeEnum.ManualMode.ToString();
        }


    }
}