Sic10/SicRT/Equipments/Schedulers/SchedulerBuffer.cs

using Aitex.Core.RT.Fsm;
using Aitex.Core.Util;
using SicRT.Scheduler;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using SicRT.Equipments;
using SicRT.Equipments.Systems;
using Mainframe.Buffers;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Devices;

namespace SicRT.Modules.Schedulers
{
    public class SchedulerBuffer : SchedulerModule 
    {
        public override bool IsAvailable
        {
            get { return _buffer.IsIdle && _buffer.IsOnline && CheckTaskDone(); }

        }
        public override bool IsOnline
        {
            get { return _buffer.IsOnline; }

        }
        public override bool IsError
        {
            get { return _buffer.IsError; }

        }

        private BufferModuleBase _buffer = null;

        private int _entityTaskToken = (int)FSM_MSG.NONE;

        public SchedulerBuffer(ModuleName module) : base(module.ToString())
        {
            _module = module.ToString();
            _buffer = Singleton<EquipmentManager>.Instance.Modules[module] as BufferModuleBase;
        }

        public bool Monitor()
        { 
            return true;
        }

        internal float GetTemperature()
        {
            IoTempMeter deviceBufferTemp = DEVICE.GetDevice<IoTempMeter>($"Buffer.BufferTemp");
            return deviceBufferTemp.FeedBack;
        }

        public override bool Cooling(bool coolingTypeIsTime,int coolingValue)
        {
            _task = TaskType.Cooling;

            _entityTaskToken = _buffer.InvokeCooling(coolingTypeIsTime, coolingValue);

            if (coolingTypeIsTime)
            {
                LogTaskStart(_task, $"{Module} cooling {coolingValue} seconds");
            }
            else 
            {
                LogTaskStart(_task, $"{Module} cooling wait temprature below {coolingValue}℃");
            }

            return _entityTaskToken != (int)FSM_MSG.NONE;
        }

        public bool PreHeat(int preTemp)
        {
            _task = TaskType.WarmUp;
            LogTaskStart(_task, $"{Module} warm up to {preTemp} ℃");
            _entityTaskToken = _buffer.InvokeWarmUp(preTemp);
            return _entityTaskToken != (int)FSM_MSG.NONE;
        }

        public bool CheckTaskDone()
        {
            bool ret = false;
            switch (_task)
            {
                case TaskType.None:
                    ret = true;
                    break;
                case TaskType.Cooling:
                    ret = _buffer.CheckAcked(_entityTaskToken);
                    break;
                case TaskType.WarmUp:
                    ret = _buffer.CheckAcked(_entityTaskToken);
                    break;
            }

            if (ret && _task != TaskType.None)
            {
                LogTaskDone(_task,"");
                _task = TaskType.None;
            }

            return ret;
        }
    }
}