610 lines
21 KiB
C#
610 lines
21 KiB
C#
using Aitex.Core.RT.DataCenter;
|
|
using Aitex.Core.RT.Device;
|
|
using Aitex.Core.RT.Event;
|
|
using Aitex.Core.RT.Fsm;
|
|
using Aitex.Core.RT.OperationCenter;
|
|
using Aitex.Core.RT.Routine;
|
|
using Aitex.Core.Util;
|
|
using Aitex.Core.Utilities;
|
|
using Aitex.Sorter.Common;
|
|
using Mainframe.TMs;
|
|
using MECF.Framework.Common.Equipment;
|
|
using MECF.Framework.Common.Schedulers;
|
|
using System;
|
|
using Mainframe.EFEMs.Routines;
|
|
|
|
namespace Mainframe.EFEMs
|
|
{
|
|
public class EFEMModule : EFEMModuleBase
|
|
{
|
|
public enum STATE
|
|
{
|
|
NotInstall,
|
|
Init,
|
|
Idle,
|
|
Homing,
|
|
Cooling,
|
|
Error,
|
|
|
|
WaferRobotPick,
|
|
WaferRobotPlace,
|
|
WaferRobotMap,
|
|
RobotHoming,
|
|
TrayRobotPick,
|
|
TrayRobotPlace,
|
|
TrayRobotMap,
|
|
OpenSlitValve,
|
|
CloseSlitValve,
|
|
}
|
|
|
|
public enum MSG
|
|
{
|
|
Home,
|
|
Reset,
|
|
Abort,
|
|
Error,
|
|
ToInit,
|
|
|
|
SetOnline,
|
|
SetOffline,
|
|
|
|
RobotHome,
|
|
WaferRobotPick,
|
|
WaferRobotPlace,
|
|
WaferRobotMap,
|
|
TrayRobotPick,
|
|
TrayRobotPlace,
|
|
TrayRobotMap,
|
|
OpenSlitValve,
|
|
CloseSlitValve,
|
|
};
|
|
|
|
public SicWaferRobot WaferRobotDevice { get; set; }
|
|
public SicTrayRobot TrayRobotDevice { get; set; }
|
|
|
|
public override bool IsReady
|
|
{
|
|
get { return FsmState == (int)STATE.Idle && CheckAllMessageProcessed(); }
|
|
}
|
|
|
|
public override bool IsError
|
|
{
|
|
get { return FsmState == (int)STATE.Error; }
|
|
}
|
|
|
|
public override bool IsInit
|
|
{
|
|
get { return FsmState == (int)STATE.Init; }
|
|
}
|
|
|
|
public bool IsBusy
|
|
{
|
|
get { return !IsInit && !IsError && !IsReady; }
|
|
}
|
|
|
|
public override bool IsIdle
|
|
{
|
|
get { return FsmState == (int)STATE.Idle && CheckAllMessageProcessed(); }
|
|
}
|
|
|
|
public bool IsAlarm
|
|
{
|
|
get
|
|
{
|
|
return FsmState == (int)STATE.Error;
|
|
}
|
|
}
|
|
|
|
public event Action<string> OnEnterError;
|
|
|
|
private TrayRobotPickRoutine _trayRobotPickRoutine;
|
|
private TrayRobotPlaceRoutine _trayRobotPlaceRoutine;
|
|
private EFEMHomeRoutine _robotHomeRoutine;
|
|
private TrayRobotMapRoutine _trayRobotMapRoutine;
|
|
private WaferRobotPlaceRoutine _WaferRobotPlaceRoutine;
|
|
private WaferRobotPickRoutine _waferRobotPickRoutine;
|
|
private WaferRobotMapRoutine _waferRobotMapRoutine;
|
|
private EfemSlitValveRoutine _slitValveRoutine;
|
|
|
|
private bool _isInit;
|
|
|
|
public SicEFEM _cassetteDevice { get; set; }
|
|
|
|
public EFEMModule(ModuleName module) : base(1)
|
|
{
|
|
Module = module.ToString();
|
|
Name = module.ToString();
|
|
IsOnline = false;
|
|
|
|
EnumLoop<STATE>.ForEach((item) =>
|
|
{
|
|
MapState((int)item, item.ToString());
|
|
});
|
|
|
|
EnumLoop<MSG>.ForEach((item) =>
|
|
{
|
|
MapMessage((int)item, item.ToString());
|
|
});
|
|
|
|
EnableFsm(50, IsInstalled ? STATE.Init : STATE.NotInstall);
|
|
}
|
|
|
|
public override bool Initialize()
|
|
{
|
|
InitRoutine();
|
|
|
|
InitDevice();
|
|
|
|
InitFsm();
|
|
|
|
InitOp();
|
|
|
|
InitData();
|
|
|
|
return base.Initialize();
|
|
}
|
|
|
|
private void InitRoutine()
|
|
{
|
|
ModuleName module = ModuleHelper.Converter(Module);
|
|
_trayRobotPlaceRoutine = new TrayRobotPlaceRoutine();
|
|
_robotHomeRoutine = new EFEMHomeRoutine();
|
|
|
|
_trayRobotPickRoutine = new TrayRobotPickRoutine();
|
|
_trayRobotPlaceRoutine = new TrayRobotPlaceRoutine();
|
|
_trayRobotMapRoutine = new TrayRobotMapRoutine();
|
|
_WaferRobotPlaceRoutine = new WaferRobotPlaceRoutine();
|
|
_waferRobotPickRoutine = new WaferRobotPickRoutine();
|
|
_waferRobotMapRoutine = new WaferRobotMapRoutine();
|
|
|
|
_slitValveRoutine = new EfemSlitValveRoutine();
|
|
|
|
}
|
|
|
|
private void InitDevice()
|
|
{
|
|
_cassetteDevice = DEVICE.GetDevice<SicEFEM>($"{Module}.{Module}");
|
|
WaferRobotDevice = DEVICE.GetDevice<SicWaferRobot>($"{ModuleName.WaferRobot}.{ModuleName.WaferRobot}");
|
|
TrayRobotDevice = DEVICE.GetDevice<SicTrayRobot>($"{ModuleName.TrayRobot}.{ModuleName.TrayRobot}");
|
|
}
|
|
|
|
private void InitFsm()
|
|
{
|
|
//Error
|
|
AnyStateTransition(MSG.Error, FsmOnError, STATE.Error);
|
|
AnyStateTransition(FSM_MSG.ALARM, FsmOnError, STATE.Error);
|
|
Transition(STATE.Error, MSG.Reset, FsmReset, STATE.Idle);
|
|
EnterExitTransition<STATE, FSM_MSG>(STATE.Error, FsmEnterError, FSM_MSG.NONE, FsmExitError);
|
|
|
|
//Home
|
|
Transition(STATE.Init, MSG.Home, FsmStartHome, STATE.Homing);
|
|
Transition(STATE.Error, MSG.Home, FsmStartHome, STATE.Homing);
|
|
Transition(STATE.Idle, MSG.Home, FsmStartHome, STATE.Homing);
|
|
Transition(STATE.Homing, FSM_MSG.TIMER, FsmMonitorHomeTask, STATE.Idle);
|
|
Transition(STATE.Homing, MSG.Error, null, STATE.Init);
|
|
Transition(STATE.Homing, MSG.Abort, FsmAbortTask, STATE.Init);
|
|
EnterExitTransition((int)STATE.Homing, FsmEnterIdle, (int)FSM_MSG.NONE, FsmExitIdle);
|
|
AnyStateTransition(MSG.ToInit, FsmToInit, STATE.Init);
|
|
|
|
//Online
|
|
Transition(STATE.Idle, MSG.SetOnline, FsmStartSetOnline, STATE.Idle);
|
|
Transition(STATE.Idle, MSG.SetOffline, FsmStartSetOffline, STATE.Idle);
|
|
|
|
|
|
Transition(STATE.Idle, MSG.WaferRobotMap, FsmStartWaferRobotMap, STATE.WaferRobotMap);
|
|
Transition(STATE.WaferRobotMap, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.WaferRobotMap, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
Transition(STATE.Idle, MSG.WaferRobotPick, FsmStartWaferRobotPick, STATE.WaferRobotPick);
|
|
Transition(STATE.WaferRobotPick, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.WaferRobotPick, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
Transition(STATE.Idle, MSG.WaferRobotPlace, FsmStartWaferRobotPlace, STATE.WaferRobotPlace);
|
|
Transition(STATE.WaferRobotPlace, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.WaferRobotPlace, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
Transition(STATE.Init, MSG.RobotHome, FsmStartRobotHome, STATE.RobotHoming);
|
|
Transition(STATE.Error, MSG.RobotHome, FsmStartRobotHome, STATE.RobotHoming);
|
|
Transition(STATE.Idle, MSG.RobotHome, FsmStartRobotHome, STATE.RobotHoming);
|
|
Transition(STATE.RobotHoming, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.RobotHoming, MSG.Error, null, STATE.Init);
|
|
Transition(STATE.RobotHoming, MSG.Abort, FsmAbortTask, STATE.Init);
|
|
|
|
Transition(STATE.Idle, MSG.TrayRobotMap, FsmStartTrayRobotMap, STATE.TrayRobotMap);
|
|
Transition(STATE.TrayRobotMap, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.TrayRobotMap, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
|
|
Transition(STATE.Idle, MSG.TrayRobotPick, FsmStartTrayRobotPick, STATE.TrayRobotPick);
|
|
Transition(STATE.TrayRobotPick, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.TrayRobotPick, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
Transition(STATE.Idle, MSG.TrayRobotPlace, FsmStartTrayRobotPlace, STATE.TrayRobotPlace);
|
|
Transition(STATE.TrayRobotPlace, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.TrayRobotPlace, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
|
|
//open SlitValve
|
|
Transition(STATE.Idle, MSG.OpenSlitValve, FsmStartOpenSlitValve, STATE.OpenSlitValve);
|
|
Transition(STATE.OpenSlitValve, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.OpenSlitValve, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
//close SlitValve
|
|
Transition(STATE.Idle, MSG.CloseSlitValve, FsmStartCloseSlitValve, STATE.CloseSlitValve);
|
|
Transition(STATE.CloseSlitValve, FSM_MSG.TIMER, FsmMonitorTask, STATE.Idle);
|
|
Transition(STATE.CloseSlitValve, MSG.Abort, FsmAbortTask, STATE.Idle);
|
|
|
|
|
|
|
|
}
|
|
|
|
private void InitOp()
|
|
{
|
|
OP.Subscribe($"{Name}.Home", (string cmd, object[] args) => CheckToPostMessage((int)MSG.Home));
|
|
|
|
OP.Subscribe($"{Name}.Reset", (string cmd, object[] args) => CheckToPostMessage((int)MSG.Reset));
|
|
OP.Subscribe($"{Name}.Abort", (string cmd, object[] args) => CheckToPostMessage((int)MSG.Abort));
|
|
OP.Subscribe($"{Module}.SetOnline", (string cmd, object[] args) => CheckToPostMessage((int)MSG.SetOnline));
|
|
OP.Subscribe($"{Module}.SetOffline", (string cmd, object[] args) => CheckToPostMessage((int)MSG.SetOffline));
|
|
|
|
OP.Subscribe($"{Module}.PickWafer", (string cmd, object[] args) => CheckToPostMessage((int)MSG.WaferRobotPick, args[0], args[1]));
|
|
OP.Subscribe($"{Module}.PlaceWafer", (string cmd, object[] args) => CheckToPostMessage((int)MSG.WaferRobotPlace, args[0], args[1]));
|
|
OP.Subscribe($"{Module}.MapWafer", (string cmd, object[] args) => CheckToPostMessage((int)MSG.WaferRobotMap, args[0]));
|
|
OP.Subscribe($"{Module}.RobotHome", (string cmd, object[] args) => CheckToPostMessage((int)MSG.RobotHome, args[0]));
|
|
OP.Subscribe($"{Module}.PickTray", (string cmd, object[] args) => CheckToPostMessage((int)MSG.TrayRobotPick, args[0], args[1]));
|
|
OP.Subscribe($"{Module}.PlaceTray", (string cmd, object[] args) => CheckToPostMessage((int)MSG.TrayRobotPlace, args[0], args[1]));
|
|
OP.Subscribe($"{Module}.MapTray", (string cmd, object[] args) => CheckToPostMessage((int)MSG.TrayRobotMap, args[0]));
|
|
OP.Subscribe($"{Module}.OpenSlitValve", (string cmd, object[] args) =>{return CheckToPostMessage((int)MSG.OpenSlitValve, args[0], args[1]);});
|
|
OP.Subscribe($"{Module}.CloseSlitValve", (string cmd, object[] args) =>{return CheckToPostMessage((int)MSG.CloseSlitValve, args[0], args[1]);});
|
|
}
|
|
|
|
private void InitData()
|
|
{
|
|
DATA.Subscribe($"{Name}.Status", () => StringFsmStatus);
|
|
DATA.Subscribe($"{Name}.IsOnline", () => IsOnline);
|
|
DATA.Subscribe($"{Name}.IsBusy", () => IsBusy);
|
|
DATA.Subscribe($"{Module}.IsAlarm", () => IsAlarm);
|
|
}
|
|
|
|
private bool FsmOnError(object[] param)
|
|
{
|
|
IsOnline = false;
|
|
|
|
if (FsmState == (int)STATE.Error)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (FsmState == (int)STATE.Init)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool FsmReset(object[] param)
|
|
{
|
|
if (!_isInit)
|
|
{
|
|
PostMsg(MSG.ToInit);
|
|
return false;
|
|
}
|
|
|
|
WaferRobotDevice.RobotReset();
|
|
TrayRobotDevice.RobotReset();
|
|
return true;
|
|
}
|
|
|
|
private bool FsmExitError(object[] param)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
private bool FsmEnterError(object[] param)
|
|
{
|
|
if (OnEnterError != null)
|
|
OnEnterError(Module);
|
|
return true;
|
|
}
|
|
|
|
private bool FsmStartHome(object[] param)
|
|
{
|
|
// Home the all robots in EFEM.
|
|
_robotHomeRoutine.Init(ModuleName.EFEM);
|
|
Result ret = StartRoutine(_robotHomeRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmMonitorHomeTask(object[] param)
|
|
{
|
|
Result ret = MonitorRoutine();
|
|
if (ret == Result.FAIL)
|
|
{
|
|
PostMsg(MSG.Error);
|
|
return false;
|
|
}
|
|
|
|
if (ret == Result.DONE)
|
|
{
|
|
_isInit = true;
|
|
OP.DoOperation($"{Module}.ResetTask");
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool FsmAbortTask(object[] param)
|
|
{
|
|
AbortRoutine();
|
|
|
|
WaferRobotDevice.Abort();
|
|
TrayRobotDevice.Abort();
|
|
return true;
|
|
}
|
|
|
|
private bool FsmExitIdle(object[] param)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
private bool FsmEnterIdle(object[] param)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
private bool FsmToInit(object[] param)
|
|
{
|
|
WaferRobotDevice.RobotReset();
|
|
TrayRobotDevice.RobotReset();
|
|
return true;
|
|
}
|
|
|
|
private bool FsmStartSetOffline(object[] param)
|
|
{
|
|
IsOnline = false;
|
|
return true;
|
|
}
|
|
|
|
private bool FsmStartSetOnline(object[] param)
|
|
{
|
|
IsOnline = true;
|
|
return true;
|
|
}
|
|
|
|
|
|
private bool FsmMonitorTask(object[] param)
|
|
{
|
|
Result ret = MonitorRoutine();
|
|
if (ret == Result.FAIL)
|
|
{
|
|
PostMsg(MSG.Error);
|
|
return false;
|
|
}
|
|
|
|
return ret == Result.DONE;
|
|
}
|
|
|
|
public override bool Home(out string reason)
|
|
{
|
|
CheckToPostMessage((int)MSG.Home);
|
|
reason = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
|
|
public override bool CheckAcked(int entityTaskToken)
|
|
{
|
|
return FsmState == (int)STATE.Idle && CheckAllMessageProcessed();
|
|
//return true;
|
|
}
|
|
|
|
public override void NoteTransferStart(ModuleName robot, Hand blade, int targetSlot, EnumTransferType transferType)
|
|
{
|
|
//CheckToPostMessage(MSG.InTransfer);
|
|
}
|
|
|
|
public override void NoteTransferStop(ModuleName robot, Hand blade, int targetSlot, EnumTransferType transferType)
|
|
{
|
|
//if (FsmState == (int)STATE.InTransfer)
|
|
// CheckToPostMessage(MSG.TransferComplete);
|
|
}
|
|
|
|
public override bool PrepareTransfer(ModuleName robot, Hand blade, int targetSlot, EnumTransferType transferType, out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public override bool TransferHandoff(ModuleName robot, Hand blade, int targetSlot, EnumTransferType transferType, out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public override bool PostTransfer(ModuleName robot, Hand blade, int targetSlot, EnumTransferType transferType, out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public override bool CheckReadyForTransfer(ModuleName robot, Hand blade, int targetSlot, EnumTransferType transferType,
|
|
out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public override bool CheckReadyForMap(ModuleName robot, Hand blade, out string reason)
|
|
{
|
|
reason = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
public void InvokeOffline()
|
|
{
|
|
PostMsg((int)MSG.SetOffline);
|
|
}
|
|
|
|
public void InvokeOnline()
|
|
{
|
|
PostMsg((int)MSG.SetOnline);
|
|
}
|
|
|
|
public override bool MapWafer(ModuleName target)
|
|
{
|
|
if(CheckToPostMessage((int)MSG.WaferRobotMap, target.ToString()))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override bool PickWafer(ModuleName target, Hand blade, int targetSlot)
|
|
{
|
|
if (CheckToPostMessage((int)MSG.WaferRobotPick, target.ToString(), targetSlot, blade))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool PlaceWafer(ModuleName target, Hand blade, int targetSlot)
|
|
{
|
|
if (CheckToPostMessage((int)MSG.WaferRobotPlace, target.ToString(), targetSlot, blade))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool GotoWafer(ModuleName target, Hand blade, int targetSlot)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public override bool MapTray(ModuleName target)
|
|
{
|
|
if (CheckToPostMessage((int)MSG.TrayRobotMap, target.ToString()))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool PickTray(ModuleName target, Hand blade, int targetSlot)
|
|
{
|
|
if (CheckToPostMessage((int)MSG.TrayRobotPick, target.ToString(), targetSlot, blade))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool PlaceTray(ModuleName target, Hand blade, int targetSlot)
|
|
{
|
|
if (CheckToPostMessage((int)MSG.TrayRobotPlace, target.ToString(), targetSlot, blade))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool GotoTray(ModuleName target, Hand blade, int targetSlot)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
|
|
private bool FsmStartWaferRobotMap(object[] param)
|
|
{
|
|
_waferRobotMapRoutine.Init(ModuleHelper.Converter((string)param[0]));
|
|
Result ret = StartRoutine(_waferRobotMapRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmStartWaferRobotPick(object[] param)
|
|
{
|
|
_waferRobotPickRoutine.Init(ModuleHelper.Converter((string)param[0]), (int)param[1]);
|
|
Result ret = StartRoutine(_waferRobotPickRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmStartWaferRobotPlace(object[] param)
|
|
{
|
|
_WaferRobotPlaceRoutine.Init(ModuleHelper.Converter((string)param[0]), (int)param[1]);
|
|
Result ret = StartRoutine(_WaferRobotPlaceRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmStartRobotHome(object[] param)
|
|
{
|
|
// // Home the specified robots in EFEM.
|
|
if (param == null || param.Length !=1 || param[0] is string == false)
|
|
return false;
|
|
string robotName = param[0] as string;
|
|
|
|
if (Enum.TryParse<ModuleName>(robotName, true, out var robot) == false)
|
|
return false;
|
|
|
|
_robotHomeRoutine.Init(robot);
|
|
Result ret = StartRoutine(_robotHomeRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
private bool FsmStartTrayRobotMap(object[] param)
|
|
{
|
|
_trayRobotMapRoutine.Init(ModuleHelper.Converter((string)param[0]));
|
|
Result ret = StartRoutine(_trayRobotMapRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
|
|
private bool FsmStartTrayRobotPick(object[] param)
|
|
{
|
|
_trayRobotPickRoutine.Init(ModuleHelper.Converter((string)param[0]), (int)param[1]);
|
|
Result ret = StartRoutine(_trayRobotPickRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmStartTrayRobotPlace(object[] param)
|
|
{
|
|
_trayRobotPlaceRoutine.Init(ModuleHelper.Converter((string)param[0]), (int)param[1]);
|
|
Result ret = StartRoutine(_trayRobotPlaceRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmStartOpenSlitValve(object[] param)
|
|
{
|
|
_slitValveRoutine.Init(ModuleHelper.Converter(param[0].ToString()), ModuleHelper.Converter(param[1].ToString()), true);
|
|
|
|
Result ret = StartRoutine(_slitValveRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
private bool FsmStartCloseSlitValve(object[] param)
|
|
{
|
|
_slitValveRoutine.Init(ModuleHelper.Converter(param[0].ToString()), ModuleHelper.Converter(param[1].ToString()), false);
|
|
|
|
Result ret = StartRoutine(_slitValveRoutine);
|
|
if (ret == Result.FAIL || ret == Result.DONE)
|
|
return false;
|
|
return ret == Result.RUN;
|
|
}
|
|
|
|
public int InvokeError()
|
|
{
|
|
if (CheckToPostMessage((int)MSG.Error))
|
|
return (int)MSG.Error;
|
|
|
|
return (int)FSM_MSG.NONE;
|
|
}
|
|
}
|
|
}
|