310 lines
10 KiB
C#
310 lines
10 KiB
C#
using System.Collections.Generic;
|
|
using Aitex.Core.RT.Event;
|
|
using Aitex.Core.RT.Routine;
|
|
using Aitex.Core.Util;
|
|
using Aitex.Sorter.Common;
|
|
using Mainframe.Buffers;
|
|
using Mainframe.TMs;
|
|
using MECF.Framework.Common.Equipment;
|
|
using MECF.Framework.Common.Schedulers;
|
|
using MECF.Framework.Common.SubstrateTrackings;
|
|
using SicPM.Routines;
|
|
using SicRT.Modules.Schedulers;
|
|
namespace SicRT.Equipments
|
|
{
|
|
internal interface IManualTransferRoutine : IRoutine
|
|
{
|
|
}
|
|
|
|
public class MoveItemEx : MoveItem
|
|
{
|
|
public int CoolingTime { get; set; }
|
|
|
|
public MoveItemEx(ModuleName sourceModule, int sourceSlot, ModuleName destinationModule, int destinationSlot, int coolingTime)
|
|
: base(sourceModule, sourceSlot, destinationModule, destinationSlot, Hand.Blade1)
|
|
{
|
|
CoolingTime = coolingTime;
|
|
}
|
|
}
|
|
|
|
public class ManualTransfer : SchedulerModuleFactory
|
|
{
|
|
private Queue<IRoutine> _moveTaskQueue = new Queue<IRoutine>();
|
|
private IRoutine _activeTask;
|
|
|
|
public Result Start(object[] objs)
|
|
{
|
|
_moveTaskQueue.Clear();
|
|
|
|
ModuleName source = (ModuleName)objs[0];
|
|
int ss = (int)objs[1];
|
|
ModuleName target = (ModuleName)objs[2];
|
|
int ds = (int)objs[3];
|
|
|
|
|
|
bool autoCooling = false;
|
|
int coolingTime = 0;
|
|
if (objs.Length >= 8)
|
|
{
|
|
autoCooling = (bool)objs[6];
|
|
coolingTime = (int)objs[7];
|
|
}
|
|
|
|
if (!WaferManager.Instance.CheckHasWafer(source, ss))
|
|
{
|
|
EV.PostWarningLog("System", "source no wafer");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
if (!WaferManager.Instance.CheckNoWafer(target, ds))
|
|
{
|
|
EV.PostWarningLog("System", "destination has wafer");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
if (source != ModuleName.EfemRobot && WaferManager.Instance.CheckHasWafer(ModuleName.EfemRobot, 0))
|
|
{
|
|
EV.PostWarningLog("System", "robot has wafer");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
if (autoCooling && !ModuleHelper.IsBuffer(source) && !ModuleHelper.IsBuffer(target))
|
|
{
|
|
if (WaferManager.Instance.CheckHasWafer(ModuleName.Buffer, 0))
|
|
{
|
|
EV.PostWarningLog("System", "Can not transfer, buffer has wafer, can not auto cooling");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
_moveTaskQueue.Enqueue(new EfemRobotMover(new MoveItemEx(source, ss, ModuleName.Buffer, 0, coolingTime)));
|
|
BufferCoolingRoutine coolingRoutine = new BufferCoolingRoutine(ModuleName.Buffer);
|
|
coolingRoutine.Init(true,coolingTime);
|
|
_moveTaskQueue.Enqueue(coolingRoutine);
|
|
_moveTaskQueue.Enqueue(new EfemRobotMover(new MoveItemEx(ModuleName.Buffer, 0, target, ds, 0)));
|
|
}
|
|
else
|
|
{
|
|
_moveTaskQueue.Enqueue(new EfemRobotMover(new MoveItemEx(source, ss, target, ds, coolingTime)));
|
|
}
|
|
|
|
_activeTask = _moveTaskQueue.Dequeue();
|
|
|
|
return _activeTask.Start();
|
|
}
|
|
|
|
|
|
public Result Monitor(object[] objs)
|
|
{
|
|
System.Diagnostics.Debug.Assert(_activeTask != null, "mover should not be null, call start first");
|
|
|
|
Result ret = _activeTask.Monitor();
|
|
if (ret == Result.FAIL)
|
|
return ret;
|
|
|
|
if (ret == Result.DONE)
|
|
{
|
|
if (_moveTaskQueue.Count > 0)
|
|
{
|
|
_activeTask = _moveTaskQueue.Dequeue();
|
|
return _activeTask.Start();
|
|
}
|
|
|
|
return Result.DONE;
|
|
}
|
|
|
|
return Result.RUN;
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_moveTaskQueue.Clear();
|
|
_activeTask = null;
|
|
}
|
|
}
|
|
|
|
|
|
public class EfemRobotMover : SchedulerModuleFactory, IRoutine
|
|
{
|
|
private MoveItemEx _moveTask;
|
|
|
|
private SchedulerModule _source;
|
|
private SchedulerModule _destination;
|
|
|
|
public EfemRobotMover(MoveItemEx moveTask)
|
|
{
|
|
_moveTask = moveTask;
|
|
}
|
|
|
|
public Result Start()
|
|
{
|
|
_source = GetModule(_moveTask.SourceModule.ToString());
|
|
_destination = GetModule(_moveTask.DestinationModule.ToString());
|
|
|
|
System.Diagnostics.Debug.Assert(_source != null, $"{_moveTask.SourceModule} not valid");
|
|
System.Diagnostics.Debug.Assert(_destination != null, $"{_moveTask.DestinationModule} not valid");
|
|
|
|
_source.ResetTask();
|
|
_destination.ResetTask();
|
|
_tmRobot.ResetTask();
|
|
|
|
if (!WaferManager.Instance.CheckHasWafer(_moveTask.SourceModule, _moveTask.SourceSlot))
|
|
{
|
|
EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} slot {_moveTask.SourceSlot + 1} has not wafer");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
if (WaferManager.Instance.CheckHasWafer(_moveTask.DestinationModule, _moveTask.DestinationSlot))
|
|
{
|
|
EV.PostWarningLog("System", $"Failed transfer, destination {_moveTask.DestinationModule} slot {_moveTask.DestinationSlot + 1} has wafer");
|
|
return Result.FAIL;
|
|
}
|
|
if (!_tmRobot.IsOnline)
|
|
{
|
|
EV.PostWarningLog("System", $"Failed transfer, TM is not online");
|
|
return Result.FAIL;
|
|
}
|
|
if (!_source.IsAvailable)
|
|
{
|
|
EV.PostWarningLog("System", $"Failed transfer, source {_moveTask.SourceModule} not ready");
|
|
return Result.FAIL;
|
|
}
|
|
if (!_destination.IsAvailable)
|
|
{
|
|
EV.PostWarningLog("System", $"Failed transfer, Destination {_moveTask.DestinationModule} not ready");
|
|
return Result.FAIL;
|
|
}
|
|
|
|
|
|
//if (ModuleHelper.IsBuffer(_source.Module))
|
|
// _source.Cooling(_moveTask.CoolingTime);
|
|
|
|
//if (ModuleHelper.IsBuffer(_destination.Module))
|
|
// _destination.Cooling(_moveTask.CoolingTime);
|
|
|
|
if (_moveTask.SourceModule == ModuleName.EfemRobot)
|
|
_moveTask.RobotHand = (Hand)_moveTask.SourceSlot;
|
|
if (_moveTask.DestinationModule == ModuleName.EfemRobot)
|
|
_moveTask.RobotHand = (Hand)_moveTask.DestinationSlot;
|
|
|
|
return Result.RUN;
|
|
}
|
|
public Result Start(params object[] objs)
|
|
{
|
|
return this.Start();
|
|
}
|
|
|
|
public Result Monitor()
|
|
{
|
|
if (_source.NoWafer(_moveTask.SourceSlot) && _destination.HasWafer(_moveTask.DestinationSlot) &&
|
|
_tmRobot.IsAvailable)
|
|
{
|
|
if (_source.IsWaitTransfer(ModuleName.EfemRobot))
|
|
_source.StopWaitTransfer(ModuleName.EfemRobot);
|
|
|
|
if (_destination.IsWaitTransfer(ModuleName.EfemRobot))
|
|
_destination.StopWaitTransfer(ModuleName.EfemRobot);
|
|
|
|
return Result.DONE;
|
|
}
|
|
|
|
//Pick
|
|
if (_moveTask.SourceModule != ModuleName.TMRobot)
|
|
{
|
|
if (_source.HasWafer(_moveTask.SourceSlot))
|
|
{
|
|
if (!_source.IsAvailable)
|
|
{
|
|
return Result.RUN;
|
|
}
|
|
|
|
if (!_source.IsReadyForPick(ModuleName.TMRobot, _moveTask.SourceSlot))
|
|
{
|
|
if (!_source.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Pick, _moveTask.SourceSlot))
|
|
return Result.FAIL;
|
|
}
|
|
|
|
if (!_source.IsAvailable)
|
|
{
|
|
return Result.RUN;
|
|
}
|
|
|
|
if (!_tmRobot.HasWafer((int)_moveTask.RobotHand))
|
|
{
|
|
if (!_tmRobot.Pick(_moveTask.SourceModule, _moveTask.SourceSlot, _moveTask.RobotHand))
|
|
{
|
|
return Result.FAIL;
|
|
}
|
|
|
|
_source.WaitTransfer(ModuleName.TMRobot);
|
|
}
|
|
|
|
if (!_tmRobot.IsAvailable)
|
|
return Result.RUN;
|
|
}
|
|
else
|
|
{
|
|
if (!_tmRobot.IsAvailable)
|
|
return Result.RUN;
|
|
|
|
if (_source.IsWaitTransfer(ModuleName.TMRobot))
|
|
_source.StopWaitTransfer(ModuleName.TMRobot);
|
|
}
|
|
}
|
|
|
|
//Place
|
|
if (_moveTask.DestinationModule != ModuleName.TMRobot)
|
|
{
|
|
if (!_destination.IsAvailable)
|
|
return Result.RUN;
|
|
|
|
if (_destination.NoWafer(_moveTask.DestinationSlot))
|
|
{
|
|
if (!_destination.IsReadyForPlace(ModuleName.TMRobot, _moveTask.DestinationSlot))
|
|
{
|
|
if (!_destination.PrepareTransfer(ModuleName.TMRobot, EnumTransferType.Place,
|
|
_moveTask.DestinationSlot))
|
|
return Result.FAIL;
|
|
}
|
|
|
|
if (!_destination.IsAvailable)
|
|
return Result.RUN;
|
|
|
|
if (_tmRobot.HasWafer((int)_moveTask.RobotHand))
|
|
{
|
|
if (!_tmRobot.Place(_moveTask.DestinationModule, _moveTask.DestinationSlot, _moveTask.RobotHand))
|
|
return Result.FAIL;
|
|
|
|
_destination.WaitTransfer(ModuleName.TMRobot);
|
|
}
|
|
|
|
if (!_tmRobot.IsAvailable)
|
|
return Result.RUN;
|
|
}
|
|
else
|
|
{
|
|
if (!_tmRobot.IsAvailable)
|
|
return Result.RUN;
|
|
|
|
if (_destination.IsWaitTransfer(ModuleName.TMRobot))
|
|
_destination.StopWaitTransfer(ModuleName.TMRobot);
|
|
}
|
|
}
|
|
|
|
return Result.RUN;
|
|
}
|
|
public void Abort()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_tmRobot.ResetTask();
|
|
_source?.ResetTask();
|
|
_destination?.ResetTask();
|
|
}
|
|
}
|
|
|
|
|
|
}
|