PunkHPX8/Framework/Common/Device/ModuleName.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.ToolLayout;

namespace MECF.Framework.Common.Equipment
{
    /// <summary>
    /// 在框架中，Module指具备放置Wafer的单元
    /// </summary>
    [DataContract]
    [Serializable]
    public enum ModuleName
    {
        [EnumMember]
        Unknown=9999,
        [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,

        [EnumMember]
        Aligner1,

        [EnumMember]
        Aligner2,
        [EnumMember]
        Robot,
 
        [EnumMember]
        VPA,
        [EnumMember]
        SRD1,
        [EnumMember]
        SRD2,
        [EnumMember]
        Dummy1,
        [EnumMember]
        Dummy2,
        [EnumMember]
        Loader1,
        [EnumMember]
        Reservoir1,
        [EnumMember]
        Reservoir2,
        [EnumMember]
        Reservoir3,
        [EnumMember]
        Reservoir4,
        [EnumMember]
        Reservoir5,

        [EnumMember]
        VPWMain1,
        [EnumMember]
        VPW1,
        [EnumMember]
        VPW2,
        [EnumMember]
        VPW3,
        [EnumMember]
        VPW4,
        [EnumMember]
        VPW5,
        [EnumMember]
        VPW6,
        [EnumMember]
        VPW7,
        [EnumMember]
        VPW8,
        [EnumMember]
        VPW9,
        [EnumMember]
        VPW10,
        [EnumMember]
        PlatingCell1,
        [EnumMember]
        PlatingCell2,
        [EnumMember]
        PlatingCell3,
        [EnumMember]
        PlatingCell4,
        [EnumMember]
        PlatingCell5,
        [EnumMember]
        PlatingCell6,
        [EnumMember]
        PlatingCell7,
        [EnumMember]
        PlatingCell8,
        [EnumMember]
        PlatingCell9,
        [EnumMember]
        PlatingCell10,
        [EnumMember]
        PlatingCell1_2,
        [EnumMember]
        PlatingCell3_4,
        [EnumMember]
        PlatingCell5_6,
        [EnumMember]
        PlatingCell7_8,
        [EnumMember]
        PlatingCell9_10
    }

    /// <summary>
    /// 模块类型
    /// </summary>
    public enum ModuleType
    {
        None,
        LoadPort,
        EfemRobot,
        Aligner,
        SRD,
        PUF,
        Loader,
        Buffer,
        Dryer,
        Rinse,
        Prewet,
        Metal,
        Dummy,
        Transporter,
        Reservoir,
        VpwMain,
        VPW,
        PlatingCell,
        PlatingCellVertical
    }
    public static class ModuleHelper
    {
        public static bool IsSRD(ModuleName unit)
        {
            return unit == ModuleName.SRD1 || unit == ModuleName.SRD2;
        }
        public static bool IsReservoir(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.Reservoir1 && (int)unit <= (int)ModuleName.Reservoir5;
        }

        public static bool IsVPWCell(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.VPW1 && (int)(unit) <= (int)ModuleName.VPW10;

        }
        public static bool IsPlatingCell(ModuleName unit)
        {
            return (int)unit >= (int)ModuleName.PlatingCell1 && (int)(unit) <= (int)ModuleName.PlatingCell4;

        }

        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 IsDummy(ModuleName unit)
        {
            return unit == ModuleName.Dummy1 || unit == ModuleName.Dummy2;
        }
        public static bool IsAligner(ModuleName unit)
        {
            return unit == ModuleName.Aligner || unit == ModuleName.Aligner1 || unit == ModuleName.Aligner2  ;
        }

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

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

        public static ModuleName Converter(string module)
        {
            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];
        }

        private static List<ModuleName> _lstModules = new List<ModuleName>();
        private static readonly object _lock = new object();
        public static bool IsInstalled(ModuleName module)
        {
            //if (_lstModules.Count == 0)
            //{
            //    LoadModules();
            //}

            //return _lstModules.Contains(module);
            return ToolLayoutConfigManager.Instance.IsInstalled(module);
        }
        public static void LoadModules()
        {
            lock (_lock)
            {
                try
                {
                    string moduleString = SC.GetStringValue("System.InstalledModules");
                    var modules = moduleString.Split(',');
                    foreach (var mod in modules)
                    {
                        var module = Converter(mod.Trim());
                        _lstModules.Add(module);
                    }
                }

                catch (Exception e)
                {
                    LOG.WriteExeption("Loading intalled module error, please check the config item: System.InstalledModules", e);
                }

            }
        }
    }

    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";

        public static ModuleName ToEnum(string value)
        {
            return (ModuleName)Enum.Parse(typeof(ModuleName), value, true);

        }
    }

}