CyberX8/CyberX8_RT/Modules/Autotransfer_LP_FA.cs

using Aitex.Core.Common;
using Aitex.Core.RT.Event;
using Aitex.Core.UI.Control;
using Aitex.Core.Util;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.Jobs;
using MECF.Framework.Common.SubstrateTrackings;
using CyberX8_RT.Dispatch;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;
using MECF.Framework.Common.WaferHolder;

namespace CyberX8_RT.Modules
{
    public interface ISchedulerFACallback
    {
        void JobCreated(ControlJobInfo cj);
        void JobCreateFailed(string module, string lotID, string jobID,string reason);
        void JobStarted(ControlJobInfo cj);
        void JobStopped(ControlJobInfo cj);
        void JobPaused(ControlJobInfo cj);
        void JobResumed(ControlJobInfo cj);

        void JobFinished(ControlJobInfo cj);

        void JobWaferStart(ControlJobInfo cj, string sequenceId, int slotID);
        void JobWaferEnd(ControlJobInfo cj, string sequenceId,int slotID);
        void WaferShuttleJobStart(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo);
        void WaferShuttleJobEnd(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo);
        void WaferShuttleRecipeStart(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo, string recipeId);
        void WaferShuttleRecipeEnd(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo, string recipeId, int processTimeLength);
        void WaferShuttleRecipeFailed(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo, string recipeId);
        void SrdRecipeStart(ControlJobInfo cj, string sequenceId, string recipeId, string module, int slotID);
        void SrdRecipeEnd(ControlJobInfo cj, string sequenceId, string recipeId, string module, int slotID);
        void SrdRecipeFailed(ControlJobInfo cj, string sequenceId, string recipeId, string module, int slotID);
    }
    public class SchedulerFACallback : ISchedulerFACallback
    {
        private const string EventPortJobStarted = "PortJobStarted";
        private const string EventPortJobStopped = "PortJobStopped";
        private const string EventPortJobPaused = "PortJobPaused";
        private const string EventPortJobResumed = "PortJobResumed";
        private const string EventPortJobFinished = "PortJobFinished";
        private const string EventPortJobFailed = "PortJobFailed";
        private const string EventPortSequenceSelected = "PortPPSelected";
        private const string EventPortSequenceSelectFailed = "PortPPSelectFailed";
        private const string EventPortJobWaferStart = "PortJobWaferStart";
        private const string EventPortJobWaferEnd = "PortJobWaferEnd";
        private const string EventWaferShuttleJobStart = "WaferShuttleJobStart";
        private const string EventWaferShuttleJobEnd = "WaferShuttleJobEnd";
        private const string EventWaferShuttleRecipeStart = "WaferShuttleRecipeStart";
        private const string EventWaferShuttleRecipeEnd = "WaferShuttleRecipeEnd";
        private const string EventWaferShuttleRecipeFailed = "WaferShuttleRecipeFailed";
        private const string EventSRDRecipeStart = "SRDRecipeStart";
        private const string EventSRDRecipeEnd = "SRDRecipeEnd";
        private const string EventSRDRecipeFailed = "SRDRecipeFailed";

