2023-04-13 11:51:03 +08:00
using Aitex.Core.Common ;
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.SCCore ;
using MECF.Framework.Common.Equipment ;
using MECF.Framework.Common.Event ;
using MECF.Framework.Common.SubstrateTrackings ;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.OcrReaders ;
using MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robots ;
using System ;
using System.Collections.Generic ;
using System.Linq ;
using System.Text ;
using System.Threading.Tasks ;
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Aligners.AlignersBase
{
public abstract class AlignerBaseDevice : Entity , IDevice , IEntity
{
protected bool IsSimulatorMode
{
get
{
if ( SC . ContainsItem ( "System.IsSimulatorMode" ) )
return SC . GetValue < bool > ( "System.IsSimulatorMode" ) ;
return false ;
}
}
private OCRReaderBaseDevice [ ] _ocrs ;
public OCRReaderBaseDevice [ ] OCRs
{
get = > _ocrs ;
set
{
_ocrs = value ;
foreach ( var ocr in _ocrs )
{
if ( ocr ! = null )
ocr . InstalledModule = RobotModuleName ;
}
}
}
public event Action < bool > ActionDone ;
public event Action < string , AlarmEventItem > OnDeviceAlarmStateChanged ;
public bool HasAlarm { get ; }
public bool IsBusy { get ; set ; }
public string ErrorCode { get ; set ; } = "" ;
public virtual bool IsReady ( )
{
return AlignerState = = AlignerStateEnum . Idle & & ! IsBusy ;
}
public object [ ] CurrentParamter { get ; private set ; }
2024-01-22 17:36:25 +08:00
2023-04-13 11:51:03 +08:00
public bool IsOnline { get ; set ; }
public WaferSize Size
{
get ; set ;
} = WaferSize . WS12 ;
public virtual int AlginerSpeedSetPoint
{
get
{
if ( SC . ContainsItem ( $"Aligner.{RobotModuleName}.AlignSpeed" ) )
return SC . GetValue < int > ( $"Aligner.{RobotModuleName}.AlignSpeed" ) ;
return 100 ;
}
set
{
if ( SC . ContainsItem ( $"Aligner.{RobotModuleName}.AlignSpeed" ) )
SC . SetItemValue ( $"Aligner.{RobotModuleName}.AlignSpeed" , value ) ;
}
}
public virtual WaferSize GetCurrentWaferSize ( )
{
return Size ;
}
public virtual double CompensationAngleValue
{
get
{
if ( SC . ContainsItem ( $"Aligner.{Name}.CompensationAngle" ) )
return SC . GetValue < double > ( $"Aligner.{Name}.CompensationAngle" ) ;
return 0 ;
}
}
public virtual bool IsGripperHoldWafer { get ; set ; }
public bool IsIdle
{
get
{
return fsm . State = = ( int ) AlignerStateEnum . Idle & & fsm . CheckExecuted ( ) & & ! IsBusy ;
}
}
public bool IsError
{
get
{
return fsm . State = = ( int ) AlignerStateEnum . Error ;
}
}
public bool IsInit
{
get
{
return fsm . State = = ( int ) AlignerStateEnum . Init ;
}
}
public double CurrentNotch { get ; set ; }
public int SpeedAxis1 { set ; get ; }
public int SpeedAxis2 { set ; get ; }
public int SpeedAxis3 { set ; get ; }
public int SpeedAxis4 { set ; get ; }
public int SpeedAxis5 { set ; get ; }
public int SpeedAxis6 { set ; get ; }
public float PositionAxis1 { get ; set ; }
public float PositionAxis2 { get ; set ; }
public float PositionAxis3 { get ; set ; }
public float PositionAxis4 { get ; set ; }
public float PositionAxis5 { get ; set ; }
public float PositionAxis6 { get ; set ; }
public int AlignerCommandTimeout { get ; private set ; }
public virtual int TimeLimitAlignWafer
{
get
{
if ( SC . ContainsItem ( $"Aligner.{Name}.TimeLimitForAlignWafer" ) )
return SC . GetValue < int > ( $"Aligner.{Name}.TimeLimitForAlignWafer" ) ;
return 90 ;
}
}
public virtual int TimeLimitAlignerHome
{
get
{
if ( SC . ContainsItem ( $"Aligner.{Name}.TimeLimitAlignerHome" ) )
return SC . GetValue < int > ( $"Aligner.{Name}.TimeLimitAlignerHome" ) ;
return 30 ;
}
}
public virtual int TimeLimitReadOcr
{
get
{
if ( SC . ContainsItem ( $"Aligner.{Name}.TimeLimitReadOCR" ) )
return SC . GetValue < int > ( $"Aligner.{Name}.TimeLimitReadOCR" ) ;
return 180 ;
}
}
public virtual int TimeLimitVerifyOcr
{
get
{
if ( SC . ContainsItem ( $"Aligner.{Name}.TimeLimitVerifyOCR" ) )
return SC . GetValue < int > ( $"Aligner.{Name}.TimeLimitVerifyOCR" ) ;
return 5 ;
}
}
public enum AlignerMsg
{
Reset ,
Clear ,
ResetToReady ,
Stop ,
StartInit ,
InitComplete ,
StartHome ,
HomeComplete ,
ERROR ,
ActionDone ,
Abort ,
StartMaintenance ,
CompleteMaintenance ,
ReadData ,
SetParameters ,
SetParametersComplete ,
Grip ,
GripComplete ,
UnGrip ,
UnGripComplete ,
LiftUp ,
LiftUpComplete ,
LiftDown ,
LiftDownComplete ,
Align ,
AlignComplete ,
PrepareAccept ,
PrepareAcceptComplete ,
}
protected AlignerBaseDevice ( string module , string name )
: base ( )
{
Module = module ;
Name = name ;
RobotModuleName = ( ModuleName ) Enum . Parse ( typeof ( ModuleName ) , Name ) ;
InitializeRobot ( ) ;
}
public string EventAlignerStartAlign { get = > RobotModuleName . ToString ( ) + "StartAligning" ; }
public string EventAlignerCompleteAlign { get = > RobotModuleName . ToString ( ) + "CompleteAligning" ; }
public string AlarmAlignFailed { get = > RobotModuleName . ToString ( ) + "AligningFailed" ; }
public string AlarmAlignTimeout { get = > RobotModuleName . ToString ( ) + "AligningTimeout" ; }
public string AlarmVerifyLaserMarkFailed { get = > RobotModuleName . ToString ( ) + "VerifyLaserMarkFailed" ; }
public string AlarmVerifyLaserMarkSlotNoFailed { get = > RobotModuleName . ToString ( ) + "VerifyLaserMarkSlotNoFailed" ; }
public string AlarmVerifyLaserMarkLengthFailed { get = > RobotModuleName . ToString ( ) + "VerifyLaserMarkLengthFailed" ; }
public string AlarmVerifyLaserMarkWithHostFailed { get = > RobotModuleName . ToString ( ) + "VerifyLaserMarkWithHostFailed" ; }
public string AlarmSlotInLaserMarkIsOccuppied { get = > RobotModuleName . ToString ( ) + "SlotInLaserMarkIsOccuppied" ; }
public string AlarmVerifyLaserMarkTimeout { get = > RobotModuleName . ToString ( ) + "VerifyLaserMarkTimeout" ; }
public string AlarmWaferInformationError { get = > RobotModuleName . ToString ( ) + "WaferInformationError" ; }
public virtual bool IsNeedChangeWaferSize ( WaferSize wz )
{
return false ;
}
protected override bool Init ( )
{
return base . Init ( ) ;
}
public void InitializeRobot ( )
{
BuildTransitionTable ( ) ;
SubscribeDataVariable ( ) ;
SubscribeOperation ( ) ;
SubscribeDeviceOperation ( ) ;
AlignerCommandTimeout = SC . ContainsItem ( "Aligner.TimeLimitAlignerCommand" ) ?
SC . GetValue < int > ( "Aligner.TimeLimitAlignerCommand" ) : 120 ;
WaferManager . Instance . SubscribeLocation ( Name , 1 ) ;
Running = true ;
}
protected virtual void SubscribeOperation ( )
{
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "LiftUp" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = LiftUp ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "LiftUp" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "LiftDown" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = LiftDown ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "LiftDown" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "SetWaferSize" ) , ( out string reason , int time , object [ ] param ) = >
{
if ( param . Length < 2 )
{
reason = "Invalide parameter" ;
return false ;
}
WaferSize size = ( WaferSize ) Enum . Parse ( typeof ( WaferSize ) , param [ 1 ] . ToString ( ) ) ;
bool ret = SetWaferSize ( size , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "SetWaferSize" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "Init" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Init ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Initializing" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "Abort" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Abort ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Abort" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "Home" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Home ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Homing" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerHome" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Home ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Homing" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "HomeModule" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = HomeModule ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "ModuleHoming" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerHomeModule" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = HomeModule ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "ModuleHoming" ) ;
return true ;
}
reason = "" ;
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "Reset" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = AlignerReset ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Resetting" ) ;
return true ;
}
reason = "" ;
return true ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerReset" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = AlignerReset ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Resetting" ) ;
return true ;
}
reason = "" ;
return true ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerAlign" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = AlignerAlign ( param , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Resetting" ) ;
return true ;
}
reason = "" ;
return true ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerSetWaferSize" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = AlignerSetWaferSize ( param , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Resetting" ) ;
return true ;
}
reason = "" ;
return true ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "PrepareAccept" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = PrepareAcceptWafer ( ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "PrepareAccept" ) ;
return true ;
}
reason = "" ;
return true ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerHold" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Grip ( 0 , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Hold Wafer" ) ;
return true ;
}
return false ;
} ) ;
OP . Subscribe ( String . Format ( "{0}.{1}" , Name , "AlignerRelease" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Release ( 0 , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Release Wafer" ) ;
return true ;
}
return false ;
} ) ;
}
protected virtual void SubscribeDeviceOperation ( )
{
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerInit" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Init ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Init" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerHome" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Home ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Home" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerHomeModule" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = HomeModule ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "ModuleHome" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerReset" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = AlignerReset ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Reset Error" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerGrip" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Grip ( 0 , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Hold Wafer" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerRelease" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Release ( 0 , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Release Wafer" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerLiftUp" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = LiftUp ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Lifter Up" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerLiftDown" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = LiftDown ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Lifter Down" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerStop" ) , ( out string reason , int time , object [ ] param ) = >
{
bool ret = Stop ( out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "Stop Align" ) ;
return true ;
}
return false ;
} ) ;
DEVICE . Register ( String . Format ( "{0}.{1}" , Name , "AlignerAlign" ) , ( out string reason , int time , object [ ] param ) = >
{
double angle = double . Parse ( ( string ) param [ 0 ] ) ;
bool ret = Align ( angle , out reason ) ;
if ( ret )
{
reason = string . Format ( "{0} {1}" , Name , "PreAlign" ) ;
return true ;
}
return false ;
} ) ;
}
public bool SetWaferSize ( WaferSize size , out string reason )
{
reason = "" ;
if ( ( CheckToPostMessage ( ( int ) AlignerMsg . SetParameters , new object [ ] { "WaferSize" , size } ) ) )
{
IsBusy = true ;
return true ;
}
return false ;
}
public bool AlignerReset ( out string reason )
{
IsBusy = false ;
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Reset , null ) )
return true ;
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Abort ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Abort , null ) )
return true ;
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Stop ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Stop , null ) )
return true ;
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool AlignerAlign ( object [ ] param , out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Align , param ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool AlignerSetWaferSize ( object [ ] param , out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . SetParameters , param ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool AlignerSetWaferSize ( WaferSize wz , out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . SetParameters , new object [ ] { "WaferSize" , wz } ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Align ( double angle , out string reason )
{
reason = "" ;
double anglevalue = angle + CompensationAngleValue ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Align , new object [ ] { anglevalue } ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool LiftDown ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . LiftDown , null ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool LiftUp ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . LiftUp , null ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Release ( int v , out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . UnGrip , new object [ ] { v } ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Grip ( int v , out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Grip , new object [ ] { v } ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Clear ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . Clear , null ) )
{
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Init ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . StartInit , null ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool Home ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . StartInit , null ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool HomeModule ( out string reason )
{
reason = "" ;
if ( CheckToPostMessage ( ( int ) AlignerMsg . StartHome , null ) )
{
IsBusy = true ;
return true ;
}
reason = $"{Name} is in {AlignerState}" ;
return false ;
}
public bool SetMaintenanceMode ( bool ismaintain )
{
if ( ismaintain )
return CheckToPostMessage ( ( int ) AlignerMsg . StartMaintenance , null ) ;
else
return CheckToPostMessage ( ( int ) AlignerMsg . CompleteMaintenance , null ) ;
}
private void SubscribeDataVariable ( )
{
DATA . Subscribe ( $"{Name}.State" , ( ) = > AlignerState . ToString ( ) ) ;
DATA . Subscribe ( $"{Name}.AlignerState" , ( ) = > AlignerState . ToString ( ) ) ;
DATA . Subscribe ( $"{Name}.Busy" , ( ) = > AlignerState ! = AlignerStateEnum . Idle & & AlignerState ! = AlignerStateEnum . Init ) ;
DATA . Subscribe ( $"{Name}.ErrorCode" , ( ) = > ErrorCode ) ;
DATA . Subscribe ( $"{Name}.Error" , ( ) = > AlignerState = = AlignerStateEnum . Error ) ;
DATA . Subscribe ( $"{Name}.Notch" , ( ) = > CurrentNotch ) ;
DATA . Subscribe ( $"{Name}.WaferOnAligner" , ( ) = > IsWaferPresent ( 0 ) ) ;
DATA . Subscribe ( $"{Name}.WaferSize" , ( ) = > GetCurrentWaferSize ( ) . ToString ( ) ) ;
// string str = string.Empty;
//
DATA . Subscribe ( $"{Module}.{Name}.State" , ( ) = > AlignerState . ToString ( ) ) ;
DATA . Subscribe ( $"{Module}.{Name}.Axis1Postion" , ( ) = > PositionAxis1 . ToString ( ) ) ;
DATA . Subscribe ( $"{Module}.{Name}.Axis2Postion" , ( ) = > PositionAxis2 . ToString ( ) ) ;
DATA . Subscribe ( $"{Module}.{Name}.Axis3Postion" , ( ) = > PositionAxis3 . ToString ( ) ) ;
DATA . Subscribe ( $"{Module}.{Name}.Axis4Postion" , ( ) = > PositionAxis4 . ToString ( ) ) ;
DATA . Subscribe ( $"{Module}.{Name}.Axis5Postion" , ( ) = > PositionAxis5 . ToString ( ) ) ;
DATA . Subscribe ( $"{Module}.{Name}.AlignerErrorCode" , ( ) = > ErrorCode ? ? ErrorCode . ToString ( ) ) ;
EV . Subscribe ( new EventItem ( "Event" , EventAlignerStartAlign , $"{RobotModuleName} start aligning wafer." , EventLevel . Information , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Event" , EventAlignerCompleteAlign , $"{RobotModuleName} complete aligning wafer." , EventLevel . Information , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmAlignTimeout , "Aligner align wafer time out." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmAlignFailed , "Aligner aligner wafer failed." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmVerifyLaserMarkFailed , "Aligner verify laser mark failed." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmVerifyLaserMarkSlotNoFailed , "Aligner verify laser mark slot no failed." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmVerifyLaserMarkLengthFailed , "Aligner verify laser mark length failed." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmVerifyLaserMarkWithHostFailed , "Aligner verify laser mark with host failed." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmVerifyLaserMarkTimeout , "Aligner wait ocr manual verification timeout." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmSlotInLaserMarkIsOccuppied , "The slot in Laser Mark is occuppied." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
EV . Subscribe ( new EventItem ( "Alarm" , AlarmWaferInformationError , "The wafer sensor status doesn't match wafer information." , EventLevel . Alarm , Aitex . Core . RT . Event . EventType . EventUI_Notify ) ) ;
}
private void BuildTransitionTable ( )
{
fsm = new StateMachine < AlignerBaseDevice > ( Name + ".StateMachine" , ( int ) AlignerStateEnum . Init , 50 ) ;
//Init sequence
AnyStateTransition ( AlignerMsg . ERROR , fError , AlignerStateEnum . Error ) ;
AnyStateTransition ( AlignerMsg . Reset , fReset , AlignerStateEnum . Resetting ) ;
AnyStateTransition ( AlignerMsg . Stop , fStop , AlignerStateEnum . Stopped ) ;
AnyStateTransition ( AlignerMsg . Abort , FsmAbort , AlignerStateEnum . Init ) ;
AnyStateTransition ( AlignerMsg . StartMaintenance , fStartMaintenance , AlignerStateEnum . Maintenance ) ;
Transition ( AlignerStateEnum . Maintenance , FSM_MSG . TIMER , fMonitorMaintenance , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Maintenance , AlignerMsg . CompleteMaintenance , fCompleteMaintenance , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Resetting , AlignerMsg . ActionDone , fResetComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Resetting , FSM_MSG . TIMER , fMonitorReset , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Init , AlignerMsg . StartInit , fStartInit , AlignerStateEnum . Initializing ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . StartInit , fStartInit , AlignerStateEnum . Initializing ) ;
Transition ( AlignerStateEnum . Error , AlignerMsg . StartInit , fStartInit , AlignerStateEnum . Initializing ) ;
Transition ( AlignerStateEnum . Init , AlignerMsg . InitComplete , fInitComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Error , AlignerMsg . InitComplete , fInitComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Initializing , AlignerMsg . InitComplete , fInitComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Initializing , AlignerMsg . ActionDone , fInitComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Initializing , FSM_MSG . TIMER , fMonitorInit , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Init , AlignerMsg . StartHome , fStartHome , AlignerStateEnum . Homing ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . StartHome , fStartHome , AlignerStateEnum . Homing ) ;
Transition ( AlignerStateEnum . Error , AlignerMsg . StartHome , fStartHome , AlignerStateEnum . Homing ) ;
Transition ( AlignerStateEnum . Init , AlignerMsg . HomeComplete , fHomeComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Error , AlignerMsg . HomeComplete , fHomeComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Homing , AlignerMsg . HomeComplete , fHomeComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Homing , AlignerMsg . ActionDone , fHomeComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Homing , FSM_MSG . TIMER , fMonitorHome , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Error , AlignerMsg . Clear , fClear , AlignerStateEnum . Init ) ;
Transition ( AlignerStateEnum . Error , AlignerMsg . ResetToReady , fResetToReady , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . SetParameters , fStartSetParameters , AlignerStateEnum . SettingServos ) ;
Transition ( AlignerStateEnum . SettingServos , AlignerMsg . SetParametersComplete , fSetComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . SettingServos , AlignerMsg . ActionDone , fSetComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . SettingServos , FSM_MSG . TIMER , fMonitorSetParamter , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . ReadData , fStartReadData , AlignerStateEnum . ReadingData ) ;
Transition ( AlignerStateEnum . ReadingData , AlignerMsg . ActionDone , null , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . ReadingData , FSM_MSG . TIMER , fMonitorReadData , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . Grip , fStartGrip , AlignerStateEnum . Gripping ) ;
Transition ( AlignerStateEnum . Gripping , AlignerMsg . GripComplete , fGripComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Gripping , AlignerMsg . ActionDone , fGripComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Gripping , FSM_MSG . TIMER , fMonitorGrip , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . UnGrip , fStartUnGrip , AlignerStateEnum . UnGripping ) ;
Transition ( AlignerStateEnum . UnGripping , AlignerMsg . UnGripComplete , fUnGripComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . UnGripping , AlignerMsg . ActionDone , fUnGripComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . UnGripping , FSM_MSG . TIMER , fMonitorUnGrip , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . LiftUp , fStartLiftup , AlignerStateEnum . LiftingUp ) ;
Transition ( AlignerStateEnum . LiftingUp , AlignerMsg . LiftUpComplete , fLiftupComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . LiftingUp , AlignerMsg . ActionDone , fLiftupComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . LiftingUp , FSM_MSG . TIMER , fMonitorLiftup , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . LiftDown , fStartLiftdown , AlignerStateEnum . LiftingDown ) ;
Transition ( AlignerStateEnum . LiftingDown , AlignerMsg . LiftDownComplete , fLiftdownComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . LiftingDown , AlignerMsg . ActionDone , fLiftdownComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . LiftingDown , FSM_MSG . TIMER , fMonitorLiftdown , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . Align , fStartAlign , AlignerStateEnum . Aligning ) ;
Transition ( AlignerStateEnum . Aligning , AlignerMsg . AlignComplete , fAlignComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Aligning , AlignerMsg . ActionDone , fAlignComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Aligning , FSM_MSG . TIMER , fMonitorAligning , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . Idle , AlignerMsg . PrepareAccept , fStartPrepareAccept , AlignerStateEnum . PrepareAccept ) ;
Transition ( AlignerStateEnum . PrepareAccept , AlignerMsg . PrepareAcceptComplete , fPrepareAcceptComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . PrepareAccept , AlignerMsg . ActionDone , fPrepareAcceptComplete , AlignerStateEnum . Idle ) ;
Transition ( AlignerStateEnum . PrepareAccept , FSM_MSG . TIMER , fMonitorPrepareAccept , AlignerStateEnum . Idle ) ;
}
protected virtual bool fMonitorPrepareAccept ( object [ ] param )
{
return false ;
}
protected virtual bool fPrepareAcceptComplete ( object [ ] param )
{
return true ;
}
protected virtual bool fStartPrepareAccept ( object [ ] param )
{
return true ;
}
protected virtual bool fMonitorHome ( object [ ] param )
{
return false ;
}
protected virtual bool fHomeComplete ( object [ ] param )
{
return true ; ;
}
protected virtual bool fStartHome ( object [ ] param )
{
return true ;
}
public virtual bool IsWaferPresent ( int slotindex )
{
return WaferManager . Instance . CheckHasWafer ( RobotModuleName , slotindex ) ;
}
public virtual RobotArmWaferStateEnum GetWaferState ( int slotindex = 0 )
{
if ( WaferManager . Instance . CheckHasWafer ( RobotModuleName , slotindex ) ! = IsWaferPresent ( slotindex ) )
{
return RobotArmWaferStateEnum . Error ;
}
return IsWaferPresent ( slotindex ) ? RobotArmWaferStateEnum . Present : RobotArmWaferStateEnum . Absent ;
}
protected virtual bool fStartMaintenance ( object [ ] param )
{
return true ;
}
protected virtual bool fMonitorMaintenance ( object [ ] param )
{
return false ;
}
protected virtual bool fCompleteMaintenance ( object [ ] param )
{
return true ;
}
protected abstract bool fStartLiftup ( object [ ] param ) ;
protected virtual bool fLiftupComplete ( object [ ] param )
{
return true ;
}
protected virtual bool fMonitorLiftup ( object [ ] param )
{
return false ;
}
protected abstract bool fStartLiftdown ( object [ ] param ) ;
protected virtual bool fLiftdownComplete ( object [ ] param )
{
return true ;
}
protected virtual bool fMonitorLiftdown ( object [ ] param )
{
return false ;
}
protected abstract bool fStartAlign ( object [ ] param ) ;
private bool fAlignComplete ( object [ ] param )
{
return true ;
}
protected virtual bool fMonitorAligning ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorUnGrip ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorGrip ( object [ ] param )
{
return false ;
}
protected virtual bool fMoveComplete ( object [ ] param )
{
return true ;
}
protected virtual bool fStartMove ( object [ ] param )
{
return true ;
}
protected virtual bool fMonitorSetParamter ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorReadData ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorReset ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorGoTo ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorMap ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorPlace ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorSwap ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorPick ( object [ ] param )
{
return false ;
}
protected virtual bool fMonitorInit ( object [ ] param )
{
return false ;
}
protected abstract bool fStop ( object [ ] param ) ;
protected abstract bool FsmAbort ( object [ ] param ) ;
protected bool fResetComplete ( object [ ] param )
{
IsBusy = false ;
return true ;
}
protected abstract bool fClear ( object [ ] param ) ;
protected virtual bool fSetComplete ( object [ ] param )
{
IsBusy = false ;
return true ;
}
protected abstract bool fStartReadData ( object [ ] param ) ;
protected abstract bool fStartSetParameters ( object [ ] param ) ;
protected abstract bool fStartUnGrip ( object [ ] param ) ;
protected abstract bool fStartGrip ( object [ ] param ) ;
protected abstract bool fResetToReady ( object [ ] param ) ;
protected abstract bool fReset ( object [ ] param ) ;
protected abstract bool fStartInit ( object [ ] param ) ;
protected abstract bool fError ( object [ ] param ) ;
protected virtual bool fUnGripComplete ( object [ ] param )
{
IsBusy = false ;
return true ;
}
protected virtual bool fGripComplete ( object [ ] param )
{
IsBusy = false ;
return true ;
}
protected virtual bool fInitComplete ( object [ ] param )
{
IsBusy = false ;
return true ;
}
public AlignerStateEnum AlignerState { get = > ( AlignerStateEnum ) fsm . State ; }
public string Module { get ; set ; }
public string Name { get ; set ; }
public ModuleName RobotModuleName { get ; private set ; }
public ModuleName CurrentInteractModule { get ; private set ; }
public virtual bool IsNeedRelease
{
get
{
return false ;
}
}
public virtual bool IsNeedPrepareBeforePlaceWafer ( )
{
return false ;
}
public virtual void Monitor ( )
{
return ;
}
public virtual void Reset ( )
{
}
public virtual void OnError ( string errortext )
{
EV . PostAlarmLog ( Module , $"{Name} occurred error: {errortext}" ) ;
IsBusy = false ;
CheckToPostMessage ( ( int ) AlignerMsg . ERROR , new object [ ] { errortext } ) ;
}
public virtual bool SetParameters ( object [ ] param )
{
return CheckToPostMessage ( ( int ) AlignerMsg . SetParameters , param ) ;
}
public virtual bool PrepareAcceptWafer ( )
{
if ( CheckToPostMessage ( ( int ) AlignerMsg . PrepareAccept , null ) )
{
IsBusy = true ;
return true ;
}
return false ;
}
public virtual bool HomeAllAxes ( out string reason )
{
reason = string . Empty ;
return true ;
}
public virtual bool QueryWaferMap ( ModuleName module , out string reason )
{
reason = "" ;
return true ;
}
public virtual bool OnActionDone ( object [ ] param )
{
IsBusy = false ;
return CheckToPostMessage ( ( int ) AlignerMsg . ActionDone , new object [ ] { "ActionDone" } ) ;
}
public bool CheckToPostMessage ( int msg , params object [ ] args )
{
if ( ! fsm . FindTransition ( fsm . State , msg ) )
{
if ( msg ! = 7 )
EV . PostWarningLog ( Name , $"{Name} is in { (AlignerStateEnum)fsm.State} state, can not do {(AlignerMsg)msg}" ) ;
return false ;
}
CurrentParamter = args ;
fsm . PostMsg ( msg , args ) ;
return true ;
}
public bool CheckToPostMessage ( AlignerMsg msg , params object [ ] args )
{
if ( ! fsm . FindTransition ( fsm . State , ( int ) msg ) )
{
if ( ( int ) msg ! = 7 )
EV . PostWarningLog ( Name , $"{Name} is in { (AlignerStateEnum)fsm.State} state, can not do {(AlignerMsg)msg}" ) ;
return false ;
}
CurrentParamter = args ;
fsm . PostMsg ( ( int ) msg , args ) ;
return true ;
}
public bool Check ( int msg , out string reason , params object [ ] args )
{
if ( ! fsm . FindTransition ( fsm . State , msg ) )
{
reason = String . Format ( "{0} is in {1} state, can not do {2}" , Name , ( AlignerStateEnum ) fsm . State , ( AlignerMsg ) msg ) ;
return false ;
}
CurrentParamter = args ;
reason = "" ;
return true ;
}
}
}