Mars200/Mars/JetEfem/LPs/FutureEfemLoadPortBase.cs

using System;
using System.Collections;
using System.Threading.Tasks;
using Aitex.Core.Common;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.Device.Unit;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.FAServices;
using MECF.Framework.Common.SubstrateTrackings;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Efems.Rorzes;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.LoadPorts;

namespace JetEfemLib.LPs
{
    public abstract class FutureEfemLoadPortBase : LoadPort, IEfemLoadPortCallback
    {
        public enum LoadPortStates
        {
            Undefined = 0,
            NotInitialized = 1,
            Initializing = 2,
            Idle = 3,
            Mapping = 4,
            MappingStation = 5,
            Homing = 6,
            Faulted = 7,
            Clamping = 8,
            Docking = 9,
            Unclamping = 10,
            Undocking = 11,
            OpeningDoor = 12,
            ClosingDoor = 13,
            Loading = 15,
            Unloading = 16,
            ReadingCarrierID = 17,
            Querying = 18,
            ChangeAccessMode = 19,
            ChangeTransferState = 20,
            WritingCarrierID = 21,
            ClearError,
            SetIndicator,
        }

        private LoadportCassetteState _cassetteState;
        public override LoadportCassetteState CassetteState
        {
            get { return _cassetteState; }
            set { _cassetteState = value; }
        }
        protected FoupClampState _clampState;
        public override FoupClampState ClampState
        {
            get { return _clampState; }
            set { _clampState = value; }
        }

        protected FoupDockState _dockState;
        public override FoupDockState DockState
        {
            get { return _dockState; }
            set { _dockState = value; }
        }
        protected FoupDoorState _doorState;
        public override FoupDoorState DoorState
        {
            get { return _doorState; }
            set { _doorState = value; }
        }


        public override bool IsAutoClampOnFoupOn
        {
            get
            {
                return SC.GetValueOrDefault<bool>($"EFEM.LoadPort.AutoClampOnFoupOn");
            }
        }

        public override bool IsAutoReadCarrierID
        {
            get
            {
                return SC.GetValueOrDefault<bool>($"EFEM.LoadPort.EnableAutoCarrierIdRead");
            }
        }

        protected RorzeEfem _efem;

        public override bool IsWaferProtrude { get; set; }

        private RD_TRIG _trigPresentAbsent = new RD_TRIG();
        private RD_TRIG _trigPresentAbsentDely = new RD_TRIG();

        private RD_TRIG _trigPlacement = new RD_TRIG();

        private R_TRIG _trigWaferProtrude = new R_TRIG();
        protected LoadPortStates _loadPortState;

        public WaferSize WaferSize { get; set; }
        public string LastMapResult { get; set; }
        public override bool IsBusy => !(_loadPortState == LoadPortStates.Idle || _loadPortState == LoadPortStates.ReadingCarrierID || _loadPortState == LoadPortStates.WritingCarrierID || _loadPortState == LoadPortStates.Querying);

        private DeviceTimer _deviceTimer = new DeviceTimer();
        private int _timeDelayNotifyCassettePresent = 100;    //ms

        public override WaferSize GetCurrentWaferSize()
        {
            return WaferSize;
        }

        //private bool _present4;
        //private bool _present6;

        protected string _efemName;

        //private bool _indicatorPlaced;
        //private bool _indicatorError;

        //private bool _isIntialized;

        public FutureEfemLoadPortBase(string module, string name, string efem)
        {
            base.Module = module;
            base.Name = name;
            base.Display = name;
            base.DeviceID = "";

            _efemName = efem;

            IsMapWaferByLoadPort = false;

            _loadPortState = LoadPortStates.NotInitialized;
        }

