CyberX8/CyberX8_RT/Modules/FaRemoteManager.cs

using Aitex.Core.RT.RecipeCenter;
using Aitex.Core.Util;
using MECF.Framework.Common.Routine;
using CyberX8_RT.Devices.EFEM;
using CyberX8_RT.Dispatch;
using CyberX8_RT.Modules.LPs;
using SecsGem.Core.Application;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Aitex.Core.RT.Log;
using MECF.Framework.Common.Jobs;

namespace CyberX8_RT.Modules
{
    public class FaRemoteManager: Singleton<FaRemoteManager>, IEquipmentCommand
    {
        #region 内部变量
        private SchedulerFACallback fACallback = new SchedulerFACallback();
        #endregion
        #region 属性
        /// <summary>
        /// Job Cycle对象
        /// </summary>
        public ICycle JobCycle { get; set; }
        #endregion

        #region Fa接口
        /// <summary>
        /// 接口指令
        /// </summary>
        /// <param name="command"></param>
        /// <param name="paras"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        public bool ExcuteCommand(string command, object[] paras, out string reason)
        {
            reason = "";
            switch (command.ToUpper())
            {
                case "PP-SELECT":
                    return FaCreateJob(paras, out reason);
                case "STARTJOB":
                    return FaStartJob(paras[0].ToString(), out reason);
                case "STOPJOB":
                    return FaStopJob(paras[0].ToString(), out reason);
                case "PAUSEJOB":
                    return FaPauseJob(paras[0].ToString(), out reason);
                case "RESUMEJOB":
                    return FaResumeJob(paras[0].ToString(), out reason);
                case "MAPCASSETTE":
                    return FaMapCassete(paras[0].ToString(), out reason);
                case "LOAD":
                    return FaLoad(paras[0].ToString(), out reason);
                case "UNLOAD":
                    return FaUnLoad(paras[0].ToString(), out reason);
                case "READID":
                    return FaReadId(paras[0].ToString(), out reason);
                case "WRITEID":
                    return FaWriteId(paras[0].ToString(), paras[1].ToString(), out reason);
                default:
                    reason = $"{command} is not supported";
                    return false;
            }
        }
        /// <summary>
        /// Fa创建任务
        /// </summary>
        /// <param name="paras"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool FaCreateJob(object[] paras, out string reason)
        {
            if (!Singleton<RouteManager>.Instance.IsFaAutoMode)
            {
                reason = "System is not in Auto,cannot create job";
                return false;
            }
            else
            {
                Dictionary<string, object> createParams = new Dictionary<string, object>();
                string jobId = paras[1].ToString();
                string module = $"LP{paras[0]}";
                string lotId=paras[2].ToString();
                createParams["Module"] =module;
                createParams["JobId"] = jobId;
                createParams["LotId"]=lotId;
                createParams["SlotSequence"] = (string[])paras[3];
                createParams["AutoStart"] = true;
                bool result= JobCycle.CreateJob(createParams, out reason);
                if(result)
                {
                    FaJobManager.Instance.Add(jobId);
                    fACallback.JobCreated(JobProcesser.Instance.GetControlJobInfoByName(jobId));
                }
                else
                {
                    fACallback.JobCreateFailed(module, lotId, jobId,reason);
                }
                return result;
            }
        }
        /// <summary>
        /// Fa启动任务
        /// </summary>
        /// <param name="jobName"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool FaStartJob(string jobName, out string reason)
        {
            if (!Singleton<RouteManager>.Instance.IsFaAutoMode)
            {
                reason = "System is not in Auto,cannot start job";
                return false;
            }
            bool result = JobCycle.StartJob(jobName, out reason);
            if (result)
            {
                Singleton<RouteManager>.Instance.CheckToPostMessage((int)RouteManager.MSG.FaStartJob);
            }
            return result;
        }
        /// <summary>
        /// Fa停止任务
        /// </summary>
        /// <param name="jobName"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool FaStopJob(string jobName, out string reason)
        {
            if (!Singleton<RouteManager>.Instance.IsFaAutoMode)
            {
                reason = "System is not in Auto,cannot stop job";
                return false;
            }
            return JobCycle.StopJob(jobName, out reason);
        }
        /// <summary>
        /// Fa暂停任务
        /// </summary>
        /// <param name="jobName"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool FaPauseJob(string jobName, out string reason)
        {
            if (!Singleton<RouteManager>.Instance.IsFaAutoMode)
            {
                reason = "System is not in Auto,cannot pause job";
                return false;
            }
            return JobCycle.PauseJob(jobName, out reason);
        }
        /// <summary>
        /// Fa恢复任务
        /// </summary>
        /// <param name="jobName"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool FaResumeJob(string jobName, out string reason)
        {
            if (!Singleton<RouteManager>.Instance.IsFaAutoMode)
            {
                reason = "System is not in Auto,cannot resume job";
                return false;
            }
            return JobCycle.ResumeJob(jobName, out reason);
        }
        /// <summary>
        /// Fa Load
        /// </summary>
        /// <param name="lp"></param>
        /// <returns></returns>
        private bool FaLoad(string lp, out string reason)
        {
            return ExecuteMsg(lp, (int)LoadPortModule.MSG.Load, out reason);
        }
        /// <summary>
        /// 获取LoadPort对象
        /// </summary>
        /// <param name="lp"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private LoadPortModule FaGetLoadPort(string lp, out string reason)
        {
            reason = "";
            if (int.TryParse(lp, out var lpValue))
            {
                EfemEntity efemEntity = Singleton<RouteManager>.Instance.GetModule<EfemEntity>("EFEM");
                LoadPortModule loadPortModule =efemEntity.GetLoadportModule(lpValue-1);
                if (loadPortModule != null)
                {
                    if (loadPortModule.LPDevice.HasCassette)
                    {
                        return loadPortModule;
                    }
                    else
                    {
                        reason = $"LP{lpValue} not found carrier, can not load";
                        return null;
                    }
                }
                else
                {
                    reason = $"LP{lp} is null";
                    return null;
                }
            }
            else
            {
                reason = $"{lp} is invalid data";
                return null;
            }
        }

