ELK/Branch/NTP02/FrameworkLocal/Common/Device/ModuleName.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;

namespace MECF.Framework.Common.Equipment
{
    /// <summary>
    /// 在框架中，Module指具备放置Wafer的单元
    /// </summary>
    [DataContract]
    [Serializable]
    public enum ModuleName
    {
        [EnumMember]
        System = 0,

        [EnumMember]
        LP1,

        [EnumMember]
        LP2,

        [EnumMember]
        LP3,

        [EnumMember]
        LP4,

        [EnumMember]
        LP5,

        [EnumMember]
        LP6,

        [EnumMember]
        LP7,

        [EnumMember]
        LP8,

        [EnumMember]
        LP9,

        [EnumMember]
        LP10,

        //robot modules
        //[EnumMember]
        //Robot,

        [EnumMember]
        VaccumRobot,

        [EnumMember]
        LoadRobot,

        [EnumMember]
        EfemRobot,

        [EnumMember]
        TMRobot,

        //upenders
        //[EnumMember]
        //Upender,

        //efem
        [EnumMember]
        EFEM,

        //aligners
        [EnumMember]
        Aligner,

        //load locks
        [EnumMember]
        LL1,

        [EnumMember]
        LL2,

        [EnumMember]
        LL3,

        [EnumMember]
        LL4,

        //load locks
        //[EnumMember]
        //LLA,

        //[EnumMember]
        //LLB,

        //[EnumMember]
        //LLC,

        //[EnumMember]
        //LLD,

        //[EnumMember]
        //LLE,

        //[EnumMember]
        //LLF,

        //[EnumMember]
        //LLG,

        //[EnumMember]
        //LLH,

        //[EnumMember]
        //VCE1,

        //[EnumMember]
        //VCE2,

        //[EnumMember]
        //VCEA,


        //transfer modules
        [EnumMember]
        TM,

        [EnumMember]
        Cooling1,

        [EnumMember]
        Cooling2,
        //buffers
        [EnumMember]
        Buffer,

        [EnumMember]
        Buffer1,

        [EnumMember]
        Buffer2,

        [EnumMember]
        Buffer3,

        [EnumMember]
        Buffer4,

        [EnumMember]
        Buffer5,

        [EnumMember]
        Buffer6,
        
        //PMs

        [EnumMember]
        PM,

        [EnumMember]
        PM1,

        [EnumMember]
        PM2,

        [EnumMember]
        PM3,

        [EnumMember]
        PM4,

        [EnumMember]
        PM5,

        [EnumMember]
        PM6,

        [EnumMember]
        PM7,

        [EnumMember]
        PM8,

        [EnumMember]
        PMA,

        [EnumMember]
        PMB,

        [EnumMember]
        PMC,

        [EnumMember]
        PMD,

        [EnumMember]
        Robot,
        [EnumMember]
        Handler,
        [EnumMember]
        WIDReader1,
        [EnumMember]
        WIDReader2,

        [EnumMember]
        TurnOverStation,

        [EnumMember]
        Host,

        [EnumMember]
        Cooling,

        [EnumMember]
        Cassette,

        [EnumMember]
        CassetteA,

        [EnumMember]
        CassetteB,


        [EnumMember]
        LoadLock,

        [EnumMember]
        SMIFLeft,

        [EnumMember]
        SMIFRight,


        [EnumMember]
        SMIFA,

        [EnumMember]
        SMIFB,
       
        [EnumMember]
        CassetteRobot,
        [EnumMember]
        SignalTower,
        [EnumMember]
        TurnStation,

        [EnumMember]
        Stocker1,
        [EnumMember]
        Stocker2,
        [EnumMember]
        Stocker3,
        [EnumMember]
        Stocker4,
        [EnumMember]
        Stocker5,
        [EnumMember]
        Stocker6,
        [EnumMember]
        Stocker7,
        [EnumMember]
        Stocker8,
        [EnumMember]
        Stocker9,
        [EnumMember]
        Stocker10,
        [EnumMember]
        Stocker11,
        [EnumMember]
        Stocker12,
        [EnumMember]
        Stocker13,
        [EnumMember]
        Stocker14,
        [EnumMember]
        Stocker15,
        [EnumMember]
        Stocker16,
        [EnumMember]
        Stocker17,
        [EnumMember]
        Stocker18,
        [EnumMember]
        Stocker19,
        [EnumMember]
        Stocker20,
        [EnumMember]
        Stocker21,