        public SchedulerFACallback()
        {
            EV.Subscribe(new EventItem("Event", EventPortJobStarted, EventPortJobStarted));
            EV.Subscribe(new EventItem("Event", EventPortJobStopped, EventPortJobStopped));
            EV.Subscribe(new EventItem("Event", EventPortJobPaused, EventPortJobPaused));
            EV.Subscribe(new EventItem("Event", EventPortJobResumed, EventPortJobResumed));
            EV.Subscribe(new EventItem("Event", EventPortJobFinished, EventPortJobFinished));
            EV.Subscribe(new EventItem("Event", EventPortJobFailed, EventPortJobFailed));
            EV.Subscribe(new EventItem("Event", EventPortSequenceSelected, EventPortSequenceSelected));
            EV.Subscribe(new EventItem("Event", EventPortSequenceSelectFailed, EventPortSequenceSelectFailed));
            EV.Subscribe(new EventItem("Event", EventPortJobWaferStart, EventPortJobWaferStart));
            EV.Subscribe(new EventItem("Event", EventPortJobWaferEnd, EventPortJobWaferEnd));
            EV.Subscribe(new EventItem("Event", EventWaferShuttleJobStart, EventWaferShuttleJobStart));
            EV.Subscribe(new EventItem("Event", EventWaferShuttleJobEnd, EventWaferShuttleJobEnd));
            EV.Subscribe(new EventItem("Event", EventWaferShuttleRecipeStart, EventWaferShuttleRecipeStart));
            EV.Subscribe(new EventItem("Event", EventWaferShuttleRecipeEnd, EventWaferShuttleRecipeEnd));
            EV.Subscribe(new EventItem("Event", EventWaferShuttleRecipeFailed, EventWaferShuttleRecipeFailed));
            EV.Subscribe(new EventItem("Event", EventSRDRecipeStart, EventSRDRecipeStart));
            EV.Subscribe(new EventItem("Event", EventSRDRecipeEnd, EventSRDRecipeEnd));
            EV.Subscribe(new EventItem("Event", EventSRDRecipeFailed, EventSRDRecipeFailed));
        }
        public void JobCreated(ControlJobInfo cj)
        {
            ModuleName module = ModuleHelper.Converter(cj.Module);

            EV.Notify(EventPortSequenceSelected, new SerializableDictionary<string, string>()
            {
                {DVIDName.LotID,  cj.LotName},
                {DVIDName.JobID,  cj.Name},
                {DVIDName.PortID, ((int)module-ModuleName.LP1+1).ToString() }
            });
        }
        public void JobCreateFailed(string module, string lotID, string jobID,string reason)
        {
            ModuleName moduleName = ModuleHelper.Converter(module);

            EV.Notify(EventPortSequenceSelectFailed, new SerializableDictionary<string, string>()
            {
                {DVIDName.LotID,  lotID},
                {DVIDName.JobID,  jobID},
                {DVIDName.PortID, ((int)moduleName-ModuleName.LP1+1).ToString() },
                {DVIDName.Reason,reason}
            });
        }
        public void JobStarted(ControlJobInfo cj)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName module = ModuleHelper.Converter(cj.Module);
                EV.Notify(EventPortJobStarted, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)module-ModuleName.LP1+1).ToString() }
                });
            }
        }

        public void JobStopped(ControlJobInfo cj)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName module = ModuleHelper.Converter(cj.Module);

                EV.Notify(EventPortJobStopped, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)module-ModuleName.LP1+1).ToString() }
                });
            }
        }
        public void JobPaused(ControlJobInfo cj)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName module = ModuleHelper.Converter(cj.Module);

                EV.Notify(EventPortJobPaused, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)module-ModuleName.LP1+1).ToString() }
                });
            }
        }
        public void JobResumed(ControlJobInfo cj)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName module = ModuleHelper.Converter(cj.Module);

                EV.Notify(EventPortJobResumed, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)module-ModuleName.LP1+1).ToString() }
                });
            }
        }
        public void JobFinished(ControlJobInfo cj)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName module = ModuleHelper.Converter(cj.Module);

                int count = cj.LotWafers.Count;
                EV.Notify(EventPortJobFinished, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)module-ModuleName.LP1+1).ToString() },
                    {DVIDName.ProcessedWaferCount, count.ToString() },
                });
            }
        }
        public void JobWaferStart(ControlJobInfo cj,string sequenceId, int slotID)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName moduleName = ModuleHelper.Converter(cj.Module);

                EV.Notify(EventPortJobWaferStart, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)moduleName-ModuleName.LP1+1).ToString()  },
                    {DVIDName.SlotID, (slotID+1).ToString() },
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }

        public void JobWaferEnd(ControlJobInfo cj,string sequenceId, int slotID)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                ModuleName moduleName = ModuleHelper.Converter(cj.Module);

                WaferInfo wafer = WaferManager.Instance.GetWafer(moduleName, slotID);

                EV.Notify(EventPortJobWaferEnd, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.PortID, ((int)moduleName-ModuleName.LP1+1).ToString() },
                    {DVIDName.SlotID, (slotID+1).ToString() },
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()},
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.WaferProcessResult, (wafer.ProcessState == EnumWaferProcessStatus.Failed ? 0:1).ToString()}
                });
            }
        }
        /// <summary>
        /// WaferShuttle job启动
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferShuttleId"></param>
        /// <param name="location"></param>
        public void WaferShuttleJobStart(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventWaferShuttleJobStart, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.WaferShuttleId, waferHolderInfo.Id},
                    {DVIDName.WaferShuttleWaferAId, waferHolderInfo.WaferAId},
                    {DVIDName.WaferShuttleWaferBId, waferHolderInfo.WaferBId},
                    {DVIDName.WaferShuttleLsAId, waferHolderInfo.CrsAId},
                    {DVIDName.WaferShuttleLsBId, waferHolderInfo.CrsBId},
                    {DVIDName.StationName, waferHolderInfo.CurrentLocation },
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
        /// <summary>
        /// WaferShuttle job启动
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferShuttleId"></param>
        /// <param name="location"></param>
        public void WaferShuttleJobEnd(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventWaferShuttleJobEnd, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.WaferShuttleId, waferHolderInfo.Id},
                    {DVIDName.WaferShuttleWaferAId, waferHolderInfo.WaferAId},
                    {DVIDName.WaferShuttleWaferBId, waferHolderInfo.WaferBId},
                    {DVIDName.WaferShuttleLsAId, waferHolderInfo.CrsAId},
                    {DVIDName.WaferShuttleLsBId, waferHolderInfo.CrsBId},
                    {DVIDName.StationName, waferHolderInfo.CurrentLocation },
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
        /// <summary>
        /// WaferShuttle recipe启动
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferShuttleId"></param>
        /// <param name="location"></param>
        public void WaferShuttleRecipeStart(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo, string recipeId)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventWaferShuttleRecipeStart, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.WaferShuttleId, waferHolderInfo.Id},
                    {DVIDName.WaferShuttleWaferAId, waferHolderInfo.WaferAId},
                    {DVIDName.WaferShuttleWaferBId, waferHolderInfo.WaferBId},
                    {DVIDName.WaferShuttleLsAId, waferHolderInfo.CrsAId},
                    {DVIDName.WaferShuttleLsBId, waferHolderInfo.CrsBId},
                    {DVIDName.StationName, waferHolderInfo.CurrentLocation },
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.RecipeID, recipeId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
        /// <summary>
        /// WaferShuttle recipe结束
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferShuttleId"></param>
        /// <param name="location"></param>
        public void WaferShuttleRecipeEnd(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo, string recipeId,int processTimeLength)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventWaferShuttleRecipeEnd, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.WaferShuttleId, waferHolderInfo.Id},
                    {DVIDName.WaferShuttleWaferAId, waferHolderInfo.WaferAId},
                    {DVIDName.WaferShuttleWaferBId, waferHolderInfo.WaferBId},
                    {DVIDName.WaferShuttleLsAId, waferHolderInfo.CrsAId},
                    {DVIDName.WaferShuttleLsBId, waferHolderInfo.CrsBId},
                    {DVIDName.StationName, waferHolderInfo.CurrentLocation },
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.RecipeID, recipeId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()},
                    {DVIDName.ProcessTimeLength,processTimeLength.ToString()}
                });
            }
        }
        /// <summary>
        /// WaferShuttle recipe启动
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferShuttleId"></param>
        /// <param name="location"></param>
        public void WaferShuttleRecipeFailed(ControlJobInfo cj, string sequenceId, WaferHolderInfo waferHolderInfo, string recipeId)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventWaferShuttleRecipeFailed, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.WaferShuttleId, waferHolderInfo.Id },
                    {DVIDName.WaferShuttleId, waferHolderInfo.Id},
                    {DVIDName.WaferShuttleWaferAId, waferHolderInfo.WaferAId},
                    {DVIDName.WaferShuttleWaferBId, waferHolderInfo.WaferBId},
                    {DVIDName.WaferShuttleLsAId, waferHolderInfo.CrsAId},
                    {DVIDName.WaferShuttleLsBId, waferHolderInfo.CrsBId},
                    {DVIDName.StationName, waferHolderInfo.CurrentLocation},
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.RecipeID, recipeId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
        /// <summary>
        /// SRD Recipe启动
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferInfo"></param>
        /// <param name="recipeId"></param>
        public void SrdRecipeStart(ControlJobInfo cj,string sequenceId,string recipeId,string module, int slotID)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventSRDRecipeStart, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.StationName,module},
                    {DVIDName.SlotID,slotID.ToString()},
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.RecipeID, recipeId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
        /// <summary>
        /// SRD Recipe结束
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferInfo"></param>
        /// <param name="recipeId"></param>
        public void SrdRecipeEnd(ControlJobInfo cj, string sequenceId, string recipeId, string module, int slotID)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventSRDRecipeEnd, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.StationName,module},
                    {DVIDName.SlotID,slotID.ToString()},
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.RecipeID, recipeId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
        /// <summary>
        /// SRD Recipe启动
        /// </summary>
        /// <param name="cj"></param>
        /// <param name="sequenceId"></param>
        /// <param name="waferInfo"></param>
        /// <param name="recipeId"></param>
        public void SrdRecipeFailed(ControlJobInfo cj, string sequenceId, string recipeId, string module, int slotID)
        {
            if (FaJobManager.Instance.Contains(cj.Name))
            {
                EV.Notify(EventSRDRecipeFailed, new SerializableDictionary<string, string>()
                {
                    {DVIDName.LotID,  cj.LotName},
                    {DVIDName.JobID,  cj.Name},
                    {DVIDName.StationName,module},
                    {DVIDName.SlotID,slotID.ToString()},
                    {DVIDName.SequenceID, sequenceId},
                    {DVIDName.RecipeID, recipeId},
                    {DVIDName.CarrierID, cj.CarrierID?.ToString()}
                });
            }
        }
    }
}