        public override bool Initialize()
        {
            //if (_efem == null && !string.IsNullOrEmpty(_efemName))
            //{
            //    _efem = DEVICE.GetDevice<FutureEfem>(_efemName);
            //    _efem.SetLoadPortCallback(ModuleHelper.Converter(Module), this);
            //}

            //DATA.Subscribe($"{Module}.IndicatorPlaced", () => _indicatorPlaced);
            //DATA.Subscribe($"{Module}.IndicatorError", () => _indicatorError);

            DATA.Subscribe($"{Module}.IsWaferProtrude", () => IsWaferProtrude);
            //DATA.Subscribe($"{Module}.IsPresent4", () => _present4);
            //DATA.Subscribe($"{Module}.IsPresent6", () => _present6);
            DATA.Subscribe($"{Module}.WaferSize", () => WaferSize.ToString());
            DATA.Subscribe($"{Module}.LastMapResult", () => LastMapResult);

            if (SC.ContainsItem("EFEM.LoadPort.TimeDelayNotifyCassettePresent"))
            {
                _timeDelayNotifyCassettePresent = SC.GetValue<int>("EFEM.LoadPort.TimeDelayNotifyCassettePresent");
            }

            return base.Initialize();
        }

        public override void Reset()
        {
            base.Reset();

            _trigWaferProtrude.RST = true;
        }

        public override bool IsEnableMapWafer()
        {
            return IsPlacement && !IsWaferProtrude;
        }

        public override bool IsEnableMapWafer(out string reason)
        {
            reason = string.Empty;
            //if (_loadPortState != LoadPortStates.Idle)
            //{
            //    reason = "Cassette is busy";
            //    return false;
            //}

            if (!IsPlacement)
            {
                reason = "Cassette not properly placed";
                return false;
            }

            if (IsWaferProtrude)
            {
                reason = "Found wafer protrude";
                return false;
            }

            if (CassetteState != LoadportCassetteState.Normal)
            {
                reason = "Cassette is abnormal";
                return false;
            }

            return IsPlacement && !IsWaferProtrude;
        }

        public override bool IsEnableTransferWafer()
        {
            return IsEnableTransferWafer(out _);
        }

        public override bool IsEnableTransferWafer(out string reason)
        {
            //if (_loadPortState != LoadPortStates.Idle)
            //{
            //    reason = "Cassette is busy";
            //    return false;
            //}

            if (!IsPlacement)
            {
                reason = "No cassette present";
                return false;
            }

            if (IsWaferProtrude)
            {
                reason = "Found wafer protrude";
                return false;
            }

            if (!_isMapped)
            {
                reason = "Cassette not mapped";
                return false;
            }

            if (DoorState != FoupDoorState.Open)
            {
                reason = "Cassette not open";
                return false;
            }

            if (CassetteState != LoadportCassetteState.Normal)
            {
                reason = "Cassette is abnormal";
                return false;
            }

            reason = "";
            return true;
        }

        public virtual void NoteStatus(string data1, string data2)
        {
            
        }

        /*
         *Report the wafer presence of all slots.
            0   =No wafer
            1   =Wafer presence
            2   =Abnormal thickness (Wafer is thick)
            3	=Cross slotted wafer
            4	=Front down wafer
            7	=Multiple wafers are in the same slot
            8	=Abnormal thickness (Wafer is thin)
         */

        public virtual void NoteSlotMap(string slotMap)
        {
            slotMap = slotMap.Replace('3', '2');
            slotMap = slotMap.Replace('4', 'W');
            slotMap = slotMap.Replace('7', 'W');
            slotMap = slotMap.Replace('8', 'W');
            slotMap = slotMap.Replace('2', 'W');
            LastMapResult = slotMap;
            base.OnSlotMapRead(slotMap);
        }

        protected IndicatorState GetIndicatorState(bool flag)
        {
            if (flag)
                return IndicatorState.ON;
            else
                return IndicatorState.OFF;
        }

        public override void ResetData()
        {
            _isMapped = false;
            _isLoaded = false;
        }

        public void NoteComplete()
        {
            //if (_loadPortState == LoadPortStates.Homing)
            //    _isIntialized = true;
            if (_loadPortState == LoadPortStates.Clamping)
                EV.Notify(EventPortClamped, new SerializableDictionary<string, string>()
                {
                    {DataVariables.PortID,PortId}
                });
            if (_loadPortState == LoadPortStates.Unclamping)
                EV.Notify(EventPortUnClamped, new SerializableDictionary<string, string>()
                {
                    {DataVariables.PortID,PortId}
                });


            _loadPortState = LoadPortStates.Idle;
        }

