732 lines
18 KiB
XML
732 lines
18 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
|
<TcPlcObject Version="1.1.0.1" ProductVersion="3.1.4026.13">
|
|
<POU Name="HV_MAIN_FB" Id="{2c8d10c9-caf7-4733-86a0-f1c82027a9a1}" SpecialFunc="None">
|
|
<Declaration><![CDATA[FUNCTION_BLOCK HV_MAIN_FB EXTENDS Station_GENERAL_MAIN_FB IMPLEMENTS I_STATION_CMD_CALL
|
|
VAR
|
|
Config : sHVConfig;
|
|
ConfigOld : sHVConfig;
|
|
IO : HV_IO_FB;
|
|
Recipe : sHVRecipe;
|
|
RecipeRead : sHVRecipe;
|
|
RecipeLoad : sHVRecipe;
|
|
|
|
Trend : Trend_FB;
|
|
|
|
ITempController : I_TempController;
|
|
|
|
TestFinish : BOOL;
|
|
END_VAR
|
|
VAR CONSTANT
|
|
StepRecipeStart : INT := 10;
|
|
TimeOut : TIME := T#10S;
|
|
END_VAR
|
|
|
|
VAR_INPUT
|
|
END_VAR
|
|
VAR_OUTPUT
|
|
|
|
|
|
TestOk : BOOL;
|
|
TestNotOk : BOOL;
|
|
END_VAR
|
|
|
|
|
|
VAR PERSISTENT
|
|
// RecipeStandby : sHVRecipe;
|
|
END_VAR
|
|
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[]]></ST>
|
|
</Implementation>
|
|
<Method Name="CheckFlow" Id="{9e31302b-4aaf-427a-9e1e-f758811b1dd2}">
|
|
<Declaration><![CDATA[METHOD CheckFlow : BOOL
|
|
VAR_INPUT
|
|
Step : REFERENCE TO INT;
|
|
END_VAR
|
|
VAR
|
|
i : USINT;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE Step OF
|
|
0:
|
|
IF CheckRecipe() THEN
|
|
Step := 50;
|
|
END_IF
|
|
50:
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
ITempController.Enable := TRUE;
|
|
ITempController.TargetTemperature := RecipeRead.TEMPERATURE;
|
|
ITempController.Tolerance := RecipeRead.TOL;
|
|
Step := 60;
|
|
TypeHVCold:
|
|
Step := 100;
|
|
END_CASE
|
|
60:
|
|
IF ITempController.TemperatureInRange() THEN
|
|
Step := 100;
|
|
ELSE
|
|
Step := 110;
|
|
END_IF
|
|
100:
|
|
iStationStatus.Ist.ReadyForFlow := TRUE;
|
|
iStationStatus.Soll.CheckFlow := FALSE;
|
|
Step := 0;
|
|
110:
|
|
iStationStatus.Ist.ReadyForFlow := FALSE;
|
|
iStationStatus.Soll.CheckFlow := FALSE;
|
|
Step := 0;
|
|
END_CASE]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="CloseInOut" Id="{a1633ec5-946a-45c9-8f77-07d6a415581e}">
|
|
<Declaration><![CDATA[METHOD CloseInOut : BOOL
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE _Step OF
|
|
0:
|
|
TestOk := FALSE;
|
|
TestNotOk := FALSE;
|
|
_Step := 10;
|
|
10:
|
|
CASE iCMD OF
|
|
CloseInCMD:
|
|
IF iStationStatus.Ist.Service THEN
|
|
_Step := 30;
|
|
ELSE
|
|
_Step := _Step +1;
|
|
END_IF
|
|
CloseOutCMD:
|
|
_Step := 30;
|
|
END_CASE
|
|
11:
|
|
IF LoadAutoRecipe() THEN
|
|
_Step := 15;
|
|
END_IF
|
|
15:
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
_Step := 20;
|
|
TypeHVCold:
|
|
_Step := 30;
|
|
END_CASE
|
|
20:
|
|
IF ITempController.TuneDone THEN
|
|
ITempController.TargetTemperature := Recipe.TEMPERATURE;
|
|
ITempController.Tolerance := Recipe.TOL;
|
|
ITempController.Enable := TRUE;
|
|
|
|
_Step := _Step +1;
|
|
ELSE
|
|
AlarmSend(iStation:=iStation,MsgId := HV_ErrorNr.eNotTuned,TRUE, eReportType.Error, sAvailableResponse.Ok, FALSE);
|
|
iStationStatus.Soll.Stop := TRUE;
|
|
END_IF
|
|
21:
|
|
IF ITempController.TemperatureInRange() THEN
|
|
_Step := 30;
|
|
ELSE
|
|
iStationStatus.Error := TRUE;
|
|
iStationStatus.ErrorIndex := AlarmSend(iStation,MsgId := HV_ErrorNr.wTempOutOfRange,TRUE, eReportType.Warning, sAvailableResponse.AbortRetryIgnore, FALSE);
|
|
iStationStatus.StepRetry := 0;
|
|
iStationStatus.StepIgnore := 30;
|
|
END_IF
|
|
30:
|
|
IF IO.Shutter.Down() THEN
|
|
CASE iCMD OF
|
|
CloseInCMD:
|
|
_Step := 40;
|
|
CloseOutCMD:
|
|
_Step := 90;
|
|
END_CASE
|
|
END_IF
|
|
40:
|
|
IF IO.ChuckVacuum.Up() THEN
|
|
_Step := 50;
|
|
END_IF
|
|
50:
|
|
IO.bOutValve := TRUE;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutCylinderPressure,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
51:
|
|
IF IO.bInPressureCylinderOk THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
_Step := 55;
|
|
END_IF
|
|
55:
|
|
IF IO.Chamber.Down() THEN
|
|
_Step := _Step +1;
|
|
END_IF
|
|
56:
|
|
DelayTimer(IN := TRUE, PT := T#3S);
|
|
IF DelayTimer.Q THEN
|
|
DelayTimer(IN := FALSE);
|
|
_Step := 60;
|
|
END_IF
|
|
60:
|
|
IF iStationStatus.Ist.Service THEN
|
|
IO.bOutExhaust := FALSE;
|
|
IO.bOutOverpressureN2 := TRUE;
|
|
IO.PressureController.rOutTargetPressure := Config.DefaultChamberPressure;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutN2Pressure,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
ELSE
|
|
_Step := 90;
|
|
END_IF
|
|
61:
|
|
IF IO.bInChamberPressureOk THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
_Step := 90;
|
|
END_IF
|
|
90:
|
|
CloseInOut := TRUE;
|
|
_Step := 0;
|
|
END_CASE
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="FB_Init" Id="{d0961d05-e82d-47be-a411-854140c0cec7}">
|
|
<Declaration><![CDATA[//FB_Init is always available implicitly and it is used primarily for initialization.
|
|
//The return value is not evaluated. For a specific influence, you can also declare the
|
|
//methods explicitly and provide additional code there with the standard initialization
|
|
//code. You can evaluate the return value.
|
|
METHOD FB_Init: BOOL
|
|
VAR_INPUT
|
|
bInitRetains: BOOL; // TRUE: the retain variables are initialized (reset warm / reset cold)
|
|
bInCopyCode: BOOL; // TRUE: the instance will be copied to the copy code afterward (online change)
|
|
END_VAR]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[_DataLoggerV2 := TRUE;
|
|
DataLoggerV2.IntervalTime := T#10MS;
|
|
_VisuName := 'HV';
|
|
_SchedulerManagement := TRUE;]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="INIT" Id="{428cfc9c-61cb-4074-9cd6-9c6a0e4b8e11}">
|
|
<Declaration><![CDATA[METHOD INIT : BOOL]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE _Step OF
|
|
0:
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
IF ITempController.TuneDone THEN
|
|
ITempController.Enable := TRUE;
|
|
ITempController.TargetTemperature := Config.StandbyTemperature;
|
|
ITempController.Tolerance := 1;
|
|
END_IF
|
|
END_CASE
|
|
_Step := 20;
|
|
20:
|
|
IO.bOutExhaust := TRUE;
|
|
_Step := 90;
|
|
90:
|
|
IF iStationStatus.WaferInfo[0].Number = 100 THEN
|
|
_Step := 91;
|
|
ELSE
|
|
_Step := 100;
|
|
END_IF
|
|
91:
|
|
DelayTimer(IN:= TRUE, PT := T#1S);
|
|
IF DelayTimer.Q THEN
|
|
DelayTimer(IN:= FALSE, PT := T#1S);
|
|
_Step := 100;
|
|
END_IF
|
|
100:
|
|
_Step := 0;
|
|
INIT := TRUE;
|
|
END_CASE
|
|
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="Initialization" Id="{6d62762c-e62a-44c2-8ce3-6477e1d32b39}">
|
|
<Declaration><![CDATA[METHOD Initialization : BOOL
|
|
VAR_INPUT
|
|
iStation : INT;
|
|
END_VAR
|
|
VAR
|
|
j : INT;
|
|
V : LREAL; // Voltage across the diode
|
|
I : LREAL; // Current through the diode
|
|
I_s : REAL := 1E-12; // Reverse saturation current (example value)
|
|
n : REAL := 1.0; // Ideality factor (example value)
|
|
V_t : REAL := 0.026; // Thermal voltage at room temperature
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[InitializationExt(iStation);
|
|
|
|
iStationStatus.NoScan := TRUE;
|
|
iStationStatus.CheckStation := TRUE;
|
|
//iStationStatus.RecipeOnlyHeader := TRUE;
|
|
iStationStatus.RecipeStatus.StepCount REF= HV_RECIPE_EDITE.STEP_COUNT;
|
|
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
iStationStatus.StandbyAvailable := TRUE;
|
|
iStationStatus.StationName := 'HV Hot';
|
|
RecipeStationName[iStation] := 'HV Hot';
|
|
TypeHVCold:
|
|
iStationStatus.StationName := 'HV Cold';
|
|
RecipeStationName[iStation] := 'HV Cold';
|
|
END_CASE
|
|
iStationStatus.ErrorList := 'HV_ErrorNr';
|
|
|
|
CASE StationsStatus[iStation].StationType OF
|
|
TypeHVHot:
|
|
ConfigManagement.Initialization(ADR(Config), ADR(ConfigOld), SIZEOF(Config), 'sHVConfig', 'HVHot');
|
|
TypeHVCold:
|
|
ConfigManagement.Initialization(ADR(Config), ADR(ConfigOld), SIZEOF(Config), 'sHVConfig', 'HVCold');
|
|
END_CASE
|
|
ConfigPlausibility REF= Config.ConfigPlausibility;
|
|
|
|
RecipeManagement.Initialization(
|
|
iStation,
|
|
ADR(RecipeLoad),
|
|
ADR(HV_RECIPE_EDITE),
|
|
ADR(HV_RECIPE_EMPTY),
|
|
ADR(RecipeRead),
|
|
ADR(Recipe),
|
|
// ADR(RecipeStandby),
|
|
SIZEOF(Recipe),
|
|
'sHVRecipe',
|
|
0
|
|
);
|
|
|
|
IO.Initialization(iStation);
|
|
IO.Config REF= Config;
|
|
|
|
//Signal REF= HVSiganl[iStation];
|
|
//Config REF= HVConfig[iStation];
|
|
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
HV_TempController.Config REF= Config.Temperature;
|
|
HV_TempController.rInTuneTargetTemperature := 80;
|
|
HV_TempController.tTaskCycleTime := T#2MS;
|
|
HV_TempController.rInMaxTemperature := HV_MaxTemperature;
|
|
HV_TempController.rInMinTemperature := 20;
|
|
StationsStatus[iStation].StandbyAvailable := TRUE;
|
|
END_CASE
|
|
|
|
ITempController := HV_TempController;
|
|
|
|
iStationStatus.CurrentStep REF= CurrentStep;
|
|
|
|
FOR j := 0 TO 100 DO
|
|
V := INT_TO_LREAL(j)/100;
|
|
I := I_s * (EXP(V / (n * V_t)) - 1);
|
|
HVRecipeArray[j] := I;
|
|
END_FOR
|
|
|
|
|
|
DataLoggerV2.Data[1].Name := 'Voltage (V)';
|
|
DataLoggerV2.Data[1].Value REF= HV_SCHUSTER.HV_I.Spannungsmesswert;
|
|
DataLoggerV2.Data[1].Tolerence := 0.01;
|
|
|
|
DataLoggerV2.Data[2].Name := 'Current (mA)';
|
|
DataLoggerV2.Data[2].Value REF= HV_SCHUSTER.HV_I.Strommesswert;
|
|
DataLoggerV2.Data[2].Tolerence := 0.001;
|
|
|
|
DataLoggerV2.Data[3].Name := 'N2 Pressure(Bar)';
|
|
DataLoggerV2.Data[3].Value REF= IO.rInChamberPressure;
|
|
DataLoggerV2.Data[3].Tolerence := 0.1;
|
|
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
DataLoggerV2.Data[4].Name := 'Temperature(°C)';
|
|
DataLoggerV2.Data[4].Value REF= HV_TempController.rOutCurrentTemperature;
|
|
DataLoggerV2.Data[4].Tolerence := 0.1;
|
|
END_CASE
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="MAIN" Id="{57f96818-f1de-40b4-804b-5da601f77892}">
|
|
<Declaration><![CDATA[METHOD MAIN : BOOL
|
|
VAR_INPUT
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
ITempController.MAIN();
|
|
END_CASE
|
|
|
|
IO();]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="PrepInOut" Id="{f80ff994-5226-46de-9e5b-8de878859f7e}">
|
|
<Declaration><![CDATA[METHOD PrepInOut : BOOL]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE _Step OF
|
|
0:
|
|
IF IO.Chamber.bInUp THEN
|
|
_Step := 50;
|
|
ELSE
|
|
_Step := 10;
|
|
END_IF
|
|
10:
|
|
IF IO.Shutter.Down() THEN
|
|
_Step := 20;
|
|
END_IF
|
|
20:
|
|
IO.bOutOverpressureN2 := FALSE;
|
|
IO.bOutExhaust := TRUE;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutN2PressureRelease,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
21:
|
|
IF IO.bInChamberNoPressure THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
_Step := 30;
|
|
END_IF
|
|
30:
|
|
IO.bOutValve := TRUE;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutCylinderPressure,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
31:
|
|
IF IO.bInPressureCylinderOk THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
_Step := 40;
|
|
END_IF
|
|
40:
|
|
IF IO.Chamber.Up() THEN
|
|
_Step := 50;
|
|
END_IF
|
|
50:
|
|
IF IO.Shutter.Up() THEN
|
|
_Step := 60;
|
|
END_IF
|
|
60:
|
|
IO.ChuckVacuum.Down(TRUE);
|
|
_Step := 90;
|
|
90:
|
|
IF IO.bInRobotFree AND NOT IO.bInRobotNotFree THEN
|
|
_Step := 100;
|
|
ELSE
|
|
iStationStatus.Error := TRUE;
|
|
iStationStatus.ErrorIndex := AlarmSend(iStation, HV_ErrorNr.eChamberOpenIsNotOpen, TRUE, eReportType.Error, sAvailableResponse.RetryCancel, FALSE);
|
|
iStationStatus.StepRetry := 0;
|
|
END_IF
|
|
100:
|
|
_Step := 0;
|
|
PrepInOut := TRUE;
|
|
END_CASE]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="RCPAddStep" Id="{cae62163-76f5-4e53-bba4-94862f0ab370}">
|
|
<Declaration><![CDATA[METHOD RCPAddStep : BOOL
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[MEMMOVE(
|
|
ADR(HV_RECIPE_EDITE.DATA[RecipeCurrentStep+1]),
|
|
ADR(HV_RECIPE_EDITE.DATA[RecipeCurrentStep]),
|
|
SIZEOF(HV_RECIPE_EDITE.DATA[RecipeCurrentStep])*(HV_RECIPE_EDITE.STEP_COUNT-RecipeCurrentStep+1)
|
|
);
|
|
HV_RECIPE_EDITE.STEP_COUNT := HV_RECIPE_EDITE.STEP_COUNT+1;
|
|
RecipeCurrentStep := RecipeCurrentStep +1;]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="RCPStepRemove" Id="{9408a95a-5c58-41b0-bfc6-85651a702066}">
|
|
<Declaration><![CDATA[METHOD RCPStepRemove : BOOL
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[IF HV_RECIPE_EDITE.STEP_COUNT = (RecipeCurrentStep) THEN
|
|
RecipeCurrentStep := RecipeCurrentStep -1;
|
|
ELSE
|
|
MEMMOVE(
|
|
ADR(HV_RECIPE_EDITE.DATA[RecipeCurrentStep]),
|
|
ADR(HV_RECIPE_EDITE.DATA[RecipeCurrentStep+1]),
|
|
SIZEOF(HV_RECIPE_EDITE.DATA[RecipeCurrentStep])*(HV_RECIPE_EDITE.STEP_COUNT-RecipeCurrentStep)
|
|
);
|
|
END_IF
|
|
HV_RECIPE_EDITE.STEP_COUNT := HV_RECIPE_EDITE.STEP_COUNT-1;]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="RecipeVisu" Id="{a08d8697-042d-4915-b544-11ccf0743ac9}">
|
|
<Declaration><![CDATA[METHOD RecipeVisu : BOOL
|
|
VAR_INPUT
|
|
END_VAR
|
|
VAR_INST
|
|
Step : INT;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE Step OF
|
|
0:
|
|
Step := 10;
|
|
10:
|
|
CurrentStepOld := RecipeCurrentStep;
|
|
Step := Step +1;
|
|
11:
|
|
IF CurrentStepOld <> RecipeCurrentStep THEN
|
|
Step := 10;
|
|
RETURN;
|
|
END_IF
|
|
|
|
|
|
IF iStationStatus.Soll.RecipeExit THEN
|
|
Step := 0;
|
|
iStationStatus.Ist.Recipe := FALSE;
|
|
iStationStatus.Soll.RecipeExit := FALSE;
|
|
END_IF
|
|
END_CASE
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="Standby" Id="{2b06bb6c-9354-43b6-9046-9535cc9317f4}">
|
|
<Declaration><![CDATA[METHOD Standby : BOOL
|
|
VAR_INPUT
|
|
bStart : BOOL;
|
|
Step : REFERENCE TO INT;
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE Step OF
|
|
0:
|
|
StandbyTimer(IN := bStart, PT := UDINT_TO_TIME(StandbyDelay[iStation]*1000));
|
|
IF StandbyTimer.Q THEN
|
|
StandbyTimer(IN := FALSE);
|
|
Step := 10;
|
|
END_IF
|
|
10:
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
// ITempController.TargetTemperature := RecipeStandby.TEMPERATURE;
|
|
ITempController.Enable := TRUE;
|
|
END_CASE
|
|
|
|
Step := 0;
|
|
END_CASE]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="Start" Id="{9f12bd79-2919-4430-8172-8e9ca53b4dd4}">
|
|
<Declaration><![CDATA[METHOD Start : BOOL
|
|
VAR_INST
|
|
i : INT;
|
|
|
|
CassetteNumber : INT;
|
|
SlotNumber : INT;
|
|
CurrentProcessStep : UINT;
|
|
|
|
TargetRelaxStation : INT;
|
|
RetryFlowName : T_MaxString;
|
|
END_VAR]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[CASE _Step OF
|
|
0:
|
|
//Profi
|
|
TestOk := TRUE;
|
|
_Step := 90;
|
|
RETURN;
|
|
|
|
|
|
|
|
|
|
HV_SCHUSTER.HV_I.Spannungsmesswert := 0;
|
|
HV_SCHUSTER.HV_I.Strommesswert := 0;
|
|
CurrentStep := 0;
|
|
_Step := StepRecipeStart;
|
|
StepRecipeStart:
|
|
IO.bOutExhaust := FALSE;
|
|
IO.bOutOverpressureN2 := TRUE;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutN2Pressure,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
11:
|
|
IO.PressureController.rOutTargetPressure := Recipe.N2;
|
|
IF IO.bInPressureCylinderOk THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
//Step := 90;
|
|
_Step := 20;
|
|
END_IF
|
|
|
|
20:
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
_Step := _Step +1;
|
|
TypeHVCold:
|
|
_Step := 30;
|
|
END_CASE
|
|
21:
|
|
StepTimer(IN := TRUE, PT := LREAL_TO_TIME(Recipe.DelayTime*1000));
|
|
IF StepTimer.Q THEN
|
|
_Step := 30;
|
|
StepTimer(IN := FALSE);
|
|
END_IF
|
|
30:
|
|
TestFinish := FALSE;
|
|
CurrentStep := CurrentStep +1;
|
|
HV_SCHUSTER.sMessrate := Recipe.DATA[CurrentStep].MeasurementRate;
|
|
HV_SCHUSTER.sRampe := Recipe.DATA[CurrentStep].Ramp;
|
|
HV_SCHUSTER.sVD := LREAL_TO_UDINT(Recipe.DATA[CurrentStep].V_Max*1000);
|
|
HV_SCHUSTER.sVR := LREAL_TO_UDINT(Recipe.DATA[CurrentStep].V_Max*1000);
|
|
HV_SCHUSTER.sID := Recipe.DATA[CurrentStep].I_Max;
|
|
HV_SCHUSTER.sIR := Recipe.DATA[CurrentStep].I_Max;
|
|
HV_SCHUSTER.R_Dir := Recipe.DATA[CurrentStep].Direction;
|
|
|
|
HV_SCHUSTER.SendParameter();
|
|
_Step := _Step +1;
|
|
31:
|
|
DelayTimer(IN := TRUE, PT := T#100MS);
|
|
IF DelayTimer.Q THEN
|
|
DelayTimer(IN := FALSE, PT := T#100MS);
|
|
_Step := 40;
|
|
END_IF
|
|
40:
|
|
IF HV_SCHUSTER.StartRead(iStation) THEN
|
|
_Step := 50;
|
|
END_IF
|
|
50:
|
|
IF HV_SCHUSTER.CheckResult(Recipe.DATA[CurrentStep].V_Limit*1000, Recipe.DATA[CurrentStep].I_Limit, ResultNotOk => TestNotOk) THEN
|
|
TestOk := NOT TestNotOk;
|
|
_Step := 60;
|
|
END_IF
|
|
60:
|
|
IF TestOk THEN
|
|
_Step := 80;
|
|
ELSE
|
|
CASE iStationStatus.OperationMode OF
|
|
AutomaticMode:
|
|
_Step := 70;
|
|
ELSE
|
|
_Step := 80;
|
|
END_CASE
|
|
END_IF
|
|
70:
|
|
CassetteNumber := iStationStatus.WaferInfo[0].CassetteNumber;
|
|
SlotNumber := iStationStatus.WaferInfo[0].Number;
|
|
CurrentProcessStep := iStationStatus.WaferInfo[0].FlowStepNumber;
|
|
RetryFlowName := CASSETTE_PROCESS[CassetteNumber][SlotNumber][CurrentProcessStep].RetryFlowName;
|
|
IF CASSETTE_PROCESS[CassetteNumber][SlotNumber][CurrentProcessStep].Retry THEN
|
|
_Step := 75;
|
|
ELSE
|
|
iStationStatus.WaferInfo[0].Defect := TRUE;
|
|
_Step := 90;
|
|
END_IF
|
|
75:
|
|
IF StationsStatus[RobotStation].Ist.Busy AND ROBOT_MAIN.TargetStation <> iStation THEN
|
|
RETURN;
|
|
END_IF
|
|
|
|
FOR i := FirstLelaxStation TO LastRelaxStation DO
|
|
IF StationsStatus[i].WaferInfo[0].Number = 0 THEN
|
|
TargetRelaxStation := i;
|
|
|
|
RETRY_MAIN[TargetRelaxStation].RetryFlowName := RetryFlowName;
|
|
CASSETTE_PROCESS[CassetteNumber][SlotNumber][iStationStatus.WaferInfo[0].FlowStepNumber+1].TargetStation := TargetRelaxStation;
|
|
|
|
_Step := 90;
|
|
RETURN;
|
|
END_IF
|
|
END_FOR
|
|
|
|
80:
|
|
IF Recipe.STEP_COUNT > CurrentStep THEN
|
|
_Step := 30;
|
|
ELSE
|
|
_Step := 90;
|
|
END_IF
|
|
90:
|
|
IO.bOutOverpressureN2 := FALSE;
|
|
IO.bOutExhaust := TRUE;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutN2PressureRelease,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
91:
|
|
IF IO.bInChamberNoPressure THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
_Step := _Step+1;
|
|
END_IF
|
|
92:
|
|
IO.bOutValve := TRUE;
|
|
ProblemTimer(
|
|
iStation,
|
|
_Step,
|
|
0,
|
|
HV_ErrorNr.eTimeoutCylinderPressure,
|
|
sAvailableResponse.RetryCancel,
|
|
TimeOut
|
|
);
|
|
_Step := _Step +1;
|
|
93:
|
|
IF IO.bInPressureCylinderOk THEN
|
|
iStationStatus.ProblemTimer := T#0S;
|
|
_Step := 95;
|
|
END_IF
|
|
95:
|
|
IF IO.Chamber.Up() THEN
|
|
_Step := 100;
|
|
END_IF
|
|
100:
|
|
Start := TRUE;
|
|
_Step := 0;
|
|
END_CASE
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
<Method Name="ToVisu" Id="{9bfbeb4b-7bab-4090-b95e-1b2c52af5555}">
|
|
<Declaration><![CDATA[METHOD ToVisu : BOOL
|
|
VAR_INPUT
|
|
END_VAR
|
|
]]></Declaration>
|
|
<Implementation>
|
|
<ST><![CDATA[VisuHVAutoRecipe REF= Recipe;
|
|
VisuHPTrend REF= Trend;
|
|
VisuHVConfig REF= Config;
|
|
//VisuHotplateSignal REF= HotplateSiganl[iStation];
|
|
VisuHV_IO REF= IO;
|
|
|
|
//VisuTempController REF= TempController;
|
|
|
|
VISU_HVMain REF= HV_MAIN[iStation];
|
|
|
|
CASE iStationStatus.StationType OF
|
|
TypeHVHot:
|
|
VisuIITempController := HV_TempController;
|
|
END_CASE
|
|
]]></ST>
|
|
</Implementation>
|
|
</Method>
|
|
</POU>
|
|
</TcPlcObject> |