1678 lines
44 KiB
Plaintext
1678 lines
44 KiB
Plaintext
COMPILE FUNCTION obj_RDS2(Method,Parms)
|
|
#pragma precomp SRP_PreCompiler
|
|
|
|
/*
|
|
Methods for RDS table ;Original object (obj_RDS) is full with methods for original data structures
|
|
|
|
05/12/2005 JCH - Initial Coding
|
|
|
|
Properties:
|
|
|
|
Methods:
|
|
|
|
Find() ;* Lookup RDS record
|
|
Delete(RdsNos) ;* Delete RDS records (@VM'd list of keys)
|
|
LockSet(RdsNos) ;* Returns TableVar if all records were locked
|
|
UnlockSet(RdsNos,TableVar) ;* Uses TableVar returned from LockSet call
|
|
ChangeWOStepProps(RSNos,CommitDts,HotLots,MUBoxes) ;* Changes RDS stuff 'en-mass' from WOStep window
|
|
AdjStepWafersIn(
|
|
GetMetKeys(
|
|
MetConversion(
|
|
LoadEpi(
|
|
ReloadEpi(
|
|
RemovePocketNCR(
|
|
*/
|
|
|
|
|
|
DECLARE FUNCTION Get_Status, Msg, Utility, obj_Tables, NextKey, obj_Prod_Spec, Dialog_Box, obj_RDS_Test
|
|
DECLARE FUNCTION obj_React_Status, Logging_Services, Environment_Services, Database_Services, Error_Services
|
|
DECLARE FUNCTION Material_Services, SRP_Array
|
|
DECLARE SUBROUTINE Set_Status, Msg, obj_Tables, obj_WO_Step, obj_RDS_Layer, obj_RDS_Test, obj_React_Status, obj_WO_Wfr
|
|
DECLARE SUBROUTINE RDS_React_Run, obj_WM_Out, obj_WM_In, ErrMsg, Send_Info, obj_Clean_Insp, Database_Services
|
|
DECLARE SUBROUTINE Logging_Services
|
|
|
|
$INSERT MSG_EQUATES
|
|
$INSERT WO_VERIFY_EQU
|
|
$INSERT WO_LOG_EQU
|
|
$INSERT RDS_EQUATES
|
|
$INSERT RDS_MAKEUP_EQU
|
|
$INSERT RDS_LAYER_EQUATES
|
|
$INSERT RDS_TEST_EQUATES
|
|
$INSERT RDS_LAYER_INFO_EQU
|
|
$INSERT QUOTE_SPEC_EQU
|
|
$INSERT PROD_SPEC_EQUATES
|
|
$INSERT SCHEDULE_EQU
|
|
$INSERT WO_STEP_EQU
|
|
$INSERT REACT_RUN_EQUATES
|
|
$INSERT DICT_EQUATES
|
|
$INSERT LOGICAL
|
|
$INSERT PRS_LAYER_EQU ;* Used to return obj_Prod_Spec values
|
|
|
|
|
|
EQU SHEETRHO_SPEC_UNITS$ TO 'ê/Ü'
|
|
EQU RES_SPEC_UNITS$ TO \EA2D636D\
|
|
|
|
* Equates used with LoadEpi and UnloadEpi (EpiPRO wafers)
|
|
|
|
EQU COL$POCKET TO 1
|
|
EQU COL$USAGE TO 2
|
|
EQU COL$ZONE TO 3
|
|
EQU COL$IN_CASS TO 4
|
|
EQU COL$IN_SLOT TO 5
|
|
EQU COL$WAFER_TYPE TO 6
|
|
EQU COL$OUT_CASS TO 7
|
|
EQU COL$OUT_SLOT TO 8
|
|
EQU COL$OUT_NCR TO 9
|
|
|
|
equ RDS_TW_PPLUS$ to 102
|
|
equ RDS_TW_PMINUS$ to 103
|
|
equ RDS_TW_NPLUS$ to 104
|
|
equ RDS_TW_NMINUS$ to 105
|
|
equ RDS_TW_PPLUS_CODE$ to 106
|
|
equ RDS_TW_PMINUS_CODE$ to 107
|
|
equ RDS_TW_NPLUS_CODE$ to 108
|
|
equ RDS_TW_NMINUS_CODE$ to 109
|
|
equ RDS_TW_PPLUS_CNT$ to 110
|
|
equ RDS_TW_PMINUS_CNT$ to 111
|
|
equ RDS_TW_NPLUS_CNT$ to 112
|
|
equ RDS_TW_NMINUS_CNT$ to 113
|
|
|
|
equ RDS_TW_PROD_CODE$ to 164
|
|
equ RDS_TW_PROD_CNT$ to 165
|
|
equ RDS_TW_PPLUS_TOOL$ to 166
|
|
equ RDS_TW_PMINUS_TOOL$ to 167
|
|
equ RDS_TW_NPLUS_TOOL$ to 168
|
|
equ RDS_TW_NMINUS_TOOL$ to 169
|
|
equ RDS_TW_PROD_TOOL$ to 170
|
|
equ RDS_TW_PPLUS_THICK$ to 171
|
|
equ RDS_TW_PMINUS_THICK$ to 172
|
|
equ RDS_TW_NPLUS_THICK$ to 173
|
|
equ RDS_TW_NMINUS_THICK$ to 174
|
|
equ RDS_TW_PROD_THICK$ to 175
|
|
equ RDS_TW_PPLUS_RES$ to 176
|
|
equ RDS_TW_PMINUS_RES$ to 177
|
|
equ RDS_TW_NPLUS_RES$ to 178
|
|
equ RDS_TW_NMINUS_RES$ to 179
|
|
equ RDS_TW_PROD_RES$ to 180
|
|
equ RDS_TW_PPLUS_CON$ to 181
|
|
equ RDS_TW_PMINUS_CON$ to 182
|
|
equ RDS_TW_NPLUS_CON$ to 183
|
|
equ RDS_TW_NMINUS_CON$ to 184
|
|
equ RDS_TW_PROD_CON$ to 185
|
|
equ RDS_TW_PPLUS_STRESS$ to 186
|
|
equ RDS_TW_PMINUS_STRESS$ to 187
|
|
equ RDS_TW_NPLUS_STRESS$ to 188
|
|
equ RDS_TW_NMINUS_STRESS$ to 189
|
|
|
|
equ RDS_TW_RECLAIM$ to 240
|
|
equ RDS_TW_RECLAIM_CODE$ to 241
|
|
equ RDS_TW_RECLAIM_CNT$ to 242
|
|
equ RDS_TW_RECLAIM_CON$ to 243
|
|
equ RDS_TW_RECLAIM_RES$ to 244
|
|
equ RDS_TW_RECLAIM_RHO$ to 245
|
|
equ RDS_TW_RECLAIM_STRESS$ to 246
|
|
equ RDS_TW_RECLAIM_THICK$ TO 247
|
|
equ RDS_TW_RECLAIM_TOOL$ to 248
|
|
equ RDS_TW_RECLAIM_TRANS$ to 249
|
|
|
|
LogPath = Environment_Services('GetApplicationRootPath') : '\LogFiles\EpiPro'
|
|
LogDate = Oconv(Date(), 'D4/')
|
|
LogTime = Oconv(Time(), 'MTS')
|
|
LogFileName = LogDate[7, 4] : '-' : LogDate[1, 2] : '-' : LogDate[4, 2] : ' Unload Log.csv'
|
|
Headers = 'Logging DTM' : @FM : 'RDS Key ID' : @FM : 'Error'
|
|
objLog = Logging_Services('NewLog', LogPath, LogFileName, CRLF$, Comma$, Headers, '', False$, False$)
|
|
LoggingDTM = LogDate : ' ' : LogTime ; // Logging DTM
|
|
|
|
ErrTitle = 'Error in Stored Procedure "obj_RDS2"'
|
|
ErrorMsg = ''
|
|
ErrCode = ''
|
|
|
|
IF NOT(ASSIGNED(Method)) THEN ErrorMsg = 'Unassigned parameter "Method" passed to subroutine'
|
|
IF NOT(ASSIGNED(Parms)) THEN Parms = ''
|
|
|
|
IF ErrorMsg NE '' THEN
|
|
Set_Status(-1,ErrTitle:@SVM:ErrorMsg)
|
|
RETURN ''
|
|
END
|
|
|
|
Result = ''
|
|
|
|
BEGIN CASE
|
|
CASE Method = 'Find' ; GOSUB Find
|
|
CASE Method = 'Delete' ; GOSUB Delete
|
|
CASE Method = 'LockSet' ; GOSUB LockSet
|
|
CASE Method = 'UnlockSet' ; GOSUB UnlockSet
|
|
CASE Method = 'ChangeWOStepProps' ; GOSUB ChangeWOStepProps
|
|
CASE Method = 'AdjStepWafersIn' ; GOSUB AdjStepWafersIn
|
|
CASE Method = 'GetMetKeys' ; GOSUB GetMetKeys
|
|
CASE Method = 'MetConversion' ; GOSUB MetConversion
|
|
CASE Method = 'UnloadEpi' ; GOSUB UnloadEpi
|
|
CASE Method = 'ReloadEpi' ; GOSUB ReloadEpi
|
|
CASE Method = 'ClearEpiUnload' ; GOSUB ClearEpiUnload
|
|
CASE Method = 'LoadMat' ; GOSUB LoadMat
|
|
CASE Method = 'ReturnMat' ; GOSUB ReturnMat
|
|
CASE Method = 'RemovePocketNCR' ; GOSUB RemovePocketNCR
|
|
CASE Method = 'SetPartNo' ; GOSUB SetPartNo
|
|
CASE Method = 'FieldsUsed' ; GOSUB FieldsUsed
|
|
CASE 1
|
|
|
|
END CASE
|
|
|
|
IF ErrorMsg NE '' THEN
|
|
Set_Status(-1,ErrTitle:@SVM:ErrorMsg)
|
|
END
|
|
|
|
RETURN Result
|
|
|
|
|
|
|
|
* * * * * * *
|
|
FieldsUsed:
|
|
* * * * * * *
|
|
|
|
RDSNo = Parms[1,@RM]
|
|
RDSRec = Parms[COL2()+1,@RM]
|
|
|
|
Fields = XLATE('DICT.RDS','%FIELDS%','','X')
|
|
|
|
KList = 2:@VM:3:@VM:4:@VM:6:@VM:8:@VM:9:@VM:10:@VM:12:@VM:14:@VM:34:@VM:31:@VM:35:@VM:36:@VM:37:@VM:38:@VM:39:@VM:40
|
|
|
|
Ans = ''
|
|
FOR I = 1 TO 278
|
|
IF RDSRec<I> NE '' THEN
|
|
LOCATE I IN KList USING @VM SETTING Dummy ELSE
|
|
LOCATE I IN Fields<FIELDS_FIELD_NO$> USING @VM SETTING Pos THEN
|
|
Ans<1,-1> = I:' ':Fields<FIELDS_NAME$,Pos>
|
|
END
|
|
END
|
|
|
|
END ;* End of check for field null
|
|
NEXT I
|
|
|
|
Result = Ans
|
|
|
|
|
|
|
|
RETURN
|
|
|
|
|
|
|
|
* * * * * * *
|
|
Find:
|
|
* * * * * * *
|
|
|
|
|
|
RDSKeys = Dialog_Box('DIALOG_RDS_QUERY',@WINDOW,'')
|
|
|
|
Result = RDSKeys
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
Delete:
|
|
* * * * * * *
|
|
|
|
RdsNos = Parms[1,@RM]
|
|
TableVar = Parms[COL2()+1,@RM]
|
|
|
|
IF RdsNos = '' THEN RETURN
|
|
|
|
IF TableVar = '' THEN
|
|
* This section of code should be removed after all calls to obj_RDS('Delete'....) have been checked
|
|
Set_Status(0)
|
|
RTParms = 'RDS'
|
|
LockedRDSNos = ''
|
|
|
|
FOR I = 1 TO COUNT(RdsNos,@VM) + (RdsNos NE '')
|
|
RdsNo = RdsNos<1,I>
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, RdsNo)
|
|
obj_Tables('LockRec',RTParms)
|
|
IF Get_Status(errCode) THEN
|
|
FOR N = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNos<1,N>)
|
|
obj_Tables('UnlockRec',RTParms) ;* Unlock everything locked up to here
|
|
NEXT N
|
|
ErrorMsg = 'Unable to lock RDS ':QUOTE(RdsNo):' for delete.'
|
|
RETURN
|
|
END ELSE
|
|
LockedRDSNos<1,I> = RdsNo
|
|
END
|
|
NEXT I
|
|
|
|
TableVar = FIELD(RTParms,@RM,3,1)
|
|
|
|
END
|
|
|
|
|
|
|
|
FOR I = 1 TO COUNT(RdsNos,@VM) + (RdsNos NE '')
|
|
RdsNo = RdsNos<1,I>
|
|
RDSRec = XLATE('RDS',RdsNo,'','X')
|
|
|
|
LSKeys = RDSRec<RDS_RDS_LAYER_KEYS$>
|
|
NCRKeys = RDSRec<RDS_NCR_KEYS$>
|
|
SurfScanKeys = RDSRec<RDS_SURFSCAN_KEYS$>
|
|
CIKeys = XLATE('REACT_RUN',RdsNo,REACT_RUN_CI_NO$,'X')
|
|
|
|
MetKeys = XLATE('RDS_LAYER',LSKeys,RDS_LAYER_RDS_TEST_KEYS$,'X')
|
|
|
|
RTParms = 'RDS':@RM:RdsNo:@RM:TableVar:@RM
|
|
obj_Tables('UnlockRec',RTParms)
|
|
|
|
IF NCRKeys NE '' THEN
|
|
OPEN 'NCR' TO NCRFile THEN
|
|
NCRCnt = COUNT(NCRKeys,@VM)
|
|
FOR NCR = 1 TO NCRCnt
|
|
DELETE NCRFile,NCRKeys<1,NCR>
|
|
|
|
NEXT NCR
|
|
END
|
|
END ;* End of NCR section
|
|
|
|
IF SurfScanKeys NE '' THEN
|
|
OPEN 'SURFACE_SCAN' TO SurfScanTable THEN
|
|
ScanCnt = COUNT(SurfScanKeys,@VM) + (SurfScanKeys NE '')
|
|
FOR Scan = 1 TO ScanCnt
|
|
DELETE SurfScanTable,SurfScanKeys<1,Scan>
|
|
NEXT Scan
|
|
END ;* End of SURFACE_SCAN open
|
|
END ;* End of SurfScan sectioin
|
|
|
|
obj_RDS_Test('Delete',MetKeys)
|
|
|
|
obj_RDS_Layer('Delete',LSKeys)
|
|
|
|
obj_Clean_Insp('Delete',CIKeys)
|
|
|
|
obj_Tables('DeleteRec','RDS':RTParms) ;* Deletes and removes the lock
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
LockSet:
|
|
* * * * * * *
|
|
|
|
RdsNos = Parms[1,@RM]
|
|
|
|
IF RdsNos = '' THEN RETURN
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS'
|
|
LockedRDSNos = ''
|
|
|
|
FOR I = 1 TO COUNT(RdsNos,@VM) + (RdsNos NE '')
|
|
RdsNo = RdsNos<1,I>
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, RdsNo)
|
|
obj_Tables('LockRec',RTParms)
|
|
IF Get_Status(errCode) THEN
|
|
FOR N = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNos<1,N>)
|
|
obj_Tables('UnlockRec',RTParms) ;* Unlock everything locked up to here
|
|
NEXT N
|
|
ErrorMsg = 'Unable to lock RDS ':QUOTE(RdsNo):'.'
|
|
RETURN
|
|
END ELSE
|
|
LockedRDSNos<1,I> = RdsNo
|
|
END
|
|
NEXT I
|
|
|
|
TableVar = FIELD(RTParms,@RM,3,1)
|
|
|
|
Result = TableVar
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
UnlockSet:
|
|
* * * * * * *
|
|
|
|
RdsNos = Parms[1,@RM]
|
|
TableVar = Parms[COL2()+1,@RM]
|
|
|
|
IF RdsNos = '' THEN RETURN
|
|
IF TableVar = '' THEN RETURN
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:@RM:TableVar
|
|
LockedRDSNos = ''
|
|
|
|
FOR I = 1 TO COUNT(RdsNos,@VM) + (RdsNos NE '')
|
|
RdsNo = RdsNos<1,I>
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, RdsNo)
|
|
obj_Tables('UnlockRec',RTParms)
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
|
|
* * * * * * *
|
|
ChangeWOStepProps:
|
|
* * * * * * *
|
|
|
|
RDSNos = Parms[1,@RM]
|
|
CommitDts = Parms[COL2()+1,@RM]
|
|
HotLots = Parms[COL2()+1,@RM]
|
|
MUBoxes = Parms[COL2()+1,@RM]
|
|
|
|
IF NOT(ASSIGNED(RDSNos)) THEN ErrorMsg = 'Unassigned Parm "RDSNos" passed to routine. (':Method:')'
|
|
IF NOT(ASSIGNED(CommitDts)) THEN CommitDts = ''
|
|
IF NOT(ASSIGNED(HotLots)) THEN HotLots = ''
|
|
IF NOT(ASSIGNED(MUBoxes)) THEN MUBoxes = ''
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
IF RDSNos = '' THEN RETURN
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS'
|
|
LockedRDSNos = ''
|
|
|
|
FOR I = 1 TO COUNT(RdsNos,@VM) + (RdsNos NE '')
|
|
|
|
RdsNo = RdsNos<1,I>
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, RdsNo)
|
|
|
|
obj_Tables('LockRec',RTParms)
|
|
IF Get_Status(errCode) THEN
|
|
FOR N = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNos<1,N>)
|
|
obj_Tables('UnlockRec',RTParms) ;* Unlock everything locked up to here
|
|
NEXT N
|
|
ErrorMsg = 'Unable to lock RDS ':QUOTE(RdsNo):' for update.'
|
|
RETURN
|
|
END ELSE
|
|
LockedRDSNos<1,I> = RdsNo
|
|
END
|
|
NEXT I
|
|
|
|
CommitDts = ICONV(CommitDts,'D') ;* Move to internal format
|
|
HotLots = ICONV(HotLots,'B')
|
|
MUBoxes = ICONV(MUBoxes,'B')
|
|
|
|
RDSTableVar = FIELD(RTParms,@RM,3)
|
|
|
|
FOR I = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
LockedRDSNo = LockedRDSNos<1,I>
|
|
READ RDSRec FROM RDSTableVar,LockedRDSNo THEN
|
|
CommitDt = CommitDts<1,I>
|
|
HotLot = HotLots<1,I>
|
|
MUBox = MUBoxes<1,I>
|
|
|
|
IF CommitDt NE RDSRec<RDS_COMMIT_DATE_FINAL$> THEN RDSRec<RDS_COMMIT_DATE_FINAL$> = CommitDt
|
|
*IF HotLot NE RDSRec<RDS_HOT_LOT$> THEN RDSRec<RDS_HOT_LOT$> = HotLot ;* No longer used
|
|
*IF MUBox NE RDSRec<RDS_MAKEUP_BOX$> THEN RDSRec<RDS_MAKEUP_BOX$> = MUBox ;* No longer used
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNo)
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
obj_Tables('WriteRec',RTParms) ;* Write and unlock RDS records
|
|
END
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
AdjStepWafersIn:
|
|
* * * * * * *
|
|
|
|
RETURN
|
|
|
|
* Dead as of 11/5/2008 JCH
|
|
|
|
StepCompRdsNos = Parms[1,@RM]
|
|
AdjRdsNos = Parms[COL2()+1,@RM]
|
|
|
|
IF StepCompRdsNos = '' THEN ErrorMsg = 'Null parameter "StepCompRdsNos" passed to routine. (':Method:')'
|
|
IF AdjRdsNos = '' THEN ErrorMsg = 'Null parameter "AdjRdsNos" passed to routine. (':Method:')'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS'
|
|
LockedRDSNos = ''
|
|
|
|
FOR I = 1 TO COUNT(AdjRdsNos,@VM) + (AdjRdsNos NE '')
|
|
|
|
AdjRdsNo = AdjRdsNos<1,I>
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, AdjRdsNo)
|
|
|
|
obj_Tables('LockRec',RTParms)
|
|
IF Get_Status(errCode) THEN
|
|
FOR N = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNos<1,N>)
|
|
obj_Tables('UnlockRec',RTParms) ;* Unlock everything locked up to here
|
|
NEXT N
|
|
ErrorMsg = 'Unable to lock RDS ':QUOTE(AdjRdsNo):' for update.'
|
|
RETURN
|
|
END ELSE
|
|
LockedRDSNos<1,I> = AdjRdsNo
|
|
END
|
|
NEXT I
|
|
|
|
RDSTableVar = FIELD(RTParms,@RM,3)
|
|
|
|
FOR I = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
LockedRDSNo = LockedRDSNos<1,I>
|
|
|
|
READ RDSRec FROM RDSTableVar,LockedRDSNo THEN
|
|
|
|
SCRdsNo = StepCompRdsNos<1,I>
|
|
SCWafersOut = XLATE('RDS',SCRdsNo,'WFRS_OUT','X') ;* Wafers out from previous step
|
|
RDSRec<RDS_CASS_WAFER_QTY$> = SCWafersOut
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNo)
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
obj_Tables('WriteRec',RTParms) ;* Write and unlock RDS records
|
|
END ELSE
|
|
status = Set_FSError()
|
|
FOR N = 1 TO COUNT(LockedRDSNos,@VM) + (LockedRDSNos NE '')
|
|
RTParms = FieldStore(RTParms, @RM, 2, 1, LockedRDSNos<1,N>)
|
|
obj_Tables('UnlockRec',RTParms) ;* Unlock everything locked up to here
|
|
NEXT N
|
|
|
|
END
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
GetMetKeys:
|
|
* * * * * * *
|
|
|
|
* Returns data structure of 'LSID*ZONE' - @VM in first column associated RDS_TEST numbers in 2nd Column.
|
|
|
|
RdsNo = Parms[1,@RM]
|
|
|
|
IF RdsNo = '' THEN RETURN
|
|
|
|
SortedLSKeys = XLATE('RDS',RdsNo,'RDS_LS_SORTED','X')
|
|
CONVERT @VM TO @FM IN SortedLSKeys
|
|
|
|
IF SortedLSKeys NE '' THEN
|
|
LSMetKeys = XLATE('RDS_LAYER',SortedLSKeys,RDS_LAYER_RDS_TEST_KEYS$,'X')
|
|
RDSMetZones = XLATE('RDS_TEST',LSMetKeys,RDS_TEST_ZONE$,'X')
|
|
ResultLine = 0
|
|
FOR I = 1 TO COUNT(SortedLSKeys,@FM) + (SortedLSKeys NE '')
|
|
SortedLSKey = SortedLSKeys<I>
|
|
LSMetKey = LSMetKeys<I>
|
|
|
|
FOR N = 1 TO COUNT(LSMetKey,@VM) + (LSMetKey NE '')
|
|
ResultLine += 1
|
|
Result<1,ResultLine> = FIELD(SortedLSKey,'*',2):'*':RDSMetZones<I,N>
|
|
Result<2,ResultLine> = LSMetKeys<I,N>
|
|
NEXT N
|
|
NEXT I
|
|
END
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
UnloadEpi:
|
|
* * * * * * *
|
|
|
|
RdsNo = Parms[1,@RM]
|
|
ReactorList = Parms[COL2()+1,@RM]
|
|
AvailSlotKeys = Parms[COL2()+1,@RM]
|
|
|
|
IF RdsNo = '' THEN ErrorMsg = 'Null parameter "RdsNo" passeed to routine.'
|
|
IF ReactorList = '' THEN ErrorMsg = 'Null parameter "ReactorList" passeed to routine.'
|
|
IF AvailSlotKeys = '' THEN ErrorMsg = 'Null parameter "AvailSlotKeys" passeed to routine.'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Send_Info('Reading RDS ':RdsNo:'...')
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:RdsNo
|
|
* RDSRec = obj_Tables('ReadRec',RTParms)
|
|
RDSRec = Database_Services('ReadDataRow', 'RDS', RDSNo)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for UnloadEpi update.'
|
|
RETURN
|
|
END
|
|
|
|
Reactor = RDSRec<RDS_REACTOR$>
|
|
|
|
RLCnt = COUNT(ReactorList,@FM) + (ReactorList NE '')
|
|
|
|
LoadFailed = 0
|
|
LoadCnt = 0
|
|
OutCassettes = ''
|
|
|
|
CassIDs = ''
|
|
OutSlotNos = ''
|
|
RDSNos = ''
|
|
PocketNos = ''
|
|
Zones = ''
|
|
InCassNos = ''
|
|
InSlotNos = ''
|
|
|
|
Send_Info('Building WM_OUT Load Data ...')
|
|
|
|
FOR I = 1 TO RLCnt
|
|
|
|
IF ReactorList<I,COL$WAFER_TYPE> = 'PROD' AND ReactorList<I,COL$USAGE> = '' AND ReactorList<I,COL$OUT_CASS> = '' THEN
|
|
AvailSlotKey = AvailSlotKeys[1,@VM]
|
|
AvailSlotKeys[1,COL2()] = ''
|
|
|
|
WONo = AvailSlotKey[1,'*']
|
|
WOStep = AvailSlotKey[COL2()+1,'*']
|
|
OutCassNo = AvailSlotKey[COL2()+1,'*']
|
|
OutSlotNo = AvailSlotKey[COL2()+1,'*']
|
|
PocketNo = ReactorList<I,COL$POCKET>
|
|
Zone = ReactorList<I,COL$ZONE>
|
|
InCass = ReactorList<I,COL$IN_CASS>
|
|
InSlot = ReactorList<I,COL$IN_SLOT>
|
|
|
|
LOCATE OutCassNo IN OutCassettes USING @VM SETTING Pos ELSE
|
|
OutCassettes = INSERT(OutCassettes,1,Pos,0,OutCassNo)
|
|
END
|
|
|
|
CassID = WONo:'*':WOStep:'*':OutCassNo
|
|
|
|
LOCATE CassID IN CassIDs USING @FM SETTING Pos THEN
|
|
OutSlotNos = INSERT(OutSlotNos,Pos,-1,0,OutSlotNo)
|
|
RDSNos = INSERT(RDSNos,Pos,-1,0,RDSNo)
|
|
PocketNos = INSERT(PocketNos,Pos,-1,0,PocketNo)
|
|
Zones = INSERT(Zones,Pos,-1,0,Zone)
|
|
InCassNos = INSERT(InCassNos,Pos,-1,0,InCass)
|
|
InSlotNos = INSERT(InSlotNos,Pos,-1,0,InSlot)
|
|
END ELSE
|
|
CassIDs = INSERT(CassIDs,Pos,0,0,CassID)
|
|
OutSlotNos = INSERT(OutSlotNos,Pos,-1,0,OutSlotNo)
|
|
RDSNos = INSERT(RDSNos,Pos,-1,0,RDSNo)
|
|
PocketNos = INSERT(PocketNos,Pos,-1,0,PocketNo)
|
|
Zones = INSERT(Zones,Pos,-1,0,Zone)
|
|
InCassNos = INSERT(InCassNos,Pos,-1,0,InCass)
|
|
InSlotNos = INSERT(InSlotNos,Pos,-1,0,InSlot)
|
|
END
|
|
|
|
RDSRec<RDS_OUT_CASS_NO$,I> = OutCassNo
|
|
RDSRec<RDS_OUT_SLOT_NO$,I> = OutSlotNo
|
|
|
|
IF RDSRec<RDS_WAFER_CHAR$,I> = 'PROD' THEN LoadCnt += 1
|
|
|
|
END
|
|
UNTIL LoadFailed
|
|
|
|
NEXT I
|
|
|
|
* RDSRec<RDS_OPERATOR_OUT$> = @USER4
|
|
* RDSRec<RDS_DATE_OUT$> = Date()
|
|
* RDSRec<RDS_TIME_OUT$> = Time()
|
|
|
|
UnloadDTM = OCONV(RDSRec<RDS_DATE_OUT$>, 'D4/' ):' ':OCONV( RDSRec<RDS_TIME_OUT$>, 'MTH' )
|
|
|
|
RemCassIDs = ''
|
|
RemOutSlotNos = ''
|
|
|
|
UnloadFailed = 0
|
|
|
|
CassCnt = COUNT(CassIDs,@FM) + (CassIDs NE '')
|
|
|
|
Def = ""
|
|
Def<MCAPTION$> = "Unloading material... Please, do not interupt this process. This may take a while!"
|
|
Def<MTYPE$> = "G"
|
|
Def<MEXTENT$> = CassCnt
|
|
Def<MTEXTWIDTH$> = 600
|
|
MsgUp = Msg(@WINDOW, Def) ;* Start gas guage message
|
|
|
|
FOR N = 1 TO CassCnt
|
|
|
|
CassID = CassIDs<N>
|
|
|
|
Send_Info('Adding Wafers to WM_OUT ':CassID:'...')
|
|
|
|
WONo = CassID[1,'*']
|
|
WOStep = CassID[COL2()+1,'*']
|
|
OutCass = CassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := OutCass:@RM
|
|
owParms := OutSlotNos<N>:@RM
|
|
owParms := RDSNos<N>:@RM
|
|
owParms := PocketNos<N>:@RM
|
|
owParms := Zones<N>:@RM
|
|
owParms := InCassNos<N>:@RM
|
|
owParms := InSlotNos<N>
|
|
|
|
Set_Status(0)
|
|
obj_WM_Out('AddWafer',owParms)
|
|
|
|
ErrorMessage = ''
|
|
If Error_Services('HasError') then ErrorMessage = Error_Services('GetMessage')
|
|
Status = Get_Status(errCode)
|
|
|
|
IF (Error_Services('HasError') or Get_Status(errCode) ) THEN
|
|
|
|
LogData = ''
|
|
LogData<1> = LoggingDTM
|
|
LogData<2> = @User4
|
|
LogData<3> = RDSNo
|
|
LogData<4> = 'Epi Unload Error. Error code: ':errCode:'.'
|
|
Logging_Services('AppendLog', objLog, LogData, @RM, @FM)
|
|
|
|
UnloadFailed = 1
|
|
|
|
RemCnt = COUNT(RemCassIDs,@FM) + (RemCassIDs NE '')
|
|
|
|
FOR R = 1 TO RemCnt
|
|
RemCassID = RemCassIDs<R>
|
|
|
|
Send_Info('Epi Unload Error - Clearing Partial Unload data ':RemCassID:'...')
|
|
|
|
WONo = RemCassID[1,'*']
|
|
WOStep = RemCassID[COL2()+1,'*']
|
|
OutCass = RemCassID[COL2()+1,'*']
|
|
|
|
OutSlotNos = RemOutSlotNos<R>
|
|
|
|
Set_Status(0)
|
|
|
|
obj_WM_Out('RemoveWafer',WONo:@RM:WOStep:@RM:OutCass:@RM:OutSlotNos)
|
|
NEXT R
|
|
|
|
END ELSE
|
|
RemCassIDs<-1> = CassID
|
|
RemOutSlotNos<-1> = OutSlotNos<N>
|
|
END
|
|
Running = Msg(@WINDOW, MsgUp, N, MSGINSTUPDATE$) ;* Update message
|
|
UNTIL UnloadFailed
|
|
NEXT N
|
|
|
|
IF NOT(UnloadFailed) THEN
|
|
|
|
Send_Info('Saving Updated RDS ':RdsNo:'...')
|
|
|
|
Database_Services('WriteDataRow', 'RDS', RDSNo, RDSRec, True$, False$, True$)
|
|
If Error_Services('HasError') then
|
|
UnloadFailed = True$
|
|
ErrorMsg = Error_Services('GetMessage')
|
|
LogData = ''
|
|
LogData<1> = LoggingDTM
|
|
LogData<2> = @User4
|
|
LogData<3> = RDSNo
|
|
LogData<4> = ErrorMsg
|
|
Logging_Services('AppendLog', objLog, LogData, @RM, @FM)
|
|
ErrMsg(ErrorMsg)
|
|
end
|
|
|
|
* Update Reactor Status with load data
|
|
|
|
If UnloadFailed EQ False$ then
|
|
* Send_Info('Updating Reactor ':Reactor:' Status...')
|
|
|
|
* InCassettes = SRP_Array('Clean', InCassNos, 'TrimAndMakeUnique', @VM)
|
|
* obj_React_Status('ReactorUnload',Reactor:@RM:WONo:@RM:InCassettes:@RM:UnloadDTM:@RM:RDSNo)
|
|
|
|
IF Get_Status(errCode) THEN ErrMsg(errCode)
|
|
|
|
Send_Info('Updating REACT_RUN record...')
|
|
|
|
RDS_React_Run(RDSNo) ;* Conversion to REACT_RUN code 9/25/2008 JCH *******
|
|
end
|
|
|
|
// Verify RDS, REACT_RUN, and WM_OUT cassette & slot data match.
|
|
DataMatch = Material_Services('VerifyEPPUnload', RDSNo)
|
|
|
|
// If data does not match, then back out all changes and log the error.
|
|
If ( (DataMatch EQ False$) or (UnloadFailed EQ True$) ) then
|
|
ErrorMsg = Error_Services('GetMessage')
|
|
LogData = ''
|
|
LogData<1> = LoggingDTM
|
|
LogData<2> = @User4
|
|
LogData<3> = RDSNo
|
|
LogData<4> = ErrorMsg
|
|
Logging_Services('AppendLog', objLog, LogData, @RM, @FM)
|
|
|
|
// Clear WM_OUT data
|
|
UnloadFailed = 1
|
|
RemCnt = COUNT(RemCassIDs,@FM) + (RemCassIDs NE '')
|
|
FOR R = 1 TO RemCnt
|
|
RemCassID = RemCassIDs<R>
|
|
Send_Info('Epi Unload Error - Clearing Partial Unload data ':RemCassID:'...')
|
|
WONo = RemCassID[1,'*']
|
|
WOStep = RemCassID[COL2()+1,'*']
|
|
OutCass = RemCassID[COL2()+1,'*']
|
|
OutSlotNos = RemOutSlotNos<R>
|
|
Set_Status(0)
|
|
obj_WM_Out('RemoveWafer',WONo:@RM:WOStep:@RM:OutCass:@RM:OutSlotNos)
|
|
If Error_Services('HasError') then
|
|
ErrorMsg = Error_Services('GetMessage')
|
|
LogData = ''
|
|
LogData<1> = LoggingDTM
|
|
LogData<2> = @User4
|
|
LogData<3> = WONo:'*':WOStep:'*':OutCass
|
|
LogData<4> = ErrorMsg
|
|
Logging_Services('AppendLog', objLog, LogData, @RM, @FM)
|
|
end
|
|
NEXT R
|
|
|
|
// Clear RDS Data
|
|
RDSRec<RDS_OPERATOR_OUT$> = ''
|
|
RDSRec<RDS_DATE_OUT$> = ''
|
|
RDSRec<RDS_TIME_OUT$> = ''
|
|
RDSRec<RDS_OUT_CASS_NO$> = ''
|
|
RDSRec<RDS_OUT_SLOT_NO$> = ''
|
|
Database_Services('WriteDataRow', 'RDS', RDSNo, RDSRec, True$, False$, False$)
|
|
|
|
// Clear REACT_RUN data (copy cleared RDS data to REACT_RUN)
|
|
RDS_React_Run(RDSNo)
|
|
|
|
end
|
|
|
|
END ELSE
|
|
obj_Tables('UnlockRec',RTParms)
|
|
END
|
|
|
|
Msg(@WINDOW,MsgUp) ;* Take message down
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ReloadEpi:
|
|
* * * * * * *
|
|
|
|
RdsNo = Parms[1,@RM]
|
|
|
|
IF RdsNo = '' THEN
|
|
ErrorMsg = 'Null parameter "RdsNo" passeed to routine.'
|
|
RETURN
|
|
END
|
|
|
|
Send_Info('Reading RDS ':RdsNo:'...')
|
|
|
|
LocalLockFlag = 1
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:RdsNo
|
|
RDSRec = obj_Tables('ReadRec',RTParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for ReloadEpi update.'
|
|
RETURN
|
|
END
|
|
|
|
WONo = RDSRec<RDS_WO$>
|
|
WOStep = RDSRec<RDS_WO_STEP_KEY$>[-1,'B*']
|
|
ReactNo = RDSRec<RDS_REACTOR$>
|
|
ToolID = 'R':ReactNo
|
|
|
|
RLCnt = COUNT(RDSRec<RDS_POCKET$>,@VM) + (RDSRec<RDS_POCKET$> NE '')
|
|
|
|
ReloadFailed = 0
|
|
LoadCnt = 0
|
|
RLWaferIDs = ''
|
|
|
|
OutCassIDs = ''
|
|
PocketNos = ''
|
|
Zones = ''
|
|
WaferChars = ''
|
|
PocketChars = ''
|
|
InCassNos = ''
|
|
InSlotNos = ''
|
|
OutSlots = ''
|
|
|
|
CurrDTM = OCONV(Date(),'D4/'):' ':OCONV(Time(),'MTS')
|
|
|
|
Send_Info('Building WM_OUT Reload Data ...')
|
|
|
|
WfrIDs = '' ;* Added 9/7/2016 JCH
|
|
RunLocs = '' ;* Added 9/7/2016 JCH
|
|
CurrSlotIDs = '' ;* Added 9/7/2016 JCH
|
|
|
|
FOR I = 1 TO RLCnt
|
|
|
|
PocketNo = RDSRec<RDS_POCKET$,I>
|
|
Zone = RDSRec<RDS_ZONE$,I>
|
|
WaferChar = RDSRec<RDS_WAFER_CHAR$,I>
|
|
PocketChar = RDSRec<RDS_POCKET_CHAR$,I>
|
|
InCass = RDSRec<RDS_IN_CASS_NO$,I>
|
|
InSlot = RDSRec<RDS_IN_SLOT_NO$,I>
|
|
OutCass = RDSRec<RDS_OUT_CASS_NO$,I>
|
|
OutSlot = RDSRec<RDS_OUT_SLOT_NO$,I>
|
|
|
|
IF WaferChar = 'PROD' AND PocketChar = '' AND OutCass NE '' THEN
|
|
|
|
WfrIDs<1,-1> = WONo:'*':InCass:'*':InSlot ;* Added 9/7/2016 JCH
|
|
RunLocs<1,-1> = RDSNo:'*':PocketNo:'*':Zone ;* Added 9/7/2016 JCH
|
|
CurrSlotIDs<1,-1> = WONo:'*':OutCass:'*':Outslot ;* Added 9/7/2016 JCH
|
|
|
|
* * * * Added 3/22/2016 JCH - wafer history * * * *
|
|
|
|
Parms = WONo:'*':InCass:'*':InSlot:@RM ;* WfrID
|
|
Parms := CurrDTM:@RM ;* EventDtm
|
|
Parms := @USER4:@RM ;* EventBy
|
|
Parms := 'RELOAD':@RM ;* Event
|
|
Parms := '':@RM ;* NewSlotID
|
|
Parms := RDSNo:'*':PocketNo:'*':Zone:@RM ;* RunLoc
|
|
Parms := '':@RM ;* NCRNo
|
|
Parms := '':@RM ;* TWUse
|
|
Parms := WONo:'*':OutCass:'*':Outslot:@RM ;* CurrSlotID
|
|
Parms := ToolID:@RM ;* NewToolID (Load Tool)
|
|
Parms := '':@RM ;* CurrToolID (Unload Tool)
|
|
Parms := '':@RM ;* NewInvLoc
|
|
Parms := '':@RM ;* CurrInvLoc
|
|
Parms := 'O' ;* Wfr Side
|
|
|
|
obj_WO_Wfr('AddEvent',Parms)
|
|
|
|
|
|
OutCassID = WONo:'*':WOStep:'*':OutCass
|
|
|
|
LOCATE OutCassID IN OutCassIDs USING @FM SETTING Pos THEN
|
|
PocketNos = INSERT(PocketNos,Pos,-1,0,PocketNo)
|
|
Zones = INSERT(Zones,Pos,-1,0,Zone)
|
|
WaferChars = INSERT(WaferChars,Pos,-1,0,WaferChar)
|
|
PocketChars = INSERT(PocketChars,Pos,-1,0,PocketChar)
|
|
InCassNos = INSERT(InCassNos,Pos,-1,0,InCass)
|
|
InSlotNos = INSERT(InSlotNos,Pos,-1,0,InSlot)
|
|
OutSlots = INSERT(OutSlots,Pos,-1,0,OutSlot)
|
|
|
|
END ELSE
|
|
OutCassIDs = INSERT(OutCassIDs,Pos,0,0,OutCassID)
|
|
PocketNos = INSERT(PocketNos,Pos,-1,0,PocketNo)
|
|
Zones = INSERT(Zones,Pos,-1,0,Zone)
|
|
WaferChars = INSERT(WaferChars,Pos,-1,0,WaferChar)
|
|
PocketChars = INSERT(PocketChars,Pos,-1,0,PocketChar)
|
|
InCassNos = INSERT(InCassNos,Pos,-1,0,InCass)
|
|
InSlotNos = INSERT(InSlotNos,Pos,-1,0,InSlot)
|
|
OutSlots = INSERT(OutSlots,Pos,-1,0,OutSlot)
|
|
END
|
|
|
|
RDSRec<RDS_OUT_CASS_NO$,I> = ''
|
|
RDSRec<RDS_OUT_SLOT_NO$,I> = ''
|
|
|
|
END
|
|
UNTIL ReloadFailed
|
|
NEXT I
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* * * * Added 9/7/2016 JCH - wafer history * * * *
|
|
|
|
IF WfrIDs NE '' THEN
|
|
|
|
Parms = WfrIDs:@RM ;* WfrIDs
|
|
Parms := CurrDTM:@RM ;* EventDtm
|
|
Parms := @USER4:@RM ;* EventBy
|
|
Parms := 'RELOAD':@RM ;* Event
|
|
Parms := '':@RM ;* NewSlotIDs
|
|
Parms := RunLocs:@RM ;* RunLocs
|
|
Parms := '':@RM ;* NCRNo
|
|
Parms := '':@RM ;* TWUse
|
|
Parms := CurrSlotIDs:@RM ;* CurrSlotIDs
|
|
Parms := ToolID:@RM ;* NewToolID (Load Tool)
|
|
Parms := '':@RM ;* CurrToolID (Unload Tool)
|
|
Parms := '':@RM ;* NewInvLoc
|
|
Parms := '':@RM ;* CurrInvLoc
|
|
Parms := 'O' ;* Wfr Side
|
|
|
|
obj_WO_Wfr('AddEvent',Parms)
|
|
|
|
END
|
|
|
|
*/
|
|
|
|
|
|
RepCassIDs = ''
|
|
RepOutSlotNos = ''
|
|
RepRDSNos = ''
|
|
RepPocketNos = ''
|
|
RepZones = ''
|
|
RepInCassNos = ''
|
|
RepInSlotNos = ''
|
|
|
|
|
|
ReloadFailed = 0
|
|
|
|
CassCnt = COUNT(OutCassIDs,@FM) + (OutCassIDs NE '')
|
|
|
|
FOR I = 1 TO CassCnt
|
|
|
|
OutCassID = OutCassIDs<I>
|
|
|
|
Send_Info('Removing Run Data from WM_OUT ':OutCassID:'...')
|
|
|
|
WONo = OutCassID[1,'*']
|
|
WOStep = OutCassID[COL2()+1,'*']
|
|
OutCass = OutCassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := OutCass:@RM
|
|
owParms := OutSlots<I>
|
|
|
|
Set_Status(0)
|
|
obj_WM_Out('RemoveWafer',owParms)
|
|
|
|
IF Get_Status(ErrCode) THEN
|
|
ReloadFailed = 1
|
|
RepCnt = COUNT(RepCassIDs,@FM) + (RepCassIDs NE '')
|
|
|
|
FOR N = 1 TO RepCnt
|
|
RepCassID = RepCassIDs<N>
|
|
|
|
Send_Info('Epi Reload Error - Restoring Unload Data ':RepCassID:'...')
|
|
|
|
WONo = RepCassID[1,'*']
|
|
WOStep = RepCassID[COL2()+1,'*']
|
|
OutCass = RepCassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := OutCass:@RM
|
|
owParms := RepOutSlotNos<N>:@RM
|
|
owParms := RepRDSNos<N>:@RM
|
|
owParms := RepPocketNos<N>:@RM
|
|
owParms := RepZones<N>:@RM
|
|
owParms := RepInCassNos<N>:@RM
|
|
owParms := RepInSlotNos<N>
|
|
|
|
Set_Status(0)
|
|
obj_WM_Out('AddWafer',owParms)
|
|
|
|
NEXT N
|
|
|
|
END ELSE
|
|
|
|
RepCassIDs<-1> = OutCassID
|
|
RepOutSlotNos<-1> = OutSlots<I>
|
|
RepRDSNos<-1> = RDSNo
|
|
RepPocketNos<-1> = PocketNos<I>
|
|
RepZones<-1> = Zones<I>
|
|
RepInCassNos<-1> = InCassNos<I>
|
|
RepInSlotNos<-1> = InSlotNos<I>
|
|
|
|
END
|
|
UNTIL ReloadFailed
|
|
NEXT I
|
|
|
|
IF NOT(ReloadFailed) THEN
|
|
|
|
Send_Info('Saving RDS record ':RdsNo:'...')
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
obj_Tables('WriteRec',RTParms)
|
|
|
|
Send_Info('Updating REACT_RUN record...')
|
|
|
|
RDS_React_Run(RDSNo) ;* Conversion to REACT_RUN code 9/25/2008 JCH **********************************************
|
|
END ELSE
|
|
obj_Tables('UnlockRec',RTParms)
|
|
END
|
|
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ClearEpiUnload:
|
|
* * * * * * *
|
|
|
|
* Clears unload destination data - used when RDS & WM_OUT get completely out of sync
|
|
|
|
|
|
RdsNo = Parms[1,@RM]
|
|
|
|
IF RdsNo = '' THEN
|
|
ErrorMsg = 'Null parameter "RdsNo" passeed to routine.'
|
|
RETURN
|
|
END
|
|
|
|
Send_Info('Reading RDS ':RdsNo:'...')
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:RdsNo
|
|
RDSRec = obj_Tables('ReadRec',RTParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for ClearEpiUnload process.'
|
|
RETURN
|
|
END
|
|
|
|
RLCnt = COUNT(RDSRec<RDS_POCKET$>,@VM) + (RDSRec<RDS_POCKET$> NE '')
|
|
|
|
FOR I = 1 TO RLCnt
|
|
RDSRec<RDS_OUT_CASS_NO$,I> = ''
|
|
RDSRec<RDS_OUT_SLOT_NO$,I> = ''
|
|
NEXT I
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
obj_Tables('WriteRec',RTParms)
|
|
|
|
Send_Info('Updating REACT_RUN record...')
|
|
|
|
RDS_React_Run(RDSNo) ;* Conversion to REACT_RUN code 9/25/2008 JCH **********************************************
|
|
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
LoadMat:
|
|
* * * * * * *
|
|
|
|
RdsNo = Parms[1,@RM]
|
|
ReactorList = Parms[COL2()+1,@RM] ;* Contains susceptor load configuration
|
|
WMIKeys = Parms[COL2()+1,@RM] ;* Contains list of locked WMI slots to use
|
|
|
|
IF RdsNo = '' THEN ErrorMsg = 'Null parameter "RdsNo" passeed to routine.'
|
|
IF ReactorList = '' THEN ErrorMsg = 'Null parameter "ReactorList" passeed to routine.'
|
|
IF WMIKeys = '' THEN ErrorMsg = 'Null parameter "AvailSlotKeys" passeed to routine.'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Send_Info('Reading RDS ':RdsNo:'...')
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:RdsNo
|
|
RDSRec = obj_Tables('ReadRec',RTParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for UnloadEpi update.'
|
|
RETURN
|
|
END
|
|
|
|
// Set BLOCK_LOAD flag until the process completes
|
|
RDSRec<RDS_BLOCK_LOAD$> = True$
|
|
Database_Services('WriteDataRow', 'RDS', RDSNo, RDSRec, True$, False$, True$)
|
|
|
|
Reactor = RDSRec<RDS_REACTOR$>
|
|
|
|
RLCnt = COUNT(ReactorList,@FM) + (ReactorList NE '')
|
|
|
|
LOOP
|
|
LastLine = ReactorList[-1,'B':@FM]
|
|
UNTIL LastLine<1,COL$POCKET> NE '' OR ReactorList = ''
|
|
ReactorList[COL1(),99] = ''
|
|
RLCnt -= 1
|
|
REPEAT
|
|
|
|
|
|
LoadFailed = 0
|
|
LoadCnt = 0
|
|
InCassettes = ''
|
|
|
|
CassIDs = ''
|
|
CassSlots = ''
|
|
CassSlotRDSNos = ''
|
|
CassSlotPkts = ''
|
|
CassSlotZones = ''
|
|
|
|
Send_Info('Building Cassette Unload Data ...')
|
|
|
|
FOR I = 1 TO RLCnt
|
|
|
|
IF ReactorList<I,COL$IN_CASS> = '' AND ReactorList<I,COL$WAFER_TYPE> = '' AND ReactorList<I,COL$USAGE> NE 'DUMMY' THEN
|
|
WMIKey = WMIKeys[1,@VM]
|
|
|
|
WMIKeys[1,COL2()] = ''
|
|
|
|
WONo = WMIKey[1,'*']
|
|
WOStep = WMIKey[COL2()+1,'*']
|
|
InCass = WMIKey[COL2()+1,'*']
|
|
InSlot = WMIKey[COL2()+1,'*']
|
|
|
|
PocketNo = ReactorList<I,COL$POCKET>
|
|
Usage = ReactorList<I,COL$USAGE>
|
|
Zone = ReactorList<I,COL$ZONE>
|
|
|
|
CassID = WONo:'*':WOStep:'*':InCass
|
|
|
|
LOCATE CassID IN CassIDs USING @FM SETTING Pos THEN
|
|
CassSlots = INSERT(CassSlots,Pos,-1,0,InSlot)
|
|
CassSlotRDSNos = INSERT(CassSlotRDSNos,Pos,-1,0,RDSNo)
|
|
CassSlotPkts = INSERT(CassSlotPkts,Pos,-1,0,PocketNo)
|
|
CassSlotZones = INSERT(CassSlotZones,Pos,-1,0,Zone)
|
|
END ELSE
|
|
CassIDs = INSERT(CassIDs,Pos,0,0,CassID)
|
|
CassSlots = INSERT(CassSlots,Pos,-1,0,InSlot)
|
|
CassSlotRDSNos = INSERT(CassSlotRDSNos,Pos,-1,0,RDSNo)
|
|
CassSlotPkts = INSERT(CassSlotPkts,Pos,-1,0,PocketNo)
|
|
CassSlotZones = INSERT(CassSlotZones,Pos,-1,0,Zone)
|
|
END
|
|
|
|
RDSRec<RDS_POCKET$,I> = PocketNo
|
|
RDSRec<RDS_ZONE$,I> = Zone
|
|
RDSRec<RDS_POCKET_CHAR$,I> = Usage
|
|
RDSRec<RDS_IN_CASS_NO$,I> = InCass
|
|
RDSRec<RDS_IN_SLOT_NO$,I> = InSlot
|
|
RDSRec<RDS_WAFER_CHAR$,I> = 'PROD'
|
|
|
|
LoadCnt += 1
|
|
|
|
LOCATE InCass IN InCassettes USING @VM SETTING Pos ELSE
|
|
InCassettes = INSERT(InCassettes,1,Pos,0,InCass)
|
|
END
|
|
|
|
END ELSE
|
|
RDSRec<RDS_POCKET$,I> = ReactorList<I,COL$POCKET>
|
|
RDSRec<RDS_ZONE$,I> = ReactorList<I,COL$ZONE>
|
|
RDSRec<RDS_POCKET_CHAR$,I> = ReactorList<I,COL$USAGE>
|
|
RDSRec<RDS_WAFER_CHAR$,I> = ReactorList<I,COL$WAFER_TYPE>
|
|
END
|
|
UNTIL LoadFailed
|
|
NEXT I
|
|
|
|
LoadFailed = 0
|
|
|
|
CassIDCnt = COUNT(CassIDs,@FM) + (CassIDs NE '')
|
|
|
|
RepCassIDs = ''
|
|
RepCassSlots = ''
|
|
|
|
Def = ""
|
|
Def<MCAPTION$> = "Loading material... Please, do not interupt this process. This may take a while!"
|
|
Def<MTYPE$> = "G"
|
|
Def<MEXTENT$> = CassIDCnt
|
|
Def<MTEXTWIDTH$> = 600
|
|
MsgUp = Msg(@WINDOW, Def) ;* Start gas guage message
|
|
|
|
FOR I = 1 TO CassIDCnt
|
|
CassID = CassIDs<I>
|
|
|
|
Send_Info('Pulling Material from WM_IN ':CassID:'...')
|
|
|
|
WONo = CassID[1,'*']
|
|
WOStep = CassID[COL2()+1,'*']
|
|
InCass = CassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := InCass:@RM
|
|
owParms := CassSlots<I>:@RM
|
|
owParms := CassSlotRDSNos<I>:@RM
|
|
owParms := CassSlotPkts<I>:@RM
|
|
owParms := CassSlotZones<I>:@RM
|
|
|
|
Set_Status(0)
|
|
obj_WM_In('RemoveWafer',owParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for UnloadEpi update.'
|
|
|
|
LoadFailed = 1
|
|
RepCnt = COUNT(RepCassIDs,@FM) + (RepCassIDs NE '')
|
|
|
|
FOR N = 1 TO RepCnt
|
|
RepCassID = RepCassIDs<N>
|
|
|
|
Send_Info('Replacing Material in WM_IN ':RepCassID:'...')
|
|
|
|
WONo = RepCassID[1,'*']
|
|
WOStep = RepCassID[COL2()+1,'*']
|
|
InCass = RepCassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := InCass:@RM
|
|
owParms := RepCassSlots<N>:@RM
|
|
|
|
obj_WM_In('ReplaceWafer',owParms)
|
|
|
|
NEXT N
|
|
END ELSE
|
|
RepCassIDs<-1> = CassID
|
|
RepCassSlots<-1> = CassSlots<I>
|
|
END
|
|
Running = Msg(@WINDOW, MsgUp, I, MSGINSTUPDATE$) ;* Update message
|
|
UNTIL LoadFailed
|
|
NEXT I
|
|
|
|
|
|
IF NOT(LoadFailed) THEN
|
|
|
|
* Update Reactor Status with load data
|
|
|
|
*Send_Info('Updating Reactor ':Reactor:' status...')
|
|
|
|
LoadDTM = OCONV( Date(), 'D2/' ):' ':OCONV( Time(), 'MTH' )
|
|
*IdleTime = obj_React_Status('ReactorLoad',Reactor:@RM:WONo:@RM:InCassettes:@RM:LoadDTM)
|
|
|
|
IF Get_Status(errCode) THEN ErrMsg(errCode)
|
|
|
|
RDSRec<RDS_WAFERS_IN$> = LoadCnt
|
|
RDSRec<RDS_VERIFY_QTY$> = LoadCnt
|
|
RDSRec<RDS_CASS_WAFER_QTY$> = LoadCnt
|
|
*RDSRec<RDS_REACT_IDLE_TIME$> = ICONV(IdleTime,'MD2') ;* hours to 2 decimal places
|
|
|
|
Send_Info('Saving Updated RDS ':RDSNo:'...')
|
|
|
|
* RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
|
|
// Remove BLOCK_LOAD flag since the process has completed
|
|
RDSRec<RDS_BLOCK_LOAD$> = False$
|
|
* obj_Tables('WriteRec',RTParms)
|
|
Database_Services('WriteDataRow', 'RDS', RDSNo, RDSRec, True$, False$, True$)
|
|
Database_Services('ReleaseKeyIDLock', 'RDS', RDSNo)
|
|
Send_Info('Updating REACT_RUN record...')
|
|
|
|
RDS_React_Run(RDSNo) ;* Conversion to REACT_RUN code 9/25/2008 JCH **********************************************
|
|
|
|
END ELSE
|
|
RDSRec = obj_Tables('UnlockRec',RTParms)
|
|
END
|
|
|
|
Msg(@WINDOW,MsgUp) ;* Take message down
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
ReturnMat:
|
|
* * * * * * *
|
|
|
|
RdsNo = Parms[1,@RM]
|
|
|
|
IF RdsNo = '' THEN ErrorMsg = 'Null parameter "RdsNo" passeed to routine.'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Send_Info('Reading RDS Record ':RdsNo:'...')
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:RdsNo
|
|
RDSRec = obj_Tables('ReadRec',RTParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for ReturnMat update.'
|
|
RETURN
|
|
END
|
|
|
|
WONo = RDSRec<RDS_WO$>
|
|
WOStep = RDSRec<RDS_WO_STEP_KEY$>[-1,'B*']
|
|
|
|
RLCnt = COUNT(RDSRec<RDS_POCKET$>,@VM) + (RDSRec<RDS_POCKET$> NE '')
|
|
|
|
ReloadFailed = 0
|
|
LoadCnt = 0
|
|
RLWaferData = ''
|
|
|
|
CassIDs = ''
|
|
CassSlots = ''
|
|
CassSlotRDSNos = ''
|
|
CassSlotPkts = ''
|
|
CassSlotZones = ''
|
|
|
|
Send_Info('Building Cassette Material Return data...')
|
|
|
|
FOR I = 1 TO RLCnt
|
|
|
|
PocketNo = RDSRec<RDS_POCKET$,I>
|
|
Zone = RDSRec<RDS_ZONE$,I>
|
|
WaferChar = RDSRec<RDS_WAFER_CHAR$,I>
|
|
PocketChar = RDSRec<RDS_POCKET_CHAR$,I>
|
|
InCass = RDSRec<RDS_IN_CASS_NO$,I>
|
|
InSlot = RDSRec<RDS_IN_SLOT_NO$,I>
|
|
OutCass = RDSRec<RDS_OUT_CASS_NO$,I>
|
|
OutSlot = RDSRec<RDS_OUT_SLOT_NO$,I>
|
|
|
|
IF WaferChar = 'PROD' AND InCass NE '' THEN
|
|
|
|
CassID = WONo:'*':WOStep:'*':InCass
|
|
|
|
LOCATE CassID IN CassIDs USING @FM SETTING Pos THEN
|
|
CassSlots = INSERT(CassSlots,Pos,-1,0,InSlot)
|
|
CassSlotRDSNos = INSERT(CassSlotRDSNos,Pos,-1,0,RdsNo)
|
|
CassSlotPkts = INSERT(CassSlotPkts,Pos,-1,0,PocketNo)
|
|
CassSlotZones = INSERT(CassSlotZones,Pos,-1,0,Zone)
|
|
END ELSE
|
|
CassIDs = INSERT(CassIDs,Pos,0,0,CassID)
|
|
CassSlots = INSERT(CassSlots,Pos,-1,0,InSlot)
|
|
CassSlotRDSNos = INSERT(CassSlotRDSNos,Pos,-1,0,RDSNo)
|
|
CassSlotPkts = INSERT(CassSlotPkts,Pos,-1,0,PocketNo)
|
|
CassSlotZones = INSERT(CassSlotZones,Pos,-1,0,Zone)
|
|
END
|
|
|
|
RDSRec<RDS_IN_CASS_NO$,I> = ''
|
|
RDSRec<RDS_IN_SLOT_NO$,I> = ''
|
|
RDSRec<RDS_POCKET_CHAR$,I> = ''
|
|
RDSRec<RDS_WAFER_CHAR$,I> = ''
|
|
|
|
END ;* End of test for PROD wafers
|
|
|
|
|
|
UNTIL ReloadFailed
|
|
NEXT I
|
|
|
|
RepCassIDs = ''
|
|
RepCassSlots = ''
|
|
RepCassSlotRDSNos = ''
|
|
RepCassSlotPkts = ''
|
|
RepCassSlotZones = ''
|
|
|
|
ReloadFailed = 0
|
|
|
|
CassIDCnt = COUNT(CassIDs,@FM) + (CassIDs NE '')
|
|
|
|
FOR I = 1 TO CassIDCnt
|
|
CassID = CassIDs<I>
|
|
|
|
Send_Info('Returning Material to WM_IN ':CassID:'...')
|
|
|
|
WONo = CassID[1,'*']
|
|
WOStep = CassID[COL2()+1,'*']
|
|
InCass = CassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := InCass:@RM
|
|
owParms := CassSlots<I>
|
|
|
|
Set_Status(0)
|
|
obj_WM_In('ReplaceWafer',owParms) ;* Puts wafer back in the WM_IN record
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ReloadFailed = 1
|
|
RepCnt = COUNT(RepCassIDs,@FM) + (RepCassIDs NE '')
|
|
|
|
FOR N = 1 TO RepCnt
|
|
RepCassID = RepCassIDs<N>
|
|
|
|
Send_Info('Restoring WM_IN record ':RepCassID:'...')
|
|
|
|
WONo = RepCassID[1,'*']
|
|
WOStep = RepCassID[COL2()+1,'*']
|
|
InCass = RepCassID[COL2()+1,'*']
|
|
|
|
owParms = WONo:@RM
|
|
owParms := WOStep:@RM
|
|
owParms := InCass:@RM
|
|
owParms := RepCassSlots<N>
|
|
owParms := RepCassSlotRDSNos<N>
|
|
owParms := RepCassSlotPkts<N>
|
|
owParms := RepCassSlotZones<N>
|
|
|
|
obj_WM_In('ReplaceWafer',owParms)
|
|
NEXT N
|
|
|
|
END ELSE
|
|
RepCassIDs<-1> = CassIDs<I>
|
|
RepCassSlots<-1> = CassSlots<I>
|
|
RepCassSlotRDSNos<-1> = CassSlotRDSNos<I>
|
|
RepCassSlotPkts<-1> = CassSlotPkts<I>
|
|
RepCassSlotZones<-1> = CassSlotZones<I>
|
|
END
|
|
UNTIL ReloadFailed
|
|
NEXT I
|
|
|
|
|
|
IF NOT(ReloadFailed) THEN
|
|
|
|
Send_Info('Saving RDS record ':RdsNo:'...')
|
|
|
|
RDSRec<RDS_WAFERS_IN$> = 0
|
|
RDSRec<RDS_VERIFY_QTY$> = 0
|
|
RDSRec<RDS_CASS_WAFER_QTY$> = 0
|
|
|
|
RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
obj_Tables('WriteRec',RTParms)
|
|
|
|
Send_Info('Updating REACT_RUN record...')
|
|
|
|
RDS_React_Run(RDSNo) ;* Conversion to REACT_RUN code 9/25/2008 JCH **********************************************
|
|
|
|
END ELSE
|
|
obj_Tables('UnlockRec',RTParms)
|
|
END
|
|
|
|
RETURN
|
|
|
|
|
|
|
|
* * * * * * *
|
|
RemovePocketNCR:
|
|
* * * * * * *
|
|
|
|
RDSNo = Parms[1,@RM]
|
|
NCRNo = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSNo = '' THEN RETURN
|
|
IF NCRNo = '' THEN RETURN
|
|
|
|
IF RDSNo = '' THEN ErrorMsg = 'Null parameter "RDSNo" passed to routine. (':Method:')'
|
|
IF NCRNo = '' THEN ErrorMsg = 'Null parameter "NCRNo" passed to routine. (':Method:')'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
Set_Status(0)
|
|
RTParms = 'RDS':@RM:RdsNo
|
|
RDSRec = Database_Services('ReadDataRow', 'RDS', RDSNo)
|
|
* RDSRec = obj_Tables('ReadRec',RTParms)
|
|
|
|
IF Get_Status(errCode) THEN
|
|
ErrorMsg = 'Unable to read RDS ':QUOTE(RdsNo):' for LoadEpi update.'
|
|
RETURN
|
|
END
|
|
|
|
OutNCRs = RDSRec<RDS_OUT_NCR$>
|
|
|
|
Done = 0
|
|
LOOP
|
|
LOCATE NCRNo IN RDSRec<RDS_OUT_NCR$> USING @VM SETTING Pos THEN
|
|
RDSRec<RDS_OUT_NCR$,Pos> = ''
|
|
END ELSE
|
|
Done = 1
|
|
END
|
|
UNTIL Done
|
|
REPEAT
|
|
|
|
* RTParms = FieldStore(RTParms, @RM, 4, 1, RDSRec)
|
|
* obj_Tables('WriteRec',RTParms)
|
|
Database_Services('WriteDataRow', 'RDS', RDSNo, RDSRec, True$, False$, True$)
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
MetConversion:
|
|
* * * * * * *
|
|
|
|
* Updates entered data into RDS_LAYER and RDS_TEST records from RDS record
|
|
|
|
|
|
RETURN ;* Dead 4/16/2006 with installation of metrology and NCR updates
|
|
|
|
|
|
|
|
* * * * * * *
|
|
LoadTestWafers:
|
|
* * * * * * *
|
|
|
|
TWLine = 0
|
|
|
|
RDSTestRec = ''
|
|
|
|
IF RDSRec<RDS_TW_NMINUS_CNT$> NE '' THEN
|
|
TWType = 'N-'
|
|
FOR T = 1 TO COUNT(RDSRec<RDS_TW_NMINUS_CODE$>,@VM) + (RDSRec<RDS_TW_NMINUS_CODE$> NE '')
|
|
|
|
TWTool = RDSRec<RDS_TW_NMINUS_TOOL$,T>
|
|
TWCode = RDSRec<RDS_TW_NMINUS_CODE$,T>
|
|
TWTrans = RDSRec<RDS_TW_NMINUS_TRANS$,T>
|
|
TWCnt = RDSRec<RDS_TW_NMINUS_CNT$,T>
|
|
TWCon = RDSRec<RDS_TW_NMINUS_CON$,T>
|
|
TWRes = RDSRec<RDS_TW_NMINUS_RES$,T>
|
|
TWRho = RDSRec<RDS_TW_NMINUS_RHO$,T>
|
|
TWStress = RDSRec<RDS_TW_NMINUS_STRESS$,T>
|
|
TWThick = RDSRec<RDS_TW_NMINUS_THICK$,T>
|
|
|
|
GOSUB LoadTWLine
|
|
|
|
NEXT T
|
|
END
|
|
|
|
IF RDSRec<RDS_TW_NPLUS_CNT$> NE '' THEN
|
|
TWType = 'N+'
|
|
FOR T = 1 TO COUNT(RDSRec<RDS_TW_NPLUS_CODE$>,@VM) + (RDSRec<RDS_TW_NPLUS_CODE$> NE '')
|
|
|
|
TWTool = RDSRec<RDS_TW_NPLUS_TOOL$,T>
|
|
TWCode = RDSRec<RDS_TW_NPLUS_CODE$,T>
|
|
TWTrans = RDSRec<RDS_TW_NPLUS_TRANS$,T>
|
|
TWCnt = RDSRec<RDS_TW_NPLUS_CNT$,T>
|
|
TWCon = RDSRec<RDS_TW_NPLUS_CON$,T>
|
|
TWRes = RDSRec<RDS_TW_NPLUS_RES$,T>
|
|
TWRho = RDSRec<RDS_TW_NPLUS_RHO$,T>
|
|
TWStress = RDSRec<RDS_TW_NPLUS_STRESS$,T>
|
|
TWThick = RDSRec<RDS_TW_NPLUS_THICK$,T>
|
|
|
|
GOSUB LoadTWLine
|
|
|
|
NEXT T
|
|
END
|
|
|
|
IF RDSRec<RDS_TW_PMINUS_CNT$> NE '' THEN
|
|
TWType = 'P-'
|
|
FOR T = 1 TO COUNT(RDSRec<RDS_TW_PMINUS_CODE$>,@VM) + (RDSRec<RDS_TW_PMINUS_CODE$> NE '')
|
|
|
|
TWTool = RDSRec<RDS_TW_PMINUS_TOOL$,T>
|
|
TWCode = RDSRec<RDS_TW_PMINUS_CODE$,T>
|
|
TWTrans = RDSRec<RDS_TW_PMINUS_TRANS$,T>
|
|
TWCnt = RDSRec<RDS_TW_PMINUS_CNT$,T>
|
|
TWCon = RDSRec<RDS_TW_PMINUS_CON$,T>
|
|
TWRes = RDSRec<RDS_TW_PMINUS_RES$,T>
|
|
TWRho = RDSRec<RDS_TW_PMINUS_RHO$,T>
|
|
TWStress = RDSRec<RDS_TW_PMINUS_STRESS$,T>
|
|
TWThick = RDSRec<RDS_TW_PMINUS_THICK$,T>
|
|
|
|
GOSUB LoadTWLine
|
|
|
|
NEXT T
|
|
END
|
|
|
|
IF RDSRec<RDS_TW_PPLUS_CNT$> NE '' THEN
|
|
TWType = 'P+'
|
|
FOR T = 1 TO COUNT(RDSRec<RDS_TW_PPLUS_CODE$>,@VM) + (RDSRec<RDS_TW_PPLUS_CODE$> NE '')
|
|
|
|
TWTool = RDSRec<RDS_TW_PPLUS_TOOL$,T>
|
|
TWCode = RDSRec<RDS_TW_PPLUS_CODE$,T>
|
|
TWTrans = RDSRec<RDS_TW_PPLUS_TRANS$,T>
|
|
TWCnt = RDSRec<RDS_TW_PPLUS_CNT$,T>
|
|
TWCon = RDSRec<RDS_TW_PPLUS_CON$,T>
|
|
TWRes = RDSRec<RDS_TW_PPLUS_RES$,T>
|
|
TWRho = RDSRec<RDS_TW_PPLUS_RHO$,T>
|
|
TWStress = RDSRec<RDS_TW_PPLUS_STRESS$,T>
|
|
TWThick = RDSRec<RDS_TW_PPLUS_THICK$,T>
|
|
|
|
GOSUB LoadTWLine
|
|
|
|
NEXT T
|
|
END
|
|
|
|
IF RDSRec<RDS_TW_PROD_CNT$> NE '' THEN
|
|
TWType = 'Prod'
|
|
FOR T = 1 TO COUNT(RDSRec<RDS_TW_PROD_CODE$>,@VM) + (RDSRec<RDS_TW_PROD_CODE$> NE '')
|
|
|
|
TWTool = RDSRec<RDS_TW_PROD_TOOL$,T>
|
|
TWCode = RDSRec<RDS_TW_PROD_CODE$,T>
|
|
TWTrans = RDSRec<RDS_TW_PROD_TRANS$,T>
|
|
TWCnt = RDSRec<RDS_TW_PROD_CNT$,T>
|
|
TWCon = RDSRec<RDS_TW_PROD_CON$,T>
|
|
TWRes = RDSRec<RDS_TW_PROD_RES$,T>
|
|
TWRho = RDSRec<RDS_TW_PROD_RHO$,T>
|
|
TWStress = RDSRec<RDS_TW_PROD_STRESS$,T>
|
|
TWThick = RDSRec<RDS_TW_PROD_THICK$,T>
|
|
|
|
GOSUB LoadTWLine
|
|
|
|
NEXT T
|
|
END
|
|
|
|
IF RDSRec<RDS_TW_RECLAIM_CNT$> NE '' THEN
|
|
TWType = 'Reclaim'
|
|
FOR T = 1 TO COUNT(RDSRec<RDS_TW_RECLAIM_CODE$>,@VM) + (RDSRec<RDS_TW_RECLAIM_CODE$> NE '')
|
|
|
|
TWTool = RDSRec<RDS_TW_RECLAIM_TOOL$,T>
|
|
TWCode = RDSRec<RDS_TW_RECLAIM_CODE$,T>
|
|
TWTrans = RDSRec<RDS_TW_RECLAIM_TRANS$,T>
|
|
TWCnt = RDSRec<RDS_TW_RECLAIM_CNT$,T>
|
|
TWCon = RDSRec<RDS_TW_RECLAIM_CON$,T>
|
|
TWRes = RDSRec<RDS_TW_RECLAIM_RES$,T>
|
|
TWRho = RDSRec<RDS_TW_RECLAIM_RHO$,T>
|
|
TWStress = RDSRec<RDS_TW_RECLAIM_STRESS$,T>
|
|
TWThick = RDSRec<RDS_TW_RECLAIM_THICK$,T>
|
|
|
|
GOSUB LoadTWLine
|
|
|
|
NEXT T
|
|
END
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
LoadTWLine:
|
|
* * * * * * *
|
|
|
|
TWLine += 1
|
|
|
|
RDSTestRec<RDS_TEST_TW_TYPE$,TWLine> = TWType
|
|
RDSTestRec<RDS_TEST_TW_TOOL$,TWLine> = TWTool
|
|
RDSTestRec<RDS_TEST_TW_CODE$,TWLine> = TWCode
|
|
RDSTestRec<RDS_TEST_TW_TRANS$,TWLine> = TWTrans
|
|
RDSTestRec<RDS_TEST_TW_CNT$,TWLine> = TWCnt
|
|
RDSTestRec<RDS_TEST_TW_CON$,TWLine> = TWCon
|
|
RDSTestRec<RDS_TEST_TW_RES$,TWLine> = TWRes
|
|
RDSTestRec<RDS_TEST_TW_RHO$,TWLine> = TWRho
|
|
RDSTestRec<RDS_TEST_TW_STRESS$,TWLine> = TWStress
|
|
RDSTestRec<RDS_TEST_TW_THICK$,TWLine> = TWThick
|
|
|
|
RETURN
|
|
|
|
|
|
* * * * * * *
|
|
SetPartNo:
|
|
* * * * * * *
|
|
|
|
RdsNos = Parms[1,@RM]
|
|
NewPartNo = Parms[COL2()+1,@RM]
|
|
RDSTableVar = Parms[COL2()+1,@RM]
|
|
|
|
IF RDSNos = '' THEN ErrorMsg = 'Null parameter "RDSNos" passed to routine. (':Method:')'
|
|
IF NewPartNo = '' THEN ErrorMsg = 'Null parameter "NewPartNo" passed to routine. (':Method:')'
|
|
|
|
IF ErrorMsg NE '' THEN RETURN
|
|
|
|
IF RDSTableVar = '' THEN
|
|
|
|
rtParms = 'RDS':@RM:RdsNos
|
|
|
|
RDSTableVar = obj_Tables('LockSet',rtParms)
|
|
|
|
IF Get_Status(errCode) THEN RETURN
|
|
END
|
|
|
|
RdsCnt = COUNT(RdsNos,@VM) + (RdsNos NE '')
|
|
|
|
FOR I = 1 TO RdsCnt
|
|
RdsNo = RdsNos<1,I>
|
|
READ RDSRec FROM RDSTableVar,RdsNo THEN
|
|
|
|
RDSRec<RDS_PART_NUM$> = NewPartNo
|
|
|
|
rtParms = 'RDS':@RM:RDSNo:@RM:RDSTableVar:@RM:RDSRec
|
|
obj_Tables('WriteRec',rtParms) ;* Writes and unlocks the RDS records
|
|
Send_Info(' RDS record ':RDSNo:' Updated. ':I:'/':RdsCnt)
|
|
END
|
|
NEXT I
|
|
|
|
RETURN
|
|
|
|
|
|
|