        [EnumMember]
        StageA,
        [EnumMember]
        StageB,
        [EnumMember]
        WaferRobot,
        [EnumMember]
        Boat,

        [EnumMember]
        CMB,

        [EnumMember]
        Cassette1,
        [EnumMember]
        Cassette2,
        [EnumMember]
        Cassette3,
        [EnumMember]
        Cassette4,
        [EnumMember]
        Cassette5,

        [EnumMember]
        CarrierRobot,
        [EnumMember]
        FIMS1,
        [EnumMember]
        FIMS2,
    }

    public static class ModuleHelper
    {
        public static bool IsTurnOverStation(ModuleName unit)
        {
            return unit == ModuleName.TurnOverStation;
        }
        public static bool IsLoadPort(ModuleName unit)
        {
            return unit == ModuleName.LP1
                   || unit == ModuleName.LP2
                   || unit == ModuleName.LP3
                   || unit == ModuleName.LP4
                   || unit == ModuleName.LP5
                   || unit == ModuleName.LP6
                   || unit == ModuleName.LP7
                   || unit == ModuleName.LP8
                   || unit == ModuleName.LP9
                   || unit == ModuleName.LP10;
        }
        public static bool IsCassette(ModuleName unit)
        {
            return unit == ModuleName.Cassette1
                   || unit == ModuleName.Cassette2
                   || unit == ModuleName.Cassette3
                   || unit == ModuleName.Cassette4
                   || unit == ModuleName.Cassette5
                   || unit == ModuleName.Cassette;
        }

        public static bool IsCOT(string unit)
        {
            return unit.ToString().Contains( "2_1")
                   || unit.ToString().Contains("2_2");
        }

        public static bool IsBuffer(ModuleName unit)
        {
            return unit == ModuleName.Buffer
                   || unit == ModuleName.Buffer1
                   || unit == ModuleName.Buffer2
                   || unit == ModuleName.Buffer3
                   || unit == ModuleName.Buffer4
                   || unit == ModuleName.Buffer5
                   || unit == ModuleName.Buffer6;
        }

        public static bool IsBufferStocker(ModuleName unit)
        {
            return unit == ModuleName.Stocker1
                   || unit == ModuleName.Stocker2
                   || unit == ModuleName.Stocker3
                   || unit == ModuleName.Stocker4
                   || unit == ModuleName.Stocker5
                   || unit == ModuleName.Stocker6
                   || unit == ModuleName.Stocker7
                   || unit == ModuleName.Stocker8
                   || unit == ModuleName.Stocker9
                   || unit == ModuleName.Stocker10
                   || unit == ModuleName.Stocker11
                   || unit == ModuleName.Stocker12
                   || unit == ModuleName.Stocker13
                   || unit == ModuleName.Stocker14
                   || unit == ModuleName.Stocker15
                   || unit == ModuleName.Stocker16;
        }
        public static bool IsPm(string unit)
        {
            return IsPm(ModuleHelper.Converter(unit));
        }
        public static bool IsPm(ModuleName unit)
        {
            return unit == ModuleName.PM1
                   || unit == ModuleName.PM2
                   || unit == ModuleName.PM3
                   || unit == ModuleName.PM4
                   || unit == ModuleName.PM5
                   || unit == ModuleName.PM6
                   || unit == ModuleName.PM7
                   || unit == ModuleName.PM8
                   || unit == ModuleName.PM
                   || unit == ModuleName.PMA
                   || unit == ModuleName.PMB
                   || unit == ModuleName.PMC
                   || unit == ModuleName.PMD
                    ;
        }
 
        public static bool IsLoadLock(string unit)
        {
            return IsLoadLock(ModuleHelper.Converter(unit));
        }

        public static bool IsLoadLock(ModuleName unit)
        {
            return unit == ModuleName.LoadLock;
        }

        public static bool IsStocker(ModuleName unit)
        {
            return unit == ModuleName.Stocker1
                   || unit == ModuleName.Stocker2
                   || unit == ModuleName.Stocker3
                   || unit == ModuleName.Stocker4
                   || unit == ModuleName.Stocker5
                   || unit == ModuleName.Stocker6
                   || unit == ModuleName.Stocker7
                   || unit == ModuleName.Stocker8
                   || unit == ModuleName.Stocker9
                   || unit == ModuleName.Stocker10
                   || unit == ModuleName.Stocker11
                   || unit == ModuleName.Stocker12
                   || unit == ModuleName.Stocker13
                   || unit == ModuleName.Stocker14
                   || unit == ModuleName.Stocker15
                   || unit == ModuleName.Stocker16
                   || unit == ModuleName.Stocker17
                   || unit == ModuleName.Stocker18
                   || unit == ModuleName.Stocker19
                   || unit == ModuleName.Stocker20
                   || unit == ModuleName.Stocker21;
        }

