Virgo_ST/VirgoRT/FAs/FaManager.cs

using Aitex.Common.Util;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.OperationCenter;
using System.Collections.Generic;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.Device;
using Aitex.Core.RT.SCCore;
using Aitex.Core.Util;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using VirgoRT.Device.YASKAWA;
using VirgoRT.Devices.EFEM;
using VirgoRT.FAs;
using VirgoRT.Modules;

namespace VirgoRT.HostWrapper
{
    class FaManager : FaHost, IHostCallback
    {
        private const string PROCESS_START_INQUIRY = "PROCESS_START_INQUIRY";

        private class DataName
        {
            public const string CommunicationStatus = "CommunicationStatus";
            public const string ControlStatus = "ControlStatus";
            public const string ControlSubStatus = "ControlSubStatus";

            public const string SpoolingState = "SpoolingState";
            public const string SpoolingActual = "SpoolingActual";
            public const string SpoolingTotal = "SpoolingTotal";
            public const string SpoolingFullTime = "SpoolingFullTime";
            public const string SpoolingStartTime = "SpoolingStartTime";
            public const string IsSpoolingEnable = "IsSpoolingEnable";
        }


        private Dictionary<string, ModuleName> _dicPortModule = new Dictionary<string, ModuleName>()
        {
            {"1", ModuleName.LP1},
            {"2", ModuleName.LP2},
        };

        public void Initialize()
        {
            base.Initialize(this, PathManager.GetCfgDir() + "ClusterGemModel.xml");

            OP.Subscribe("System.FACommand", InvokeFaCommand);

            DATA.Subscribe("System.CommunicationStatus", () => FaCommunicationState);
            DATA.Subscribe("System.ControlStatus", () => FaControlState);
            DATA.Subscribe("System.ControlSubStatus", () => FaControlSubState);

            DATA.Subscribe("System.SpoolingState", () => SpoolingState);
            DATA.Subscribe("System.SpoolingActual", () => SpoolingActual);
            DATA.Subscribe("System.SpoolingTotal", () => SpoolingTotal);
            DATA.Subscribe("System.SpoolingFullTime", () => SpoolingFullTime);
            DATA.Subscribe("System.SpoolingStartTime", () => SpoolingStartTime);
            DATA.Subscribe("System.IsSpoolingEnable", () => IsSpoolingEnable);

            EV.Subscribe(new EventItem(PROCESS_START_INQUIRY));
        }

        private bool InvokeFaCommand(string arg1, object[] arg2)
        {
            Invoke(arg2[0].ToString(), null);
            return true;
        }

        public string GetSvidValue(string svName)
        {
            if (svName == "PMA.RecipeProcessTime")
                svName = "PMA.RecipeTotalElapsedSeconds";
            else if (svName == "PMB.RecipeProcessTime")
                svName = "PMB.RecipeTotalElapsedSeconds";

            object data = DATA.Poll(svName);
            if (data != null)
            {
                return data.ToString();
            }

            return "";
        }

        public List<string> GetListSvidValue(string svName)
        {
            List<string> result = new List<string>();
            foreach (var VARIABLE in result)
            {

            }

            return result;
        }

        public bool MapCassette(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice==null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette )
            {
                reason = $"{portId} cassette not placed";
                return false;
            }

            if (LPDevice.Protrusion)
            {
                reason = $"{portId} cassette wafer protrude";
                return false;
            }

            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }

            if (SC.ContainsItem("EFEM.CheckSideDoorOnEAPMap") && SC.GetValue<bool>("EFEM.CheckSideDoorOnEAPMap"))
            {
                if (Singleton<RouteManager>.Instance.EFEM.EfemDevice.DoorSwitch != LidState.Close)
                {
                    reason = $"EFEM side door not closed, can not map {portId}";
                    return false;
                }
            }

            if (SC.ContainsItem("EFEM.CheckCassetteDoorOnEAPMap") &&
                SC.GetValue<bool>("EFEM.CheckCassetteDoorOnEAPMap"))
            {
                if (Singleton<RouteManager>.Instance.EFEM.EfemDevice.CassetteDoor != LidState.Close)
                {
                    reason = $"Cassette door not closed, can not map {portId}";
                    return false;
                }
            }

