654 lines
21 KiB
C#
654 lines
21 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using Aitex.Core.Common;
|
||
using Aitex.Core.RT.Event;
|
||
using Aitex.Core.Util;
|
||
using MECF.Framework.Common.Equipment;
|
||
using MECF.Framework.Common.Schedulers;
|
||
using MECF.Framework.Common.SubstrateTrackings;
|
||
|
||
namespace SicRT.Modules.Schedulers
|
||
{
|
||
public class SchedulerModule
|
||
{
|
||
protected enum TaskType
|
||
{
|
||
None,
|
||
|
||
PrepareTransfer,
|
||
|
||
Pick,
|
||
|
||
Place,
|
||
|
||
PickAndPlace,
|
||
|
||
Preprocess,
|
||
Process,
|
||
PostProcess,
|
||
|
||
OpenCover,
|
||
CloseCover,
|
||
|
||
Load,
|
||
Unload,
|
||
|
||
Align,
|
||
|
||
TransferTarget,
|
||
|
||
Cooling,
|
||
WarmUp,
|
||
|
||
Vent,
|
||
Pump,
|
||
Purge,
|
||
Group,
|
||
Separate,
|
||
Map
|
||
}
|
||
|
||
/// <summary>
|
||
/// 访问变量时先锁定，避免多线程竞争问题。
|
||
/// </summary>
|
||
protected readonly object SyncRoot = new object();
|
||
|
||
/// <summary>
|
||
/// 调度器处于Transfer状态超时。
|
||
/// <br/>
|
||
/// 如果调度器保持在Transfer任务并超过了指定时间，需自动退出Transfer任务。
|
||
/// </summary>
|
||
protected readonly DeviceTimer TimTransferTaskTimeout;
|
||
|
||
/// <summary>
|
||
/// 检测首次进入Transfer任务的状态。
|
||
/// </summary>
|
||
protected readonly R_TRIG TrigTransferTaskEntered;
|
||
|
||
public ModuleName Module => ModuleHelper.Converter(_module);
|
||
|
||
public virtual bool IsAvailable { get; }
|
||
public virtual bool IsOnline { get; }
|
||
public virtual bool IsError { get; }
|
||
public virtual bool IsReady { get; }
|
||
|
||
public virtual bool IsService { get; }
|
||
|
||
private R_TRIG[] firstDetectWaferArriveTrigs = new R_TRIG[25];
|
||
private R_TRIG[] firstDetectWaferLeaveTrigs = new R_TRIG[25];
|
||
private R_TRIG[] firstDetectTrayArriveTrigs = new R_TRIG[25];
|
||
private R_TRIG[] firstDetectTrayLeaveTrigs = new R_TRIG[25];
|
||
|
||
protected string _module;
|
||
|
||
protected TaskType _task = TaskType.None;
|
||
|
||
protected ModuleName _inProcessRobot;
|
||
|
||
public SchedulerModule(string module)
|
||
{
|
||
_module = module;
|
||
for (int i = 0; i < firstDetectWaferArriveTrigs.Length; i++)
|
||
{
|
||
firstDetectWaferArriveTrigs[i] = new R_TRIG();
|
||
}
|
||
for (int i = 0; i < firstDetectWaferLeaveTrigs.Length; i++)
|
||
{
|
||
firstDetectWaferLeaveTrigs[i] = new R_TRIG();
|
||
}
|
||
for (int i = 0; i < firstDetectTrayArriveTrigs.Length; i++)
|
||
{
|
||
firstDetectTrayArriveTrigs[i] = new R_TRIG();
|
||
}
|
||
for (int i = 0; i < firstDetectTrayLeaveTrigs.Length; i++)
|
||
{
|
||
firstDetectTrayLeaveTrigs[i] = new R_TRIG();
|
||
}
|
||
|
||
TimTransferTaskTimeout = new DeviceTimer();
|
||
TrigTransferTaskEntered = new R_TRIG();
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查调度器是否空闲。
|
||
/// </summary>
|
||
/// <Remarks>
|
||
/// 调度器空闲的条件除调度器无任务执行，还需要判断Module的状态是否为Idle或Error。
|
||
/// 因为如果调度器执行过程中，Module发生错误，也应该将调度器标记为空闲，否则调度器可能卡死而导致Auto流程无法继续。
|
||
/// 以下为调度器和Module可能出现冲突的状态，和判决方法：
|
||
/// <para>1. 如果调度器无任务，但Module还未Idle，则说明上个Routine还未执行完毕，则认为Task还未完成。</para>
|
||
/// <para>2. 如果调度器有任务，但Module已经Idle或Error，则说明Routine已执行完毕，但可能出错，则认为Task完成。</para>
|
||
/// </Remarks>
|
||
/// <param name="isTaskDone">调度器执行的任务是否结束。</param>
|
||
/// <param name="fsmStopped">调度器关联的Module的状态机是否Idle或Alarm</param>
|
||
/// <returns></returns>
|
||
protected bool SuperCheckTaskDone(bool isTaskDone, bool fsmStopped)
|
||
{
|
||
// Transfer状态需特殊对待。该状态在调度器的CheckTaskDone()中未处理，因为机械手的异常可能导致被操作的调度器卡死在Transfer任务中。
|
||
// 因此需要建立超时机制，如果调度器停留在Transfer状态时间过长，则可能是机械手发生异常，需要自动退出Transfer任务。
|
||
if (_task == TaskType.TransferTarget)
|
||
{
|
||
if (TimTransferTaskTimeout.IsTimeout())
|
||
{
|
||
// 强制结束TransferTarget任务
|
||
_task = TaskType.None;
|
||
TimTransferTaskTimeout.Stop();
|
||
isTaskDone = true;
|
||
}
|
||
else
|
||
{
|
||
// 调度器仍然在Transfer任务中
|
||
return false;
|
||
}
|
||
}
|
||
|
||
isTaskDone &= fsmStopped;
|
||
|
||
if (isTaskDone)
|
||
{
|
||
if (_task != TaskType.None)
|
||
{
|
||
LogTaskDone(_task, "");
|
||
_task = TaskType.None;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
if (fsmStopped)
|
||
{
|
||
LogTaskDone(_task, "Task Failed");
|
||
_task = TaskType.None;
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
protected void LogTaskStart(TaskType cmd, string message)
|
||
{
|
||
EV.PostInfoLog("Scheduler", $"Task Start: {_module},{cmd} {message}");
|
||
|
||
}
|
||
protected void LogTaskDone(TaskType cmd, string message)
|
||
{
|
||
EV.PostInfoLog("Scheduler", $"Task Done: {_module},{cmd} {message}");
|
||
}
|
||
public virtual void ResetTask()
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
_task = TaskType.None;
|
||
TimTransferTaskTimeout.Stop();
|
||
}
|
||
}
|
||
|
||
public virtual bool WaitTransfer(ModuleName robot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
_task = TaskType.TransferTarget;
|
||
_inProcessRobot = robot;
|
||
TimTransferTaskTimeout.Start(30000);
|
||
LogTaskStart(_task, $"Note {robot} in transfer");
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public bool IsWaitTransfer(ModuleName robot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return _task == TaskType.TransferTarget && _inProcessRobot == robot;
|
||
}
|
||
}
|
||
|
||
public virtual bool StopWaitTransfer(ModuleName robot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
LogTaskDone(_task, $"Note {robot} transfer complete");
|
||
_inProcessRobot = ModuleName.System;
|
||
_task = TaskType.None;
|
||
TimTransferTaskTimeout.Stop();
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public WaferInfo GetWaferInfo(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return WaferManager.Instance.GetWafer(ModuleHelper.Converter(_module), slot);
|
||
}
|
||
}
|
||
|
||
public bool CheckWaferStatus(int slot, WaferStatus waferStatus)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return WaferManager.Instance.CheckWafer(ModuleHelper.Converter(_module), slot, waferStatus);
|
||
}
|
||
}
|
||
|
||
public bool HasWafer(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return WaferManager.Instance.CheckHasWafer(ModuleHelper.Converter(_module), slot);
|
||
}
|
||
}
|
||
|
||
public bool NoWafer(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return WaferManager.Instance.CheckNoWafer(ModuleHelper.Converter(_module), slot);
|
||
}
|
||
}
|
||
|
||
public bool HasTray(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return WaferManager.Instance.CheckHasTray(ModuleHelper.Converter(_module), slot);
|
||
}
|
||
}
|
||
|
||
public bool NoTray(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return WaferManager.Instance.CheckNoTray(ModuleHelper.Converter(_module), slot);
|
||
}
|
||
}
|
||
|
||
public bool FirstDetectWaferArrive(int slot)
|
||
{
|
||
firstDetectWaferArriveTrigs[slot].CLK = HasWafer(slot);
|
||
return firstDetectWaferArriveTrigs[slot].Q;
|
||
}
|
||
|
||
public bool FirstDetectWaferLeave(int slot)
|
||
{
|
||
firstDetectWaferLeaveTrigs[slot].CLK = NoWafer(slot);
|
||
return firstDetectWaferLeaveTrigs[slot].Q;
|
||
}
|
||
|
||
public bool FirstDetectTrayArrive(int slot)
|
||
{
|
||
firstDetectTrayArriveTrigs[slot].CLK = HasTray(slot);
|
||
return firstDetectTrayArriveTrigs[slot].Q;
|
||
}
|
||
|
||
public bool FirstDetectTrayLeave(int slot)
|
||
{
|
||
firstDetectTrayLeaveTrigs[slot].CLK = NoTray(slot);
|
||
return firstDetectTrayLeaveTrigs[slot].Q;
|
||
}
|
||
|
||
public bool HasTrayAndExceedProcessCount(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
WaferInfo wi = WaferManager.Instance.GetWafer(ModuleHelper.Converter(_module), slot);
|
||
if (wi == null)
|
||
return false;
|
||
|
||
return wi.TrayState == WaferTrayStatus.Normal && wi.TrayProcessCount <= 0;
|
||
}
|
||
}
|
||
|
||
public bool HasTrayAndNotExceedProcessCount(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
WaferInfo wi = WaferManager.Instance.GetWafer(ModuleHelper.Converter(_module), slot);
|
||
if (wi == null)
|
||
return false;
|
||
|
||
return wi.TrayState == WaferTrayStatus.Normal && wi.TrayProcessCount > 0;
|
||
}
|
||
}
|
||
|
||
public virtual bool CheckWaferNextStepIsThis(ModuleName module, int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
if (!WaferManager.Instance.CheckHasWafer(module, slot))
|
||
return false;
|
||
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(module, slot);
|
||
|
||
if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
|
||
return false;
|
||
|
||
if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
|
||
return false;
|
||
|
||
if (!wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules.Contains(Module))
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 判断下一步的模块是否有Wafer
|
||
/// </summary>
|
||
/// <param name="slot"></param>
|
||
/// <returns></returns>
|
||
public virtual bool CheckWaferNextStepModuleNoWafer(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
if (!WaferManager.Instance.CheckHasWafer(Module, slot))
|
||
return false;
|
||
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(Module, slot);
|
||
|
||
if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
|
||
return false;
|
||
|
||
if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
|
||
return false;
|
||
|
||
List<ModuleName> lstModuleName = wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules;
|
||
if (lstModuleName.Count > 0)
|
||
{
|
||
for (int i = 0; i < lstModuleName.Count; i++)
|
||
{
|
||
if (WaferManager.Instance.CheckNoWafer(lstModuleName[i], 0))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public virtual bool CheckWaferNextStepModuleNoTray(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
if (!WaferManager.Instance.CheckHasWafer(Module, slot))
|
||
return false;
|
||
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(Module, slot);
|
||
|
||
if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
|
||
return false;
|
||
|
||
if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count)
|
||
return false;
|
||
|
||
List<ModuleName> lstModuleName = wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules;
|
||
if (lstModuleName.Count > 0)
|
||
{
|
||
for (int j = 0; j < lstModuleName.Count; j++)
|
||
{
|
||
if (lstModuleName[j] == ModuleName.Buffer)
|
||
{
|
||
string strSots = wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep]
|
||
.StepParameter["SlotSelection"].ToString();
|
||
if (string.IsNullOrEmpty(strSots))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
string[] bufferSlots = strSots.Split(',');
|
||
for (int k = 0; k < bufferSlots.Length; k++)
|
||
{
|
||
if (Int32.TryParse(bufferSlots[k], out int bufferSlot))
|
||
{
|
||
if (WaferManager.Instance.CheckNoTray(ModuleName.Buffer, bufferSlot - 1))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (WaferManager.Instance.CheckNoTray(lstModuleName[j], 0))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 判断Wafer的步骤是否都完成了
|
||
/// </summary>
|
||
/// <param name="waferModule"></param>
|
||
/// <param name="waferSlot"></param>
|
||
/// <returns></returns>
|
||
public virtual bool CheckWaferSequenceStepDone(int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(Module, slot);
|
||
|
||
if (wafer.IsEmpty)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count &&
|
||
wafer.ProcessJob.Sequence.Steps.Count > 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public virtual bool CheckWaferNeedProcess(int waferSlot, ModuleName processIn = ModuleName.System)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(Module, waferSlot);
|
||
|
||
if (wafer.IsEmpty)
|
||
return false;
|
||
|
||
if (wafer.Status == WaferStatus.Dummy && wafer.ProcessState == EnumWaferProcessStatus.Wait)
|
||
{
|
||
if (ModuleHelper.IsPm(processIn))
|
||
{
|
||
return (CheckNeedRunClean(out bool withWafer, out _) && withWafer);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
if (wafer.ProcessJob == null || wafer.ProcessJob.Sequence == null ||
|
||
wafer.ProcessJob.Sequence.Steps == null)
|
||
return false;
|
||
|
||
if (wafer.NextSequenceStep >= wafer.ProcessJob.Sequence.Steps.Count ||
|
||
wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep].StepModules == null)
|
||
return false;
|
||
|
||
if (processIn != ModuleName.System && !wafer.ProcessJob.Sequence.Steps[wafer.NextSequenceStep]
|
||
.StepModules.Contains(processIn))
|
||
return false;
|
||
|
||
bool hasPm = false;
|
||
for (int i = wafer.NextSequenceStep; i < wafer.ProcessJob.Sequence.Steps.Count; i++)
|
||
{
|
||
foreach (var stepModule in wafer.ProcessJob.Sequence.Steps[i].StepModules)
|
||
{
|
||
if (ModuleHelper.IsPm(stepModule))
|
||
{
|
||
hasPm = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (hasPm)
|
||
break;
|
||
}
|
||
|
||
if (processIn == ModuleName.System && !hasPm)
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool CheckNeedRunClean(out bool withWafer, out string recipeName)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
recipeName = string.Empty;
|
||
withWafer = false;
|
||
|
||
//SequenceInfo seq = GetCurrentSequenceInfo();
|
||
//int waferProcessed = StatsDataManager.Instance.GetValue($"{Module}.WaferProcessedSincePreviousClean");
|
||
|
||
//if (seq == null)
|
||
// return false;
|
||
|
||
|
||
//foreach (var stepInfo in seq.Steps)
|
||
//{
|
||
// if (!stepInfo.StepModules.Contains(Module))
|
||
// continue;
|
||
|
||
// if (stepInfo.StepParameter.ContainsKey("CleanIntervalWaferless")
|
||
// && int.TryParse((string)stepInfo.StepParameter["CleanIntervalWaferless"], out int interval)
|
||
// && stepInfo.StepParameter.ContainsKey("CleanRecipeWaferless")
|
||
// && !string.IsNullOrEmpty((string)stepInfo.StepParameter["CleanRecipeWaferless"]))
|
||
// {
|
||
// if (interval > 0 && waferProcessed >= interval)
|
||
// {
|
||
// recipeName = (string)stepInfo.StepParameter["CleanRecipeWaferless"];
|
||
// withWafer = false;
|
||
// return true;
|
||
// }
|
||
// }
|
||
|
||
// if (stepInfo.StepParameter.ContainsKey("CleanIntervalWafer")
|
||
// && int.TryParse((string)stepInfo.StepParameter["CleanIntervalWafer"], out interval)
|
||
// && stepInfo.StepParameter.ContainsKey("CleanRecipeWafer")
|
||
// && !string.IsNullOrEmpty((string)stepInfo.StepParameter["CleanRecipeWafer"]))
|
||
// {
|
||
// if (interval > 0 && waferProcessed >= interval)
|
||
// {
|
||
// recipeName = (string)stepInfo.StepParameter["CleanRecipeWafer"];
|
||
// withWafer = true;
|
||
// return true;
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public virtual bool IsReadyForPick(ModuleName robot, int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool IsReadyForPlace(ModuleName robot, int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool PrepareTransfer(ModuleName robot, EnumTransferType type, int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool PostTransfer(ModuleName robot, EnumTransferType type, int slot)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool Process(string recipeName, bool isCleanRecipe, bool withDummyWafer)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool Cooling(bool coolingType, int coolingTime)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool Aligning()
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool WarmUp(int warmUpTime)
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
|
||
public virtual bool CheckWaferTraySeparated()
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool CheckWaferTrayGrouped()
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
public virtual bool CheckSlitValveClosed() //检查闸板阀是否关闭
|
||
{
|
||
lock (SyncRoot)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
}
|