ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemRT/Servers/Check.cs

using System;
using Aitex.Core.Common;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Event;
using Aitex.Core.Util;

using EFEM.RT.Tasks;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts.LoadPortBase;

namespace EFEM.RT
{
    [Flags]
    public enum ErrorCheckList1
    {
        VAC      = 0x0001,
        AIR      = 0x0002,
        STALL    = 0x0004,
        TIMEOUT  = 0x0008,

        LIMIT    = 0x0010,
        SENSOR   = 0x0020,
        POSITION = 0x0040,
        EMS      = 0x0080,

        COMM     = 0x0100,
        COMM2    = 0x0200,
        VACON    = 0x0400,
        VACOFF   = 0x0800,

        CLAMPON  = 0x1000,
        CLAMPOF  = 0x2000,

    };

    [Flags]
    public enum ErrorCheckList2
    {
        RRTWAF   = 0x0001,
        CRSWAF   = 0x0002,
        THICKWAF = 0x0004,
        THINWAF  = 0x0008,

        DBLWAF  = 0x0010,
        BAOWAF  = 0x0020,
        COMMAND = 0x0040,
        PODNG   = 0x0080,            //Pod abnormal load error

        PODMISMATCH = 0x0100,       //Pod type mismatch
        VAC_S       = 0x0200,       //Chucking sensor abnormal
        CLAMP_S     = 0x0400,       //Clamp sensor abnormal 
        SAFTY       = 0x0800,       //Hand/finger pinch sensor reaction

        LOCKNG = 0x1000,            //FOUP lock disabled
        UNLOCKNG = 0x2000,          //FOUP unlock disabled
        L_KEY_LK = 0x4000,          //Latch key lock failure 
        L_KEY_UL = 0x8000,          //Latch key unlock failure 
    };

    [Flags]
    public enum ErrorCheckList3
    {
        MAP_S       = 0x0001,            //Mapping sensor abnormal
        MAP_S1      = 0x0002,            //Mapping sensor preparation disabled
        MAP_S2      = 0x0004,            //Mapping sensor containing disabled
        WAFLOST     = 0x0008,            //Wafer fall Disabled

        ALIGNNG     = 0x0010,           //Alignment failure 
        DRIVER      = 0x0020,            //Driver abnormal
        DRPOWERDOWN = 0x0040,            //Drive power off
        HARDWARE    = 0x0080,          //Hardware failure 

        INTERNAL     = 0x0100,          // Internal error 
        E84_TIMEOUTx = 0x0200,          //E84 timeout
        E84_CS_VALID = 0x0400,          //E84_CS_VALID  E84CS_0, CS_1, VALIDerror
        READFAIL     = 0x0800,      //Reading error 
        PODNG = 0x1000,
        PODMISMATCH = 0x2000,
        VAC_S = 0x4000,
        CLAMP_S = 0x8000,
    };



    public interface IPolicy
    {
        bool Check(string device, out string reason);
    }

    public class CheckImp
    {
        protected ErrorCheckList1 flag1 = 0;
        protected ErrorCheckList2 flag2 = 0;
        protected ErrorCheckList3 flag3 = 0;

        protected int LoadPortQuantity = DeviceDefineManager.Instance.GetValue<int>("LoadPortQuantity") ?? 0;
        
        protected int LoadLockQuantity = DeviceDefineManager.Instance.GetValue<int>("LoadLockQuantity") ?? 0;
        protected int BufferQuantity = DeviceDefineManager.Instance.GetValue<int>("BufferQuantity") ?? 0;
        protected bool AlignerInstalled = DeviceDefineManager.Instance.GetValue<bool>("AlignerInstalled") ?? false;
        protected bool CoolingBufferInstalled = DeviceDefineManager.Instance.GetValue<bool>("CoolingBufferInstalled") ?? false;


        protected bool RobotIsSingleArm = DeviceDefineManager.Instance.GetValue<bool>("RobotIsSingleArm") ?? false;

        protected bool MultiWaferSize = DeviceDefineManager.Instance.GetValue<bool>("MultiWaferSize") ?? false;


        public const string PARAM_NG = "PARAM_NG";

        protected int _token;

        public bool HasInfoMessage { get; set; }

        public CheckImp()
        {
            HasInfoMessage = true;
        }

