Sic01/SicRT/Equipments/Schedulers/SchedulerModule.cs

using Aitex.Core.RT.Event;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Schedulers;
using MECF.Framework.Common.SubstrateTrackings;

namespace SicRT.Modules.Schedulers
{
    public class SchedulerModule
    {
        protected enum TaskType
        {
            None,

            PrepareTransfer,

            Pick,

            Place,

            PickAndPlace,

            Preprocess,
            Process,
            PostProcess,

            OpenCover,
            CloseCover,

            Load,
            Unload,

            Align,

            TransferTarget,

            Cooling,

            WarmUp,

            Vent,
            Pump,
            Purge,

            IdlePurgeProcess
        }

        public ModuleName Module
        {
            get { return ModuleHelper.Converter(_module); }
        }
        public virtual bool IsAvailable { get; }
        public virtual bool IsOnline { get; }
        public virtual bool IsError { get; }
        public virtual bool IsReady { get; }


        protected string _module;

        protected TaskType _task = TaskType.None;

        protected ModuleName _inProcessRobot;

        public SchedulerModule(string module)
        {
            _module = module;
        }
        protected void LogTaskStart(TaskType cmd, string message)
        {
            EV.PostInfoLog("Scheduler", $"Task start:{_module},{cmd} {message}");
             
        }
        protected void LogTaskDone(TaskType cmd, string message)
        {
            EV.PostInfoLog("Scheduler", $"Task done:{_module},{cmd} {message}");
        }
        public void ResetTask()
        {
            _task = TaskType.None;
        }

        public bool WaitTransfer(ModuleName robot)
        {
            _task = TaskType.TransferTarget;
            _inProcessRobot = robot;
            LogTaskStart(_task, $"Note {robot} in transfer");
            return true;
        }

        public bool IsWaitTransfer(ModuleName robot)
        {
            return _task == TaskType.TransferTarget && _inProcessRobot == robot;
        }

        public bool StopWaitTransfer(ModuleName robot)
        {
            LogTaskDone(_task, $"Note {robot} transfer complete");
            _inProcessRobot = ModuleName.System;

            _task = TaskType.None;
            return true;
        }
        public bool HasWafer(int slot)
        {
            return WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot);
        }

        public bool NoWafer(int slot)
        {
            return WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);
        }


        public virtual bool IsReadyForPick(ModuleName robot, int slot)
        {
            return true;
        }

        public virtual bool IsReadyForPlace(ModuleName robot, int slot)
        {
            return true;
        }

        public virtual bool PrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            return true;
        }

        public virtual bool PostTransfer(ModuleName robot, EnumTransferType type, int slot)
        {
            return true;
        }

        public virtual bool Process(string recipeName, bool isCleanRecipe, bool withDummyWafer)
        {
            return true;
        }

        public virtual bool Cooling(bool coolingType,int coolingTime)
        {
            return true;
        }

        public virtual bool WarmUp(int warmUpTime)
        {
            return true;
        }

    }

}