1666 lines
74 KiB
Plaintext
1666 lines
74 KiB
Plaintext
Compile function JONATHAN_Services(@Service, @Params)
|
|
#pragma precomp SRP_PreCompiler
|
|
|
|
Declare function Gan_Services, Obj_Notes_Sent, msg, Check_Notes, Jonathan_Services, Database_Services, SRP_Datetime, Datetime
|
|
Declare function Lsl_Users_Services, SRP_Time, RList, Error_Services, Obj_Wo_Mat, Pm_Services, Date_Services, Test_Run_Services
|
|
Declare function Reactor_Services, Reactor_Log_Services, Environment_Services, Logging_Services, Obj_Wm_out, Obj_wo_mat
|
|
Declare function Test_Wafer_Prod_Services, RDS_Services, SRP_Sort_Array, Return_To_Fab_Services, Lot_Services
|
|
DECLARE FUNCTION obj_WO_Mat , obj_WO_Mat_QA, Active_Directory_Services, SRP_Array, obj_vendor_code, obj_wm_out
|
|
Declare subroutine Start_Window, RList, Set_Status, Database_Services, Obj_Sap, Sap_Services, Btree.Extract
|
|
Declare subroutine Reactor_Services, Logging_Services, Extract_SI_Keys, Get_Status, obj_notes, obj_wo_react
|
|
Declare subroutine OBJ_WO_MAT_QA, PSN_Services, Print_Shipment_dev, obj_shipment, SRP_Run_Command
|
|
|
|
$insert LOGICAL
|
|
$insert NOTE_PTRS_EQU
|
|
$insert MSG_EQUATES
|
|
$Insert APP_INSERTS
|
|
$Insert RLIST_EQUATES
|
|
$Insert WO_LOG_EQUATES
|
|
$Insert RDS_EQUATES
|
|
$Insert WO_STEP_EQUATES
|
|
$Insert WO_MAT_QA_EQUATES
|
|
$Insert REACT_RUN_EQUATES
|
|
$Insert RDS_LAYER_EQUATES
|
|
$Insert RDS_TEST_EQUATES
|
|
$Insert PM_EQUATES
|
|
$Insert PM_SPEC_EQUATES
|
|
$Insert WO_MAT_EQUATES
|
|
$Insert WM_OUT_EQUATES
|
|
$Insert ICAR_EQUATES
|
|
$Insert LSL_USERS_EQUATES
|
|
$Insert TEST_WAFER_PROD_EQUATES
|
|
$Insert PRODUCT_OPERATION_EQUATES
|
|
$Insert WO_REACT_EQUATES
|
|
$Insert COMPANY_EQUATES
|
|
$Insert CUST_EPI_PART_EQUATES
|
|
$Insert EPI_PART_EQUATES
|
|
/*$Insert TEST_RUN_EQUATES
|
|
$Insert TEST_RUN_WAFER_EQUATES
|
|
$Insert TEST_WAFER_PROD_EQUATES
|
|
$Insert TEST_RUN_TYPE_EQUATES
|
|
*/
|
|
$Insert REACTOR_EQUATES
|
|
|
|
|
|
GoToService
|
|
|
|
Return Response or ""
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SERVICES
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Service GetWMONextOpenSlots()
|
|
debug
|
|
test = obj_wm_out('NextOpenSlots', '173330':@RM:1)
|
|
end service
|
|
|
|
Service PrintReactorLabel(ReactNo, LoadLockSide)
|
|
|
|
If ( (ReactNo NE '') and (LoadLockSide NE '') ) then
|
|
BaseZpl = '^XA^LH10,10^FO35,5^BY2^B3N,,80,N^FD10SR{ReactNo}.{LoadLockSidePrefix}^FS^FO10,105^A045,90^FB400,1,,C^FDR{ReactNo} {LoadLockSide}^FS^XZ'
|
|
Convert 'R' to '' in ReactNo
|
|
If LoadLockSide _EQC 'Both' then
|
|
LoadLockSidePrefix = 'L'
|
|
ZplLeft = BaseZpl
|
|
Swap '{ReactNo}' with ReactNo in ZplLeft
|
|
Swap '{LoadLockSidePrefix}' with LoadLockSidePrefix in ZplLeft
|
|
Swap '{LoadLockSide}' with 'Left' in ZplLeft
|
|
ZplRight = BaseZpl
|
|
LoadLockSidePrefix = 'R'
|
|
Swap '{ReactNo}' with ReactNo in ZplRight
|
|
Swap '{LoadLockSidePrefix}' with LoadLockSidePrefix in ZplRight
|
|
Swap '{LoadLockSide}' with 'Right' in ZplRight
|
|
Zpl = ZplLeft:ZplRight
|
|
end else
|
|
LoadLockSidePrefix = LoadLockSide[1, 1]
|
|
Zpl = BaseZpl
|
|
Swap '{ReactNo}' with ReactNo in Zpl
|
|
Swap '{LoadLockSidePrefix}' with LoadLockSidePrefix in Zpl
|
|
Swap '{LoadLockSide}' with LoadLockSide in Zpl
|
|
end
|
|
//Labeling_Services('PrintLabel', Zpl, '\\messp1003.infineon.com\MESZBRPRT008')
|
|
OSWrite ZPL to 'C:\Users\MESOuellette\Desktop\ReactorLabel' : ReactNo : '.zpl'
|
|
end else
|
|
Error_Services('Add', 'Error in ':Service:' service. Null ReactNo or LoadLockSide passed in.')
|
|
end
|
|
|
|
end service
|
|
|
|
Service DeleteTWUseKeyByRDS(RDSNo)
|
|
Debug
|
|
Response = 0
|
|
ErrorMessage = ''
|
|
TestRunKeys = Test_Run_Services('GetTestRunKeysByRDS', RDSNo)
|
|
for each testrunkey in testrunkeys using @VM
|
|
Table = 'TEST_RUN'
|
|
KeyID = testrunkey
|
|
Resp = Database_Services('UnlockKeyID', Table, KeyID)
|
|
If Resp then
|
|
Database_Services('DeleteDataRow', 'TEST_RUN', testrunkey)
|
|
if error_services('NoError') then
|
|
Response = 1
|
|
end else
|
|
errorMessage = Error_Services('GetMessage')
|
|
Response = 0
|
|
end
|
|
end else
|
|
errorMessage = 'Error: unable to unlock record'
|
|
Response = 0
|
|
end
|
|
|
|
Next testrunkey
|
|
|
|
end service
|
|
|
|
Service PrintRDSLabel(RDSNo)
|
|
WONo = XLATE('RDS', RDSNo, RDS_WO$, 'X')
|
|
CustNo = XLATE( 'WO_LOG', WONo, wo_log_cust_no$, 'X' )
|
|
PrintCompany = XLATE('COMPANY', CustNo, COMPANY_CO_NAME$, 'X')
|
|
PrintRONum = XLATE('RDS', RDSNo, RDS_CASS_NO$, 'X')
|
|
|
|
EpiPartNo = XLATE('WO_LOG', WONo, WO_LOG_EPI_PART_NO$, 'X')
|
|
CustEpiPartSpecNo = XLATE('EPI_PART', EpiPartNo, CUST_EPI_PART_SPEC_NO$,'X')[-1,'B':@VM] ;* Last (current) Customer Spec Number
|
|
|
|
PrintPSN = XLATE( 'RDS', RdsIds, rds_prod_spec_id$, 'X' )
|
|
|
|
PrintSpecType = OCONV( XLATE( 'RDS', RDSNo, 'SPEC_TYPE', 'X' ), '[SPEC_TYPE_CONV]' )
|
|
PrintLotNum = XLATE( 'RDS', RDSNo, rds_lot_num$, 'X' )
|
|
|
|
PrintQty = XLATE( 'RDS', RDSNo, 'WAFERS_SCHEDULED', 'X' )
|
|
|
|
PrintRDSId = RDSNo
|
|
|
|
PrintSubPartNum = XLATE( 'RDS', RDSNo, 'SUB_PART_NUM', 'X' )
|
|
|
|
WOMatRec = WONo : '*' : PrintRONum
|
|
SubSupplier = obj_Vendor_Code('SemiToEpi',WOMatRec<WO_MAT_SUB_VEND_CD$>)
|
|
VendCd = XLATE('COMPANY',CustNo,COMPANY_VEND_CD$,'X')
|
|
IF VendCd NE '' THEN
|
|
SubSupplier = VendCd ;* Substrate supplier code found in the EPI_PART window. 12/9/2011 for cust 7067
|
|
END
|
|
PrintSuppCd = SubSupplier
|
|
PSStageKey = PrintPSN:'*QA'
|
|
PrintRecipe = XLATE('PRS_STAGE',PSStageKey,'MET_RECIPE','X')
|
|
PrintQARecipe = FIELD(PrintRecipe, @VM, 1)
|
|
Str = ''
|
|
Str := '^XA'
|
|
Str := '^LH0,0'
|
|
Str := '^PR1' ;* Print speed 2 inches per second
|
|
Str := '^LL406' ;* Label length @203 dpi
|
|
Str := '^PW900'
|
|
Str := '^MD22' ;* Media darkness
|
|
Str := '^MMT' ;* Media mode t=tear off mode
|
|
*Str := '^PQ2' ;* Print 2 labels for each pass through here
|
|
|
|
****** First Line, Cust, WO and RO
|
|
Str := '^FO25,25^AC,18^FDCust: ^FS':CRLF$
|
|
Str := '^FO95,14^A045,35^FD':PrintCompany:'^FS':CRLF$
|
|
Str := '^FO570,25^AC18^FDWO: ^FS':CRLF$
|
|
Str := '^FO610,14^A045,35^FD':WONo:'^FS':CRLF$
|
|
Str := '^FO730,25^AC18^FDRO: ^FS':CRLF$
|
|
Str := '^FO770,14^A045,35^FD':PrintRONum:'^FS':CRLF$
|
|
|
|
****** Second Line, Cust Spec, PSN and Type
|
|
Str := '^FO25,75^AC18^FD(P)Cust Spec: ^FS':CRLF$
|
|
Str := '^FO185,65^A045,35^FD':CustEpiPartSpecNo:'^FS':CRLF$
|
|
Str := '^FO25,95^BY2,2.0^B3,,50,N^FDP':CustEpiPartSpecNo:'^FS':CRLF$
|
|
Str := '^FO640,75^AC18^FDPSN:^FS':CRLF$
|
|
Str := '^FO690,65^A045,35^FD':PrintPSN:'^FS':CRLF$
|
|
Str := '^FO630,125^AC18^FDType:^FS':CRLF$
|
|
Str := '^FO690,115^A045,30^FD':PrintSpecType:'^FS':CRLF$
|
|
|
|
****** Third Line, Sub Lot, Qty and RDS
|
|
Str := '^FO25,175^AC18^FD(2T)Sub Lot:^FS':CRLF$
|
|
Str := '^FO175,165^A045,35^FD':PrintLotNum:'^FS':CRLF$
|
|
Str := '^FO25,195^BY1,3.0^B3,,50,N^FD2T':PrintLotNum:'^FS':CRLF$
|
|
Str := '^FO400,175^AC18^FD(Q)Qty:^FS':CRLF$
|
|
Str := '^FO500,165^A045,35^FD':PrintQty:'^FS':CRLF$
|
|
Str := '^FO400,195^B3,,50,N^FDQ':PrintQty:'^FS':CRLF$
|
|
Str := '^FO590,175^AC18^FD(1T)RDS: ^FS':CRLF$
|
|
Str := '^FO690,165^A045,35^FD':PrintRDSId:'^FS':CRLF$
|
|
Str := '^FO630,195^B3,,50,N^FD1T':PrintRDSId:'^FS':CRLF$
|
|
|
|
****** Fourth Line, SubPN, Vendor and QA Metrology recipe
|
|
Str := '^FO25,275^AC18^FD(S)Sub PN:^FS':CRLF$
|
|
Str := '^FO145,265^A045,35^FD':PrintSubPartNum:'^FS':CRLF$
|
|
Str := '^FO25,295^B3,,50,N^FDS':PrintSubPartNum:'^FS':CRLF$
|
|
Str := '^FO400,275^AC18^FD(1V)Vend:^FS':CRLF$
|
|
Str := '^FO510,265^A045,35^FD':PrintSuppCd:'^FS':CRLF$
|
|
Str := '^FO400,295^B3,,50,N^FD1V':PrintSuppCd:'^FS':CRLF$
|
|
Str := '^FO590,275^AC18^FD':PrintQARecipe:'^FS':CRLF$
|
|
|
|
****** Fifth Line, Motto and Data Matrix barcode
|
|
Str := '^FO25,370^A045,28':CRLF$
|
|
Str := "^FDWe do what we promise. That's quality made by Infineon.^FS":CRLF$
|
|
Str := '^FO725,320^CI28':CRLF$
|
|
Str := '^BXN,2,200^FDP':CustEpiPartSpecNo:'|S':PrintSubPartNum:'|1T':PrintRDSId:'|2T':PrintLotNum:'|':PrintPSN:'|Q':PrintQty:'|1V':PrintSuppCd:'|SEQ':1:'^FS':CRLF$
|
|
|
|
****** End the print job (ZPL script)
|
|
Str:= '^XZ'
|
|
|
|
OSWrite Str to 'C:\Users\mesouellette\Desktop\' : RDSNo : 'zpl.zpl'
|
|
end service
|
|
|
|
Service GetTestRunKeyByRDS(RDSNo)
|
|
Debug
|
|
Response = Test_Run_Services('GetTestRunKeysByRDS', RDSNo)
|
|
end service
|
|
|
|
|
|
Service ReactorAssignmentHistoryByWO(ReactorNo, WO)
|
|
debug
|
|
table = "RDS"
|
|
ErrorMessage = ''
|
|
RDSRecords = ''
|
|
RDSSortedByAssignmentDTM = ''
|
|
Open "DICT ":table To @DICT Else
|
|
ErrorMessage = 'Error opening RDS dictionary'
|
|
End
|
|
If ErrorMessage EQ '' then
|
|
srch_strng = "WO":@VM:WO:@FM:"REACTOR":@VM:ReactorNo:@FM
|
|
option = ""
|
|
flag = ""
|
|
Btree.Extract(srch_strng, table, @DICT, RDSRecords, option, flag)
|
|
end
|
|
RDSRecordsWithPreEpiSig = ''
|
|
for each RDSKey in RDSRecords using @VM setting RDSPos
|
|
ThisRDSRec = Database_Services('ReadDataRow', 'RDS', RDSKey, True$, 0, False$)
|
|
ThisRDSPreEpiDT = ThisRDSRec<RDS_PRE_EPI_SIG_DATE$>
|
|
ThisRDSPreEpiTM = ThisRDSRec<RDS_PRE_EPI_SIG_TIME$>
|
|
ThisRDSPreEpiDTM = SRP_Datetime('Combine', ThisRDSPreEpiDT, ThisRDSPreEpiTM)
|
|
RDSRecordsWithPreEpiSig<1, RDSPos> = RDSKey
|
|
RDSRecordsWithPreEpiSig<2, RDSPos> = ThisRDSPreEpiDTM
|
|
Next RDSKey
|
|
|
|
RDSSortedByAssignmentDTM = SRP_Sort_Array(RDSRecordsWithPreEpiSig, 'AN2', 0)
|
|
FinalRDSSortedByAssignmentDTM = ''
|
|
|
|
for each RDS in RDSSortedByAssignmentDTM<1> using @VM setting SortedRDSPos
|
|
ThisRDSDtm = RDSSortedByAssignmentDTM<2, SortedRDSPos>
|
|
if ThisRDSDtm GT 0 then
|
|
FinalRDSSortedByAssignmentDTM<1, -1> = RDS
|
|
FinalRDSSortedByAssignmentDTM<2, -1> = OConv(ThisRDSDtm, 'DT')
|
|
end
|
|
Next RDS
|
|
|
|
Response = FinalRDSSortedByAssignmentDTM<1>
|
|
end service
|
|
|
|
* Service ReactorLoadHistoryByWO(ReactNo, WO)
|
|
* Response = ''
|
|
* If ( (ReactNo NE '') and (StartDTM NE '') and (StopDTM NE '')) then
|
|
* Open 'RDS' to RDSTable then
|
|
* OPEN 'DICT.RDS' TO @DICT then
|
|
* SelectSent = 'SELECT RDS WITH REACTOR EQ ':ReactNo:' AND WITH WO EQ ':WO:' BY-DSND PRE_EPI_SIG_DT'
|
|
* Set_Status(0)
|
|
* errCode = ''
|
|
* RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
|
|
* If Not(Get_Status(errCode)) then
|
|
* @RecCount = 0
|
|
* EOF = False$
|
|
* Loop
|
|
* Readnext @ID else EOF = True$
|
|
* While EOF EQ False$
|
|
* READO @RECORD FROM RDSTable,@ID then
|
|
* @RecCount += 1
|
|
* RDSNo = {SEQ}
|
|
* DateIn = OCONV({DATETIME_IN},'DT2/^HS')
|
|
* DateOut = OCONV({DATETIME_OUT},'DT2/^HS')
|
|
* LoadOperator = {OPERATOR_IN}
|
|
* UnLoadOperator = {OPERATOR_OUT}
|
|
*
|
|
* Response<@RecCount, 1> = RDSNo
|
|
* Response<@RecCount, 2> = DateIn
|
|
* Response<@RecCount, 3> = DateOut
|
|
* Response<@RecCount, 4> = LoadOperator
|
|
* Response<@RecCount, 5> = UnLoadOperator
|
|
* end
|
|
* Repeat
|
|
* end else
|
|
* ErrMsg = 'Error in service ':Service:'. Error code: ':errCode:'.'
|
|
* Error_Services('Add', ErrorMsg)
|
|
* end
|
|
* end else
|
|
* ErrorMsg = 'Unable to Open "DICT.RDS" table!'
|
|
* Error_Services('Add', ErrorMsg)
|
|
* end
|
|
* end else
|
|
* ErrorMsg = 'Unable to Open "RDS" table!'
|
|
* Error_Services('Add', ErrorMsg)
|
|
* end
|
|
* end
|
|
*
|
|
*
|
|
* end service
|
|
|
|
Service GetMetroReqd(RdsNo)
|
|
|
|
IsTWReqd = False$
|
|
RDSRec = Database_Services('ReadDataRow', 'RDS', RDSNo)
|
|
WONo = RDSRec<6>
|
|
WoStepNo = 1
|
|
ReactNo = RDSRec<2>
|
|
ThisReactorRunOrder = 0
|
|
|
|
//This gets all the RDS's for this WO that have run on the same reactor in the order that they were assgined to that reactor.
|
|
ReactRDSNos = Jonathan_Services('ReactorAssignmentHistoryByWO', ReactNo, WONo)
|
|
RDSNosMetroData = ''
|
|
//Row 1 is RDS No
|
|
//Row 2 is Layer 1 THICK
|
|
//Row 3 is Layer 1 SheetRho
|
|
//Row 4 is Layer 1 CRES
|
|
//Row 5 is Layer 2 THICK
|
|
//Row 6 is Layer 2 SheetRho
|
|
//Row 7 is Layer 2 CRES
|
|
|
|
for each RDSId in ReactRDSNos using @VM setting iPos
|
|
RDSNosMetroData<1, iPos> = RDSId
|
|
ThisRDSLayerKeys = XLATE('RDS', RDSId, 150, 'X')
|
|
for each RDSLayerKey in ThisRDSLayerKeys using @VM
|
|
MetRecIds = XLATE('RDS_LAYER', RDSLayerKey, 3, 'X')
|
|
for each MetRecId in MetRecIds using @VM
|
|
ThisMetRecLayerRec = Database_Services('ReadDataRow', 'RDS_TEST', MetRecId, True$, 0, False$)
|
|
ThisMetRecLayerId = ThisMetRecLayerRec<2>
|
|
ThisMetRecThickDtm = ThisMetRecLayerRec<144>
|
|
ThisMetRecSheetRhoDtm = ThisMetRecLayerRec<145>
|
|
ThisMetRecHgcvDtm = ThisMetRecLayerRec<146>
|
|
Begin Case
|
|
Case ThisMetRecLayerId EQ 'L1'
|
|
RDSNosMetroData<2, iPos> = ThisMetRecThickDtm
|
|
RDSNosMetroData<3, iPos> = ThisMetRecSheetRhoDtm
|
|
RDSNosMetroData<4, iPos> = ThisMetRecHgcvDtm
|
|
Case ThisMetRecLayerId EQ 'L2'
|
|
RDSNosMetroData<5, iPos> = ThisMetRecThickDtm
|
|
RDSNosMetroData<6, iPos> = ThisMetRecSheetRhoDtm
|
|
RDSNosMetroData<7, iPos> = ThisMetRecHgcvDtm
|
|
End Case
|
|
Next MetRecId
|
|
Next RDSLayerKey
|
|
Next RDSId
|
|
LOCATE RdsNo IN ReactRDSNos USING @VM SETTING ThisReactorRunOrder ELSE Return
|
|
PSNo = RDSRec<114>
|
|
PSRec = Database_Services('ReadDataRow', 'PROD_SPEC', PSNo)
|
|
PRSLayerKeys = PSRec<145>
|
|
for each PRSLayerKey in PRSLayerKeys using @VM
|
|
PRSPropKeys = Database_Services('ReadDataColumn', 'PRS_LAYER', PRSLayerKey, 5)
|
|
for each PRSPropKey in PRSPropKeys using @VM
|
|
PRSPropRec = Database_Services('ReadDataRow', 'PRS_PROP', PRSPropKey)
|
|
WaferType = PRSPropRec<6>
|
|
TestType = Field(PRSPropKey, '*', 3)
|
|
Layer = Field(PRSPropKey, '*', 2)
|
|
MeasureFreq = PRSPropRec<8>
|
|
Start = PRSPropRec<17>
|
|
If WaferType NE 'Product' AND WaferType NE 'Prod' then
|
|
BEGIN CASE
|
|
CASE MeasureFreq = 'F' AND ThisReactorRunOrder = 1 ; IsTWReqd = 1
|
|
CASE ThisReactorRunOrder = Start ; IsTWReqd = 1
|
|
CASE NUM(MeasureFreq)
|
|
//FindLastEntryArray = SRP_Array('Reverse', RDSNosMetroData, @VM)
|
|
Begin Case
|
|
Case TestType EQ 'CRES'
|
|
LastCresEntryRDS = ''
|
|
Case TestType EQ 'RES'
|
|
/////////////////////////////
|
|
if Layer EQ 1 then
|
|
LastResEntryLayer1RDS = ''
|
|
for each resEntry in RDSNosMetroData<3> using @VM setting tPos
|
|
if resEntry NE '' then
|
|
LastResEntryLayer1RDS = RDSNosMetroData<1, tPos>
|
|
end
|
|
Until RDSNosMetroData<1, tPos> EQ RDSNo
|
|
Next resEntry
|
|
If LastResEntryLayer1RDS NE '' then
|
|
Locate LastResEntryLayer1RDS in ReactRDSNos using @VM setting LastMeasurePos then
|
|
RunsSinceLastTest = ThisReactorRunOrder - LastMeasurePos
|
|
If RunsSinceLastTest GE MeasureFreq OR RunsSinceLastTest EQ 0 then
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
end else
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
if Layer EQ 2 then
|
|
LastResEntryLayer2RDS = ''
|
|
for each resEntry in RDSNosMetroData<6> using @VM setting tPos
|
|
if resEntry NE '' then
|
|
LastResEntryLayer2RDS = RDSNosMetroData<1, tPos>
|
|
end
|
|
Until RDSNosMetroData<1, tPos> EQ RDSNo
|
|
Next resEntry
|
|
If LastResEntryLayer2RDS NE '' then
|
|
Locate LastResEntryLayer2RDS in ReactRDSNos using @VM setting LastMeasurePos then
|
|
RunsSinceLastTest = ThisReactorRunOrder - LastMeasurePos
|
|
If RunsSinceLastTest GE MeasureFreq OR RunsSinceLastTest EQ 0 then
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
end else
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
|
|
//////////////////////////////////////////
|
|
Case TestType EQ 'THICK'
|
|
if Layer EQ 1 then
|
|
|
|
LastThickEntryLayer1RDS = ''
|
|
for each thickEntry in RDSNosMetroData<2> using @VM setting tPos
|
|
if thickEntry NE '' then
|
|
LastThickEntryLayer1RDS = RDSNosMetroData<1, tPos>
|
|
end
|
|
Until RDSNosMetroData<1, tPos> EQ RDSNo
|
|
Next thickEntry
|
|
If LastThickEntryLayer1RDS NE '' then
|
|
Locate LastThickEntryLayer1RDS in ReactRDSNos using @VM setting LastMeasurePos then
|
|
RunsSinceLastTest = ThisReactorRunOrder - LastMeasurePos
|
|
If RunsSinceLastTest GE MeasureFreq OR RunsSinceLastTest EQ 0 then
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
end else
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
if Layer EQ 2 then
|
|
LastThickEntryLayer2RDS = ''
|
|
for each thickEntry in RDSNosMetroData<5> using @VM setting tPos
|
|
if thickEntry NE '' then
|
|
LastThickEntryLayer2RDS = RDSNosMetroData<1, tPos>
|
|
end
|
|
Until RDSNosMetroData<1, tPos> EQ RDSNo
|
|
Next thickEntry
|
|
If LastThickEntryLayer2RDS NE '' then
|
|
Locate LastThickEntryLayer2RDS in ReactRDSNos using @VM setting LastMeasurePos then
|
|
RunsSinceLastTest = ThisReactorRunOrder - LastMeasurePos
|
|
If RunsSinceLastTest GE MeasureFreq OR RunsSinceLastTest EQ 0 then
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
end else
|
|
IsTWReqd = true$
|
|
end
|
|
end
|
|
|
|
End Case
|
|
|
|
END CASE
|
|
end
|
|
Until IsTWReqd EQ True$
|
|
Next PRSPropKey
|
|
Until IsTWReqd EQ True$
|
|
Next PRSLayerKey
|
|
Response = IsTWReqd
|
|
end service
|
|
|
|
* Service UnlockRecord()
|
|
* Response = Database_Services('ReleaseKeyIDLock', 'WO_MAT', '172548*2')
|
|
* end service
|
|
*
|
|
*
|
|
* Service LaunchOIWizardEdge()
|
|
* Command = 'explorer https://goto.infineon.com/oiwizard/returntofab'
|
|
* SRP_Run_Command(Command)
|
|
* end service
|
|
*
|
|
* Service CheckOIWizardValid(OIWizardId)
|
|
*
|
|
* Valid = XLATE('OI_WIZARD', OIWizardId, 'VALID', 'X')
|
|
* Response = Valid
|
|
* end service
|
|
*
|
|
* Service DeleteAllRTFRecords()
|
|
* AllRTFRecord = Return_To_Fab_Services('GetAllReturnToFabRecords', False$)
|
|
* for each RTFRecordId in AllRTFRecord using @VM
|
|
* Database_Services('DeleteDataRow', 'RETURN_TO_FAB_LOTS', RTFRecordId, True$, False$)
|
|
* Next RTFRecordId
|
|
* end service
|
|
*
|
|
* Service GetWMORDSNos(WMOKeyId)
|
|
* debug
|
|
* //AllRDSNos = XLATE('WM_OUT',WMOutKeys,WM_OUT_RDS$,'X')
|
|
* Response = XLATE('WM_OUT',WMOKeyId,WM_OUT_RDS$,'X')
|
|
* end service
|
|
*
|
|
* Service SendShipDoc()
|
|
* debug
|
|
* ShipNo = 171117
|
|
* ShipNo = 171497
|
|
* ShipRec = Database_Services('ReadDataRow', 'COC', ShipNo)
|
|
* Print_Shipment_Dev(ShipNo,ShipRec,1)
|
|
* end service
|
|
*
|
|
* Service GetReactPMKeys()
|
|
* debug
|
|
* PMKeyList = Database_Services('ReadDataRow', 'SYSLISTS', 'REACT_PM_KEYS_TO_CHECK')
|
|
* Data = ''
|
|
* for i = 2 to DCOUNT(PMKEYLIST, @FM)
|
|
* thisId = PMKeyList<i>
|
|
* ReactorPMRec = Database_Services('ReadDataRow', 'REACTOR_PM', thisId)
|
|
* Reactor = ReactorPMRec<4>
|
|
* ReactorServId = ReactorPMRec<1>
|
|
* ServDesc = XLATE('REACT_SERVS', ReactorServId, 1, 'X')
|
|
* LineToAdd = Reactor : ',' : ServDesc : ',' : thisId : CRLF$
|
|
* Data := LineToAdd
|
|
* Next i
|
|
* OSWrite Data to 'C:\Users\mesouellette.INFINEON\Desktop\reactpms.csv'
|
|
* end service
|
|
*
|
|
* Service ClearEmailBox()
|
|
* debug
|
|
* emailList = Database_Services('ReadDataRow', 'SYSLISTS', 'EMAIL_RECS')
|
|
* for each email in emailList using @FM
|
|
* Database_Services('DeleteDataRow', 'EMAIL_BOX', email)
|
|
* Next email
|
|
* end service
|
|
*
|
|
* Service TestDelimiters()
|
|
* debug
|
|
* String = 'TWUPDATE|TW123456|2'
|
|
* Operation = Field(String, '|', 1)
|
|
* TWLotId = Field(String, '|', 2)
|
|
* TWLotQuantity = Field(String, '|', 3)
|
|
* end service
|
|
*
|
|
* Service SetupTestWaferProds()
|
|
* debug
|
|
* ProdIdList = Test_Wafer_Prod_Services('GetAllTestWaferProdIDs')
|
|
* for each ProdId in ProdIdList using @FM
|
|
* //Create TW_CREATE LotOperation Record
|
|
* TWCreateID = ProdId : '*TW_CREATE'
|
|
* TWProdOperationCreateRec = ''
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_PROD_ID$> = ProdID
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_ID$> = 'TW_CREATE'
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_SEQUENCE$> = 1
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_TEST_WAFER_PROD_ID$> = ProdId
|
|
* Database_Services('WriteDataRow', 'PRODUCT_OPERATION', TWCreateId, TWProdOperationCreateRec)
|
|
* //Create TW_READY_TO_USE LotOperation Record
|
|
* TWRTUID = ProdId : '*TW_READY_TO_USE'
|
|
* TWProdOperationCreateRec = ''
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_PROD_ID$> = ProdID
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_ID$> = 'TW_READY_TO_USE'
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_SEQUENCE$> = 2
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_TEST_WAFER_PROD_ID$> = ProdId
|
|
* Database_Services('WriteDataRow', 'PRODUCT_OPERATION', TWRTUID, TWProdOperationCreateRec)
|
|
* //Create TW_IN_USE LotOperation Record
|
|
* TWInUseId = ProdId : '*TW_IN_USE'
|
|
* TWProdOperationCreateRec = ''
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_PROD_ID$> = ProdID
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_ID$> = 'TW_IN_USE'
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_SEQUENCE$> = 3
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_TEST_WAFER_PROD_ID$> = ProdId
|
|
* Database_Services('WriteDataRow', 'PRODUCT_OPERATION', TWInUseId, TWProdOperationCreateRec)
|
|
* //Create TW_CLOSE LotOperation Record
|
|
* TWCloseId = ProdId : '*TW_CLOSE'
|
|
* TWProdOperationCreateRec = ''
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_PROD_ID$> = ProdID
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_ID$> = 'TW_CLOSE'
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_OPERATION_SEQUENCE$> = 4
|
|
* TWProdOperationCreateRec<PRODUCT_OPERATION_TEST_WAFER_PROD_ID$> = ProdId
|
|
* Database_Services('WriteDataRow', 'PRODUCT_OPERATION', TWCloseId, TWProdOperationCreateRec)
|
|
* Next ProdId
|
|
* end service
|
|
*
|
|
* Service TestLotNumberGeneration()
|
|
* LotNums = ''
|
|
* SRP_Stopwatch('Reset')
|
|
* SRP_Stopwatch('Start', 'LotNumGen')
|
|
* for i = 1 to 96
|
|
* LotNum = Lot_Services('GenerateNewLotId', 'TW')
|
|
* LotNums<1,-1> = LotNum
|
|
* Database_Services('WriteDataRow', 'LOT', LotNum, '')
|
|
* Next i
|
|
* SRP_Stopwatch('Stop', 'LotNumGen')
|
|
* debug
|
|
* Result = SRP_Stopwatch("GetBenchmark", "LotNumGen")
|
|
*
|
|
* end service
|
|
*
|
|
*
|
|
* Service UpdateICARRecs()
|
|
* debug
|
|
* ICARList = Database_Services('ReadDataRow', 'SYSLISTS', 'ICAR_UPDATE')
|
|
* For each IcarKey in ICARList using @FM
|
|
* ICARRec = Database_Services('ReadDataRow', 'ICAR', IcarKey)
|
|
* ThisShift = ICARRec<ICAR_SHIFT$>
|
|
* NewShift = ''
|
|
* Begin Case
|
|
* Case ThisShift = '1'
|
|
* NewShift = 'A'
|
|
* Case ThisShift = '2'
|
|
* NewShift = 'B'
|
|
* Case ThisShift = '3'
|
|
* NewShift = 'C'
|
|
* Case ThisShift = '4'
|
|
* NewShift = 'D'
|
|
* End Case
|
|
* If NewShift NE '' then
|
|
* ICARRec<ICAR_SHIFT$> = NewShift
|
|
* Database_Services('WriteDataRow', 'ICAR', IcarKey, ICARRec)
|
|
* end
|
|
* Next IcarKey
|
|
* end service
|
|
*
|
|
* Service UpdateNCRs()
|
|
* for i = 204484 to 204535
|
|
* NCRRecord = Database_Services('ReadDataRow', 'NCR', i)
|
|
* NCRRecordShift = NCRRecord<NCR_SHIFT$>
|
|
* NewNCRShift = ''
|
|
* Begin Case
|
|
* Case NCRRecordShift EQ 1
|
|
* NewNCRShift = 'A'
|
|
* Case NCRRecordShift EQ 2
|
|
* NewNCRShift = 'B'
|
|
* Case NCRRecordShift EQ 3
|
|
* NewNCRShift = 'C'
|
|
* Case NCRRecordShift EQ 4
|
|
* NewNCRShift = 'D'
|
|
* End Case
|
|
* NCRRecord<NCR_SHIFT$> = NewNCRShift
|
|
* Database_Services('WriteDataRow', 'NCR', i, NCRRecord)
|
|
* Next i
|
|
* end service
|
|
*
|
|
* Service FixWMOQAStatus()
|
|
* debug
|
|
* WOMatData = Database_Services('ReadDataRow', 'SYSLISTS', 'WMO_FIX_UP_QA')
|
|
* for each WOMatKey in WOMatData using @FM
|
|
* If RowExists('WO_MAT', WOMatKey) then
|
|
* WOMatRec = Database_Services('ReadDataRow', 'WO_MAT', WOMatKey)
|
|
* LastTranIndex = Dcount(WOMatRec<WO_MAT_INV_ACTION$>, @VM)
|
|
* LastInvWH = WOMatRec<WO_MAT_INV_WH$, LastTranIndex>
|
|
* LastInvLoc = WOMatRec<WO_MAT_INV_LOCATION$, LastTranIndex>
|
|
* LastInvAction = WOMatRec<WO_MAT_INV_ACTION$, LastTranIndex>
|
|
* //LastInvTag = WOMatRec<WO_MAT_INV_TAG$, LastTranIndex>
|
|
*
|
|
* NewIndex = LastTranIndex + 1
|
|
* WOMatRec<WO_MAT_INV_WH$, NewIndex> = LastInvWH
|
|
* WOMatRec<WO_MAT_INV_LOCATION$, NewIndex> = LastInvLoc
|
|
* WOMatRec<WO_MAT_INV_ACTION$, NewIndex> = LastInvAction
|
|
* //New Data
|
|
* WOMatRec<WO_MAT_INV_DTM$, NewIndex> = SRP_DateTime('Now')
|
|
* WOMatRec<WO_MAT_INV_USER$, NewIndex> = 'OI_ADMIN'
|
|
* WOMatRec<WO_MAT_INV_TAG$,NewIndex> = 'Duplicating Last Transaction to update Fabtime Reporting.'
|
|
* Database_Services('WriteDataRow', 'WO_MAT', WOMatKey, WOMatRec)
|
|
* end
|
|
* Next WOMatKey
|
|
*
|
|
* end service
|
|
*
|
|
* Service MatchOItoFabtime()
|
|
* OIRTSList = Database_Services('ReadDataRow', 'SYSLISTS', 'OI_RTS')
|
|
* FabtimeRTSList = Database_Services('ReadDataRow', 'SYSLISTS', 'FABTIME_RTS')
|
|
* MissingLots = ''
|
|
* for each WOMatKey in OIRTSList using @FM
|
|
* Locate WOMatKey in FabtimeRTSList using @FM setting iPos else
|
|
* MissingLot = ''
|
|
* MissingLot<1, 1> = WOMatKey
|
|
* InvDTMs = XLATE('WO_MAT', WoMatKey, 9, 'X')
|
|
* LastInvDtmIndex = Dcount(InvDTMs, @VM)
|
|
* LastInvDtm = InvDTMs<1,LastInvDtmIndex>
|
|
* MissingLot<1, 2> = Oconv(LastInvDtm, 'DT')
|
|
* MissingLots<-1> = MissingLot
|
|
* end
|
|
* Next WOMatKey
|
|
* swap @FM with CRLF$ in MissingLots
|
|
* swap @VM with ',' in MissingLots
|
|
* OSWrite MissingLots on 'C:\Users\mesouellette.INFINEON\Desktop\OIFabtimeRTSCompare.csv'
|
|
* end service
|
|
*
|
|
* Service GetCurrStatus(WOMatKey)
|
|
* Response = Xlate('WO_MAT', WOMatKey, 'CURR_STATUS', 'X')
|
|
* end service
|
|
*
|
|
* Service TestPrintingShipLabels(WONo, StepNo, CassNo)
|
|
* debug
|
|
* //Cassette1 variable is the cassette id, WMO Key for EPP and RDS for non epp
|
|
* //RDSType is either EPP or SIC. derives from whether it is a WMO key or an RDS key
|
|
* //EPP Input would be ex: 172123.1.23
|
|
* //Non-Epp Input would be ex: 1T456789
|
|
* ReactType = XLATE('WO_LOG', WONo, 67, 'X')
|
|
* If ReactType NE 'EPP' then
|
|
* WOMatKey = WONo : '*' : CassNo
|
|
* Cassette1 = Xlate('WO_MAT', WOMatKey, 12, 'X')
|
|
* RDSType = 'SIC'
|
|
* end else
|
|
* Cassette1 = WONo : '*1*' : CassNo
|
|
* RDSType = 'EPP'
|
|
* end
|
|
*
|
|
*
|
|
* Print_SAP_Cass_Ship_Label(WONo,StepNo,CassNo,Cassette1, RDSType)
|
|
* end service
|
|
*
|
|
* Service UpdateEPIParts()
|
|
* debug
|
|
* DataList = Database_Services('ReadDataRow', 'SYSLISTS', 'LIST_EPI_PART_SPECTRUM')
|
|
* for each EpiPart in DataList using @FM
|
|
* if RowExists('EPI_PART', EpiPart) then
|
|
* EpiPartRec = Database_Services('ReadDataRow', 'EPI_PART',EpiPart)
|
|
* EpiPartRec<EPI_PART_GENERATE_SPECTRUM_LABEL$> = True$
|
|
* Database_Services('WriteDataRow', 'EPI_PART', EpiPart, EpiPartRec)
|
|
* end
|
|
* Next EpiPart
|
|
* end service
|
|
*
|
|
* Service UpdateToVarmPartNumsSecond()
|
|
* debug
|
|
* DataList = Database_Services('ReadDataRow', 'SYSLISTS', 'AFFECTED_PSN_VARM')
|
|
* For each PSN in DataList using @FM
|
|
* PSNRec = Database_Services('ReadDataRow', 'PROD_SPEC', PSN)
|
|
* ProdVers = XLATE('PROD_SPEC', PSN, 'PROD_VER_NO', 'X')
|
|
* for each ProdVer in ProdVers using @VM
|
|
* ProdVerActive = XLATE('PROD_VER', ProdVer, 33, 'X')
|
|
* If ProdVerActive EQ 'A' then
|
|
* ProdVerEpiPartNo = XLATE('PROD_VER', ProdVer, 2, 'X')
|
|
* //Now Create a new Epi Part rec based on the VARM Part No
|
|
* CurrEpiPartRec = Database_Services('ReadDataRow', 'EPI_PART', ProdVerEpiPartNo)
|
|
* VMPartNumber = CurrEpiPartRec<EPI_PART_VARM_PART_NO$>
|
|
* If VMPartNumber NE ProdVerEpiPartNo AND VMPartNumber NE '' then
|
|
* NewEpiPartKey = VMPartNumber
|
|
* NewEpiPartRec = CurrEpiPartRec
|
|
* NewEpiPartRec<EPI_PART_VARM_DESCRIPTION$> = ProdVerEpiPartNo
|
|
* Database_Services('WriteDataRow', 'EPI_PART', NewEpiPartKey, NewEpiPartRec)
|
|
* //Now create new Customer Epi Part
|
|
* CustNo = XLATE('PROD_VER', ProdVer, PROD_VER_CUST_NO$, 'X')
|
|
* OldCustEpiPartKey = CustNo : '*' : ProdVerEpiPartNo
|
|
* NewCustEpiPartKey = CustNo : '*' : VMPartNumber
|
|
* OldCustEpiPartRec = Database_Services('ReadDataRow', 'CUST_EPI_PART', OldCustEpiPartKey)
|
|
*
|
|
* NewCustEpiPartRec = OldCustEpiPartRec
|
|
* NewCustEpiPartRec<CUST_EPI_PART_CUST_PART_NO$> = VMPartNumber
|
|
* Database_Services('WriteDataRow', 'CUST_EPI_PART', NewCustEpiPartKey, NewCustEpiPartRec)
|
|
*
|
|
* //Update Prod Ver to have the new VM Part Number
|
|
* ProdVerRec = Database_Services('ReadDataRow', 'PROD_VER', ProdVer)
|
|
* ProdVerRec<PROD_VER_EPI_PART_NO$> = VMPartNumber
|
|
* Database_Services('WriteDataRow', 'PROD_VER', ProdVer, ProdVerRec)
|
|
* UpdatePSNRec = Database_Services('ReadDataRow', 'PROD_SPEC', PSN)
|
|
* UpdatePSNRec = Insert(UpdatePSNRec, PROD_SPEC_CUST_PART_NO$, -1, 0, VMPartNumber)
|
|
* Database_Services('WriteDataRow', 'PROD_SPEC', PSN, UpdatePSNRec)
|
|
* end
|
|
* end
|
|
* Next ProdVer
|
|
* Next PSN
|
|
* end service
|
|
*
|
|
* Service UpdateSinglePSN(PSN)
|
|
* PSNRec = Database_Services('ReadDataRow', 'PROD_SPEC', PSN)
|
|
* ProdVers = XLATE('PROD_SPEC', PSN, 'PROD_VER_NO', 'X')
|
|
* for each ProdVer in ProdVers using @VM
|
|
* ProdVerActive = XLATE('PROD_VER', ProdVer, 33, 'X')
|
|
* If ProdVerActive EQ 'A' then
|
|
* ProdVerEpiPartNo = XLATE('PROD_VER', ProdVer, 2, 'X')
|
|
* //Now Create a new Epi Part rec based on the VARM Part No
|
|
* CurrEpiPartRec = Database_Services('ReadDataRow', 'EPI_PART', ProdVerEpiPartNo)
|
|
* VMPartNumber = CurrEpiPartRec<EPI_PART_VARM_PART_NO$>
|
|
* If VMPartNumber NE ProdVerEpiPartNo AND VMPartNumber NE '' then
|
|
* NewEpiPartKey = VMPartNumber
|
|
* NewEpiPartRec = CurrEpiPartRec
|
|
* NewEpiPartRec<EPI_PART_VARM_DESCRIPTION$> = ProdVerEpiPartNo
|
|
* Database_Services('WriteDataRow', 'EPI_PART', NewEpiPartKey, NewEpiPartRec)
|
|
* //Now create new Customer Epi Part
|
|
* CustNo = XLATE('PROD_VER', ProdVer, PROD_VER_CUST_NO$, 'X')
|
|
* OldCustEpiPartKey = CustNo : '*' : ProdVerEpiPartNo
|
|
* NewCustEpiPartKey = CustNo : '*' : VMPartNumber
|
|
* OldCustEpiPartRec = Database_Services('ReadDataRow', 'CUST_EPI_PART', OldCustEpiPartKey)
|
|
*
|
|
* NewCustEpiPartRec = OldCustEpiPartRec
|
|
* NewCustEpiPartRec<CUST_EPI_PART_CUST_PART_NO$> = VMPartNumber
|
|
* Database_Services('WriteDataRow', 'CUST_EPI_PART', NewCustEpiPartKey, NewCustEpiPartRec)
|
|
*
|
|
* //Update Prod Ver to have the new VM Part Number
|
|
* ProdVerRec = Database_Services('ReadDataRow', 'PROD_VER', ProdVer)
|
|
* ProdVerRec<PROD_VER_EPI_PART_NO$> = VMPartNumber
|
|
* Database_Services('WriteDataRow', 'PROD_VER', ProdVer, ProdVerRec)
|
|
* UpdatePSNRec = Database_Services('ReadDataRow', 'PROD_SPEC', PSN)
|
|
* UpdatePSNRec = Insert(UpdatePSNRec, PROD_SPEC_CUST_PART_NO$, -1, 0, VMPartNumber)
|
|
* Database_Services('WriteDataRow', 'PROD_SPEC', PSN, UpdatePSNRec)
|
|
* end
|
|
* end
|
|
* Next ProdVer
|
|
* end service
|
|
*
|
|
* Service UpdateToVarmPartNums()
|
|
* debug
|
|
* NewVarmMappingData = Database_Services('ReadDataRow', 'SYSLISTS', 'NEW_VARM_MAPPING')
|
|
*
|
|
* For each NewVarmMapping in NewVarmMappingData using @FM
|
|
* swap ',' with @VM in NewVarmMapping
|
|
* OldEpiPartNo = NewVarmMapping<1,1>
|
|
* NewEpiPartNo = NewVarmMapping<1,2>
|
|
*
|
|
* //Get Old Epi Part Rec
|
|
* OldEpiPartRec = Database_Services('ReadDataRow', 'EPI_PART', OldEpiPartNo)
|
|
* //Add the old part number in the description
|
|
* OldEpiPartRec<EPI_PART_VARM_DESCRIPTION$> = OldEpiPartNo
|
|
* //Write the OldEpiPartRec
|
|
* Database_Services('WriteDataRow', 'EPI_PART', OldEpiPartNo, OldEpiPartRec)
|
|
*
|
|
* //Get Fresh version of old record
|
|
* NewEpiPartRec = Database_Services('ReadDataRow', 'EPI_PART', OldEpiPartNo, True$, 0)
|
|
* //Write new record with new VARM Part #
|
|
* Database_Services('WriteDataRow', 'EPI_PART', NewEpiPartNo, NewEpiPartRec)
|
|
*
|
|
* //Get Old Customer Epi Part Key
|
|
* OldCustEpiPartkEY = NewEpiPartRec<EPI_PART_CUST_EPI_PART_KEY$, 1>
|
|
* //Get Old Customer Epi Part Rec
|
|
* OldCustEpiPartRec = Database_Services('ReadDataRow', 'CUST_EPI_PART', OldCustEpiPartkEY)
|
|
* NewCustEpiPartKey = OldCustEpiPartkEY
|
|
* swap OldEpiPartNo with NewEpiPartNo in NewCustEpiPartKey
|
|
* NewCustEpiPartRec = OldCustEpiPartRec
|
|
* NewCustEpiPartRec<CUST_EPI_PART_CUST_PART_NO$> = NewEpiPartNo
|
|
* Database_Services('WriteDataRow', 'EPI_PART', NewCustEpiPartKey, NewCustEpiPartRec)
|
|
*
|
|
* //Update Prod ver record with the new Epi Part Number.
|
|
* CurrProdVerKey = NewEpiPartRec<EPI_PART_PROD_VER_NO$>
|
|
* CurrProdVerRec = Database_Services('ReadDataRow', 'PROD_VER', CurrProdVerKey)
|
|
* CurrProdVerRec<PROD_VER_EPI_PART_NO$> = NewEpiPartNo
|
|
* Database_Services('WriteDataRow', 'PROD_VER', CurrProdVerKey, CurrProdVerRec)
|
|
*
|
|
*
|
|
* swap ',' with @VM in NewVarmMapping
|
|
* EpiPartNo = NewVarmMapping<1,1>
|
|
* NewVarmPartNum = NewVarmMapping<1,2>
|
|
* EpiPartRec = Database_Services('ReadDataRow', 'EPI_PART', EpiPartNo)
|
|
* EpiPartRec<EPI_PART_VARM_PART_NO$> = NewVarmPartNum
|
|
* Database_Services('WriteDataRow', 'EPI_PART', EpiPartNo, EpiPartRec)
|
|
* Next NewVarmMapping
|
|
*
|
|
* end service
|
|
*
|
|
* Service UpdateVARmPartMapping()
|
|
* debug
|
|
* NewVarmMappingData = Database_Services('ReadDataRow', 'SYSLISTS', 'NEW_VARM_MAPPING')
|
|
*
|
|
* For each NewVarmMapping in NewVarmMappingData using @FM
|
|
* swap ',' with @VM in NewVarmMapping
|
|
* EpiPartNo = NewVarmMapping<1,1>
|
|
* NewVarmPartNum = NewVarmMapping<1,2>
|
|
* EpiPartRec = Database_Services('ReadDataRow', 'EPI_PART', EpiPartNo)
|
|
* EpiPartRec<EPI_PART_VARM_PART_NO$> = NewVarmPartNum
|
|
* Database_Services('WriteDataRow', 'EPI_PART', EpiPartNo, EpiPartRec)
|
|
* Next NewVarmMapping
|
|
* end service
|
|
*
|
|
* Service GetRDSwithMultipleRDSTestKeys()
|
|
* debug
|
|
* LotsWithBadRDSTestKeys = ''
|
|
* RDSList = Database_Services('ReadDataRow', 'SYSLISTS', 'TEST_JONATHAN')
|
|
* for each RDS in RDSList using @FM setting rPos
|
|
* RDSLayerKeys = XLATE('REACT_RUN', RDS, 5, 'X')
|
|
* for each RDSLayerKey in RDSLayerKeys using @Fm
|
|
* RDSTestKeys = XLATE('RDS_LAYER', RDSLayerKey, 3, 'X')
|
|
* IF Dcount(RDSTestKeys, @VM) GE 2 then
|
|
* LotsWithBadRDSTestKeys<-1> = RDSLayerKey
|
|
* end
|
|
* Next RDSLayerKey
|
|
* Next RDS
|
|
* end service
|
|
*
|
|
* Service GetWOMatRepStatus()
|
|
* debug
|
|
* WONo = 173078
|
|
* CassNo = 5
|
|
* ID = WONo : '*' : CassNo
|
|
* WOMatRec = Database_Services('ReadDataRow', 'WO_MAT', ID)
|
|
* test = obj_WO_Mat('ReportStatus',ID:@RM:WOMatRec)
|
|
* end service
|
|
*
|
|
* Service GetWMOutRepStatus()
|
|
* debug
|
|
* WONo = 173078
|
|
* CassNo = 5
|
|
* RepStatus = XLATE('WO_MAT',WONo:'*':CassNo,'REP_STATUS','X')[-1,'B':@VM]
|
|
* IF RepStatus = '' OR RepStatus[1,3] NE 'WMO' THEN
|
|
* CurrStatus = Jonathan_Services('GetWMOutCurrStatus')
|
|
* test = OCONV(CurrStatus,'[WM_OUT_CURR_STATUS_CONV]')
|
|
* end else
|
|
* test = RepStatus
|
|
* END
|
|
* end service
|
|
*
|
|
* Service GetWMOutCurrStatus()
|
|
* debug
|
|
* RecID = '173078*1*5'
|
|
* Record = Database_Services('ReadDataRow', 'WM_OUT', RecID)
|
|
* CurrStatus = OBJ_WM_OUT('CurrStatus', RecID:@RM:Record)
|
|
* Response = CurrStatus
|
|
* end service
|
|
*
|
|
* Service Get5SType()
|
|
* Datalist = Database_Services('ReadDataRow', 'SYSLISTS', 'TEST_JONATHAN')
|
|
* PMSpecs = ''
|
|
* for each data in datalist using @FM setting iPos
|
|
* PMSpecs<iPos, 1> = data
|
|
* Is5S = Xlate('PM_SPEC', data, PM_SPEC_FIVE_S_FLAG$, 'X')
|
|
* PMSpecs<iPos, 2> = Is5S
|
|
* Next data
|
|
* debug
|
|
* end service
|
|
*
|
|
* Service TestLogging()
|
|
* Headers = 'Logging DTM' : @FM : 'Machine' : @FM : 'Log'
|
|
* ColumnWidths = 20 : @FM : 15 : @FM : 300
|
|
* LogPath = Environment_Services('GetApplicationRootPath') : '\LogFiles\JonathansTest'
|
|
* LogDate = Oconv(Date(), 'D4/')
|
|
* LogFileName = LogDate[7, 4] : '-' : LogDate[1, 2] : '-' : LogDate[4, 2] : '_ReactorLogPM.csv'
|
|
* objLog = Logging_Services('NewLog', LogPath, LogFileName, CRLF$, ' ', Headers, ColumnWidths, False$, False$)
|
|
*
|
|
* LogData = ''
|
|
* LogData<1> = ''
|
|
* LogData<2> = ''
|
|
* LogData<3> = 'This is a test'
|
|
* Logging_Services('AppendLog', objLog, LogData, @RM, @FM, False$)
|
|
* end service
|
|
*
|
|
*
|
|
* Service UpdateYesterdayAvail()
|
|
* Today = 20702
|
|
* DataArray = ''
|
|
* //ASM Reactors
|
|
* ASMRecordKey = 'ASM*': Today
|
|
* ASMUptimeRec = Reactor_Services('GetReactorUptimeMetricsByTypeAndTimeSpan', Today, Today + 1, 'ASM')
|
|
* Database_Services('WriteDataRow', 'REACTOR_DAILY_UPTIME', ASMRecordKey, ASMUptimeRec, True$, False$, True$)
|
|
* //HTR Reactors
|
|
* HTRRecordKey = 'HTR*': Today
|
|
* HTRUptimeRec = Reactor_Services('GetReactorUptimeMetricsByTypeAndTimeSpan', Today, Today + 1, 'HTR')
|
|
* Database_Services('WriteDataRow', 'REACTOR_DAILY_UPTIME', HTRRecordKey, HTRUptimeRec, True$, False$, True$)
|
|
* //EPP Reactors
|
|
* EPPRecordKey = 'EPP*': Today
|
|
* EPPUptimeRec = Reactor_Services('GetReactorUptimeMetricsByTypeAndTimeSpan', Today, Today + 1, 'EPP')
|
|
* Database_Services('WriteDataRow', 'REACTOR_DAILY_UPTIME', EPPRecordKey, EPPUptimeRec, True$, False$, True$)
|
|
* //All Reactors
|
|
* ALLRecordKey = 'ALL*': Today
|
|
* ALLUptimeRec = Reactor_Services('GetReactorUptimeMetricsByTypeAndTimeSpan', Today, Today + 1, 'ALL')
|
|
* Database_Services('WriteDataRow', 'REACTOR_DAILY_UPTIME', ALLRecordKey, ALLUptimeRec, True$, False$, True$)
|
|
* end service
|
|
*
|
|
*
|
|
*
|
|
* Service SetReactorMetrics()
|
|
* Reactors = Reactor_Services('GetReactorNumbers')
|
|
* table = 'REACTOR_LOG'
|
|
* for each ReactorNo in Reactors using @FM setting rPos
|
|
* LatestTubeChangeRLIDASM = ''
|
|
* LatestTubeChangeASMDTM = ''
|
|
* LatestSuscChangRLIDASM = ''
|
|
* LatestArmChangeIDASM = ''
|
|
* LatestSuscChangRLIDHTR = ''
|
|
* LatestArmChangeIDHTR = ''
|
|
* ReactorType = XLATE('REACTOR', ReactorNo, REACTOR_REACT_TYPE$, 'X')
|
|
*
|
|
* //Reset all metrics to 0
|
|
* ReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
* ReactorRec<REACTOR_SUSC_THK$> = 0;
|
|
* ReactorRec<REACTOR_SUSC_WFR_CNT$> = 0;
|
|
* ReactorRec<REACTOR_TUBE_BELL_JAR_THK$> = 0;
|
|
* ReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = 0;
|
|
* ReactorRec<REACTOR_LOWER_QUARTZ_THK$> = 0;
|
|
* ReactorRec<REACTOR_LOWER_QUARTZ_WFR$> = 0;
|
|
* ReactorRec<REACTOR_ARMS_WFR_CNT$> = 0;
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, ReactorRec)
|
|
*
|
|
*
|
|
* Begin Case
|
|
* Case ReactorType EQ 'ASM' OR ReactorType EQ 'ASM+'
|
|
* //Susceptor 699
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '699')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
*
|
|
* CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
|
|
* CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
|
|
* CurrSuscThk = OldReactorRec<REACTOR_SUSC_THK$>
|
|
* CurrSuscWfrCnt = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
|
|
* CurrLowerQuartzThk = OldReactorRec<REACTOR_LOWER_QUARTZ_THK$>
|
|
* CurrLowerQuartzWfr = OldReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrTubeBellJarThk = '' then CurrTubeBellJarThk = 0
|
|
* If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
|
|
* If CurrSuscThk = '' then CurrSuscThk = 0
|
|
* If CurrSuscWfrCnt = '' then CurrSuscWfrCnt = 0
|
|
* If CurrLowerQuartzThk = '' then CurrLowerQuartzThk = 0
|
|
* If CurrLowerQuartzWfr = '' then CurrLowerQuartzWfr = 0
|
|
*
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* WaferCount = XLATE('RDS', RDSNo, RDS_WAFERS_IN$, 'X')
|
|
* ThkAddition = WaferCount * TargetThickness
|
|
* NewReactorRec = OldReactorRec
|
|
* NewReactorRec<REACTOR_SUSC_THK$> = CurrSuscThk + ThkAddition
|
|
* NewReactorRec<REACTOR_SUSC_WFR_CNT$> = CurrSuscWfrCnt + WaferCount
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
*
|
|
* //TubeChange 240
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '240')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
*
|
|
* CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
|
|
* CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrTubeBellJarThk = '' then CurrTubeBellJarThk = 0
|
|
* If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
|
|
*
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* WaferCount = XLATE('RDS', RDSNo, RDS_WAFERS_IN$, 'X')
|
|
* ThkAddition = WaferCount * TargetThickness
|
|
* NewReactorRec = OldReactorRec
|
|
* NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$> = CurrTubeBellJarThk + ThkAddition
|
|
* NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + WaferCount
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
* //Arms 21
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '21')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
* CurrArmsWfrCnt = OldReactorRec<REACTOR_ARMS_WFR_CNT$>
|
|
* If CurrArmsWfrCnt = '' then CurrArmsWfrCnt = 0
|
|
* RDSNo = RDSRow<1,1>
|
|
* WaferCount = XLATE('RDS', RDSNo, RDS_WAFERS_IN$, 'X')
|
|
* NewReactorRec = OldReactorRec
|
|
* NewReactorRec<REACTOR_ARMS_WFR_CNT$> = CurrArmsWfrCnt + WaferCount
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
* Case ReactorType EQ 'HTR'
|
|
* //Susceptor 699
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '699')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
*
|
|
* CurrSuscThk = OldReactorRec<REACTOR_SUSC_THK$>
|
|
* CurrSuscWfrCnt = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrSuscThk = '' then CurrSuscThk = 0
|
|
* If CurrSuscWfrCnt = '' then CurrSuscWfrCnt = 0
|
|
*
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* WaferCount = XLATE('RDS', RDSNo, RDS_WAFERS_IN$, 'X')
|
|
* CntAddition = (WaferCount / 5)
|
|
* ThkAddition = (WaferCount / 5) * TargetThickness
|
|
* NewReactorRec = OldReactorRec
|
|
* NewReactorRec<REACTOR_SUSC_THK$> = CurrSuscThk + ThkAddition
|
|
* NewReactorRec<REACTOR_SUSC_WFR_CNT$> = CurrSuscWfrCnt + CntAddition
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
*
|
|
* //TubeChange 1280
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '1280')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
*
|
|
* CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
|
|
* CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrTubeBellJarThk = '' then CurrTubeBellJarThk = 0
|
|
* If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
|
|
*
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* WaferCount = XLATE('RDS', RDSNo, RDS_WAFERS_IN$, 'X')
|
|
* CntAddition = (WaferCount / 5)
|
|
* ThkAddition = (WaferCount / 5) * TargetThickness
|
|
* NewReactorRec = OldReactorRec
|
|
* NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$> = CurrTubeBellJarThk + ThkAddition
|
|
* NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + CntAddition
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
*
|
|
* //Arms 21
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '21')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
* CurrArmsWfrCnt = OldReactorRec<REACTOR_ARMS_WFR_CNT$>
|
|
* If CurrArmsWfrCnt = '' then CurrArmsWfrCnt = 0
|
|
* RDSNo = RDSRow<1,1>
|
|
* WaferCount = XLATE('RDS', RDSNo, RDS_WAFERS_IN$, 'X')
|
|
* NewReactorRec = OldReactorRec
|
|
* NewReactorRec<REACTOR_ARMS_WFR_CNT$> = CurrArmsWfrCnt + WaferCount
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
*
|
|
* Case ReactorType EQ 'EPP'
|
|
*
|
|
* //BellJar 1092
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '1092')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
*
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* NewReactorRec = OldReactorRec
|
|
* CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
|
|
* CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrTubeBellJarThk = '' then CurrTubeBellJarThk = 0
|
|
* If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
|
|
* NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$> = CurrTubeBellJarThk + TargetThickness
|
|
* NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + 1
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
*
|
|
*
|
|
* //1067 Lower Quartz
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '1067')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
*
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* NewReactorRec = OldReactorRec
|
|
* CurrLowerQuartzThk = OldReactorRec<REACTOR_LOWER_QUARTZ_THK$>
|
|
* CurrLowerQuartzCnt = OldReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrLowerQuartzThk = '' then CurrLowerQuartzThk = 0
|
|
* If CurrLowerQuartzCnt = '' then CurrLowerQuartzCnt = 0
|
|
* NewReactorRec<REACTOR_LOWER_QUARTZ_THK$> = CurrLowerQuartzThk + TargetThickness
|
|
* NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$> = CurrLowerQuartzCnt + 1
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
*
|
|
* //699 Susceptor
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '699')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
*
|
|
* for each RDSRow in RDSList using @FM
|
|
* OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
|
|
* RDSNo = RDSRow<1,1>
|
|
* TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
|
|
* TargetThickness = OConv(TargetThickness, 'MD3')
|
|
* NewReactorRec = OldReactorRec
|
|
* CurrSuscThk = OldReactorRec<REACTOR_SUSC_THK$>
|
|
* CurrSuscCnt = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
|
|
*
|
|
* // Set values to 0 if blank
|
|
* If CurrSuscThk = '' then CurrSuscThk = 0
|
|
* If CurrSuscCnt = '' then CurrSuscCnt = 0
|
|
* NewReactorRec<REACTOR_SUSC_THK$> = CurrSuscThk + TargetThickness
|
|
* NewReactorRec<REACTOR_SUSC_WFR_CNT$> = CurrSuscCnt + 1
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* Next RDSRow
|
|
* LatestSusceptorChangeRLID = Reactor_Log_Services('GetLogsByReactorAndServID', ReactorNo, '699')<1,4>
|
|
* RLDTM = XLATE('REACTOR_LOG', LatestSusceptorChangeRLID, 'END_DTM', 'X')
|
|
* RDSList = Reactor_Services('GetReactorCassLoadHistoryRange', ReactorNo, RLDTM, SRP_Datetime('Now'))
|
|
* NewReactorRec<REACTOR_SUSC_THK$> = CurrSuscThk + TargetThickness
|
|
* NewReactorRec<REACTOR_SUSC_WFR_CNT$> = CurrSuscWfrCnt + 1
|
|
* Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec)
|
|
* End Case
|
|
* Next ReactorNo
|
|
* end service
|
|
*
|
|
* Service LaunchWindow()
|
|
* Start_Window('NDW_VIEW_TEST_RUN','', '10000001')
|
|
* end service
|
|
*
|
|
* Service GetTestRunObj(TestRunID)
|
|
* debug
|
|
* TestRunObj = ''
|
|
* TestRunRec = Test_Run_Services('GetTestRunById', TestRunID)
|
|
* //Start getting translated values for object
|
|
* RunDTM = OConv(TestRunRec<TEST_RUN_RUN_DTM$>, 'DT')
|
|
* ReasonForTest = Xlate('TEST_RUN_TYPE', TestRunRec<TEST_RUN_RUN_TYPE_ID$>, TEST_RUN_TYPE_RUN_TYPE$, 'X')
|
|
* RelatedRDS = TestRunRec<TEST_RUN_RDS_ID$>
|
|
* RelatedPSN = TestRunRec<TEST_RUN_PROD_SPEC_ID$>
|
|
* EqpType = TestRunRec<TEST_RUN_EQUIPMENT_TYPE$>
|
|
* EqpID = TestRunRec<TEST_RUN_EQUIPMENT_ID$>
|
|
* TWKeys = TestRunRec<TEST_RUN_TEST_RUN_WAFER_IDS$>
|
|
* TWUsageProds = ''
|
|
* TWUsageQtys = ''
|
|
* for each TWKey in TWKeys using @VM setting tPos
|
|
* TRWRec = Test_Run_Services('GetTestRunWaferByID', TWKey)
|
|
* TestWaferProdName = XLATE('TEST_WAFER_PROD', TRWRec<TEST_RUN_WAFER_TEST_WAFER_PROD_ID$>, TEST_WAFER_PROD_PART_NAME$, 'X')
|
|
* Locate TestWaferProdName in TWUsageProds setting iPos then
|
|
* TWUsageProds<1,iPos> = TestWaferProdName
|
|
* TWUsageQtys<1,iPos> = TWUsageQtys<1,iPos> + 1
|
|
* end else
|
|
* TWUsageProds<1,-1> = TestWaferProdName
|
|
* TWUsageQtys<1,-1> = 1
|
|
* end
|
|
* Next TWKey
|
|
* end service
|
|
*
|
|
* Service WFR_STATUS(WMOKey)
|
|
*
|
|
* Result = ''
|
|
* WfrStatus = ''
|
|
* WMOSlots = Xlate('WM_OUT', WMOKey, 'RDS', 'X')
|
|
* WMOZoneProfile = Xlate('WM_OUT', WMOKey, WM_OUT_ZONE$, 'X')
|
|
* WMORDSTestKeys = XLATE('WM_OUT', WMOKey, 'CASS_RDS_MET_KEYS', 'X')
|
|
* for each RDSNo in WMOSlots using @VM setting sPos
|
|
*
|
|
* ReactRunRec = Database_Services('ReadDataRow', 'REACT_RUN', RDSNo)
|
|
* SlotZone = Xlate('WM_OUT', WMOKey, WM_OUT_ZONE$, 'X')<1, sPos>
|
|
* //Get the RDS_Test for this slot.
|
|
* //Find the right RDS Test Key
|
|
* ThisSlotRDSTestKeys = ''
|
|
* for each RDSTestKey in WMORDSTestKeys using @VM
|
|
* RDSTestRec = Database_Services('ReadDataRow', 'RDS_TEST', RDSTestKey)
|
|
* If RDSTestRec<RDS_TEST_ZONE$> EQ SlotZone AND RDSTestRec<RDS_TEST_RDS_NO$> EQ RDSNo then
|
|
* ThisSlotRDSTestKeys<1, -1> = RDSTestKey
|
|
*
|
|
* end
|
|
*
|
|
* Next RDSTestKey
|
|
* RDSTestDataEntered = XLATE('RDS_TEST', ThisSlotRDSTestKeys, 'MET_ENTERED', 'X')
|
|
* If RDSTestDataEntered NE '' then
|
|
* Locate False$ in RDSTestDataEntered using @VM setting iPos then Result = 'ULMET' else
|
|
* MetOutOfSpec = Sum(Xlate('RDS_TEST', ThisSlotRDSTestKeys, 'OUT_OF_SPEC', 'X'))
|
|
* If MetOutOfSpec then
|
|
* //Check for an NCR
|
|
* SlotNcr = Xlate('WM_OUT', WMOKey, 'WM_OUT_SLOT_NCR', 'X')<1, sPos>
|
|
* If SlotNcr NE '' then
|
|
* MetOutOfSpec = False$
|
|
* end
|
|
* end
|
|
* If MetOutOfSpec then
|
|
* Result = 'SPEC'
|
|
* end else
|
|
* Result = 'ULOAD'
|
|
* end
|
|
* end
|
|
* end else
|
|
* Result = 'ULMET'
|
|
* end
|
|
*
|
|
* WfrStatus<sPos> = Result
|
|
* Next RDSNo
|
|
* debug
|
|
* end service
|
|
*
|
|
* Service Test()
|
|
* Debug
|
|
* RDSTestKeys = XLATE('WM_OUT', '172172*1*10', 'CASS_RDS_MET_KEYS', 'X')
|
|
* TestDataEntered = XLATE('RDS_TEST', RDSTestKeys, 'MET_ENTERED', 'X')
|
|
* //WMOWafers = XLATE('WM_OUT', '172172*1*10', 'WFR_STATUS', 'X')
|
|
* end service
|
|
*
|
|
* Service TestEquates()
|
|
* debug
|
|
* test = WO_MAT_MAKEUP_BOX$
|
|
* end service
|
|
*
|
|
* Service GetWWInfo()
|
|
* debug
|
|
* WWInfo = Date_Services('GetWeekNum', '20345.12345')
|
|
* end service
|
|
*
|
|
* Service PMINformation()
|
|
*
|
|
* end service
|
|
*
|
|
* Service RGBToInt()
|
|
* debug
|
|
* R = 242
|
|
* G = 156
|
|
* B = 63
|
|
* IntegerVal = (B * 65536) + (G * 256) + R
|
|
* end service
|
|
*
|
|
* Service TestPMMFS()
|
|
* Debug
|
|
*
|
|
* PMRec = Database_Services('ReadDataRow', 'PM', '10115')
|
|
* Late = XLATE('PM', '10115', 'LATE', 'X')
|
|
* SchedQty = XLATE('PM_SPEC', PMRec<PM_PMS_ID$>, 'LATE_START_QTY', 'X')
|
|
* CompQty = PMRec<PM_COMP_QTY$>
|
|
*
|
|
* end service
|
|
*
|
|
* Service AddComments()
|
|
* debug
|
|
* Response = Dialog_Box('NDW_ADD_COMMENT', @WINDOW)
|
|
* end service
|
|
*
|
|
* Service Get5SPMs()
|
|
* test = Pm_Services('Get5SPMs', True$)
|
|
* end service
|
|
*
|
|
*
|
|
* Service GetOnShiftSupervisor()
|
|
* debug
|
|
* Response = Lsl_Users_Services('GetShiftByDate', '8/23/2023 06:00')
|
|
* end service
|
|
*
|
|
* Service TriggerCassComp(WOMatKey)
|
|
* debug
|
|
* SAP_Services('AddCassCompTransaction', WOMatKey)
|
|
* end service
|
|
*
|
|
* Service TestGRProps(WOMatKey)
|
|
* *172174
|
|
* *1
|
|
* debug
|
|
* WOMatRec = Database_Services('ReadDataRow', 'WO_MAT', WOMatKey)
|
|
* GRProps = obj_WO_Mat('GetGRProps',WOMatKey:@RM:WOMatRec)
|
|
*
|
|
* end service
|
|
*
|
|
* Service TriggerScrap(WorkOrderNo, CassNo, TransQty)
|
|
* //172172
|
|
* //1
|
|
* //2
|
|
* obj_SAP('AddTransaction','SCRAP_IN':@RM:WorkOrderNo:@RM:CassNo:@RM:TransQty)
|
|
* end service
|
|
*
|
|
* Service TriggerBatchMove
|
|
*
|
|
* end service
|
|
*
|
|
* Service TestOEE
|
|
* keyId = '20259*35*5117*U442'
|
|
* stopDTM = XLATE('DAILY_PERFORMANCE_REPORT', keyId, 'STOP_DTM', 'X')
|
|
* OEE = XLATE('DAILY_PERFORMANCE_REPORT', keyId, 'OEE_CALCULATION', 'X')
|
|
* Response = OEE
|
|
* end service
|
|
*
|
|
* Service TestZero()
|
|
* debug
|
|
* ShouldBeZero = 1 - 1
|
|
* end service
|
|
*
|
|
* Service IsRDSMetOutOfSpec(RDSNo)
|
|
* debug
|
|
* *RDSNo = '586181'
|
|
* RDSRec = Database_Services('ReadDataRow', 'RDS', RDSNo)
|
|
* RDSWaferZones = RDSRec<RDS_ZONE$>
|
|
* ReactorType = Xlate('RDS', RDSNo, 'REACTOR_TYPE', 'X')
|
|
* IsEpiPro = Xlate('RDS', RDSNo, 'REACTOR_TYPE', 'X') EQ 'EPP'
|
|
* LSKeys = XLATE('REACT_RUN',RDSNo, REACT_RUN_RDS_LAYER_KEYS$, 'X')
|
|
* for each LayerSpecKey in LSKeys using @VM setting lPos
|
|
* LSRec = Database_Services('ReadDataRow', 'RDS_LAYER', LayerSpecKey)
|
|
* IsMetOOS = XLATE('RDS_LAYER',LayerSpecKey,'TEST_OUT_OF_SPEC','X')<1, lPos>
|
|
* IF IsMetOOS then
|
|
* If IsEpiPro then
|
|
* RDSTestKey = LSRec<RDS_LAYER_RDS_TEST_KEYS$, lPos>
|
|
* RDSTestZone = XLate('RDS_TEST', RDSTestKey, RDS_TEST_ZONE$, 'X')
|
|
* RDSTestLayer = XLate('RDS_TEST', RDSTestKey, RDS_TEST_LS_ID$, 'X')
|
|
* WafersInZone = ''
|
|
*
|
|
* for each WaferZone in RDSWaferZones using @VM setting wPos
|
|
* If WaferZone EQ RDSTestZone then
|
|
* WafersInZone<-1> = wPos
|
|
* end
|
|
* Next WaferZone
|
|
* Response = RDSTestLayer : ' Zone ' : RDSTestZone : ' Out of Spec'
|
|
* end else
|
|
* Response = 'Out of Spec'
|
|
* end
|
|
* end
|
|
*
|
|
* Next LayerSpec
|
|
* TestOutOfSpec = XLATE('RDS_LAYER',LSKeys,'TEST_OUT_OF_SPEC','X')
|
|
* MetOutOfSpec = SUM(XLATE('RDS_LAYER',LSKeys,'TEST_OUT_OF_SPEC','X'))
|
|
*
|
|
*
|
|
*
|
|
* end service
|
|
*
|
|
*
|
|
* Service TestCOMB_Status()
|
|
* debug
|
|
*
|
|
*
|
|
* RDSNo = '586181'
|
|
* RDSWOMatKey = XLATE('RDS', RDSNo, 'WO_MAT_KEY', 'X')
|
|
* WOMatRepStatus = XLATE('WO_MAT',RDSWOMatKey,'REP_STATUS','X')
|
|
* RunStatus = XLATE('REACT_RUN',RDSNo,'RUN_STATUS','X')
|
|
* RunStatus = OCONV(RunStatus,'[RUN_STATUS_CONV]')
|
|
* Ans = ''
|
|
* BEGIN CASE
|
|
* CASE WOMatRepStatus NE '' AND RunStatus NE ''
|
|
* Ans = WOMatRepStatus
|
|
*
|
|
* CASE WOMatRepStatus = '' AND RunStatus NE ''
|
|
* Ans = RunStatus
|
|
*
|
|
* CASE WOMatRepStatus NE '' AND RunStatus = ''
|
|
* Ans = WOMatRepStatus
|
|
*
|
|
* CASE 1
|
|
* Ans = ''
|
|
* END CASE
|
|
* CombStatus = Xlate('RDS', RDSNo, 'COMB_STATUS', 'X')
|
|
* Response = CombStatus
|
|
* end service
|
|
*
|
|
* Service TestChatGPT()
|
|
* Stop
|
|
* end service
|
|
*
|
|
* Service getWOMat()
|
|
* debug
|
|
* effectedCassettes = ''
|
|
* for WONo = 171809 to 172010
|
|
* for CassNo = 1 to 99
|
|
* WOMatKey = WONo : '*' : CassNo
|
|
* WOMatQaRec = Database_Services('ReadDataRow', 'WO_MAT_QA', WOMatKey)
|
|
* Profiles = WOMatQaRec<WO_MAT_QA_PROFILE$>
|
|
* DataPoints = WOMatQARec<WO_MAT_QA_DATA_POINTS$>
|
|
* For each Profile in Profiles using @VM setting ProfIndex
|
|
* If Profile EQ '1THICK_ONLY' then
|
|
*
|
|
* List = DataPoints<1, ProfIndex>
|
|
* IF DCOUNT(List, @SVM) LT 5 AND DCOUNT(List, @SVM) GT 0 then
|
|
* debug
|
|
* EffectedCassettes<-1> = WOMatKey : ',' : XLATE('WO_MAT', WOMatKey, 'RDS_NO', 'X') : CRLF$
|
|
* end
|
|
* end
|
|
*
|
|
* Next Profile
|
|
*
|
|
*
|
|
* Next CassNo
|
|
* Next WONo
|
|
* OSWrite effectedCassettes To 'C:\users\ecouellette\desktop\effectedCassettes.csv'
|
|
* end service
|
|
*
|
|
* Service ChangeCustNoByWO(WONo, NewCustNo, NewProdVerNo, NewPSNo)
|
|
* // Update WO_LOG record
|
|
* WOLogRec = Database_Services('ReadDataRow', 'WO_LOG', WONo)
|
|
* If Error_Services('NoError') then
|
|
* WOLogRec<WO_LOG_CUST_NO$> = NewCustNo
|
|
* WOLogRec<WO_LOG_PROD_VER_NO$> = NewProdVerNo
|
|
* Database_Services('WriteDataRow', 'WO_LOG', WONo, WOLogRec, True$, False$, True$)
|
|
* If Error_Services('NoError') then
|
|
* WOStepKey = WONo:'*1'
|
|
* // Update WO_STEP record
|
|
* WOStepRec = Database_Services('ReadDataRow', 'WO_STEP', WOStepKey)
|
|
* If Error_Services('NoError') then
|
|
* WOStepRec<WO_STEP_PROD_SPEC_ID$> = NewPSNo
|
|
* Database_Services('WriteDataRow', 'WO_STEP', WOStepKey, WOStepRec, True$, False$, True$)
|
|
* If Error_Services('NoError') then
|
|
* // Update RDS Keys
|
|
* RDSKeys = Xlate('WO_STEP', WOStepKey, 'RDS_KEY', 'X')
|
|
* If RDSKeys NE '' then
|
|
* For each RDSKey in RDSKeys using @VM setting vPos
|
|
* RDSRec = Database_Services('ReadDataRow', 'RDS', RDSKey)
|
|
* If Error_Services('NoError') then
|
|
* RDSRec<RDS_CUST_NO$> = NewCustNo
|
|
* RDSRec<RDS_PROD_SPEC_ID$> = NewPSNo
|
|
* Database_Services('WriteDataRow', 'RDS', RDSKey, RDSRec, True$, False$, True$)
|
|
* end
|
|
* Until Error_Services('HasError')
|
|
* Next RDSKey
|
|
* end
|
|
* end
|
|
* end
|
|
* end
|
|
* end
|
|
* If Error_Services('HasError') then
|
|
* Error_Services('DisplayError')
|
|
* end
|
|
*
|
|
* return
|
|
* end service
|
|
*
|
|
* Service GetRDSMovesByDays(Day, FilePath)
|
|
*
|
|
* SelectSent = 'SELECT RDS WITH DATE_OUT EQ ':QUOTE(Day)
|
|
* Set_Status(0)
|
|
* RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
|
|
*
|
|
*
|
|
* rdsArray = ''
|
|
* IF @RecCount then
|
|
* EoF = 0
|
|
* NumKeys = @RecCount
|
|
* Cnt = 0
|
|
*
|
|
* Loop
|
|
* ReadNext rds Else EoF = 1
|
|
* until EoF
|
|
* rdsMoves = XLATE('RDS', rds, 'WAFERS_IN', 'X')
|
|
* rdsArray := rds : ',' : rdsMoves : CRLF$
|
|
* Repeat
|
|
*
|
|
* end
|
|
* OSWrite rdsArray to FilePath
|
|
* ClearSelect TARGET_ACTIVELIST$
|
|
* end service
|
|
*
|
|
* Service DetermineNearShiftChange
|
|
* debug
|
|
*
|
|
* CurrTime = 64320
|
|
* CurrHour = SRP_TIME('Hour', CurrTime)
|
|
* end service
|
|
*
|
|
* Service OutPutSchedule(StartDate, EndDate)
|
|
* debug
|
|
* OutputData = ''
|
|
* StartDateConv = IConv(StartDate, 'D')
|
|
* EndDateConv = IConv(EndDate, 'D')
|
|
*
|
|
* for i = StartDateConv to EndDateConv
|
|
* //DayStartDTM = i : '.' : 21600
|
|
* //NightStartDTM = i : '.' : 64800
|
|
* DayStartDTM = SRP_Datetime('AddHours', i, 7)
|
|
* NightStartDTM = SRP_Datetime('AddHours', i, 18)
|
|
*
|
|
* DayShift = Lsl_Users_Services('GetShiftByDate', OCONV(DayStartDTM, 'DT'))<1,1>
|
|
* NightShift = Lsl_Users_Services('GetShiftByDate', OCONV(NightStartDTM, 'DT'))<1,1>
|
|
* OutputData := OConv(i, 'D4/H') : ',' : DayShift : ' and ' : NightShift : CRLF$
|
|
* Next i
|
|
* OSWrite OutputData to 'C:\Users\MESOuellette\Desktop\ShiftCalendar.csv'
|
|
* end service
|
|
*
|
|
* Service TestMassDates()
|
|
* OutputData = ''
|
|
* ExpectedCalRec = Database_Services('ReadDataRow', 'SYSLISTS', 'CAL_EXPECTED')
|
|
* for i = 1 to DCOUNT(ExpectedCalRec<1>, @VM)
|
|
* Dtm = ExpectedCalRec<1, i>
|
|
* ExpectedShift = ExpectedCalRec<2, i>
|
|
* ReturnedShift = Lsl_Users_Services('GetShiftByDate', Dtm)<1,1>
|
|
* Pass = (ExpectedShift EQ ReturnedShift)
|
|
*
|
|
* ExpectedCalRec<3,i> = ReturnedShift
|
|
* ExpectedCalRec<4,i> = Pass
|
|
* OutputData := Dtm : ',' : ExpectedShift : ',' : ReturnedShift : ',' : Pass : CRLF$
|
|
* Next i
|
|
* OSWrite OutputData to 'C:\Users\MESOuellette\Desktop\CalDataTestResults.csv'
|
|
* end service
|
|
*
|
|
* Service TestShiftCalendar
|
|
* debug
|
|
* shiftCalData = ''
|
|
* for date = 20090 to 20454
|
|
*
|
|
* DayShift = SRP_Datetime('AddHours', date, 12)
|
|
* NightShift = SRP_Datetime('AddHours', DayShift, 11)
|
|
*
|
|
* OnShiftDay = Lsl_Users_Services('GetShiftByDate', OCONV(DayShift, 'DT'), 1)
|
|
* OnShiftNight = Lsl_Users_Services('GetShiftByDate', OCONV(NightShift, 'DT'), 1)
|
|
* ShiftCalData := OCONV(DayShift, 'DT') : ',' : OnShiftDay<1,1> : ',' : OnShiftNight : CRLF$
|
|
* Next date
|
|
*
|
|
* OSWrite shiftCalData to 'C:\Users\MESOuellette\Desktop\CalData.csv'
|
|
* end service
|
|
*
|
|
* Service GetInboundPending
|
|
* debug
|
|
* rv = Set_Status(0)
|
|
* LookBack = 15 /* Days */
|
|
* StartDate = OCONV(Date()-LookBack, 'D4/')
|
|
* SelectStatement = "SELECT WO_MAT WITH SAP_TX_DT >= ": Quote(StartDate) :" AND WITHOUT SAP_BATCH_NO"
|
|
* RowCount = 0
|
|
* SelectStatement = "SELECT WO_MAT WITH SAP_BATCH_NO EQ ''"
|
|
* RList(SelectStatement, 5)
|
|
* If @List_Active EQ 3 then
|
|
* SelectStatement = "SELECT WO_MAT WITH SAP_TX_DT >= ": Quote(StartDate)
|
|
* RList(SelectStatement, 5)
|
|
* If @List_Active EQ 3 then
|
|
* EOF = False$
|
|
* Loop
|
|
* ReadNext KeyID else EOF = True$
|
|
* Until EOF
|
|
* WOMatRow = Database_Services('ReadDataRow', 'WO_MAT', KeyID)
|
|
* If WOMatRow<87> EQ '' then RowCount += 1
|
|
* Repeat
|
|
* end
|
|
* end
|
|
* end service
|
|
*
|
|
* Service CheckForNew()
|
|
*
|
|
* Response = True$
|
|
* if xlate( 'NOTE_PTRS', @user4, 'NEW_MESSAGES', 'X' ) then
|
|
* NotePtrRec = xlate( 'NOTE_PTRS', @user4, '', 'X' )
|
|
* LOCATE 'Yes' in NotePtrRec<note_ptrs_new$> using @VM setting mPos then
|
|
* * the top one is new meaning they got a new one
|
|
* Response = True$
|
|
* end else
|
|
* Response = False$
|
|
* end
|
|
* end
|
|
* end service
|
|
*
|
|
* Service GetNewNotes()
|
|
* debug
|
|
* void = Jonathan_Services('CheckForNew')
|
|
* end service
|
|
*
|
|
* Service TestGit()
|
|
* debug
|
|
* end service
|
|
*
|
|
* Service TestMessages()
|
|
* debug
|
|
* if xlate( 'NOTE_PTRS', @user4, 'NEW_MESSAGES', 'X' ) then
|
|
* NotePtrRec = xlate( 'NOTE_PTRS', @user4, '', 'X' )
|
|
* if NotePtrRec<note_ptrs_new$,1> = 'Yes' then
|
|
* * the top one is new meaning they got a new one
|
|
* MsgInfo = ''
|
|
* MsgInfo<micon$> = '!'
|
|
* Mtext = 'You have a new message from ':NotePtrRec<note_ptrs_from$,1>:'.'
|
|
* MsgInfo<mtext$> = MText
|
|
* MsgInfo<mcol$> = -2
|
|
* MsgInfo<mrow$> = -2
|
|
* Void = msg( '', MsgInfo )
|
|
* end
|
|
* end
|
|
*
|
|
* NotesSent = obj_Notes_Sent('GetUserKeys','LEHRICH')
|
|
* NewMessages = XLATE('NOTE_PTRS','LEHRICH','NEW_MESSAGES','X')
|
|
* //NotesSent = obj_Notes_Sent('GetUserKeys','JONATHAN_O')
|
|
* IF NotesSent NE '' OR NewMessages > 0 THEN
|
|
* Start_Window( 'NOTE_PTRS', @WINDOW, '*CENTER', '', '' )
|
|
* END
|
|
* end service
|
|
*
|
|
* Service GetSAPYield
|
|
* debug
|
|
* counts = Gan_Services('GetYieldInfo', 223271 , '')
|
|
* end service
|
|
*
|
|
* Service DoSomething()
|
|
*
|
|
* Response = "Hello, World!"
|
|
*
|
|
* End Service
|
|
*
|
|
* Service DoSomethingWithParameters(Input, Ref Output)
|
|
*
|
|
* Output = Input:", World!"
|
|
*
|
|
* End Service
|
|
|
|
|
|
|
|
|
|
|
|
|