        /// <summary>
        /// 读取Id
        /// </summary>
        /// <param name="lp"></param>
        /// <returns></returns>
        private bool FaMapCassete(string lp, out string reason)
        {
            return ExecuteMsg(lp, (int)LoadPortModule.MSG.Map, out reason);
        }
        /// <summary>
        /// 读取Id
        /// </summary>
        /// <param name="lp"></param>
        /// <returns></returns>
        private bool FaReadId(string lp, out string reason)
        {
            return ExecuteMsg(lp, (int)LoadPortModule.MSG.ReadCarrierId, out reason);
        }
        /// <summary>
        /// 读取Id
        /// </summary>
        /// <param name="lp"></param>
        /// <returns></returns>
        private bool FaWriteId(string lp, string carrierId, out string reason)
        {
            return ExecuteMsg(lp, (int)LoadPortModule.MSG.WriteCarrierID, out reason);
        }
        /// <summary>
        /// Fa Unload
        /// </summary>
        /// <param name="lp"></param>
        /// <returns></returns>
        private bool FaUnLoad(string lp, out string reason)
        {
            ControlJobInfo controlJobInfo = JobProcesser.Instance.GetControlJobInfoByLoadPort(lp);
            if (controlJobInfo != null)
            {
                reason = $"{lp} has controljob {controlJobInfo.Name},cannot unload";
                return false;
            }
            return ExecuteMsg(lp, (int)LoadPortModule.MSG.Unload, out reason);
        }
        /// <summary>
        /// 执行消息
        /// </summary>
        /// <param name="lp"></param>
        /// <param name="msg"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private bool ExecuteMsg(string lp,int msg,out string reason)
        {
            if (!CheckAuto())
            {
                reason = "System is not in Auto";
                return false;
            }
            LoadPortModule loadport = FaGetLoadPort(lp, out reason);
            if (loadport != null)
            {
                bool result = loadport.CheckToPostMessage(msg);
                if (!result)
                {
                    reason = $"{lp} in invalid state";
                }
                return result;
            }
            else
            {
                reason = $"{lp} is not LoadPort";
                return false;
            }
        }
        /// <summary>
        /// 获取所有Sequence
        /// </summary>
        /// <returns></returns>
        public string[] GetSequenceList()
        {
            return RecipeFileManager.Instance.GetProductionRecipeList().ToArray();
        }
        /// <summary>
        /// 获取recipe内容
        /// </summary>
        /// <param name="ppid"></param>
        /// <returns></returns>
        public string GetSequenceBody(string ppid)
        {            
            return RecipeFileManager.Instance.LoadRecipeContent(ppid);
        }
        /// <summary>
        /// 获取固定格式的Recipe内容 
        /// </summary>
        /// <param name="ppid"></param>
        /// <returns></returns>
        public List<string> GetFormatedSequence(string ppid)
        {
            List<string> result = new List<string>();
            string reason = string.Empty;

            try
            {
                string content = RecipeFileManager.Instance.LoadRecipeContent(ppid);

                result.Add(content);
            }
            catch (Exception ex)
            {
                reason = ex.Message;
            }


            return result;
        }
        /// <summary>
        /// 删除Sequence
        /// </summary>
        /// <param name="ppid"></param>
        /// <returns></returns>
        public bool deleteSequence(string ppid)
        {
            return false;
        }
        /// <summary>
        /// 更新Sequence
        /// </summary>
        /// <param name="ppid"></param>
        /// <param name="body"></param>
        /// <returns></returns>
        public bool UpdateSequence(string ppid, string body)
        {
            return false;
        }

        public void ShowTerminalMessage(string message)
        {
        }

        public bool CreateProcessJob(string processJobId, string sequenceName, string carrierId, out string reason)
        {
            reason = "";
            return true;
        }

        public void UpdateProcessJobCarrierSlot(string processJobId, string moduleName, List<int> slots)
        {
        }

        public void CreateControlJob(string controlJobId, string carrierId, List<string> processJobs)
        {
        }

        public bool CheckCreateControlJobCondition(List<string> modules, out string reason)
        {
            reason = "";
            return true;
        }

        public bool StartControlJob(string controlJob)
        {
            return true;
        }

        public bool StopControlJob(string controlJob)
        {
            return true;
        }

        public bool AbortControlJob(string controlJob)
        {
            return true;
        }

        public bool PauseControlJob(string controlJob)
        {
            return true;
        }

        public bool ResumeControlJob(string controlJob)
        {
            return true;
        }

        public bool CheckAuto()
        {
            return Singleton<RouteManager>.Instance.IsAutoMode;
        }

        public void UpdateControlJobModule(string controlJobId, string moduleName)
        {
        }

        public void WriteWarningLog(string msg)
        {
        }

        public void WriteErrorLog(string msg)
        {
        }

        public void WriteInfoLog(string msg)
        {
        }
        #endregion
    }
}