Kepler-Release/Venus/Venus_RT/Modules/Schedulers/TransferModule.cs

using MECF.Framework.Common.Equipment;
using Venus_RT.Modules.Schedulers;
using Venus_RT.Scheduler;
using Aitex.Core.RT.Routine;
using System.Collections.Generic;
using Venus_Core;

namespace Venus_RT.Modules
{
    public class TransferModule
    {
        protected SchedulerEfemRobot _efemRobot = new SchedulerEfemRobot();
        protected SchedulerTMRobot _tmRobot = null;
        protected SchedulerSETMRobot _setm = null;

        protected SchedulerLoadPort _lp1 = new SchedulerLoadPort(ModuleName.LP1);
        protected SchedulerLoadPort _lp2 = new SchedulerLoadPort(ModuleName.LP2);
        protected SchedulerLoadPort _lp3 = new SchedulerLoadPort(ModuleName.LP3);

        protected SchedulerLoadLock _lla = new SchedulerLoadLock(ModuleName.LLA);
        protected SchedulerLoadLock _llb = new SchedulerLoadLock(ModuleName.LLB);

        protected SchedulerAligner _aligner1 = new SchedulerAligner(ModuleName.Aligner1);
        protected SchedulerAligner _aligner2 = new SchedulerAligner(ModuleName.Aligner2);
        protected SchedulerAligner _cooling1 = new SchedulerAligner(ModuleName.Cooling1);
        protected SchedulerAligner _cooling2 = new SchedulerAligner(ModuleName.Cooling2);

        protected SchedulerPM _pma = new SchedulerPM(ModuleName.PMA);
        protected SchedulerPM _pmb = new SchedulerPM(ModuleName.PMB);

        protected SchedulerPM _pmc = new SchedulerPM(ModuleName.PMC);
        protected SchedulerPM _pmd = new SchedulerPM(ModuleName.PMD);

        public TransferModule()
        {
        }


        public SchedulerModule GetScheduler(ModuleName module)
        {
            if (!ModuleHelper.IsInstalled(module))
                return null;

            switch (module)
            {
                case ModuleName.LP1:
                    return _lp1;
                case ModuleName.LP2:
                    return _lp2;
                case ModuleName.LP3:
                    return _lp3;

                case ModuleName.Aligner1:
                    return _aligner1;

                case ModuleName.Aligner2:
                    return _aligner2;

                case ModuleName.Cooling1:
                    return _cooling1;

                case ModuleName.Cooling2:
                    return _cooling2;
                case ModuleName.EfemRobot:
                    return _efemRobot;

                case ModuleName.LLA:
                    return _lla;
                case ModuleName.LLB:
                    return _llb;

                case ModuleName.TMRobot:
                    switch(RtInstance.ConfigType)
                    {
                        case ConfigType.VenusSE:
                        case ConfigType.VenusDE:
                            {
                                if (_setm == null)
                                    _setm = new SchedulerSETMRobot();

                                return _setm;
                            }
                        default:
                            {
                                if(_tmRobot == null)
                                    _tmRobot = new SchedulerTMRobot();

                                return _tmRobot;
                            }
                    }

                case ModuleName.PMA:
                    return _pma;
                case ModuleName.PMB:
                    return _pmb;
                case ModuleName.PMC:
                    return _pmc;
                case ModuleName.PMD:
                    return _pmd;

            }

            return null;
        }
    }

    public interface IAutoTransfer
    {
        bool HasJobRunning
        {
            get;
        }
        Result Monitor();
        bool CheckAllJobDone();

        bool CheckJobJustDone(out string sJobName);
        Result Start(params object[] objs);

        void Map(string moduleName);
        bool CheckRecipeUsedInJob(string pathName);

        bool CheckSequenceUsedInJob(string pathName);

        void CreateJob(Dictionary<string, object> param);

        void AbortJob(string jobName);

        void StopJob(string jobName);
        void ResumeJob(string jobName);

        void PauseJob(string jobName);

        void StartJob(string jobName);

        void ResetIdlePurgeTime(string module);
        void ResetIdleCleanTime(string module);

        void Clear();
    }
}