        public static bool IsCooling(string unit)
        {
            return IsCooling(ModuleHelper.Converter(unit));
        }
        public static bool IsCooling(ModuleName unit)
        {
            return unit == ModuleName.Cooling;
        }

        public static bool IsAligner(string unit)
        {
            return IsAligner(ModuleHelper.Converter(unit));
        }
        

        public static bool IsAligner(ModuleName unit)
        {
            return unit == ModuleName.Aligner;
        }
        public static bool IsRobot(string unit)
        {
            return IsRobot(ModuleHelper.Converter(unit));
        }
        public static bool IsRobot(ModuleName unit)
        {
            return unit.ToString().Contains("Robot");
        }

        public static bool IsEfemRobot(string unit)
        {
            return IsEfemRobot(ModuleHelper.Converter(unit));
        }

        public static bool IsEfemRobot(ModuleName unit)
        {
            return unit == ModuleName.EfemRobot;
        }

        public static bool IsTMRobot(string unit)
        {
            return IsTMRobot(ModuleHelper.Converter(unit));
        }

        public static bool IsTMRobot(ModuleName unit)
        {
            return unit == ModuleName.TMRobot;
        }
        public static bool IsTurnStation(ModuleName unit)
        {
            return unit == ModuleName.TurnStation;
        }

        public static string GetAbbr(ModuleName module)
        {
            switch (module)
            {
                case ModuleName.Aligner: return "PA";
                case ModuleName.Robot: return "RB";
                default: return module.ToString();
            }
        }

        public static string GetE84LpName(string device)
        {
            string e84 = string.Empty;
            switch(device)
            {
                case "P1":
                case "LP1":
                    e84 = "Loadport1E84";
                    break;
                case "P2":
                case "LP2":
                    e84 = "Loadport2E84";
                    break;
                case "P3":
                case "LP3":
                    e84 = "Loadport3E84";
                    break;
                case "P4":
                case "LP4":
                    e84 = "Loadport4E84";
                    break;
                case "P5":
                case "LP5":
                    e84 = "Loadport5E84";
                    break;
                case "P6":
                case "LP6":
                    e84 = "Loadport6E84";
                    break;
                case "P7":
                case "LP7":
                    e84 = "Loadport7E84";
                    break;
                case "P8":
                case "LP8":
                    e84 = "Loadport8E84";
                    break;
                case "P9":
                case "LP9":
                    e84 = "Loadport9E84";
                    break;
                case "P10":
                case "LP10":
                    e84 = "Loadport10E84";
                    break;
            }

            return e84;
        }
        
        public static ModuleName Converter(string module)
        {
            module = module.Replace("-", "_");
            if (module.ToLower().Contains("1_1"))
                return ModuleName.Cassette1;
            if (module.ToLower().Contains("1_2"))
                return ModuleName.Cassette2;
            if (module.ToLower().Contains("1_3"))
                return ModuleName.Cassette3;
            if (module.ToLower().Contains("1_4"))
                return ModuleName.Cassette4;
            if (module.ToLower().Contains("1_5"))
                return ModuleName.Cassette5;
            return (ModuleName) Enum.Parse(typeof(ModuleName), module);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="index">0 based</param>
        /// <returns></returns>
        public static ModuleName GetLoadPort(int index)
        {
            ModuleName[] lps = new ModuleName[]
            {
                ModuleName.LP1, ModuleName.LP2, ModuleName.LP3, ModuleName.LP4, ModuleName.LP5,
                ModuleName.LP6, ModuleName.LP7, ModuleName.LP8, ModuleName.LP9, ModuleName.LP10,
            };
            return lps[index];
        }
    }

    public class ModuleNameString
    {
        public const string System = "System";

        public const string LDULD = "LDULD";
        public const string BufferOut = "BufferOut";
        public const string BufferIn = "BufferIn";
        public const string Dryer = "Dryer";
        public const string QDR = "QDR";
        public const string Robot = "Robot";
        public const string Handler = "Handler";

    }
}