ZZ-EFEM/Jet/Jet_001_2P_Jet/EfemRT/Devices/CoolBuffer.cs

using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.BufferStations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EFEM.RT.Devices
{
    public class Buffer : BufferStation
    {
        //public override int InfoPadCarrierIndex
        //{
        //    get => base.InfoPadCarrierIndex;

        //    set => base.InfoPadCarrierIndex = value;
        //}
        private int slotNumber = 25;
        public IoSensor BufferInrerlock=null;
        //public bool MapError { get; set; }
        public string SlotMap
        {
            get
            {
                WaferInfo[] wafers = WaferManager.Instance.GetWafers(ModuleHelper.Converter(Name));
                string slot = "";
                for (int i = 0; i < ValidSlotsNumber; i++)
                {
                    slot += wafers[i].IsEmpty ? "0" : "1";
                }

                return slot;
            }
        }
        public Buffer(string module, string name,int slotNumber,IoSensor bufferInrerlock ) : base(module, name, slotNumber)
        {
            this.slotNumber = slotNumber;
            if (bufferInrerlock!=null)
                BufferInrerlock = bufferInrerlock;
        }
        private bool _isMapped;
        private bool EnableMap { get; set; }
        public bool IsNeedMap
        {  get
            {
                if (SC.ContainsItem($"System.IsEnableBufferMap"))
                    return SC.GetValue<bool>($"System.IsEnableBufferMap");

                return true;

            }
        }
        public override bool IsMapped
        {
            get
            {
                return _isMapped;
            }
        }
        public int ValidSlotsNumber
        {
            get
            {
                if (SC.ContainsItem($"System.{Name}SlotCount"))
                    return SC.GetValue<int>($"System.{Name}SlotCount");

                return 25;

            }
        }
        public int waferSize
        {
            get
            {
                if (SC.ContainsItem($"System.{Name}WaferSize"))
                    return SC.GetValue<int>($"System.{Name}WaferSize");
                return 8;
            }
        }
          
        public WaferSize Size
        {
            get 
            { 
                 switch (waferSize)
                {
                    case 0:
                        return WaferSize.WS0;
                    case 1:
                        return WaferSize.WS0;
                    case 2:
                        return WaferSize.WS2;
                    case 3:
                        return WaferSize.WS3;
                    case 4:
                        return WaferSize.WS4;
                    case 5:
                        return WaferSize.WS5;
                    case 6:
                        return WaferSize.WS6;
                    case 7:
                    case 8:
                        return WaferSize.WS8;
                    case 12:
                        return WaferSize.WS12;
                    default:
                        return WaferSize.WS0;
               }
            }
        }
        public override bool Initialize()
        {
            //DATA.Subscribe($"{Name}.WaferSize", () =>
            //{
            //    CurrentWaferSize = WaferManager.Instance.GetWaferSize(ModuleHelper.Converter(Name), 0);
            //    return WaferManager.Instance.GetWaferSize(ModuleHelper.Converter(Name), 0).ToString();
            //});

            //OP.Subscribe($"{Name}.SetWaferSize6", (string cmd, object[] args) =>
            //{
            //    CurrentWaferSize = WaferSize.WS6;
            //    InfoPadCarrierIndex = 1;
            //    return true;
            //});

            //OP.Subscribe($"{Name}.SetWaferSize8", (string cmd, object[] args) =>
            //{
            //    CurrentWaferSize = WaferSize.WS8;
            //    InfoPadCarrierIndex = 2;
            //    return true;
            //});
            //DATA.Subscribe($"System.Enable{Name}Map", () => EnableMap);
            DATA.Subscribe($"{Name}.ValidSlotsNumber", () => ValidSlotsNumber);
            DATA.Subscribe($"{Name}.WaferSizeByWafer", () => WaferManager.Instance.GetWaferSize(ModuleHelper.Converter(Name), 0));
            IsMapped = false; //SC.GetValue<bool>("System.EnableBufferMap");
           // IsNeedMap = SC.GetValue<bool>($"System.IsEnableBufferMap");
            return base.Initialize();
        }
        public override bool IsEnableTransferWafer(out string reason)
        {

            if (IsNeedMap&& !_isMapped )
            {  
                reason = "not mapped";
                EV.PostAlarmLog(Name,$"{Name} not mapped");
                return false;
            }
            if (IsNeedMap && MapError)
            {
                reason = "MapError";
                EV.PostAlarmLog(Name, $"{Name} MapError");
                return false;
            }
            if (BufferInrerlock != null && !BufferInrerlock.Value)
            {
                reason = $"TM Robot Is Extending to {Name}";
                EV.PostAlarmLog(Name, $"TM Robot Is Extending to {Name}");
                return false;
            }
            return base.IsEnableTransferWafer(out reason);
        }
        public override bool IsEnableMapWafer(out string reason)
        {
            reason = "Not supported";
            if (BufferInrerlock != null && !BufferInrerlock.Value)
            {
                reason = $"TM Robot Is Extending to {Name}";
                EV.PostAlarmLog(Name, $"TM Robot Is Extending to {Name}");
                return false;
            }
            //return false;
            return true;
        }

        public override void OnSlotMapRead(string slotMap)
        {
            ModuleName module = ModuleHelper.Converter(Name);
            for (int i = 0; i <ValidSlotsNumber; i++)
            {
                // No wafer: "0", Wafer: "1", Crossed:"2", Undefined: "?", Overlapping wafers: "W"
                WaferInfo wafer = null;
                switch (slotMap[i])
                {
                    case '0':
                        WaferManager.Instance.DeleteWafer(module, i);
                        break;
                    case '1':
                        wafer = WaferManager.Instance.CreateWafer(module, i, WaferStatus.Normal);
                        WaferManager.Instance.UpdateWaferSize(module, i, Size);

                        break;
                    case '2':
                        wafer = WaferManager.Instance.CreateWafer(module, i, WaferStatus.Crossed);
                        WaferManager.Instance.UpdateWaferSize(module, i, Size);
                        EV.PostAlarmLog("Buffer", $"{module} map crossed wafer on slot:{i + 1}.");
                        break;
                    case 'W':
                        wafer = WaferManager.Instance.CreateWafer(module, i, WaferStatus.Double);
                        WaferManager.Instance.UpdateWaferSize(module, i, Size);
                        EV.PostAlarmLog("Buffer", $"{module} map double wafer on slot:{i + 1}.");
                        break;
                    case '?':
                        wafer = WaferManager.Instance.CreateWafer(module, i, WaferStatus.Unknown);
                        WaferManager.Instance.UpdateWaferSize(module, i, Size);
                        EV.PostAlarmLog("Buffer", $"{module} map unknown wafer on slot:{i + 1}.");
                        break;
                }
            }
            if (slotMap.Contains('2') || slotMap.Contains('W') || slotMap.Contains('?'))
                MapError = true;
            else MapError = false;
            _isMapped = true;
        }
    }
}