        public void NoteCancel(string error)
        {
            IsBusy = false;
            EV.PostAlarmLog(Module, $"{Module} is canceled since {error}");
        }

        public void NoteFailed(string error)
        {
            IsBusy = false;
            EV.PostAlarmLog(Module, $"{Module} is failed since {error}");
        }

        public void NoteCarrierID(string carrierID)
        {
            base.OnCarrierIdRead(ModuleHelper.Converter(Module), Name, carrierID);
        }

        public void NoteWRITETAG(string cid)
        {
            base.ProceedSetCarrierID(cid);
        }

        public override bool FALoad(out string reason)  //map and loads
        {
            reason = "";
            OP.DoOperation($"{Name}.Load");

            return true;
        }

        public override bool FAUnload(out string reason)
        {
            reason = "";
            OP.DoOperation($"{Name}.Unload");

            return true;
        }

        public override bool Home(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            _loadPortState = LoadPortStates.Homing;
            //_isIntialized = false;
            _isMapped = false;
            if (!_efem.HomeLoadPort(Module, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            _isLoaded = false;
            return true;
        }

        public override bool ClearError(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            //_loadPortState = LoadPortStates.ClearError;
            //if (!_efem.ClearAlarm(Module, out reason))
            //{
            //    _loadPortState = LoadPortStates.Faulted;
            //    return false;
            //}
            return true;
        }

        public override bool Clamp(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            if (ClampState == FoupClampState.Close)
            {
                return true;
            }

            _loadPortState = LoadPortStates.Clamping;
            if (!_efem.ClampCarrier(Module, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            return true;
        }

        public override bool Unclamp(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }
            //if(DoorState != FoupDoorState.Close)
            //{
            //    reason = "cassette not closed";
            //    return false;
            //}
            //if(DockState != FoupDockState.Undocked)
            //{
            //    reason = "cassette not undocked";
            //    return false;
            //}

            //if (ClampState == FoupClampState.Open)
            //{
            //    return true;
            //}

            _loadPortState = LoadPortStates.Unclamping;
            if (!_efem.UnclampCarrier(Module, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            _isMapped = false;
            return true;
        }

        public override bool Dock(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            //if (ClampState != FoupClampState.Close)
            //{
            //    reason = "cassette not clamped";
            //    return false;
            //}

            if (DockState == FoupDockState.Docked)
            {
                return true;
            }

            _loadPortState = LoadPortStates.Docking;
            if (!_efem.MoveCarrierPort(Module, "Dock", out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            return true;
        }

        public override bool Undock(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            //if (DoorState != FoupDoorState.Close)
            //{
            //    reason = "cassette not closed";
            //    return false;
            //}

            if (DockState == FoupDockState.Undocked)
            {
                return true;
            }

            _loadPortState = LoadPortStates.Undocking;
            if (!_efem.MoveCarrierPort(Module, "Undock", out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            _isMapped = false;
            return true;
        }

        public override bool OpenDoor(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            //if (ClampState != FoupClampState.Close)
            //{
            //    reason = "cassette not clamped";
            //    return false;
            //}

            //if (DockState != FoupDockState.Docked)
            //{
            //    reason = "cassette not docked";
            //    return false;
            //}

            if (DoorState == FoupDoorState.Open)
            {
                return true;
            }

            _loadPortState = LoadPortStates.OpeningDoor;
            if (!_efem.OpenCarrierDoor(Module, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            return true;
        }

        public override bool CloseDoor(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            //if (ClampState != FoupClampState.Close)
            //{
            //    reason = "cassette not clamped";
            //    return false;
            //}

            //if (DockState != FoupDockState.Docked)
            //{
            //    reason = "cassette not docked";
            //    return false;
            //}

            if (DoorState == FoupDoorState.Close)
            {
                return true;
            }

            _loadPortState = LoadPortStates.ClosingDoor;
            if (!_efem.CloseCarrierDoor(Module, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            _isMapped = false;
            return true;
        }

        public override bool ReadRfId(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }
            //_loadPortState = LoadPortStates.ReadingCarrierID;
            if (!_efem.ReadCarrierId(Module, out string carrierId, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            return true;
        }

        public override bool WriteRfId(string carrierId, out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }
            //_loadPortState = LoadPortStates.WritingCarrierID;
            if (!_efem.WriteCarrierId(Module, carrierId, out reason))
            {
                SerializableDictionary<string, string> dvid = new SerializableDictionary<string, string>();

                dvid["PortID"] = PortId;
                dvid[PORT_CTGRY] = PortCategory;
                EV.Notify(EventCarrierIdWriteFailed, dvid);

                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            return true;
        }

        public override bool ChangeAccessMode(bool auto, out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            _loadPortState = LoadPortStates.ChangeAccessMode;

            if (!_efem.ChangeLoadPortAccessMode(ModuleHelper.Converter(Module), auto ? LPAccessMode.AUTO.ToString() : LPAccessMode.MANUAL.ToString(), out reason))
            //if (!_efem.SetLoadPortLight(ModuleHelper.Converter(Module), IndicatorType.AccessManual, auto ? IndicatorState.OFF : IndicatorState.ON, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }
            return true;
        }
        public override bool GetAccessMode(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }


            if (!_efem.GetLoadPortAccessMode(ModuleHelper.Converter(Module), out reason))
            {
                return false;
            }
            return true;
        }

        public override bool SetIndicator(IndicatorType light, IndicatorState state)
        {
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                return false;
            }

            if (!LoadPortIndicatorLightMap.ContainsKey(light))
            {
                EV.PostWarningLog(Module, $"Not supported indicator {light}");
                return false;
            }
            _loadPortState = LoadPortStates.SetIndicator;
            if (!_efem.SetLoadPortLight(ModuleHelper.Converter(Module), light, state, out string reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                LOG.Write(reason);
                return false;
            }

            return true;
        }

        public override bool QueryState(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            _loadPortState = LoadPortStates.Querying;
            if (!_efem.GetLoadPortStatus(Module, out _cassetteState, out _clampState, out _dockState, out _doorState, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }

            return true;
        }

        public override bool QueryWaferMap(out string reason)
        {
            reason = string.Empty;
            if (_efem == null || !_efem.Connection.IsConnected)
            {
                reason = "efem not connected";
                return false;
            }

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            if (_efem.CheckIsBusy(ModuleName.EfemRobot))
            {
                reason = "efem robot is busy";
                return false;
            }

            //if (ClampState != FoupClampState.Close)
            //{
            //    reason = "cassette not clamped";
            //    return false;
            //}

            //if (DockState != FoupDockState.Docked)
            //{
            //    reason = "cassette not docked";
            //    return false;
            //}

            if (DoorState != FoupDoorState.Open)
            {
                reason = "cassette not open";
                return false;
            }

            _loadPortState = LoadPortStates.Mapping;
            if (!_efem.MapCarrier(Module, out string slotMap, out reason))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }

            return true;
        }

        public override bool GetMapInfo(out string reason)
        {
            reason = string.Empty;

            if (!IsPlacement)
            {
                reason = "no carrier at load port";
                return false;
            }

            _loadPortState = LoadPortStates.Querying;
            if (!_efem.QueryMapResult(Module, out reason, false))
            {
                _loadPortState = LoadPortStates.Faulted;
                return false;
            }

            return true;
        }

        public override bool Stop(out string reason)
        {
            reason = string.Empty;
            _loadPortState = LoadPortStates.Idle;

            return true;
        }

        public void CarrierProcessStartEventNotify()
        {
            EV.Notify(UniversalEvents.CarrierProcessStart, new SerializableDictionary<string, object>()
            {
                { DataVariables.PortID, Module},
                { DataVariables.CarrierID, _carrierId},
            });
        }

        public void CarrierProcessCompleteEventNotify()
        {
            EV.Notify(UniversalEvents.CarrierProcessComplete, new SerializableDictionary<string, object>()
            {
                { DataVariables.PortID, Module},
                { DataVariables.CarrierID, _carrierId},
            });
        }

        public void WriteLoadPortAccessModeSuccess()
        {
            Task.Delay(200).ContinueWith(x => GetAccessMode(out string reason));
        }
    }
}