            OP.DoOperation($"{_dicPortModule[portId]}.Map");

            reason = string.Empty;
            return true;
        }

        public bool PPSelect(string portId, string jobId, string lotId, string[] slotSequence, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

 
            if (!Singleton<RouteManager>.Instance.IsAutoMode)
            {
                reason = $"System not in auto mode";
                return false;
            }

            Dictionary<string, object> param = new Dictionary<string, object>()
            {
                {"JobId", jobId},
                {"LotId", lotId},
                {"Module", _dicPortModule[portId].ToString()},
                {"SlotSequence", slotSequence},
                {"AutoStart", false},
            };

            OP.DoOperation("System.CreateJob", param);

            reason = string.Empty;
            return true;
        }

        public bool StartJob(string jobId, out string reason)
        {
            var param = new object[] { jobId };
            OP.DoOperation("System.StartJob", param);

            reason = string.Empty;
            return true;
        }

        public bool AbortJob(string jobId, out string reason)
        {
            var param = new object[] { jobId };
            OP.DoOperation("System.AbortJob", param);

            reason = string.Empty;
            return true;
        }

        public bool PauseJob(string jobId, out string reason)
        {
            var param = new object[] { jobId };
            OP.DoOperation("System.PauseJob", param);

            reason = string.Empty;
            return true;
        }

        public bool ResumeJob(string jobId, out string reason)
        {
            var param = new object[] { jobId };
            OP.DoOperation("System.ResumeJob", param);

            reason = string.Empty;
            return true;
        }

        public bool StopJob(string jobId, out string reason)
        {
            var param = new object[] { jobId };
            OP.DoOperation("System.StopJob", param);

            reason = string.Empty;
            return true;
        }


        public bool Load(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }
 

            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }
            OP.DoOperation($"{_dicPortModule[portId]}.Load");

            reason = string.Empty;
            return true;
        }

        public bool Unload(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }
 

            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }

            if (SC.GetValue<bool>("EFEM.AutoUnlockAfterUnload") )
            {
                OP.DoOperation($"{_dicPortModule[portId]}.Unload");
            }
            else
            {
                OP.DoOperation($"{_dicPortModule[portId]}.Undock");
            }

            

            reason = string.Empty;
            return true;
        }

        public bool Lock(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }
 

            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }
            OP.DoOperation($"{_dicPortModule[portId]}.Clamp");

            reason = string.Empty;
            return true;
        }

        public bool Unlock(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }
 

            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }
            OP.DoOperation($"{_dicPortModule[portId]}.Unclamp");

            reason = string.Empty;
            return true;
        }

        public bool ReadID(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }
 

            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }
            OP.DoOperation($"{_dicPortModule[portId]}.ReadCarrierId");

            reason = string.Empty;
            return true;
        }

        public bool ReadTag(string portId, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }


            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }
            OP.DoOperation($"{_dicPortModule[portId]}.ReadTagData");

            reason = string.Empty;
            return true;
        }


        public bool WriteID(string portId, string carrierID, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }


            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }

            OP.DoOperation($"{_dicPortModule[portId]}.WriteCarrierID", carrierID);

            reason = string.Empty;
            return true;
        }
        public bool WriteTag(string portId, string tagData, out string reason)
        {
            if (!_dicPortModule.ContainsKey(portId))
            {
                reason = $"{portId} not valid";
                return false;
            }

            var LPDevice = Singleton<RouteManager>.Instance.EFEM.EfemDevice[_dicPortModule[portId]] as Loadport;
            if (LPDevice == null)
            {
                reason = $"{portId} not valid";
                return false;
            }

            if (!LPDevice.HasCassette)
            {
                reason = $"{portId} cassette not placed";
                return false;
            }


            if (LPDevice.Status == DeviceState.Error)
            {
                reason = $"{portId} port in error, need reset";
                return false;
            }

            OP.DoOperation($"{_dicPortModule[portId]}.WriteTagData", tagData);

            reason = string.Empty;
            return true;
        }
    }
}