PunkHPX8/PunkHPX8_RT/Schedulers/SchedulerManager.cs

using Aitex.Core.Common;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.Common.ToolLayout;
using PunkHPX8_RT.Schedulers.Aligner;
using PunkHPX8_RT.Schedulers.EfemRobot;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PunkHPX8_RT.Schedulers.Srd;
using PunkHPX8_RT.Dispatch;
using PunkHPX8_RT.Modules;
using Aitex.Core.RT.SCCore;
using PunkHPX8_RT.Modules.VpwMain;

namespace PunkHPX8_RT.Schedulers
{
    public class SchedulerManager : Singleton<SchedulerManager>
    {
        #region 内部变量
        /// <summary>
        /// 模块类型集合字典
        /// </summary>
        private Dictionary<ModuleType, List<SchedulerModule>> _scheduleModuleTypeDic = new Dictionary<ModuleType, List<SchedulerModule>>();
        /// <summary>
        /// 模块字典
        /// </summary>
        private Dictionary<ModuleName, SchedulerModule> _scheduleModuleDic = new Dictionary<ModuleName, SchedulerModule>();
        /// <summary>
        /// 是否启用QDR时间轴
        /// </summary>
        private bool _isQdrCheckConflict = false;
        #endregion

        #region 属性
        /// <summary>
        /// 是否启用QDR时间轴
        /// </summary>
        public bool IsQdrCheckConflict { get { return _isQdrCheckConflict; } }
        #endregion

        #region 初始化
        /// <summary>
        /// 初始化
        /// </summary>
        public void Initialize()
        {
            _isQdrCheckConflict = SC.GetValue<bool>("Scheduler.IsQdrCheckConflict");
            AddScheduleModule(ModuleType.EfemRobot, new SchedulerRobot(ModuleName.EfemRobot));
            AddScheduleModule(ModuleType.Aligner, new SchedulerAligner(ModuleName.Aligner1));
            InitializeSchedulerModules(SrdItemManager.Instance.InstalledModules,ModuleType.SRD,typeof(SchedulerSrd));
            InitializeSchedulerModules(VpwCellItemManager.Instance.InstalledModules, ModuleType.VPW, typeof(SchedulerVPW));
        }
        /// <summary>
        /// 重置
        /// </summary>
        public void ResetSchedulerModule()
        {
            List<ModuleName> moduleNames = _scheduleModuleDic.Keys.ToList();
            foreach(ModuleName item in moduleNames)
            {
                _scheduleModuleDic[item].ResetTask();
            }
        }
        /// <summary>
        /// 初始化调度Module集合
        /// </summary>
        private void InitializeSchedulerModules(List<string> installedModules,ModuleType moduleType,Type type)
        {
            foreach(string item in installedModules)
            {
                InitializeSchedulerModule(item, moduleType, type);
            }
        }
        /// <summary>
        /// 初始化调度Module
        /// </summary>
        /// <param name="item"></param>
        /// <param name="moduleType"></param>
        /// <param name="type"></param>
        private void InitializeSchedulerModule(string item, ModuleType moduleType, Type type)
        {
            ModuleName moduleName = (ModuleName)Enum.Parse(typeof(ModuleName), item);
            SchedulerModule schedulerModule = (SchedulerModule)System.Activator.CreateInstance(type, moduleName);
            AddScheduleModule(moduleType, schedulerModule);
        }

        /// <summary>
        /// 增加调度模块
        /// </summary>
        /// <param name="moduleType"></param>
        /// <param name="module"></param>
        private void AddScheduleModule(ModuleType moduleType, SchedulerModule module)
        {
            List<SchedulerModule> schedulers = new List<SchedulerModule>();
            if (_scheduleModuleTypeDic.ContainsKey(moduleType))
            {
                schedulers = _scheduleModuleTypeDic[moduleType];
            }
            else
            {
                _scheduleModuleTypeDic[moduleType] = schedulers;
            }
            schedulers.Add(module);
            _scheduleModuleDic[module.Module] = module;
        }
        #endregion
        /// <summary>
        /// 获取调度对象
        /// </summary>
        /// <param name="moduleName"></param>
        /// <returns></returns>
        public SchedulerModule GetScheduler(ModuleName moduleName)
        {
            return _scheduleModuleDic.ContainsKey(moduleName)?_scheduleModuleDic[moduleName]:null;
        }
        /// <summary>
        /// 根据模块类型获取调度模块集合
        /// </summary>
        /// <param name="moduleType"></param>
        /// <returns></returns>
        public List<SchedulerModule> GetModuleTypeScheduleModules(ModuleType moduleType) 
        {
            return _scheduleModuleTypeDic.ContainsKey(moduleType) ? _scheduleModuleTypeDic[moduleType]: null;
        }
        /// <summary>
        /// 获取配对的VPW
        /// </summary>
        /// <returns></returns>
        public VpwCellEntity GetMatchedVpw(string module)
        {
            VpwCellEntity vpwCellEntity1 = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(ModuleName.VPW1.ToString());
            VpwCellEntity vpwCellEntity2 = Singleton<RouteManager>.Instance.GetModule<VpwCellEntity>(ModuleName.VPW2.ToString());
            if (vpwCellEntity1 == null || vpwCellEntity2 == null)
            {
                return null;
            }
            if (!vpwCellEntity1.IsAuto || !vpwCellEntity2.IsAuto)
            {
                return null;
            }
            if(!WaferManager.Instance.CheckHasWafer(ModuleName.VPW1,0)||!WaferManager.Instance.CheckHasWafer(ModuleName.VPW2,0))
            {
                return null;
            }
            if (module == ModuleName.VPW1.ToString())
            {
                return vpwCellEntity2;
            }
            else
            {
                return vpwCellEntity1;
            }
        }
    }
}