2023-03-28 13:24:11 +08:00
using System ;
using System.Linq ;
using System.Threading ;
using System.Threading.Tasks ;
using Aitex.Core.Common ;
using Aitex.Core.RT.DataCenter ;
using Aitex.Core.RT.Event ;
using Aitex.Core.RT.Fsm ;
using Aitex.Core.RT.OperationCenter ;
using Aitex.Core.RT.Routine ;
using Aitex.Core.RT.SCCore ;
using Aitex.Core.Util ;
using Aitex.Core.Utilities ;
using Aitex.Sorter.Common ;
using MECF.Framework.Common.Equipment ;
using MECF.Framework.Common.Schedulers ;
using MECF.Framework.Common.SubstrateTrackings ;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.PMs ;
2023-04-13 15:35:13 +08:00
using SicModules.PMs.RecipeExecutions ;
using SicModules.PMs.Routines ;
using SicModules.PMs.Routines.Recipe ;
2023-03-28 13:24:11 +08:00
2023-04-13 15:35:13 +08:00
namespace SicModules.PMs
2023-03-28 13:24:11 +08:00
{
public partial class PMModule : PMModuleBase , IRecipeExecutor
{
public enum STATE
{
NotInstall ,
NotConnected ,
Init ,
Idle ,
//Safety,
ProcessIdle ,
Homing ,
ToAtmIdle ,
ToProcessIdle ,
Pump ,
Vent ,
Purge ,
OpenSlitValve ,
CloseSlitValve ,
Error ,
PrepareTransfer ,
PostTransfer ,
PreProcess ,
PostProcess ,
Process ,
ProcessAborting ,
Aborting ,
LeakCheck ,
MFCCali ,
Paused ,
LidMoving ,
LidMoving0 ,
BottomMoving ,
OpenLid ,
Clean ,
Isolation ,
ExchangeMO ,
ServopUp ,
ServoDown ,
ServoHome ,
ServoReset ,
ToDefault ,
PcCalibration ,
ServoReset0 ,
ServoReset1 ,
ServoDown0 ,
ServoDown1 ,
ServopUp0 ,
ServopUp1 ,
ServoHome0 ,
ServoHome1 ,
PcCalibration0 ,
PreTransfer ,
VacIdle ,
ToProcessIdle1 ,
ToVacIdle1 ,
ToVacIdle ,
ToProcessIdle2 ,
PrePMMacro ,
PMMacro ,
PostPMMacro ,
PMMacroPause ,
ServiceIdle ,
StopHeat ,
CleanProcess ,
}
public enum MSG
{
Home ,
Reset ,
Abort ,
ProcessAbort ,
Error ,
Error1 ,
Connected ,
Disconnected ,
Transfer ,
PrepareTransfer ,
PostTransfer ,
Pump ,
Vent ,
Purge ,
OpenSlitValve ,
CloseSlitValve ,
SelectRecipe ,
RunRecipe ,
RecipeSkipStep ,
Pause ,
Continue ,
PostProcess ,
Process ,
LeakCheck ,
StartMFCCalibration ,
ChamberMoveBody ,
ChamberMoveBottom ,
ShowMessage ,
ToInit ,
ToSafety ,
AtmIdle ,
ToProcessIdle ,
OpenLid ,
Clean ,
Isolation ,
ExchangeMO ,
ServopUp ,
ServoDown ,
ServoHome ,
ServoReset ,
ToDefault ,
PreTransfer ,
PcCalibration ,
VacIdle ,
RunPMMacro ,
PMMacro ,
PostPMMacro ,
ToServiceIdle ,
StopHeat ,
CleanProcess
}
public enum ServoStates
{
Home ,
Homing ,
Up ,
Uping ,
Down ,
Downing
}
public bool IsServiceIdle { get ; set ; }
public ServoStates ServoState { get ; set ; }
public bool IsMoRoutineRuning
{
get { return FsmState = = ( int ) STATE . ExchangeMO ; }
}
public bool IsServiceMode
{
get { return IsServiceIdle ; } // !IsOnline; }
}
public override bool IsInit
{
get { return FsmState = = ( int ) STATE . Init ; }
}
public bool IsSafety
{
get { return false ; }
//get { return FsmState == (int)STATE.Safety; }
}
public bool IsBusy
{
get { return ! IsInit & & ! IsSafety & & ! IsError & & ! IsIdle & & ! IsProcessIdle ; }
}
public bool IsProcessing
{
get { return FsmState = = ( int ) STATE . Process ; }
}
public override bool IsIdle
{
get { return FsmState = = ( int ) STATE . Idle & & CheckAllMessageProcessed ( ) ; }
}
public override bool IsProcessIdle
{
get { return FsmState = = ( int ) STATE . ProcessIdle & & CheckAllMessageProcessed ( ) ; }
}
public RecipeRunningInfo RecipeRunningInfo
{
get
{
return _recipeRunningInfo ;
}
}
public override bool IsReady
{
get { return ( FsmState = = ( int ) STATE . Idle | | FsmState = = ( int ) STATE . ProcessIdle | | FsmState = = ( int ) STATE . VacIdle ) & & CheckAllMessageProcessed ( ) ; }
}
public override bool IsError
{
get { return FsmState = = ( int ) STATE . Error ; }
}
public override bool IsService
{
get { return IsServiceIdle ; }
}
public bool IsAlarm
{
get
{
return FsmState = = ( int ) STATE . Error ;
}
}
public bool IsWarning
{
get
{
int count = 0 ;
var warnings = EV . GetAlarmEvent ( ) ;
foreach ( var warm in warnings )
{
if ( warm . Level = = EventLevel . Warning & & warm . Source = = Name )
count + + ;
}
return ! IsAlarm & & count > 0 ;
}
}
public bool IsPaused { get ; set ; }
public int CurrentRoutineLoop
{
get
{
if ( FsmState = = ( int ) STATE . Purge )
{
return _purgeRoutine . LoopCounter + 1 ; // CurrentLoop从0开始
}
else if ( FsmState = = ( int ) STATE . Clean )
{
return _cleanRoutine . LoopCounter + 1 ;
}
return 0 ;
}
}
public int CurrentRoutineLoopTotal
{
get
{
if ( FsmState = = ( int ) STATE . Purge )
{
return _purgeRoutine . LoopTotalTime ;
}
else if ( FsmState = = ( int ) STATE . Clean )
{
return _cleanRoutine . LoopTotalTime ;
}
return 0 ;
}
}
public void ResetToleranceChecker ( )
{
}
public void OnProcessStart ( string v1 , string recipeName , bool v2 )
{
}
public void PauseRecipe ( out string reason )
{
reason = string . Empty ;
StopRamp ( ) ;
}
public bool CheckEndPoint ( )
{
return true ;
}
public bool CheckAllDevicesStable ( float v1 , float v2 , float v3 , float v4 , float v5 , float v6 , float v7 , float v8 , float v9 )
{
return true ;
}
public bool CheckEnableRunProcess ( out string reason )
{
reason = string . Empty ;
return true ;
}
public void AbortRunProcess ( out string reason )
{
_pmInterLock . SetPMProcessRunning ( false , out reason ) ;
_pmInterLock . SetPMPreProcessRunning ( false , out reason ) ;
reason = string . Empty ;
StopRamp ( ) ;
SetRotationServo ( 0 , 0 ) ;
}
public event Action < string > OnEnterError ;
//private PMPumpRoutine _pumpRoutine;
//private PMVentRoutine _ventRoutine;
private PMChamberMoveBodyRoutine _chamberMoveBodyRoutine ;
private PMButttomSectionMoveRoutine pMButttomSectionMoveRoutine ;
private PMLeakCheckRoutine _leakCheckRoutine ;
private PMPumpRoutine _pumpRoutine ;
private PMPurgeRoutine _purgeRoutine ;
private PMToAtmIdleRoutine _toAtmIdleRoutine ;
private PMVacIdleRoutine _vacIdleRoutine ;
private PMVentRoutine _ventRoutine ;
private PMToIsolationRoutine _toIsolationRoutine ;
private PMCleanRoutine _cleanRoutine ;
private PMExchangeMoRoutine _changeMoRoutine ;
private PreProcess _preprocessRoutine ;
private Process _processRoutine ;
private PostProcess _postprocessRoutine ;
private PMToProcessIdleRoutine _pmtoProcessIdle ;
private PMProcessAbortRoutine _pmProcessAbort ;
private ModuleName _module ;
private RecipeRunningInfo _recipeRunningInfo = new RecipeRunningInfo ( ) ;
private PMServoToPressure _pmServoToPressure ;
private PMPcCalibrationRoutine _pmPcCalibrationRoutine ;
private PMPostTransferRoutine _pmPostTransfer ;
private PMPrepareTransferRoutine _pmPreTransfer ;
private PMMacroRoutine _pMMacroRoutine ;
private PMStopHeatEnableRoutine _stopHeatEnableRoutine ;
private CleanRecipe _cleanRecipe ;
private bool _isInitFlag = false ;
public PMModule ( ModuleName module ) : base ( 1 )
{
_module = module ;
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 ( ) ;
InitInterlock ( ) ;
InitFsm ( ) ;
InitOp ( ) ;
InitData ( ) ;
InitalDeviceFunc ( ) ;
return base . Initialize ( ) ;
}
private void InitRoutine ( )
{
_purgeRoutine = new PMPurgeRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_leakCheckRoutine = new PMLeakCheckRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_chamberMoveBodyRoutine = new PMChamberMoveBodyRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
pMButttomSectionMoveRoutine = new PMButttomSectionMoveRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_preprocessRoutine = new PreProcess ( ModuleHelper . Converter ( Module ) , this ) ;
_processRoutine = new Process ( ModuleHelper . Converter ( Module ) , this ) ;
_postprocessRoutine = new PostProcess ( ModuleHelper . Converter ( Module ) , this ) ;
_toAtmIdleRoutine = new PMToAtmIdleRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_vacIdleRoutine = new PMVacIdleRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_ventRoutine = new PMVentRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_pumpRoutine = new PMPumpRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_cleanRoutine = new PMCleanRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_purgeRoutine = new PMPurgeRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_toIsolationRoutine = new PMToIsolationRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_changeMoRoutine = new PMExchangeMoRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_pmServoToPressure = new PMServoToPressure ( ModuleHelper . Converter ( Module ) , this ) ;
_pmtoProcessIdle = new PMToProcessIdleRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_pmPcCalibrationRoutine = new PMPcCalibrationRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_pmPostTransfer = new PMPostTransferRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_pmPreTransfer = new PMPrepareTransferRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_pMMacroRoutine = new PMMacroRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_stopHeatEnableRoutine = new PMStopHeatEnableRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
_cleanRecipe = new CleanRecipe ( ModuleHelper . Converter ( Module ) , this ) ;
_pmProcessAbort = new PMProcessAbortRoutine ( ModuleHelper . Converter ( Module ) , this ) ;
}
private void InitData ( )
{
DATA . Subscribe ( $"{Module}.Status" , ( ) = > StringFsmStatus . Replace ( "0" , "" ) . Replace ( "1" , "" ) . Replace ( "2" , "" ) ) ;
DATA . Subscribe ( $"{Module}.IsOnline" , ( ) = > IsOnline ) ;
DATA . Subscribe ( $"{Module}.IsService" , ( ) = > IsServiceIdle ) ;
DATA . Subscribe ( $"{Module}.IsAlarm" , ( ) = > IsAlarm ) ;
DATA . Subscribe ( $"{Module}.IsWarning" , ( ) = > IsWarning ) ;
DATA . Subscribe ( $"{Module}.IsIdle" , ( ) = > ! IsWarning & & ( IsIdle | | IsInit | | IsSafety ) ) ;
DATA . Subscribe ( $"{Module}.WaferSize" , ( ) = > WaferManager . Instance . GetWaferSize ( _module , 0 ) . ToString ( ) ) ;
DATA . Subscribe ( $"{Name}.LeakCheckElapseTime" , ( ) = >
{
if ( FsmState = = ( int ) STATE . LeakCheck )
return _leakCheckRoutine . ElapsedTime ;
return 0 ;
} ) ;
DATA . Subscribe ( $"{Name}.ChamberPressure" , ( ) = > ChamberPressure ) ;
DATA . Subscribe ( $"{Name}.ServoStates" , ( ) = > ServoState . ToString ( ) ) ;
DATA . Subscribe ( $"{Name}.SelectedRecipeName" , ( ) = > _recipeRunningInfo . RecipeName ) ;
DATA . Subscribe ( $"{Name}.RecipeStepNumber" , ( ) = > _recipeRunningInfo . StepNumber ) ;
DATA . Subscribe ( $"{Name}.RecipeStepName" , ( ) = > _recipeRunningInfo . StepName ) ;
DATA . Subscribe ( $"{Name}.RecipeStepElapseTime" , ( ) = > _recipeRunningInfo . StepElapseTime ) ;
DATA . Subscribe ( $"{Name}.RecipeStepTime" , ( ) = > _recipeRunningInfo . StepTime ) ;
DATA . Subscribe ( $"{Name}.RecipeTotalElapseTime" , ( ) = > _recipeRunningInfo . TotalElapseTime ) ;
DATA . Subscribe ( $"{Name}.RecipeTotalTime" , ( ) = > _recipeRunningInfo . TotalTime ) ;
DATA . Subscribe ( $"{Name}.CurrentRoutineLoop" , ( ) = > CurrentRoutineLoop ) ;
DATA . Subscribe ( $"{Name}.CurrentRoutineLoopTotal" , ( ) = > CurrentRoutineLoopTotal ) ;
DATA . Subscribe ( $"{Name}.RecipeStepElapseTime2" , ( ) = > _recipeRunningInfo . StepElapseTime2 ) ;
DATA . Subscribe ( $"{Name}.RecipeTotalElapseTime2" , ( ) = > _recipeRunningInfo . TotalElapseTime2 ) ;
//DATA.Subscribe($"{Name}.ArH2Switch", () => _recipeRunningInfo.ArH2Switch);
//DATA.Subscribe($"{Name}.N2FlowMode", () => _recipeRunningInfo.N2FlowMode);
}
private void InitOp ( )
{
OP . Subscribe ( $"{Module}.Home" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Home ) ) ;
OP . Subscribe ( $"{Module}.Reset" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Reset ) ) ;
OP . Subscribe ( $"{Module}.Abort" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Abort ) ) ;
OP . Subscribe ( $"{Module}.Pump" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Pump ) ) ;
OP . Subscribe ( $"{Module}.Vent" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Vent ) ) ;
OP . Subscribe ( $"{Module}.Purge" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Purge ) ) ;
OP . Subscribe ( $"{Module}.OpenLid" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . OpenLid ) ) ;
OP . Subscribe ( $"{Module}.Isolation" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Isolation ) ) ;
OP . Subscribe ( $"{Module}.Clean" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Clean ) ) ;
OP . Subscribe ( $"{Module}.ExchangeMO" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ExchangeMO , ( string ) args [ 0 ] ) ) ;
OP . Subscribe ( $"{Module}.ToDefault" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ToDefault ) ) ;
OP . Subscribe ( $"{Module}.SetOnline" , ( string cmd , object [ ] args ) = > PutOnline ( ) ) ;
OP . Subscribe ( $"{Module}.SetOffline" , ( string cmd , object [ ] args ) = > PutOffline ( ) ) ;
OP . Subscribe ( $"{Name}.SelectRecipe" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . SelectRecipe , args [ 0 ] ) ) ;
OP . Subscribe ( $"{Name}.RunRecipe" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . RunRecipe , ( string ) args [ 0 ] , ( bool ) args [ 1 ] , ( bool ) args [ 2 ] ) ) ;
OP . Subscribe ( $"{Name}.RecipeSkipStep" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . RecipeSkipStep ) ) ;
OP . Subscribe ( $"{Name}.Pause" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Pause ) ) ;
OP . Subscribe ( $"{Name}.Continue" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . Continue , args [ 0 ] . ToString ( ) ) ) ;
OP . Subscribe ( $"{Name}.LeakCheck" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . LeakCheck , args ) ) ;
OP . Subscribe ( $"{Module}.ChamberMoveBodyOpen" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ChamberMoveBody , args ) ) ;
OP . Subscribe ( $"{Module}.ChamberBottomOpen" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ChamberMoveBottom , args ) ) ;
OP . Subscribe ( $"{Module}.ShowMessage" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ShowMessage , args ) ) ;
OP . Subscribe ( $"{Module}.ToAtmIdle" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . AtmIdle ) ) ;
OP . Subscribe ( $"{Module}.ToVacIdle" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . VacIdle ) ) ;
OP . Subscribe ( $"{Module}.ToProcessIdle" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ToProcessIdle ) ) ;
OP . Subscribe ( $"{Module}.ServoHome" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ServoHome ) ) ;
OP . Subscribe ( $"{Module}.ServoUp" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ServopUp ) ) ;
OP . Subscribe ( $"{Module}.ServoDown" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ServoDown ) ) ;
OP . Subscribe ( $"{Module}.ServoReset" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ServoReset ) ) ;
OP . Subscribe ( $"{Module}.PostTransfer" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . PostTransfer ) ) ;
OP . Subscribe ( $"{Module}.PreTransfer" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . PreTransfer ) ) ;
OP . Subscribe ( $"{Module}.SetToServiceIdle" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . ToServiceIdle ) ) ;
OP . Subscribe ( $"{Module}.PcCalibration" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . PcCalibration ) ) ;
OP . Subscribe ( $"{Module}.RunPMMacro" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . RunPMMacro , ( string ) args [ 0 ] ) ) ;
OP . Subscribe ( $"{Module}.CleanRecipe" , ( string cmd , object [ ] args ) = > CheckToPostMessage ( ( int ) MSG . CleanProcess , ( string ) args [ 0 ] ) ) ;
}
private void InitFsm ( )
{
//Error
Transition ( STATE . Error , MSG . Reset , FsmReset , STATE . Idle ) ;
AnyStateTransition ( MSG . Error , FsmOnError , STATE . Error ) ; //在Service模式下,不成功
AnyStateTransition ( FSM_MSG . ALARM , FsmOnError , STATE . Error ) ;
AnyStateTransition ( MSG . Error1 , FsmOnError1 , STATE . Error ) ; //在Routine失败时生效
AnyStateTransition ( MSG . ToInit , FsmToInit , STATE . Init ) ;
EnterExitTransition < STATE , FSM_MSG > ( STATE . Error , FsmEnterError , FSM_MSG . NONE , FsmExitError ) ;
Transition ( STATE . Init , MSG . Disconnected , null , STATE . NotConnected ) ;
Transition ( STATE . Init , MSG . Home , FsmStartHome , STATE . Homing ) ;
//not connected
Transition ( STATE . NotConnected , MSG . Connected , null , STATE . Init ) ;
//Home(ToSafety过程)
EnterExitTransition ( ( int ) STATE . Homing , FsmEnterHome , ( int ) FSM_MSG . NONE , FsmExitHome ) ;
Transition ( STATE . Error , MSG . Home , FsmStartHome , STATE . Homing ) ;
Transition ( STATE . Homing , FSM_MSG . TIMER , FsmMonitorHomeTask , STATE . Idle ) ;
Transition ( STATE . Homing , MSG . Error , null , STATE . Idle ) ;
Transition ( STATE . Homing , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//AtmIdle
Transition ( STATE . Idle , MSG . AtmIdle , FsmToAtmIdle , STATE . ToAtmIdle ) ;
Transition ( STATE . VacIdle , MSG . AtmIdle , FsmToAtmIdle , STATE . ToAtmIdle ) ;
Transition ( STATE . ProcessIdle , MSG . AtmIdle , FsmToAtmIdle , STATE . ToAtmIdle ) ;
Transition ( STATE . ToAtmIdle , FSM_MSG . TIMER , FsmMonitorSafetyTask , STATE . Idle ) ;
Transition ( STATE . ToAtmIdle , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//Idle
Transition ( STATE . Idle , MSG . ToProcessIdle , FsmToProcessIdle , STATE . ToProcessIdle ) ; //ToProcessIdle
Transition ( STATE . ToProcessIdle , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . ToProcessIdle , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
Transition ( STATE . Idle , MSG . Home , FsmStartHome , STATE . Homing ) ; //ToSafety (Homing过程)
//VacIdle
Transition ( STATE . Idle , MSG . VacIdle , FsmVacIdle , STATE . ToVacIdle ) ;
Transition ( STATE . ToVacIdle , FSM_MSG . TIMER , FsmMonitorTask , STATE . VacIdle ) ;
Transition ( STATE . ToVacIdle , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
Transition ( STATE . ProcessIdle , MSG . VacIdle , FsmVacIdle , STATE . ToVacIdle1 ) ;
Transition ( STATE . VacIdle , MSG . ToProcessIdle , FsmToProcessIdle , STATE . ToProcessIdle1 ) ;
Transition ( STATE . ToProcessIdle1 , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . ToProcessIdle1 , MSG . Abort , FsmAbortTask , STATE . VacIdle ) ;
Transition ( STATE . ToVacIdle1 , FSM_MSG . TIMER , FsmMonitorTask , STATE . VacIdle ) ;
Transition ( STATE . ToVacIdle1 , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
//ToServiceIdle
Transition ( STATE . Idle , MSG . ToServiceIdle , FsmToService , STATE . Idle ) ;
Transition ( STATE . VacIdle , MSG . ToServiceIdle , FsmToService , STATE . VacIdle ) ;
Transition ( STATE . Error , MSG . ToServiceIdle , FsmToService , STATE . Error ) ;
//ProcessIdle
Transition ( STATE . ProcessIdle , MSG . ToProcessIdle , FsmToProcessIdle , STATE . ToProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . PrepareTransfer , FsmStartPrepareTransfer , STATE . PrepareTransfer ) ;
Transition ( STATE . PrepareTransfer , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . PrepareTransfer , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . PreTransfer , FsmStartPreTransfer2 , STATE . PreTransfer ) ;
Transition ( STATE . PreTransfer , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . PreTransfer , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . PostTransfer , FsmStartPostTransfer , STATE . PostTransfer ) ;
Transition ( STATE . PostTransfer , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . PostTransfer , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . OpenSlitValve , FsmStartOpenSlitValve , STATE . OpenSlitValve ) ;
Transition ( STATE . OpenSlitValve , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . OpenSlitValve , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . CloseSlitValve , FsmStartCloseSlitValve , STATE . CloseSlitValve ) ;
Transition ( STATE . CloseSlitValve , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . CloseSlitValve , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . CleanProcess , FsmStartCleanRecipe , STATE . CleanProcess ) ;
Transition ( STATE . CleanProcess , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . CleanProcess , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
//MoveBody
Transition ( STATE . Idle , MSG . ChamberMoveBody , FsmStartMoveBody , STATE . LidMoving ) ;
Transition ( STATE . LidMoving , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . LidMoving , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//PcCalibration
Transition ( STATE . Idle , MSG . PcCalibration , FsmStartPcCalibration , STATE . PcCalibration ) ;
Transition ( STATE . PcCalibration , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . PcCalibration , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//ShowMessage
Transition ( STATE . Idle , MSG . ShowMessage , ShowMessage , STATE . Idle ) ;
Transition ( STATE . Init , MSG . ShowMessage , ShowMessage , STATE . Init ) ; //测试时防报错
//Pump
Transition ( STATE . Idle , MSG . Pump , FsmStartPump , STATE . Pump ) ;
Transition ( STATE . Pump , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . Pump , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//Vent
Transition ( STATE . Idle , MSG . Vent , FsmStartVent , STATE . Vent ) ;
Transition ( STATE . Vent , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . Vent , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//Purge
Transition ( STATE . Idle , MSG . Purge , FsmStartPurge , STATE . Purge ) ;
Transition ( STATE . Purge , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . Purge , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//Leak check
Transition ( STATE . Idle , MSG . LeakCheck , FsmStartLeakCheck , STATE . LeakCheck ) ;
Transition ( STATE . LeakCheck , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . LeakCheck , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//OpenLid
Transition ( STATE . Idle , MSG . OpenLid , FsmStartPurge , STATE . OpenLid ) ;
Transition ( STATE . OpenLid , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . OpenLid , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//Clean
Transition ( STATE . Idle , MSG . Clean , FsmStartClean , STATE . Clean ) ;
Transition ( STATE . Clean , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . Clean , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//ExchangeMO
Transition ( STATE . Idle , MSG . ExchangeMO , FsmStartExchangeMO , STATE . ExchangeMO ) ;
Transition ( STATE . ExchangeMO , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . ExchangeMO , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//Pump
Transition ( STATE . VacIdle , MSG . Pump , FsmStartPump , STATE . Pump ) ;
//Vent
Transition ( STATE . VacIdle , MSG . Vent , FsmStartVent , STATE . Vent ) ;
//Purge
Transition ( STATE . VacIdle , MSG . Purge , FsmStartPurge , STATE . Purge ) ;
//Leak check
Transition ( STATE . VacIdle , MSG . LeakCheck , FsmStartLeakCheck , STATE . LeakCheck ) ;
//OpenLid
Transition ( STATE . VacIdle , MSG . OpenLid , FsmStartPurge , STATE . OpenLid ) ;
//Clean
Transition ( STATE . VacIdle , MSG . Clean , FsmStartClean , STATE . Clean ) ;
//ExchangeMO
Transition ( STATE . VacIdle , MSG . ExchangeMO , FsmStartExchangeMO , STATE . ExchangeMO ) ;
//FsmStartToIsolation
Transition ( STATE . Idle , MSG . Isolation , FsmStartToIsolation , STATE . Isolation ) ;
Transition ( STATE . Isolation , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . Isolation , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
//ProcessIdle
Transition ( STATE . ProcessIdle , MSG . SelectRecipe , FsmSelectRecipe , STATE . ProcessIdle ) ;
Transition ( STATE . ProcessIdle , MSG . RunRecipe , FsmStartPreProcess , STATE . PreProcess ) ;
//PreProcess
Transition ( STATE . PreProcess , FSM_MSG . TIMER , FsmMonitorTask , STATE . PreProcess ) ;
Transition ( STATE . PreProcess , MSG . ProcessAbort , null , STATE . Idle ) ;
Transition ( STATE . PreProcess , MSG . Abort , null , STATE . Idle ) ;
//Process
Transition ( STATE . PreProcess , MSG . Process , FsmStartProcess , STATE . Process ) ;
Transition ( STATE . Process , FSM_MSG . TIMER , FsmMonitorTask , STATE . Process ) ;
Transition ( STATE . Process , MSG . ProcessAbort , FsmStartProcessAbort , STATE . ProcessAborting ) ;
Transition ( STATE . Process , MSG . Abort , FsmStartProcessAbort , STATE . Aborting ) ;
Transition ( STATE . ProcessAborting , FSM_MSG . TIMER , FsmMonitorProcessAbortingTask , STATE . Error ) ;
Transition ( STATE . Aborting , FSM_MSG . TIMER , FsmMonitorProcessAbortingTask , STATE . Idle ) ;
Transition ( STATE . ProcessAborting , MSG . Abort , FsmAbortTask , STATE . Error ) ;
EnterExitTransition < STATE , FSM_MSG > ( STATE . Process , FsmEnterProcess , FSM_MSG . NONE , FsmExitProcess ) ;
Transition ( STATE . Process , MSG . Pause , FsmRecipePause , STATE . Paused ) ;
Transition ( STATE . Paused , FSM_MSG . TIMER , FsmMonitorTask , STATE . Paused ) ;
Transition ( STATE . Paused , MSG . Continue , FsmStartContinue , STATE . Process ) ;
Transition ( STATE . Paused , MSG . Error , null , STATE . Paused ) ;
Transition ( STATE . Process , MSG . RecipeSkipStep , FsmSkipStep , STATE . Process ) ;
//PostProcess
Transition ( STATE . Process , MSG . PostProcess , FsmStartPostProcess , STATE . PostProcess ) ;
Transition ( STATE . PostProcess , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . PostProcess , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
EnterExitTransition < STATE , FSM_MSG > ( STATE . PostProcess , null , FSM_MSG . NONE , ExitPostProcess ) ;
//MFC Calibration
Transition ( STATE . ProcessIdle , MSG . StartMFCCalibration , FsmStartMFCCalibration , STATE . MFCCali ) ;
Transition ( STATE . MFCCali , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . MFCCali , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
Transition ( STATE . Idle , MSG . SelectRecipe , FsmSelectRecipe , STATE . Idle ) ;
//PMMacro相关状态
Transition ( STATE . Idle , MSG . RunPMMacro , FsmStartPMMacro , STATE . PMMacro ) ;
Transition ( STATE . VacIdle , MSG . RunPMMacro , FsmStartPMMacro , STATE . PMMacro ) ;
Transition ( STATE . ProcessIdle , MSG . RunPMMacro , FsmStartPMMacro , STATE . PMMacro ) ;
Transition ( STATE . PMMacro , FSM_MSG . TIMER , FsmMonitorTask , STATE . Idle ) ;
Transition ( STATE . PMMacro , MSG . Abort , FsmAbortTask , STATE . Idle ) ;
Transition ( STATE . PMMacro , MSG . Pause , FsmPMMacroPause , STATE . PMMacroPause ) ;
Transition ( STATE . PMMacroPause , FSM_MSG . TIMER , FsmMonitorTask , STATE . PMMacroPause ) ;
Transition ( STATE . PMMacroPause , MSG . Continue , FsmPMMacroContinue , STATE . PMMacro ) ;
EnterExitTransition < STATE , FSM_MSG > ( STATE . PMMacro , null , FSM_MSG . NONE , FsmExitPMMacro ) ;
//StopHeat
Transition ( STATE . ProcessIdle , MSG . StopHeat , FsmStartStopHeat , STATE . StopHeat ) ;
Transition ( STATE . StopHeat , FSM_MSG . TIMER , FsmMonitorTask , STATE . ProcessIdle ) ;
Transition ( STATE . StopHeat , MSG . Abort , FsmAbortTask , STATE . ProcessIdle ) ;
}
private bool FsmToInit ( object [ ] param )
{
return true ;
}
private bool FsmExitError ( object [ ] param )
{
return true ;
}
private bool FsmEnterError ( object [ ] param )
{
if ( OnEnterError ! = null )
OnEnterError ( Module ) ;
if ( IsOnline )
{
EV . PostWarningLog ( Module , $"{Module}" ) ;
}
return true ;
}
private bool FsmStartPostTransfer ( object [ ] param )
{
bool needEnableHeat = false ;
if ( param . Length > 0 & & bool . TryParse ( param [ 0 ] . ToString ( ) , out needEnableHeat ) )
{
_pmPostTransfer . Init ( needEnableHeat ) ;
}
Result ret = StartRoutine ( _pmPostTransfer ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartPrepareTransfer ( object [ ] param )
{
QueueRoutine . Clear ( ) ;
double targetPressure = SC . GetValue < double > ( $"TM.PressureBalance.BalancePressure" ) ;
_pmServoToPressure . Init ( targetPressure ) ;
QueueRoutine . Enqueue ( _pmServoToPressure ) ;
Result ret = StartRoutine ( ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartPreTransfer2 ( object [ ] param )
{
Result ret = StartRoutine ( _pmPreTransfer ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartSetOffline ( object [ ] param )
{
IsOnline = false ;
return true ;
}
private bool FsmStartSetOnline ( object [ ] param )
{
if ( IsServiceIdle )
{
EV . PostWarningLog ( Module , $"can not set {Module} online while in service mode" ) ;
return false ;
}
else
{
IsOnline = true ;
return true ;
}
}
private bool FsmToAtmIdle ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsAtmIdleRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.AtmIdleFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . AtmRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _toAtmIdleRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmVacIdle ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsVacIdleRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.VacIdleFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . VacRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _vacIdleRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmToProcessIdle ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsProcessIdleRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.ProcessIdleFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . ProcessIdleRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _pmtoProcessIdle ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartPump ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsPumpRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.PumpFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . PumpRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _pumpRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartVent ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsVentRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.VentFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . VentRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _ventRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartPurge ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsPurgeRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.PurgeFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . PurgeRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _purgeRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartClean ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsCleanRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.CleanFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . CleanRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _cleanRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartExchangeMO ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( $"PM.IsExchangeMO{param[0]}Routine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.ExchangeMO{param[0]}FileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . ExchangeMORoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
_changeMoRoutine . Init ( param [ 0 ] . ToString ( ) ) ;
ret = StartRoutine ( _changeMoRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartToIsolation ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsIsolationRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.IsolationFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . IsolationRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
ret = StartRoutine ( _toIsolationRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartLeakCheck ( object [ ] param )
{
Result ret ;
if ( SC . GetValue < bool > ( "PM.IsLeakCheckRoutine" ) )
{
string RoutineFileName = SC . GetStringValue ( $"PM.{Module}.LeakCheckFileName" ) ;
_pMMacroRoutine . Init ( RoutineFileName , RoutineType . LeakCheckRoutine ) ;
ret = StartRoutine ( _pMMacroRoutine ) ;
}
else
{
if ( param ! = null & & param . Length > = 2 )
{
_leakCheckRoutine . Init ( ( int ) param [ 0 ] , ( int ) param [ 1 ] ) ;
}
else
{
_leakCheckRoutine . Init ( ) ;
}
ret = StartRoutine ( _leakCheckRoutine ) ;
}
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmAbortTask ( object [ ] param )
{
Result ret = Result . RUN ;
AbortRoutine ( ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmToService ( object [ ] param )
{
if ( IsOnline )
{
return false ;
}
else
{
IsServiceIdle = ! IsServiceIdle ;
}
return true ;
}
private bool FsmStartStopHeat ( object [ ] param )
{
Result ret = StartRoutine ( _stopHeatEnableRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartMoveBody ( object [ ] param )
{
_chamberMoveBodyRoutine . Init ( param ) ;
Result ret = StartRoutine ( _chamberMoveBodyRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartPcCalibration ( object [ ] param )
{
Result ret = StartRoutine ( _pmPcCalibrationRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartCleanRecipe ( object [ ] param )
{
_cleanRecipe . Init ( param [ 0 ] . ToString ( ) ) ;
Result ret = StartRoutine ( _cleanRecipe ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool ShowMessage ( object [ ] param )
{
EV . PostWarningLog ( Module , $"{param[0]}" ) ;
return true ;
}
private bool FsmStartOpenSlitValve ( object [ ] param )
{
return true ;
}
private bool FsmStartCloseSlitValve ( object [ ] param )
{
return true ;
}
private bool FsmSelectRecipe ( object [ ] param )
{
_recipeRunningInfo . RecipeName = ( string ) param [ 0 ] ;
return true ;
}
private bool FsmStartPreProcess ( object [ ] param )
{
//if(IsServiceIdle)
//{
// EV.PostWarningLog(Module, $"can not set {Module} process while in service mode");
// return false;
//}
_preprocessRoutine . Init ( ( string ) param [ 0 ] , ( bool ) param [ 1 ] , ( bool ) param [ 2 ] ) ;
Result ret = StartRoutine ( _preprocessRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmStartProcess ( object [ ] param )
{
Result ret = StartRoutine ( _processRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmEnterProcess ( object [ ] param )
{
WaferManager . Instance . UpdateWaferProcessStatus ( ModuleHelper . Converter ( Module ) , 0 , EnumWaferProcessStatus . InProcess ) ;
return true ;
}
private bool FsmExitProcess ( object [ ] param )
{
if ( ! _processRoutine . IsPaused )
{
WaferManager . Instance . UpdateWaferProcessStatus ( ModuleHelper . Converter ( Module ) , 0 , EnumWaferProcessStatus . Completed ) ;
_processRoutine . ExitProcess ( ) ;
if ( ! RecipeRunningInfo . IsRoutineAbort )
{
EV . PostWarningLog ( Module , $"Exit Process: Recipe Name {_recipeRunningInfo.RecipeName},Recipe Step:{_recipeRunningInfo.StepNumber},Step Time:{_recipeRunningInfo.StepTime}" ) ;
//StopProcess();
}
}
return true ;
}
private bool FsmRecipePause ( object [ ] param )
{
_processRoutine . PauseRecipe ( ) ;
return true ;
}
private bool FsmStartContinue ( object [ ] param )
{
_processRoutine . SetContinue ( ( string ) param [ 0 ] ) ;
return true ;
}
private bool FsmSkipStep ( object [ ] param )
{
_processRoutine . SkipCurrentRecipeStep ( ) ;
return true ;
}
private bool FsmStartPostProcess ( object [ ] param )
{
Result ret = StartRoutine ( _postprocessRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool ExitPostProcess ( object [ ] param )
{
_pmInterLock . SetPMProcessRunning ( false , out string reason ) ;
_pmInterLock . SetPMPreProcessRunning ( false , out reason ) ;
return true ;
}
private bool FsmStartMFCCalibration ( object [ ] param )
{
return true ;
}
private bool FsmStartPMMacro ( object [ ] param )
{
_pMMacroRoutine . Init ( ( string ) param [ 0 ] ) ;
Result ret = StartRoutine ( _pMMacroRoutine ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmPMMacroPause ( object [ ] param )
{
_pMMacroRoutine . PauseRecipe ( ) ;
return true ;
}
private bool FsmPMMacroContinue ( object [ ] param )
{
_pMMacroRoutine . SetContinue ( ( string ) param [ 0 ] ) ;
return true ;
}
private bool FsmExitPMMacro ( object [ ] param )
{
_pMMacroRoutine . ExitProcess ( ) ;
return true ;
}
private bool FsmMonitorProcessAbortingTask ( object [ ] param )
{
Result ret = MonitorRoutine ( ) ;
if ( ret = = Result . FAIL )
{
return false ;
}
if ( ret = = Result . DONE )
{
return true ;
}
return false ;
}
private bool FsmStartProcessAbort ( object [ ] param )
{
Result ret = StartRoutine ( _pmProcessAbort ) ;
if ( ret = = Result . FAIL | | ret = = Result . DONE )
return false ;
return ret = = Result . RUN ;
}
private bool FsmOnError ( object [ ] param )
{
if ( IsServiceIdle )
{
return false ;
}
IsOnline = false ;
2023-04-13 12:20:36 +08:00
if ( FsmState . Equals ( ( int ) STATE . ProcessAborting ) )
{
return false ;
}
2023-03-28 13:24:11 +08:00
StopRamp ( ) ;
_pmInterLock . SetPMProcessRunning ( false , out string reason ) ;
_pmInterLock . SetPMPreProcessRunning ( false , out reason ) ;
if ( FsmState . Equals ( ( int ) STATE . Process ) )
{
PostMsg ( MSG . ProcessAbort ) ;
return false ;
}
return true ;
}
private bool FsmOnError1 ( object [ ] param )
{
IsOnline = false ;
2023-04-13 12:20:36 +08:00
if ( FsmState . Equals ( ( int ) STATE . ProcessAborting ) )
{
return false ;
}
2023-03-28 13:24:11 +08:00
if ( FsmState . Equals ( ( int ) STATE . Error ) )
{
return false ;
}
else
{
StopRamp ( ) ;
_pmInterLock . SetPMProcessRunning ( false , out string reason ) ;
_pmInterLock . SetPMPreProcessRunning ( false , out reason ) ;
}
return true ;
}
private bool FsmReset ( object [ ] param )
{
var alarms = EV . GetAlarmEvent ( ) ;
int alarmCount = alarms ! = null ? alarms . FindAll ( a = > ( a . Level = = EventLevel . Alarm ) & & a . Source = = Module ) . Count : 0 ;
if ( alarmCount > 0 )
{
EV . ClearAlarmEvent ( ) ;
}
if ( ! _isInitFlag )
{
PostMsg ( MSG . ToInit ) ;
return false ;
}
return true ;
}
private bool FsmStartHome ( object [ ] param )
{
_isInitFlag = false ;
return true ;
}
private bool FsmExitHome ( object [ ] param )
{
return true ;
}
private bool FsmEnterHome ( object [ ] param )
{
return true ;
}
private bool FsmMonitorHomeTask ( object [ ] param )
{
Result ret = MonitorRoutine ( ) ;
if ( ret = = Result . FAIL )
{
PostMsg ( MSG . Error1 ) ;
return false ;
}
if ( ret = = Result . DONE )
{
_isInitFlag = true ;
return true ;
}
return false ;
}
private bool FsmMonitorSafetyTask ( object [ ] param )
{
Result ret = MonitorRoutine ( ) ;
if ( ret = = Result . FAIL )
{
PostMsg ( MSG . Error1 ) ;
return false ;
}
if ( ret = = Result . DONE )
{
return true ;
}
return false ;
}
private FixSizeQueue < double > InnerTempRecordQueue = new FixSizeQueue < double > ( 16 ) ;
private FixSizeQueue < double > MiddleTempRecordQueue = new FixSizeQueue < double > ( 16 ) ;
private FixSizeQueue < double > OuterTempRecordQueue = new FixSizeQueue < double > ( 16 ) ;
private void MonitorAETempRasingFastAlarm ( )
{
var AETempInnerRasingRate = SC . GetValue < double > ( $"PM.{Module}.Heater.SCRTempRasingRate" ) ;
var AETempMiddleRasingRate = SC . GetValue < double > ( $"PM.{Module}.Heater.AETempMiddleRasingRate" ) ;
var AETempOuterRasingRate = SC . GetValue < double > ( $"PM.{Module}.Heater.AETempOuterRasingRate" ) ;
var AETempRasingFastIsAlarm = SC . GetValue < bool > ( $"PM.{Module}.Heater.AETempRasingFastIsAlarm" ) ;
if ( FsmState = = ( int ) STATE . Process )
{
//if (InnerTempRecordQueue.Count == 16)
//{
// var InnerHalfBeforeAverage = InnerTempRecordQueue.ToList().Take(8).ToList().Average();
// var InnerHalfAfterAverage = InnerTempRecordQueue.ToList().Skip(8).ToList().Average();
// if (Math.Abs(InnerHalfAfterAverage - InnerHalfBeforeAverage) > AETempInnerRasingRate)
// {
// if (AETempRasingFastIsAlarm)
// {
// EV.PostAlarmLog(Module, $"AETemp Inner rasing fast");
// }
// else
// {
// EV.PostWarningLog(Module, $"AETemp Inner rasing fast");
// }
// }
//}
if ( MiddleTempRecordQueue . Count = = 16 )
{
var MiddleHalfBeforeAverage = MiddleTempRecordQueue . ToList ( ) . Take ( 8 ) . ToList ( ) . Average ( ) ;
var MiddleHalfAfterAverage = MiddleTempRecordQueue . ToList ( ) . Skip ( 8 ) . ToList ( ) . Average ( ) ;
if ( Math . Abs ( MiddleHalfAfterAverage - MiddleHalfBeforeAverage ) > AETempMiddleRasingRate )
{
if ( AETempRasingFastIsAlarm )
{
EV . PostAlarmLog ( Module , $"AETemp Middle rasing fast" ) ;
}
else
{
EV . PostWarningLog ( Module , $"AETemp Middle rasing fast" ) ;
}
}
}
if ( OuterTempRecordQueue . Count = = 16 )
{
var OuterHalfBeforeAverage = MiddleTempRecordQueue . ToList ( ) . Take ( 8 ) . ToList ( ) . Average ( ) ;
var OuterHalfAfterAverage = MiddleTempRecordQueue . ToList ( ) . Skip ( 8 ) . ToList ( ) . Average ( ) ;
if ( Math . Abs ( OuterHalfAfterAverage - OuterHalfBeforeAverage ) > AETempOuterRasingRate )
{
if ( AETempRasingFastIsAlarm )
{
EV . PostAlarmLog ( Module , $"AETemp Outer rasing fast" ) ;
}
else
{
EV . PostWarningLog ( Module , $"AETemp Outer rasing fast" ) ;
}
}
}
}
InnerTempRecordQueue . Enqueue ( TC1 . InnerTemp ) ;
MiddleTempRecordQueue . Enqueue ( TC1 . MiddleTemp ) ;
OuterTempRecordQueue . Enqueue ( TC1 . OuterTemp ) ;
//tempMonitorDT.Start(0);
}
private bool FsmMonitorTask ( object [ ] param )
{
MonitorAETempRasingFastAlarm ( ) ;
Result ret = MonitorRoutine ( ) ;
if ( ret = = Result . FAIL )
{
PostMsg ( MSG . Error1 ) ;
return false ;
}
if ( ret = = Result . DONE & & FsmState = = ( int ) STATE . PreProcess )
{
PostMsg ( MSG . Process ) ;
return true ;
}
if ( ret = = Result . DONE & & FsmState = = ( int ) STATE . Process )
{
PostMsg ( MSG . PostProcess ) ;
return true ;
}
return ret = = Result . DONE ;
}
public override bool Home ( out string reason )
{
CheckToPostMessage ( ( int ) MSG . Home ) ;
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 void NoteTransferStart ( ModuleName robot , Hand blade , int targetSlot , EnumTransferType transferType )
{
}
public override void NoteTransferStop ( ModuleName robot , Hand blade , int targetSlot , EnumTransferType transferType )
{
}
public override bool CheckLidClosed ( )
{
throw new System . NotImplementedException ( ) ;
}
private bool PutOnline ( )
{
if ( IsService )
{
EV . PostWarningLog ( Module , $"{Module} is Service State,do not Online" ) ;
return false ;
}
IsOnline = true ;
NotifyModuleOfflineCancellation . Cancel ( ) ;
return true ;
}
private bool PutOffline ( )
{
IsOnline = false ;
NotifyModuleOfflineCancellation ? . Dispose ( ) ;
NotifyModuleOfflineCancellation = new CancellationTokenSource ( ) ;
NotifyModuleOfflineTask ( 5 * 60 * 1000 ) ; //5min
return true ;
}
public void InvokeOffline ( )
{
PutOffline ( ) ;
//PostMsg((int)MSG.SetOffline);
}
public void InvokeOnline ( )
{
PutOnline ( ) ;
//PostMsg((int)MSG.SetOnline);
}
private CancellationTokenSource NotifyModuleOfflineCancellation = new CancellationTokenSource ( ) ;
private Task NotifyModuleOfflineTask ( int delayTime )
{
var t1 = Task . Run ( async ( ) = >
{
await Task . Delay ( delayTime , NotifyModuleOfflineCancellation . Token ) . ContinueWith ( x = > EV . PostWarningLog ( Module , $"{Module} is still in offline" ) , NotifyModuleOfflineCancellation . Token ) ;
} ) ;
return t1 ;
}
}
}