        public bool CheckError(string device, out string reason)
        {
            reason = "UNDEFINITION";     
            #region Check flag1
            if (flag1.HasFlag(ErrorCheckList1.VAC))
            {
                if (!Check<ABS.VacPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.AIR))
            {
                if (!Check<ABS.AirPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.STALL))
            {
                if (!Check<ABS.StallPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag1.HasFlag(ErrorCheckList1.LIMIT))
            {
                if (!Check<ABS.LIMITPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.SENSOR))
            {
                if (!Check<ABS.SENSORPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.POSITION))
            {
                if (!Check<ABS.POSITIONPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.EMS))
            {
                if (!Check<ABS.EMSPolicy>(device, out reason))
                {
                    return false;
                }
            }
            
            if (flag1.HasFlag(ErrorCheckList1.COMM))
            {
                if (!Check<ABS.COMMPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.COMM2))
            {
                if (!Check<ABS.COMM2Policy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.VACON))
            {
                if (!Check<ABS.VACONPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.VACOFF))
            {
                if (!Check<ABS.VACOFPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag1.HasFlag(ErrorCheckList1.CLAMPON))
            {
                if (!Check<ABS.CLAMPONPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag1.HasFlag(ErrorCheckList1.CLAMPOF))
            {
                if (!Check<ABS.CLAMPOFPolicy>(device, out reason))
                {
                    return false;
                }
            }

            #endregion

            #region Check flag2
            if (flag2.HasFlag(ErrorCheckList2.RRTWAF))
            {
                if (!Check<ABS.PRTWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.CRSWAF))
            {
                if (!Check<ABS.CRSWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.THICKWAF))
            {
                if (!Check<ABS.THICKWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.THINWAF))
            {
                if (!Check<ABS.THINWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag2.HasFlag(ErrorCheckList2.DBLWAF))
            {
                if (!Check<ABS.DBLWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.BAOWAF))
            {
                if (!Check<ABS.BOWWAFPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.COMMAND))
            {
                if (!Check<ABS.COMMANDPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.PODNG))
            {
                if (!Check<ABS.PODNGPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag2.HasFlag(ErrorCheckList2.PODMISMATCH))
            {
                if (!Check<ABS.PODMISMATCHPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.VAC_S))
            {
                if (!Check<ABS.VAC_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.CLAMP_S))
            {
                if (!Check<ABS.CLAMP_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.SAFTY))
            {
                if (!Check<ABS.SAFTYPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag2.HasFlag(ErrorCheckList2.LOCKNG))
            {
                if (!Check<ABS.LOCKNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.UNLOCKNG))
            {
                if (!Check<ABS.UNLOCKNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.L_KEY_LK))
            {
                if (!Check<ABS.L_KEY_LKPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag2.HasFlag(ErrorCheckList2.L_KEY_UL))
            {
                if (!Check<ABS.L_KEY_ULPolicy>(device, out reason))
                {
                    return false;
                }
            }
            #endregion

            #region Check flag3
            if (flag3.HasFlag(ErrorCheckList3.MAP_S))
            {
                if (!Check<ABS.MAP_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.MAP_S1))
            {
                if (!Check<ABS.MAP_S1Policy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.MAP_S2))
            {
                if (!Check<ABS.MAP_S2Policy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.WAFLOST))
            {
                if (!Check<ABS.WAFLOSTPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag3.HasFlag(ErrorCheckList3.ALIGNNG))
            {
                if (!Check<ABS.ALIGNNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.PODNG))
            {
                if (!Check<ABS.PODNGPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.PODMISMATCH))
            {
                if (!Check<ABS.PODMISMATCHPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.VAC_S))
            {
                if (!Check<ABS.VAC_SPolicy>(device, out reason))
                {
                    return false;
                }
            }


            if (flag3.HasFlag(ErrorCheckList3.CLAMP_S))
            {
                if (!Check<ABS.CLAMP_SPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.DRIVER))
            {
                if (!Check<ABS.DRIVERPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.DRPOWERDOWN))
            {
                if (!Check<ABS.DRPOWERDOWNPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.HARDWARE))
            {
                if (!Check<ABS.HARDWAREPolicy>(device, out reason))
                {
                    return false;
                }
            }

            if (flag3.HasFlag(ErrorCheckList3.INTERNAL))
            {
                if (!Check<ABS.INTERNALPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.E84_TIMEOUTx))
            {
                if (!Check<ABS.E84_TIMEOUTxPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.E84_CS_VALID))
            {
                if (!Check<ABS.E84_CS_VALIDPolicy>(device, out reason))
                {
                    return false;
                }
            }
            if (flag3.HasFlag(ErrorCheckList3.READFAIL))
            {
                if (!Check<ABS.READFAILPolicy>(device, out reason))
                {
                    return false;
                }
            }
            #endregion
            reason = "UNDEFINITION";
            return false;
        }

        public bool Check<T>(string device, out string reason) where T : class, IPolicy, new()
        {
            reason = string.Empty;
            
            return Singleton<T>.Instance.Check(device, out reason);
        }

        /// <summary>
        /// 指令参数
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        protected string Args2Unit(string args)
        {
            string unit = string.Empty;
            if (string.IsNullOrEmpty(args) || args.StartsWith("ALL") || args.StartsWith("SYSTEM"))
            {
                unit = DeviceName.System;
            }
            else if (args.StartsWith("ROB"))
            {
                unit = DeviceName.Robot;
            }
            else if (args.StartsWith("ALIGN"))
            {
                if (this.AlignerInstalled)
                    unit = DeviceName.Aligner;
                else if (this.CoolingBufferInstalled)
                {
                    //if (args.EndsWith("ALIGN1") || args.EndsWith("ALIGN"))
                    //{
                    //    unit = DeviceName.CoolingBuffer1;
                    //}
                    //else if (args.EndsWith("ALIGN2"))
                    //{
                    //    unit = DeviceName.CoolingBuffer2;
                    //}
                    if (args.EndsWith("ALIGN1") || args.EndsWith("ALIGN"))
                    {
                        unit = DeviceName.CoolingBuffer1;
                       
                    }
                    else if (args.EndsWith("ALIGN2"))
                    {
                        unit = DeviceName.CoolingBuffer2;
                        
                    }
                    else if (args.EndsWith("ALIGN3"))
                    {
                        unit = DeviceName.Aligner1;
                       
                    }
                    else if (args.EndsWith("ALIGN4"))
                    {
                        unit = DeviceName.Aligner2;
                        
                    }
                }
            }
            else if (args.Equals("P1") && LoadPortQuantity > 0)
            {
                unit = DeviceName.LP1;

            }
            else if (args.Equals("P2") && LoadPortQuantity > 1)
            {
                unit = DeviceName.LP2;

            }
            else if (args.Equals("P3") && LoadPortQuantity > 2)
            {
                unit = DeviceName.LP3;

            }
            else if (args.Equals("P4") && LoadPortQuantity > 3)
            {
                unit = DeviceName.LP4;
            }
            else if (args.Equals("P5") && LoadPortQuantity > 4)
            {
                unit = DeviceName.LP5;
            }
            else if (args.Equals("P6") && LoadPortQuantity > 5)
            {
                unit = DeviceName.LP6;
            }
            else if (args.Equals("P7") && LoadPortQuantity > 6)
            {
                unit = DeviceName.LP7;
            }
            else if (args.Equals("P8") && LoadPortQuantity > 7)
            {
                unit = DeviceName.LP8;
            }
            else if (args.Equals("P9") && LoadPortQuantity > 8)
            {
                unit = DeviceName.LP9;
            }
            else if (args.Equals("P10") && LoadPortQuantity > 9)
            {
                unit = DeviceName.LP10;
            }
            else if ( (args.Equals("LLA") || args.StartsWith("LLLA")) && LoadLockQuantity >0)
            {
                unit = DeviceName.LoadlockA;
            }
            else if ((args.Equals("LLB") || args.StartsWith("LLLB")) && LoadLockQuantity > 1)
            {
                unit = DeviceName.LoadlockB;
            }
            else if (args.Equals("LLC") && LoadLockQuantity > 2)
            {
                unit = DeviceName.LoadlockC;
            }
            else if (args.Equals("LLD") && LoadLockQuantity > 3)
            {
                unit = DeviceName.LoadlockD;
            }
            else if (args.Equals("STOWER"))
            {
                unit = DeviceName.SignalTower;
            }
            else if (args.Equals("BF1"))
            {    
                unit = DeviceName.Buffer1;
            }
            else if (args.Equals("BF2"))
            {
                unit = DeviceName.Buffer2;
            }
            else if (args.Equals("BUFFER"))
            {
                unit = DeviceName.Buffer;
            }
            return unit;
        }


        protected bool ParseMoveTarget(string args, out ModuleName target, out int slot)
        {
            target = ModuleName.System;
            slot = 1;
            if (args.StartsWith("ALIGN"))
            {
        
                if (this.AlignerInstalled)
                {
                    target = ModuleName.Aligner;
                    slot = 1;
                }
                else if (this.CoolingBufferInstalled)
                {
                    if (args.EndsWith("ALIGN1")|| args.EndsWith("ALIGN"))
                    {
                        target = ModuleName.CoolingBuffer1;
                        slot = 1;
                    }
                    else if (args.EndsWith("ALIGN2"))
                    {
                        target = ModuleName.CoolingBuffer2;
                        slot = 1;
                    }
                    else if (args.EndsWith("ALIGN3"))
                    {
                        target = ModuleName.Aligner1;
                        slot = 1;
                    }
                    else if (args.EndsWith("ALIGN4"))
                    {
                        target = ModuleName.Aligner2;
                        slot = 1;
                    }
                }
                return true;
            }
            else if (args.StartsWith("P1") && LoadPortQuantity > 0)
            {
                target = ModuleName.LP1;
                if (int.TryParse(args.Replace("P1", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P2") && LoadPortQuantity > 1)
            {
                target = ModuleName.LP2;
                if (int.TryParse(args.Replace("P2", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P3") && LoadPortQuantity > 2)
            {
                target = ModuleName.LP3;
                if (int.TryParse(args.Replace("P3", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("P4") && LoadPortQuantity > 3)
            {
                target = ModuleName.LP4;
                if (int.TryParse(args.Replace("P4", ""), out slot))
                {
                    return true;
                }
            }
            else if ((args.StartsWith("LLLA") || args.StartsWith("LLA")))
            {
                if(BufferQuantity == 0 && LoadLockQuantity > 0)
                    target = ModuleName.LL1;
                if(LoadLockQuantity==0 && BufferQuantity>0)
                    target = ModuleName.Buffer1;
                string temp = args.Replace("LLLA", "").Replace("LLA",""); 
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if ((args.StartsWith("LLLB") || args.StartsWith("LLB")) )
            {
                if (BufferQuantity==0 && LoadLockQuantity > 1)
                        target = ModuleName.LL2;
                if (LoadLockQuantity == 0 && BufferQuantity > 1)
                    target = ModuleName.Buffer2;
               // target = ModuleName.LL2;
                string temp = args.Replace("LLLB", "").Replace("LLB", ""); 
                if (string.IsNullOrEmpty(temp))
                {
                    slot = 1;
                    return true;
                }
                else
                {
                    if (int.TryParse(temp, out slot))
                        return true;
                }
            }
            else if (args.StartsWith("BF1") && BufferQuantity > 0)
            {
                target = ModuleName.Buffer1;
                if (int.TryParse(args.Replace("BF1", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("BF2") && BufferQuantity > 1)
            {
                target = ModuleName.Buffer2;
                if (int.TryParse(args.Replace("BF2", ""), out slot))
                {
                    return true;
                }
            }
            else if (args.StartsWith("BUFFER"))
            {
                target = ModuleName.Buffer;
                if (int.TryParse(args.Replace("BUFFER", ""), out slot))
                {
                    return true;
                }
            }

            return false;
        }


        protected bool ParseMoveArm(string args, out Hand arm)
        {
            arm = Hand.Blade2;

            switch (args)
            {
                case "ARM1":
                    arm = Hand.Blade2;
                    break;
                case "ARM2":
                    arm = Hand.Blade1;
                    break;
                case "ARM3":
                    arm = Hand.Both;
                    break;

                default:
                    return false;
            }

            if (RobotIsSingleArm)
            {
                if (arm != Hand.Blade1)
                    return false;
            }

            return true;
        }

        protected bool CheckWaferSize(string waferSize, ModuleName target, int slot)
        {
            if (!Enum.TryParse<WaferSize>(waferSize, out WaferSize ws))
            {
                EV.PostWarningLog("EFEM", $"{waferSize} is not a valid size type");
                return false;
            }

            if (ModuleHelper.IsLoadPort(target))
            {
                LoadPortBaseDevice lp = DEVICE.GetDevice<LoadPortBaseDevice>(target.ToString());
                if (lp.GetCurrentWaferSize() != ws) //lp.CassetteState == LoadportCassetteState.Normal &&
                {
                    EV.PostWarningLog("EFEM", $"{lp.GetCurrentWaferSize()} is not match target {ws}");
                    return false;
                }
            }
            else
            {
                if (WaferManager.Instance.CheckHasWafer(target, slot))
                {
                    if (WaferManager.Instance.GetWaferSize(target, slot) != ws)
                    {
                        EV.PostWarningLog("EFEM", $"{WaferManager.Instance.GetWaferSize(target, slot)} is not match target {ws}");

                        return false;
                    }
                }
            }

            return true;
        }
 

        protected bool CheckIsPort(string device)
        {
            return device==DeviceName.LP1 || device == DeviceName.LP2 || device == DeviceName.LP3 || device == DeviceName.LP4;
        }

        protected bool CheckIsTower(string device)
        {
            return  device == DeviceName.SignalTower;
        }
        protected IServerModule GetEntity(string name)
        {
            IServerModule result = Singleton<EntityFactory>.Instance.GetEntity(name);
            if (result.Name == DeviceName.Aligner && !AlignerInstalled)
                return null;
            return result;
        }
    }



}