Heisig_GmbH/infineon_legacy_plc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
infineon_legacy_plc/PLC/2 Spinner/POUs/SPINNER_MAIN_FB.TcPOU
m.heisig fe882dc444 Initial
2026-01-08 11:08:17 +01:00

2018 lines
52 KiB
XML
Raw Permalink Blame History

<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1" ProductVersion="3.1.4026.13">
<POU Name="SPINNER_MAIN_FB" Id="{c7fceb75-aa54-497e-93fe-fb07235b3581}" SpecialFunc="None">
<Declaration><![CDATA[FUNCTION_BLOCK SPINNER_MAIN_FB EXTENDS Station_GENERAL_MAIN_FB IMPLEMENTS I_STATION_CMD_CALL
VAR
Chuck : GENERAL_Axis_FB;
BSRAxis : GENERAL_Axis_FB;
// KUKA : Spinner_KUKA_FB;
IO : SPINNER_IO_FB;
Config : sSpinnerConfig;
ConfigOld : sSpinnerConfig;
//Start
CheckChuckVacuum : BOOL;
Recipe : sSpinnerRecipe;
RecipeRead : sSpinnerRecipe;
RecipeLoad : sSpinnerRecipe;
NozzlesChecked : BOOL;
bNozzleCheck : BOOL;
Robot : Meca500_FB;
rCheckPrepoutCalibrationPosition : INT;
bCheckPrepoutCalibration : BOOL;
bCalibration : BOOL;
Center : ARRAY [0..1] OF sPoint;
CenterCalibrated : sPoint;
END_VAR
VAR CONSTANT
VacuumTime : TIME := T#2S;
//Start
StepRecipeStart : INT := 10;
StepEnd : INT := 30;
DoorLockTimeOut : TIME := T#5S;
MotorLiftTimeOut : TIME := T#5S;
ShutterTimeout : TIME := T#10S;
BrushOutTimeOut : TIME := T#10S;
WindowTimeOut : TIME := T#1S;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[]]></ST>
</Implementation>
<Folder Name="NozzleCheck" Id="{39012b6f-0bee-4b6f-a58a-0b3b906d51e6}" />
<Folder Name="START" Id="{a226f0c2-2ef6-4de8-82f0-8135aecd9009}" />
<Folder Name="SubstrateCalibration" Id="{8f9eb005-f836-4a85-aae2-000cdfc2cfe0}" />
<Method Name="CheckFlow" Id="{f7f20637-7730-4761-9bb9-1dc5628aec8f}">
<Declaration><![CDATA[METHOD CheckFlow : BOOL
VAR_INPUT
Step : REFERENCE TO INT;
END_VAR
VAR
i, j : SINT;
END_VAR
VAR_INST
TargetNozzleCheck : DWORD;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[CASE Step OF
0:
CASE iChuckSize OF
-1:
Step := 110;
ELSE
IF iChuckSize = CheckFlowGripperSize[iStation] THEN
Step := 20;
ELSE
Step := 10;
END_IF
END_CASE
10:
IF ChuckChange() THEN
Step := 0;
END_IF
20:
IF CheckRecipe() THEN
Step := 30;
END_IF
30:
TargetNozzleCheck := 0;
FOR i :=1 TO 32 DO
iMediaArray[i].MediaUsedInFlow := FALSE;
END_FOR
FOR i := 1 TO USINT_TO_SINT(RecipeRead.STEP_COUNT) DO
FOR j :=1 TO 32 DO
IF GETBIT32(RecipeRead.DATA[i].MEDIA, j) THEN
iMediaArray[j].MediaUsedInFlow := TRUE;
iMediaArray[j].bReferencePrepareMedia := TRUE;
TargetNozzleCheck := SETBIT32(TargetNozzleCheck, j);
END_IF
END_FOR
END_FOR
Step := Step +1;
31:
FOR i :=1 TO 32 DO
IF iMediaArray[i].MediaUsedInFlow THEN
IF NOT iMediaArray[i].bReferenceTankState THEN
Step := 110;
RETURN;
END_IF
END_IF
END_FOR
Step := 60;
40:
IF RecipeRead.NozzlesCheck THEN
Step := 50;
ELSE
Step := 60;
END_IF
50:
//IF NozzlesCheck(TargetNozzleCheck) THEN
Step := 60;
//END_IF
60:
IF NOT IO.bInExhaustOk THEN
Step := 110;
RETURN;
END_IF
IF NOT MEDIA_MAIN.IO.bInN2Ok THEN
Step := 110;
RETURN;
END_IF
Step := 100;
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="ChuckChange" Id="{1ce36624-fb01-4cb8-909f-9823ccffd426}">
<Declaration><![CDATA[METHOD ChuckChange : BOOL
VAR_INPUT
END_VAR
VAR_INST
Step : INT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[IF iStationStatus.Soll.Stop THEN
Step := 0;
RETURN;
END_IF
CASE Step OF
0:
IF WaferInSystem THEN
;
ELSE
Step := 10;
END_IF
10:
IF iStationStatus.Ist.CloseOut THEN
Step := Step +1;
ELSIF NOT iStationStatus.Ist.Busy THEN
iCMD := CloseOutCMD;
END_IF
11:
CASE iChuckSize OF
-1:
;
0:
Step := 70;
ELSE
Step := 20;
END_CASE
20:
IF LoadSpecialRecipe(eRecipeType.TypeCleaning) THEN
iCMD := CloseInCMD;
iStationStatus.Soll.AutoStart := TRUE;
_RecipeCleaning := TRUE;
_NoLoadRecipe := TRUE;
Step := 30;
END_IF
30:
IF iStationStatus.Ist.PrepOut THEN
Step := 35;
ELSIF NOT iStationStatus.Ist.Busy THEN
iCMD := PrepOutCMD;
END_IF
35:
IF NOT ChuckChangeBusy THEN
ChuckChangeBusy := TRUE;
Step := 40;
END_IF
40:
IF ROBOT_MAIN.RobotControl.GET_Chuck(iStation, 0) THEN
Step := 45;
END_IF
45:
IF IO.ChuckChange(FALSE) THEN
Step := 50;
END_IF
50:
IF ROBOT_MAIN.RobotControl.PUT_Chuck(iStation, iChuckSize) THEN
Step := 70;
END_IF
70:
IF ROBOT_MAIN.RobotControl.GET_Chuck(iStation, CheckFlowGripperSize[iStation]) THEN
Step := 75;
END_IF
75:
IF IO.ChuckChange(FALSE) THEN
Step := Step+1;
END_IF
76:
IF iStationStatus.Ist.PrepIn OR iStationStatus.Ist.PrepOut THEN
Step := 80;
ELSIF NOT iStationStatus.Ist.Busy THEN
iCMD := PrepInCMD;
END_IF
80:
IF ROBOT_MAIN.RobotControl.PUT_Chuck(iStation, 0) THEN
Step := 90;
END_IF
90:
ChuckChangeBusy := FALSE;
ChuckChange := TRUE;
Step := 0;
END_CASE]]></ST>
</Implementation>
</Method>
<Method Name="CloseInOut" Id="{3d6f1437-bfaa-4e68-a9d6-214c2bef7dcd}">
<Declaration><![CDATA[METHOD CloseInOut : BOOL
VAR CONSTANT
VacuumTime : TIME := T#2S;
ShutterTimeout : TIME := T#5S;
MotorLiftTimeOut : TIME := T#5S;
END_VAR
VAR_INST
i : USINT;
j : SINT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[CASE _Step OF
0:
CASE iCMD OF
CloseInCMD:
_Step := _Step +1;
CloseOutCMD:
{IF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Up() THEN
_Step := 30;
END_IF
{ELSE}
Step := 30;
{END_IF}
END_CASE
1:
IF IO.MotorRinse.Check() THEN
_Step := _Step +1;
END_IF
2:
IF IO.ChuckRinse.Check() THEN
_Step := _Step +1;
END_IF
3:
IF IO.RobotRinse.Check() THEN
_Step := _Step +1;
END_IF
4:
IF LoadAutoRecipe() THEN
_Step := 15;
END_IF
15:
{IF defined (variable: vSpinnerDoorLcok)}
IF IO.Lock.Lock() AND IO.RobotDoorLock.Lock() THEN
_Step := _Step +1;
END_IF
{ELSIF defined (variable: vSpinnerHatch)}
IF IO.Hatch.Close() THEN
Step := 20;
END_IF
{ELSIF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Up() THEN
_Step := 20;
END_IF
{ELSE}
Step := 20;
{END_IF}
16:
{IF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Up() THEN
_Step := 20;
END_IF
{ELSE}
Step := 20;
{END_IF}
20:
IF iStationStatus.Ist.Service THEN
_Step := 30;
ELSE
FOR i := 1 TO Recipe.STEP_COUNT DO
FOR j := 1 TO 31 DO
IF GETBIT32(Recipe.DATA[i].MEDIA, j) THEN
iMediaArray[j].bReferencePrepareMedia := TRUE;
IF NOT iMediaArray[j].bReferenceTankState THEN
RETURN;
END_IF
END_IF
END_FOR
END_FOR
_Step := 30;
END_IF
30:
{IF defined (variable: vSpinnerMotorLift)}
IF IO.MotorLift.Down() THEN
Step := 32;
END_IF
{ELSIF defined (variable: vSpinnerSplashRing)}
IF IO.SplashRing.Up() THEN
Step := 32;
END_IF
{ELSE}
_Step := 32;
{END_IF}
32:
CASE iCMD OF
CloseInCMD:
_Step := 35;
CloseOutCMD:
IF iStationStatus.WaferInfo[0].Number = 100 THEN
_Step := 40;
ELSE
_Step := 50;
END_IF
END_CASE
35:
IF Chuck.bOutReady AND Chuck.bOutEnabled AND Chuck.bInEnable THEN
_Step := 40;
ELSE
Chuck.bOutReady := FALSE;
_Step := _Step +1;
END_IF
36:
IF Chuck.Init() THEN
_Step := 35;
END_IF
40:
IF _RecipeCleaning THEN
_Step := 50;
RETURN;
END_IF
{IF defined (variable: vChuckVacuum)}
IF IO.ChuckVacuum.Up() THEN
_Step := 50;
END_IF
{ELSE}
Step := 50;
{END_IF}
50:
CASE iCMD OF
CloseInCMD:
_Step := 60;
RETURN;
IF IO.MotorRinse.Check() THEN
_Step := 60;
END_IF
CloseOutCMD:
_Step := 100;
END_CASE
60:
{IF defined (variable: vJulabo)}
FOR i := 1 TO vJulabo DO
Julabo[i].TargetTemperature := Recipe.Temperature[i];
Julabo[i].TargetTemperature := Recipe.Tolerance[i];
Julabo[i].bInEnable := TRUE;
END_FOR
Step := Step +1;
{ELSE}
_Step := 70;
{END_IF}
61:
{IF defined (variable: vJulabo)}
FOR i := 1 TO vJulabo DO
IF NOT Julabo[i].CheckTemp() THEN
RETURN;
END_IF
END_FOR
Step := 70;
{END_IF}
70:
IF _RecipeCleaning OR _RecipeEmergency THEN
_Step := 80;
RETURN;
END_IF
IF Robot.MoveStartPosition() THEN
_Step := 80;
END_IF
80:
{IF defined (variable: vSpinnerWasteTank)}
IF IO.bInWasteTankOK THEN
Step := 90;
ELSE
iStationStatus.ErrorIndex := AlarmSend(iStationStatus.iStation, SPINNER_ErrorNr.wWasteTank, TRUE, eReportType.Warning, sAvailableResponse.RetryCancel, FALSE);
iStationStatus.StepRetry := 80;
iStationStatus.Error := TRUE;
END_IF
{ELSE}
_Step := 90;
{END_IF}
90:
_Step := 100;
100:
_Step := 0;
CloseInOut := TRUE;
END_CASE]]></ST>
</Implementation>
</Method>
<Method Name="FB_Init" Id="{4d780ade-4cd3-4c92-a20d-24fac5b7ba0a}">
<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;
_VisuName := 'ETCHER';
_bStatusText := TRUE;
_SchedulerManagement := TRUE;
_ManualSizeSelectionAvailable := TRUE;
]]></ST>
</Implementation>
</Method>
<Method Name="GetCenter" Id="{3de78bbd-2b43-4642-ab7b-56946e5cc602}" FolderPath="SubstrateCalibration\">
<Declaration><![CDATA[METHOD GetCenter : BOOL;
VAR_INPUT
Puddle : INT;
END_VAR
VAR_INST
Step : INT;
iSize : USINT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[CASE Step OF
0:
ROBOT_MAIN.TargetStation := iStation;
ROBOT_MAIN.TargetPuddle := Puddle;
CMD[RobotStation] := GetCMD;
IF StationsStatus[RobotStation].Ist.Busy THEN
Step := Step +1;
END_IF
1:
IF NOT StationsStatus[RobotStation].Ist.Busy THEN
Step := 10;
END_IF
10:
ROBOT_MAIN.TargetStation := AlignerStation;
ROBOT_MAIN.TargetPuddle := Puddle;
CMD[RobotStation] := PutCMD;
IF StationsStatus[RobotStation].Ist.Busy THEN
Step := Step +1;
END_IF
11:
IF NOT StationsStatus[RobotStation].Ist.Busy THEN
Step := 20;
END_IF
20:
ALIGNER_MAIN.bCalibration := TRUE;
CMD[AlignerStation] := CloseInCMD;
StationsStatus[AlignerStation].Soll.AutoStart := TRUE;
Step := Step +1;
21:
IF StationsStatus[AlignerStation].Ist.PrepOut THEN
CASE rCheckPrepoutCalibrationPosition OF
0:
Center[0] := ALIGNER_MAIN.Center;
180:
Center[1] := ALIGNER_MAIN.Center;
END_CASE
Step := 50;
END_IF
50:
ROBOT_MAIN.TargetStation := AlignerStation;
ROBOT_MAIN.TargetPuddle := Puddle;
CMD[RobotStation] := GetCMD;
IF StationsStatus[RobotStation].Ist.Busy THEN
Step := Step +1;
END_IF
51:
IF NOT StationsStatus[RobotStation].Ist.Busy THEN
Step := 60;
END_IF
60:
ROBOT_MAIN.TargetStation := iStation;
ROBOT_MAIN.TargetPuddle := Puddle;
CMD[RobotStation] := PutCMD;
IF StationsStatus[RobotStation].Ist.Busy THEN
Step := Step +1;
END_IF
61:
IF NOT StationsStatus[RobotStation].Ist.Busy THEN
Step := 100;
END_IF
100:
iStationStatus.Ist.PrepIn := FALSE;
iStationStatus.Ist.PrepOut := FALSE;
Step := 0;
GetCenter := TRUE;
END_CASE]]></ST>
</Implementation>
</Method>
<Property Name="iChuckSize" Id="{5f66ddb7-13be-4f58-acb5-9cdc429266a1}">
<Declaration><![CDATA[PROPERTY iChuckSize : INT]]></Declaration>
<Get Name="Get" Id="{a5e16635-3300-498c-bb18-69526593bde1}">
<Declaration><![CDATA[VAR
i, iCount : INT;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[FOR i := 1 TO 3 DO
IF NOT IO.bInChuckAvailable[i] AND NOT IO.bInChuckCoding[i] THEN
iChuckSize := i;
iCount := iCount +1;
ELSIF NOT IO.bInChuckAvailable[i] THEN
iCount := iCount +1;
ELSIF NOT IO.bInChuckCoding[i] THEN
iCount := iCount +1;
END_IF
END_FOR
IF iCount > 1 THEN
iChuckSize := -1;
END_IF]]></ST>
</Implementation>
</Get>
</Property>
<Method Name="INIT" Id="{f22c5665-a43b-4068-a66a-c631e269acfa}">
<Declaration><![CDATA[METHOD INIT : BOOL
VAR
i : INT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[CASE _Step OF
0:
{IF defined (variable: vSpinnerDoorLcok)}
IF IO.Lock.Lock() THEN
_Step := 11;
END_IF
{ELSIF defined (variable: vSpinnerHatch)}
IF IO.Hatch.Close() THEN
_Step := 20;
END_IF
{ELSE}
_Step := 15;
{END_IF}
11:
IF IO.RobotDoorLock.Lock() THEN
_Step := 15;
END_IF
15:
{IF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Up() THEN
_Step := 20;
END_IF
{ELSE}
_Step := 20;
{END_IF}
20:
{IF defined (variable: vSpinnerMotorLift)}
IF IO.MotorLift.bInUp THEN
_Step := _Step +1;
ELSIF IO.MotorLift.bInDown THEN
IO.MotorLift.Down();
_Step := 30;
RETURN;
ELSE
_Step := _Step +1;
END_IF
{ELSE}
_Step := 25;
{END_IF}
21:
{IF defined (variable: vSpinnerMotorLift)}
IO.MotorLift.Up();
DelayTimer(IN := TRUE, PT := T#1S);
IF DelayTimer.Q THEN
DelayTimer(IN := FALSE, PT := T#1S);
_Step := _Step +1;
END_IF
{END_IF}
22:
{IF defined (variable: vSpinnerMotorLift)}
IF IO.MotorLift.Down() THEN
_Step := 30;
END_IF
{END_IF}
25:
{IF defined (variable: vSpinnerSplashRing)}
IF IO.SplashRing.Up() THEN
_Step := 30;
END_IF
{ELSE}
_Step := 30;
{END_IF}
30:
BSRAxis.bOutReady := FALSE;
IF BSRAxis.Init() THEN
_Step := _Step +1;
END_IF
31:
IF BSRAxis.bOutReady THEN
_Step := 40;
END_IF
40:
IF IO.ChuckChange(FALSE) THEN
_Step := _Step +1;
END_IF
41:
Chuck.bOutReady := FALSE;
_Step := _Step +1;
42:
IF Chuck.Init() THEN
_Step := 50;
END_IF
50:
{IF defined (variable: vJulabo)}
FOR i := 1 TO vJulabo DO
Julabo[i].Init(Config.JulaboDefaultTemperature);
END_FOR
{ELSE}
_Step := 60;
{END_IF}
60:
IF Robot.INIT() THEN
_Step := 90;
END_IF
90:
{IF defined (variable: vChuckVacuum)}
IO.ChuckVacuum.Up(TRUE);
_Step := _Step +1;
{ELSE}
IO.bOutMediaEnable := TRUE;
iStationStatus.WaferInfo.Number := 0;
Step := 100;
{END_IF}
91:
{IF defined (variable: vChuckVacuum)}
WaferCheckTimer(IN := TRUE, PT := WaferCheckTime);
IF WaferCheckTimer.Q THEN
WaferCheckTimer(IN := FALSE);
iStationStatus.WaferInfo[0].Number := 0;
_Step := _Step +1;
RETURN;
END_IF
IF IO.ChuckVacuum.bInUp THEN
WaferCheckTimer(IN := FALSE);
iStationStatus.WaferInfo[0].Number := 100;
_Step := 100;
END_IF
{END_IF}
92:
{IF defined (variable: vChuckVacuum)}
IO.ChuckVacuum.Down(TRUE);
WaferCheckTimer(IN := FALSE);
_Step := 100;
{END_IF}
100:
INIT := TRUE;
_Step := 0;
END_CASE
]]></ST>
</Implementation>
</Method>
<Method Name="Initialization" Id="{78d7def2-a005-497b-9f89-53647a3aadc7}">
<Declaration><![CDATA[METHOD Initialization : BOOL
VAR_INPUT
iStation : INT;
END_VAR
VAR
i : INT;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[InitializationExt(iStation);
iStationStatus.NoScan := TRUE;
iStationStatus.StandbyAvailable := TRUE;
iStationStatus.CleanningRecipeAvailable := TRUE;
iStationStatus.EmergencyRecipeAvailable := TRUE;
iStationStatus.ConfigEnterAllowedInAdmin := TRUE;
iStationStatus.StationName := CONCAT('Etcher ', StationIndex);
RecipeStationName[iStation] := 'Etcher';
iStationStatus.ErrorList := 'SPINNER_ErrorNr';
ConfigPlausibility REF= Config.ConfigPlausibility;
iStationStatus.RecipeStatus.StepCount REF= SPINNER_RECIPE_EDITE.STEP_COUNT;
ConfigManagement.Initialization(ADR(Config), ADR(ConfigOld), SIZEOF(Config), 'sSpinnerConfig', CONCAT('Etcher', StationIndex));
RecipeManagement.Initialization(
iStation,
ADR(RecipeLoad),
ADR(SPINNER_RECIPE_EDITE),
ADR(SPINNER_RECIPE_EMPTY),
ADR(RecipeRead),
ADR(Recipe),
SIZEOF(sSpinnerRecipe),
'sSpinnerRecipe',
SIZEOF(sSpinnerStepData)
);
IO.Config REF= Config;
IO.Chuck REF= Chuck;
IO.Initialization(iStation);
IO._RecipeStandby REF= _RecipeStandby;
FOR i := 1 TO 9 DO
NozzleCheckNames[i] := iMediaArray[i].ServiceName[0];
END_FOR
Robot.Config REF= Config.Robot;
Robot.ControlIndex_Init := eSpinnerMedienNamen.Robot_Init;
Robot.ControlIndex_Home := eSpinnerMedienNamen.Robot_Home;
Robot.ControlIndex_StratPosition := eSpinnerMedienNamen.Robot_StartPosition;
Robot.ControlIndex_Move := eSpinnerMedienNamen.Robot_Move;
Robot.ControlIndex_Pause := eSpinnerMedienNamen.Robot_Pause;
Robot.ControlIndex_BrakeRelease := eSpinnerMedienNamen.Robot_BrakeRelease;
Robot.Initialization(iStation);
Robot.ExternalModeErrorIndex := SPINNER_ErrorNr.eRobotNotInExternalMode;
Robot.HomePositionErrorIndex := SPINNER_ErrorNr.eRobotNotInHomePosition;
iMediaArray[eSpinnerMedienNamen.NozzleCheck].ServiceName[0] := 'Nozzle Check';
iMediaArray[eSpinnerMedienNamen.NozzleCheck].bReferenceControl REF= bNozzleCheck;
iMediaArray[eSpinnerMedienNamen.NozzleCheck].InputAvailable := TRUE;
//Signal REF= SpinnerSiganl[iStation];
//Chuck
//Chuck REF= SpinnerChuck[iStation];
Chuck.iStation := iStation;
Chuck.DeviceID := 1;
Chuck.rInTolerance := 0.1;
Chuck.Factor := 6;
Chuck.bInEnableNegative := TRUE;
Chuck.bInEnablePositive := TRUE;
Chuck.bInSoEReset := TRUE;
Chuck.bInOnlySpeed := TRUE;
Chuck.sInName := 'Chuck';
Chuck.sInPositionUnit := '°';
Chuck.sInVelocityUnit := 'rpm';
Chuck.sInAccelerationUnit := 'rpm/s';
Chuck.rInMinVelocity := 0;
//End_Chuck
//BSR Axis
BSRAxis.iStation := iStation;
BSRAxis.DeviceID := 2;
BSRAxis.rInTolerance := 0.1;
BSRAxis.bInEnableNegative := TRUE;
BSRAxis.bInEnablePositive := TRUE;
BSRAxis.sInName := 'BSR';
BSRAxis.sInPositionUnit := '°';
BSRAxis.rInMinPosition := 0; // °
BSRAxis.rInMaxPosition := 90; // °
BSRAxis.sInVelocityUnit := '°/s';
BSRAxis.rInMinVelocity := 1; // °/s
BSRAxis.rInMaxVelocity := 90; // °/s
BSRAxis.rInTargetVelocity := BSRAxis.rInMaxVelocity;
BSRAxis.sInAccelerationUnit := '°/s2';
BSRAxis.rInMinAcceleration := 1; // °/s2
BSRAxis.rInMaxAcceleration := 900; // °/s2
BSRAxis.rInTargetAcceleration := BSRAxis.rInMaxAcceleration;
iStationStatus.CurrentStep REF= CurrentStep;
iStationStatus.STEP_COUNT REF= Recipe.STEP_COUNT;
DataLoggerV2.Data[1].Name := 'Chuck Speed(RPM)';
DataLoggerV2.Data[1].Value REF= Chuck.rOutCurrentVelocity;
DataLoggerV2.Data[1].Precision := 0;
DataLoggerV2.Data[1].Tolerence := 1;
DataLoggerV2.Data[2].Name := 'BSR(mm)';
DataLoggerV2.Data[2].Value REF= BSRAxis.rOutCurrentModuloPosition;
DataLoggerV2.Data[2].Precision := 1;
DataLoggerV2.Data[2].Tolerence := 1;
DataLoggerV2.Data[3].Name := 'Robot X Axis(mm)';
DataLoggerV2.Data[3].Value REF= Robot.rInCurrentCartesianPosition[1];
DataLoggerV2.Data[3].Precision := 3;
DataLoggerV2.Data[3].Tolerence := 0.01;
DataLoggerV2.Data[4].Name := 'Robot Y Axis(mm)';
DataLoggerV2.Data[4].Value REF= Robot.rInCurrentCartesianPosition[2];
DataLoggerV2.Data[4].Precision := 3;
DataLoggerV2.Data[4].Tolerence := 0.01;
DataLoggerV2.Data[5].Name := 'Robot Z Axis(mm)';
DataLoggerV2.Data[5].Value REF= Robot.rInCurrentCartesianPosition[3];
DataLoggerV2.Data[5].Precision := 3;
DataLoggerV2.Data[5].Tolerence := 0.01;
DataLoggerV2.Data[6].Name := 'Robot A Axis(°)';
DataLoggerV2.Data[6].Value REF= Robot.rInCurrentCartesianPosition[4];
DataLoggerV2.Data[6].Precision := 3;
DataLoggerV2.Data[6].Tolerence := 0.01;
DataLoggerV2.Data[7].Name := 'Robot B Axis(°)';
DataLoggerV2.Data[7].Value REF= Robot.rInCurrentCartesianPosition[5];
DataLoggerV2.Data[7].Precision := 3;
DataLoggerV2.Data[7].Tolerence := 0.01;
DataLoggerV2.Data[8].Name := 'Robot C Axis(°)';
DataLoggerV2.Data[8].Value REF= Robot.rInCurrentCartesianPosition[6];
DataLoggerV2.Data[8].Precision := 3;
DataLoggerV2.Data[8].Tolerence := 0.01;
DataLoggerV2.Data[9].Name := 'FLOW SF1(ml)';
DataLoggerV2.Data[9].Value REF= IO.FlowSensor[1].rOutCurrentFlow;
DataLoggerV2.Data[9].Precision := 0;
DataLoggerV2.Data[9].Tolerence := 1;
DataLoggerV2.Data[10].Name := 'FLOW SF3(ml)';
DataLoggerV2.Data[10].Value REF= IO.FlowSensor[2].rOutCurrentFlow;
DataLoggerV2.Data[10].Precision := 0;
DataLoggerV2.Data[10].Tolerence := 1;
DataLoggerV2.Data[11].Name := 'FLOW SF2(ml)';
DataLoggerV2.Data[11].Value REF= IO.FlowSensor[3].rOutCurrentFlow;
DataLoggerV2.Data[11].Precision := 0;
DataLoggerV2.Data[11].Tolerence := 1;
DataLoggerV2.Data[12].Name := 'FLOW SEF2(ml)';
DataLoggerV2.Data[12].Value REF= IO.FlowSensor[4].rOutCurrentFlow;
DataLoggerV2.Data[12].Precision := 0;
DataLoggerV2.Data[12].Tolerence := 1;
DataLoggerV2.Data[13].Name := 'FLOW SEF1(ml)';
DataLoggerV2.Data[13].Value REF= IO.FlowSensor[5].rOutCurrentFlow;
DataLoggerV2.Data[13].Precision := 0;
DataLoggerV2.Data[13].Tolerence := 1;
DataLoggerV2.Data[14].Name := 'FLOW C2H4O2(ml)';
DataLoggerV2.Data[14].Value REF= IO.FlowSensor[6].rOutCurrentFlow;
DataLoggerV2.Data[14].Precision := 0;
DataLoggerV2.Data[14].Tolerence := 1;
DataLoggerV2.Data[15].Name := 'FLOW Static Nozzle C2H4O2(ml)';
DataLoggerV2.Data[15].Value REF= IO.FlowSensor[7].rOutCurrentFlow;
DataLoggerV2.Data[15].Precision := 0;
DataLoggerV2.Data[15].Tolerence := 1;
DataLoggerV2.Data[16].Name := 'FLOW FilmEtchings(ml)';
DataLoggerV2.Data[16].Value REF= IO.FlowSensor[8].rOutCurrentFlow;
DataLoggerV2.Data[16].Precision := 0;
DataLoggerV2.Data[16].Tolerence := 1;
DataLoggerV2.Data[17].Name := 'FLOW HF(ml)';
DataLoggerV2.Data[17].Value REF= IO.FlowSensor[9].rOutCurrentFlow;
DataLoggerV2.Data[17].Precision := 0;
DataLoggerV2.Data[17].Tolerence := 1;
]]></ST>
</Implementation>
</Method>
<Method Name="MAIN" Id="{89bf7a08-7a8c-4c5a-ae80-d4001a31b9af}">
<Declaration><![CDATA[METHOD MAIN : BOOL
VAR_INPUT
END_VAR
VAR
Nozzle : DWORD;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[IO();
IF NOT Robot.bInHomePosition THEN
iStationStatus.Ist.PrepIn := FALSE;
iStationStatus.Ist.PrepOut := FALSE;
END_IF
//Chuck
Chuck.rInMaxVelocity := MaxSetSpeed(iStationStatus.iStation);
Chuck.rInMaxAcceleration := MaxSetAcceleration(iStationStatus.iStation);
Chuck();
//End_Chuck
Robot();
BSRAxis();
iStationStatus.ErrorIndex := AlarmSend(
iStation := iStation,
MsgId := SPINNER_ErrorNr.eChuckStorageFault,
Popup := FALSE,
ReportType := eReportType.Error,
Availableresponse := sAvailableResponse.OK,
Input := iChuckSize <> -1);
IF NOT TrayJob.Start THEN
NozzlesChecked := FALSE;
END_IF
iMediaArray[eSpinnerMedienNamen.NozzleCheck].Invisible := FALSE;
IF NozzleCheckIndex = 0 THEN
iMediaArray[eSpinnerMedienNamen.NozzleCheck].Invisible := TRUE;
END_IF
IF NOT iStationStatus.Ist.InitDone THEN
iMediaArray[eSpinnerMedienNamen.NozzleCheck].Invisible := TRUE;
END_IF
//IF KUKA.bInProcessPositionStart OR
// KUKA.bOutInProcessPosition THEN
// iMediaArray[eSpinnerMedienNamen.NozzleCheck].Invisible := TRUE;
//END_IF
IF bNozzleCheck THEN
Nozzle := SETBIT32(Nozzle, NozzleCheckIndex);
// NozzlesCheck(Nozzle);
END_IF
IF bCalibration THEN
SubstrateCalibration();
END_IF
]]></ST>
</Implementation>
</Method>
<Method Name="MEDIA" Id="{817f236a-321f-4dcb-bd14-188335317e5f}">
<Declaration><![CDATA[METHOD MEDIA : BOOL
VAR_INPUT
TargetMedia : UDINT;
END_VAR
VAR
i : SINT;
CleanerMediaName : eSpinnerMedienNamen;
HighPressurePump: INT;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[FOR i := 1 TO 31 DO
iMediaArray[i].bReferenceControl := GETBIT32(TargetMedia, i);
END_FOR
IF IO.bOutPuddleNozzleC2H4O2 THEN
IO.bOutSwitchC2H4O2_DIW := TRUE;
END_IF
IF IO.bOutPuddleNozzleDIWHot THEN
IO.bOutSwitchC2H4O2_DIW := FALSE;
END_IF
IF IO.bOutPuddleNozzleSF3 THEN
IO.bOutSwitchSF3_FilmEtchings := TRUE;
END_IF
IF IO.bOutPuddleNozzleFilmEtchings THEN
IO.bOutSwitchSF3_FilmEtchings := FALSE;
END_IF
IF IO.bOutPuddleNozzleSF2 THEN
IO.bOutSwitchSF1_SEF1 := TRUE;
END_IF
IF IO.bOutPuddleNozzleSEF1 THEN
IO.bOutSwitchSF1_SEF1 := FALSE;
END_IF
LeviPump[2].bOutRecirculation := TRUE;
LeviPump[8].bOutRecirculation := TRUE;
LeviPump[9].bOutRecirculation := TRUE;]]></ST>
</Implementation>
</Method>
<Method Name="NozzlesCheck" Id="{ee5e12ad-fd28-4602-91ab-9a9926040c79}" FolderPath="NozzleCheck\">
<Declaration><![CDATA[METHOD NozzlesCheck : BOOL
VAR_INPUT
TargetNozzleCheck : DWORD := 0;
END_VAR
VAR_INST
Step : INT;
TargetNozzle : ARRAY[1..6] OF BOOL;
NozzlesCheckCounter : USINT;
DelayTimer : TON;
ProblemTimer : TON;
fbProblemTimer : ProblemTimer_FB;
Error : BOOL;
ReferencePosition : sPoint;
END_VAR
VAR
i : SINT;
CurrentFlow : LREAL;
FlowOk : BOOL;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[IF iStationStatus.Soll.Stop THEN
Step := 0;
fbProblemTimer(iStation := iStation);
RETURN;
END_IF
fbProblemTimer(iStation := iStation, Step := Step);
IF fbProblemTimer.Error THEN
RETURN;
END_IF
CASE Step OF
0:
//NozzlesChecked := TRUE;
IF NozzlesChecked THEN
Step := 210;
ELSE
Step := 10;
END_IF
10:
IF NOT iStationStatus.Ist.Busy AND iStationStatus.Ist.CloseOut THEN
Step := 15;
END_IF
15:
FOR i :=1 TO 32 DO
IF GETBIT32(TargetNozzleCheck, i) THEN
iMediaArray[i].bReferencePrepareMedia := TRUE;
END_IF
END_FOR
Step := 20;
20:
//IF KUKA.ProcessProgramStart() THEN
// FOR i := 1 TO 6 DO
// TargetNozzle[i] := FALSE;
// END_FOR
// Step := 30;
//END_IF
30:
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSF3)) THEN
TargetNozzle[1] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleFilmEtchings)) THEN
TargetNozzle[1] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSF1)) THEN
TargetNozzle[2] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleC2H4O2)) THEN
TargetNozzle[3] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleDIWHot)) THEN
TargetNozzle[3] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSEF2)) THEN
TargetNozzle[4] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleHF)) THEN
TargetNozzle[5] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSF2)) THEN
TargetNozzle[6] := TRUE;
END_IF
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSEF1)) THEN
TargetNozzle[6] := TRUE;
END_IF
Step := 40;
40:
NozzlesCheckCounter := NozzlesCheckCounter +1;
IF NozzlesCheckCounter > 6 THEN
NozzlesCheckCounter := 0;
Step := 200;
ELSE
IF TargetNozzle[NozzlesCheckCounter] THEN
Step := 50;
END_IF
END_IF
50:
IF NozzlesCheck_MoveToSafePosition(NozzlesCheckCounter) THEN
Step := 60;
END_IF
60:
IF NozzlesCheck_MoveToNozzlePosition(NozzlesCheckCounter) THEN
Step := 70;
END_IF
70:
LeviPump[2].bOutRecirculation := TRUE;
LeviPump[8].bOutRecirculation := TRUE;
LeviPump[9].bOutRecirculation := TRUE;
CASE NozzlesCheckCounter OF
1:
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSF3)) THEN
IO.bOutPuddleNozzleSF3 := TRUE;
IO.bOutSwitchSF3_FilmEtchings := TRUE;
ELSIF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleFilmEtchings)) THEN
IO.bOutPuddleNozzleFilmEtchings := TRUE;
IO.bOutSwitchSF3_FilmEtchings := FALSE;
END_IF
2:
IO.bOutPuddleNozzleSF1 := TRUE;
3:
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleC2H4O2)) THEN
IO.bOUTPuddleNozzleC2H4O2 := TRUE;
IO.bOutSwitchC2H4O2_DIW := TRUE;
ELSIF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleDIWHot)) THEN
IO.bOutPuddleNozzleDIWHot := TRUE;
IO.bOutSwitchC2H4O2_DIW := FALSE;
END_IF
4:
IO.bOutPuddleNozzleSEF2 := TRUE;
5:
IO.bOutPuddleNozzleHF := TRUE;
6:
IF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSF2)) THEN
IO.bOutPuddleNozzleSF2 := TRUE;
IO.bOutSwitchSF1_SEF1 := TRUE;
ELSIF GETBIT32(TargetNozzleCheck, ANY_TO_SINT(eSpinnerMedienNamen.PuddleNozzleSEF1)) THEN
IO.bOutPuddleNozzleSEF1 := TRUE;
IO.bOutSwitchSF1_SEF1 := FALSE;
END_IF
END_CASE
Step := Step +1;
71:
FlowOk := iMediaArray[NozzlesCheckCounter].FlowOk;
IF iMediaArray[NozzlesCheckCounter].Underrange THEN
fbProblemTimer.MsgID := iMediaArray[NozzlesCheckCounter].ErrorIndex_Underrange;
ELSIF iMediaArray[NozzlesCheckCounter].Overrange THEN
fbProblemTimer.MsgID := iMediaArray[NozzlesCheckCounter].ErrorIndex_Overrange;
END_IF
fbProblemTimer.AvailableResponse := sAvailableResponse.AbortRetryIgnore;
fbProblemTimer.StepRetry := 70;
fbProblemTimer.StepIgnore := 150;
fbProblemTimer.Timeout := T#5S;
IF FlowOk THEN
fbProblemTimer.Timeout := T#0S;
Step := 80;
//Test
//Step := 150;
END_IF
80:
ReferencePosition := Config.Robot.NozzleCalibration[NozzlesCheckCounter].ReferencePosition;
IF IO.StrahlSensor.ChangeParameter(NozzlesCheckCounter) THEN
Step := Step +1;
END_IF
81:
//KUKA.rOutOverride := 1;
IF ABS(ReferencePosition.Y-IO.StrahlSensor.rInPositionZ) > 0.02 THEN
Step := 90;
ELSIF ABS(ReferencePosition.X-IO.StrahlSensor.rInPositionX) > 0.02 THEN
Step := 100;
ELSE
//rNozzleCalibration[NozzlesCheckCounter].X := KUKA.rOutCCord - KUKA.rInCCord;
//rNozzleCalibration[NozzlesCheckCounter].Y := KUKA.rOutACord - KUKA.rInACord;
Step := 150;
END_IF
90:
//KUKA.bOut_Jog_A_N := FALSE;
//KUKA.bOut_Jog_A_P := FALSE;
IF ABS(ReferencePosition.Y-IO.StrahlSensor.rInPositionZ) > 0.02 THEN
//IF KUKA.bIn_ROB_STOPPED THEN
// Step := Step +1;
//END_IF
ELSE
Step := 80;
END_IF
91:
//KUKA.bOut_Jog_A_P := ReferencePosition.Y > IO.StrahlSensor.rInPositionZ;
//KUKA.bOut_Jog_A_N := NOT KUKA.bOut_Jog_A_P;
Step := Step +1;
92:
IF ABS(ReferencePosition.Y - IO.StrahlSensor.rInPositionZ) < 0.02 THEN
Step := 90;
END_IF
(*IF KUKA.bOut_Jog_A_P THEN
IF ReferencePosition.Y < IO.StrahlSensor.rInPositionZ THEN
Step := 90;
END_IF
END_IF
IF KUKA.bOut_Jog_A_N THEN
IF ReferencePosition.Y > IO.StrahlSensor.rInPositionZ THEN
Step := 90;
END_IF
END_IF*)
100:
//KUKA.bOut_Jog_C_N := FALSE;
//KUKA.bOut_Jog_C_P := FALSE;
IF ABS(ReferencePosition.X-IO.StrahlSensor.rInPositionX) > 0.02 THEN
//IF KUKA.bIn_ROB_STOPPED THEN
// Step := Step +1;
//END_IF
ELSE
Step := 80;
END_IF
101:
//KUKA.bOut_Jog_C_P := ReferencePosition.X < IO.StrahlSensor.rInPositionX;
//KUKA.bOut_Jog_C_N := NOT KUKA.bOut_Jog_C_P;
Step := Step +1;
102:
IF ABS(ReferencePosition.X - IO.StrahlSensor.rInPositionX) < 0.02 THEN
Step := 100;
END_IF
(*IF KUKA.bOut_Jog_C_P THEN
IF ReferencePosition.X > IO.StrahlSensor.rInPositionX THEN
Step := 100;
END_IF
END_IF
IF KUKA.bOut_Jog_C_N THEN
IF ReferencePosition.X < IO.StrahlSensor.rInPositionX THEN
Step := 100;
END_IF
END_IF*)
150:
IO.bOutPuddleNozzleHF := FALSE;
IO.bOutPuddleNozzleSF3 := FALSE;
IO.bOutSwitchSF3_FilmEtchings := FALSE;
IO.bOutPuddleNozzleSF1 := FALSE;
IO.bOUTPuddleNozzleC2H4O2 := FALSE;
IO.bOutSwitchC2H4O2_DIW := FALSE;
IO.bOutPuddleNozzleSEF2 := FALSE;
IO.bOutPuddleNozzleSEF1 := FALSE;
//KUKA.bOut_Jog_A_N := FALSE;
//KUKA.bOut_Jog_A_P := FALSE;
//KUKA.bOut_Jog_C_N := FALSE;
//KUKA.bOut_Jog_C_P := FALSE;
IF NozzlesCheck_MoveToSafePosition(NozzlesCheckCounter) THEN
Step := 40;
END_IF
200:
IO.StrahlSensor.bOutSensorOn := FALSE;
//IF KUKA.ProcessProgramStop() THEN
// Step := 210;
//END_IF
210:
NozzlesChecked := TRUE;
NozzlesCheck := TRUE;
Step := 0;
bNozzleCheck := FALSE;
END_CASE
]]></ST>
</Implementation>
</Method>
<Method Name="NozzlesCheck_MoveToNozzlePosition" Id="{ebcd94b9-5c75-41ac-92fe-36bbd0a6a851}" FolderPath="NozzleCheck\">
<Declaration><![CDATA[METHOD NozzlesCheck_MoveToNozzlePosition : BOOL;
VAR_INPUT
NozzleNr : USINT := 0;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[KUKA.rOutNozzleNumber := NozzleNr;
KUKA.rOutTargetSpeed := 200;
KUKA.MoveType := eSpinnerKUKAMoveType.MoveNozzlePosition;
IF KUKA.StartPos() THEN
NozzlesCheck_MoveToNozzlePosition := TRUE;
END_IF]]></ST>
</Implementation>
</Method>
<Method Name="NozzlesCheck_MoveToSafePosition" Id="{5d0267ea-8970-4847-87ae-b5bca9f8d641}" FolderPath="NozzleCheck\">
<Declaration><![CDATA[METHOD NozzlesCheck_MoveToSafePosition : BOOL;
VAR_INPUT
NozzleNr : USINT := 0;
END_VAR
VAR_INST
sTargetPosition : sPosition;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[KUKA.rOutXCord := 0;
KUKA.rOutYCord := 0;
KUKA.rOutZCord := 60;
KUKA.rOutACord := 0;
KUKA.rOutBCord := 0;
KUKA.rOutCCord := 0;
KUKA.rOutNozzleNumber := NozzleNr;
KUKA.rOutTargetSpeed := 200;
KUKA.MoveType := eSpinnerKUKAMoveType.MovePosition;
IF KUKA.StartPos() THEN
NozzlesCheck_MoveToSafePosition := TRUE;
END_IF]]></ST>
</Implementation>
</Method>
<Method Name="PrepInOut" Id="{a24592fb-d617-4050-bfa7-310dbc32a579}">
<Declaration><![CDATA[METHOD PrepInOut : BOOL]]></Declaration>
<Implementation>
<ST><![CDATA[CASE _Step OF
0:
{IF defined (variable: vSpinnerDoorLcok)}
IF IO.Lock.Lock() THEN
_Step := 10;
END_IF
{ELSIF defined (variable: vSpinnerHatch)}
IF IO.Hatch.Close() THEN
_Step := 20;
END_IF
{ELSIF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Up() THEN
_Step := 20;
END_IF
{ELSE}
_Step := 20;
{END_IF}
10:
{IF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Up() THEN
_Step := 20;
END_IF
{ELSE}
_Step := 20;
{END_IF}
20:
{IF defined (variable: vSpinnerMotorLift)}
IF IO.MotorLift.Down() THEN
_Step := 30;
END_IF
{ELSIF defined (variable: vSpinnerSplashRing)}
IF IO.SplashRing.Up() THEN
_Step := 30;
END_IF
{ELSE}
_Step := 30;
{END_IF}
30:
IF IO.ChuckChange(FALSE) THEN
_Step := _Step +1;
END_IF
31:
IO.ChuckVacuum.Up(TRUE);
IF Chuck.bOutReady AND Chuck.bOutEnabled AND Chuck.bInEnable THEN
_Step := 35;
ELSE
Chuck.bOutReady := FALSE;
Chuck.bInEnable := FALSE;
_Step := _Step +1;
END_IF
32:
IF Chuck.Init() THEN
_Step := 35;
END_IF
35:
IF Chuck.bOutReady THEN
IF bCheckPrepoutCalibration THEN
Chuck.rInTargetPosition := rCheckPrepoutCalibrationPosition;
ELSE
Chuck.rInTargetPosition := Config.Chuck.HomePosition;
END_IF
Chuck.rInTargetVelocity := Config.Chuck.HomeSpeed;
Chuck.rInTargetAcceleration := Config.Chuck.HomeAcceleration;
Chuck.bInStartModuloPosition := TRUE;
Chuck.bOutReady := FALSE;
_Step := _Step +1;
END_IF
36:
IF Chuck.bOutReady THEN
_Step := 40;
END_IF
40:
IF BSRAxis.bOutReady THEN
BSRAxis.rInTargetPosition := 0;
BSRAxis.rInTargetVelocity := 90;
BSRAxis.rInTargetAcceleration := 900;
BSRAxis.bInStartPosition := TRUE;
BSRAxis.bOutReady := FALSE;
_Step := _Step +1;
END_IF
41:
IF BSRAxis.bOutReady THEN
_Step := 50;
END_IF
50:
CASE iCMD OF
PrepInCMD:
{IF defined (variable: vChuckVacuum)}
IF IO.ChuckVacuum.Down() THEN
_Step := 60;
END_IF
{ELSE}
Step := 60;
{END_IF}
PrepOutCMD:
_Step := 60;
END_CASE
60:
IF Robot.MoveHome() THEN
_Step := 70;
END_IF
70:
{IF defined (variable: vSpinnerMotorLift)}
IF IO.MotorLift.Up() THEN
Step := Step +1;
END_IF
{ELSIF defined (variable: vSpinnerSplashRing)}
IF IO.SplashRing.Down() THEN
Step := 80;
END_IF
{ELSIF defined (variable: vSpinnerShutter)}
IF IO.Shutter.Down() THEN
_Step := 80;
END_IF
{ELSE}
Step := 80;
{END_IF}
71:
DelayTimer(IN := TRUE, PT := T#1S);
IF DelayTimer.Q THEN
DelayTimer(IN := FALSE);
_Step := 80;
END_IF
80:
CASE iCMD OF
PrepInCMD:
_Step := 90;
PrepOutCMD:
_Step := 90;
END_CASE
90:
//{IF defined (variable: vSpinnerDoorLcok)}
//IO.Lock.UnLock();
//{ELSIF defined (variable: vSpinnerHatch)}
//IO.Hatch.Open();
//{END_IF}
IF IO.ChuckVacuum.Down() THEN
_Step := 100;
END_IF
100:
IO.bOutMeasuringChamberRinseN2 := FALSE;
_Step := 0;
PrepInOut := TRUE;
END_CASE
]]></ST>
</Implementation>
</Method>
<Method Name="RCPAddStep" Id="{ace338c9-9605-43e4-bccc-2c077e477951}">
<Declaration><![CDATA[METHOD RCPAddStep : BOOL
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[MEMMOVE(
ADR(SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep+1]),
ADR(SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep]),
SIZEOF(SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep])*(SPINNER_RECIPE_EDITE.STEP_COUNT-RecipeCurrentStep+1)
);
SPINNER_RECIPE_EDITE.STEP_COUNT := SPINNER_RECIPE_EDITE.STEP_COUNT+1;
RecipeCurrentStep := RecipeCurrentStep +1;
SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep].LOOPS := 0;
SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep].STEPWITH := 0;
]]></ST>
</Implementation>
</Method>
<Method Name="RCPStepRemove" Id="{60477bd1-4840-48b3-9c6a-8c6c30d9fe10}">
<Declaration><![CDATA[METHOD RCPStepRemove : BOOL
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[IF SPINNER_RECIPE_EDITE.STEP_COUNT = (RecipeCurrentStep) THEN
RecipeCurrentStep := RecipeCurrentStep -1;
ELSE
MEMMOVE(
ADR(SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep]),
ADR(SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep+1]),
SIZEOF(SPINNER_RECIPE_EDITE.DATA[RecipeCurrentStep])*(SPINNER_RECIPE_EDITE.STEP_COUNT-RecipeCurrentStep)
);
END_IF
SPINNER_RECIPE_EDITE.STEP_COUNT := SPINNER_RECIPE_EDITE.STEP_COUNT-1;]]></ST>
</Implementation>
</Method>
<Method Name="RecipeVisu" Id="{d347167b-e1b9-4a37-919f-21269bfefb11}">
<Declaration><![CDATA[METHOD RecipeVisu : BOOL
VAR
i : INT;
Counter : BYTE;
END_VAR
VAR_INST
Step : INT;
(* RecipeOldArm : ARRAY[1..SPINNER_MaxNumberOfArm] OF sSpinnerRecipeArmStep;*)
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[CASE Step OF
0:
iMediaArray[eSpinnerMedienNamen.PuddleNozzleHF].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleFilmEtchings].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleC2H4O2].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSF1].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSF2].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSF3].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSEF1].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSEF2].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleDIWHot].InvisibleRecipe := FALSE;
iMediaArray[eSpinnerMedienNamen.StaticNozzleC2H4O2].InvisibleRecipe := FALSE;
IF VisuEmergencyRecipe OR VisuCleaningRecipe THEN
iMediaArray[eSpinnerMedienNamen.PuddleNozzleHF].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleFilmEtchings].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleC2H4O2].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSF1].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSF2].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSF3].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSEF1].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.PuddleNozzleSEF2].InvisibleRecipe := TRUE;
iMediaArray[eSpinnerMedienNamen.StaticNozzleC2H4O2].InvisibleRecipe := TRUE;
END_IF
Step := 10;
10:
CurrentStepOld := RecipeCurrentStep;
Step := 20;
20:
IF CurrentStepOld <> RecipeCurrentStep THEN
Step := 10;
RETURN;
END_IF
IF iStationStatus.Soll.RecipeExit THEN
Step := 0;
iStationStatus.Ist.Recipe := FALSE;
iStationStatus.Soll.RecipeExit := FALSE;
VisuElems.CURRENTVISU := iStationStatus.StationVisu.RecipeExit;
END_IF
END_CASE
]]></ST>
</Implementation>
</Method>
<Method Name="Rezeptendebedingungen" Id="{997c6b03-b2e3-4cd1-91c3-0280731560e3}" FolderPath="START\">
<Declaration><![CDATA[METHOD Rezeptendebedingungen
VAR_INPUT
Step : REFERENCE TO INT;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[IF (0 < Recipe.DATA[CurrentStep].LOOPS) THEN (* gerade abgearbeiteter Rezeptschritt ist letzter in Schleife *)
_SollLoops := Recipe.DATA[CurrentStep].LOOPS;
IF (_LOOP < Recipe.DATA[CurrentStep].loops) THEN (* Schleife läuft noch*)
_LOOP := _LOOP +1;
stepwith := Recipe.DATA[CurrentStep].stepwith;
CurrentStep :=CurrentStep - stepwith;
Step := StepRecipeStart; (* auf Start Rezeptschritt *)
(*evtl anders machen:*)
ELSE (* Schleife ist gerade zu Ende loop wieder auf Start setzen für evtl. nächse Schleife *)
_LOOP := 0;
_SollLoops := 0;
CurrentStep :=CurrentStep +1;
IF CurrentStep > Recipe.STEP_COUNT THEN (*Rezeptende*)
Step := Step +1;
ELSE
Step := StepRecipeStart;
END_IF
END_IF
ELSE (* dieser step ist nicht Ende einer Schleife - loop nicht behandeln*)
CurrentStep :=CurrentStep +1;
IF CurrentStep > Recipe.STEP_COUNT THEN (*Rezeptende*)
Step := Step +1;
ELSE
Step := StepRecipeStart;
END_IF
END_IF
]]></ST>
</Implementation>
</Method>
<Method Name="Standby" Id="{5a083c89-19a0-442b-87d2-5f719dc6b801}">
<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:
IF LoadSpecialRecipe(eRecipeType.TypeStandby) THEN
_RecipeStandby := TRUE;
Step := 20;
END_IF
20:
IF iCMD = CloseOutCMD OR iStationStatus.Soll.Stop OR NOT _RecipeStandby THEN
_RecipeStandby := FALSE;
Step := 0;
END_IF
END_CASE
]]></ST>
</Implementation>
</Method>
<Method Name="Start" Id="{e9426635-6213-41ba-98df-33e12a8d3094}" FolderPath="START\">
<Declaration><![CDATA[METHOD Start : BOOL
VAR CONSTANT
StepRecipeStart : INT := 10;
StepEnd : INT := 30;
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[(*ActLoop := LOOP;
LoopText := USINT_TO_STRING(ActLoop);
LoopText := CONCAT(LoopText, '/');
LoopText := CONCAT(LoopText, USINT_TO_STRING(SollLoops));
iStationStatus.LoopText := LoopText;*)
IF NOT IO.ChuckVacuum.bInUp AND CheckChuckVacuum THEN
AlarmSend(iStation:=iStationStatus.iStation,MsgId := SPINNER_ErrorNr.eChuckVacuumOn,TRUE, eReportType.Error,sAvailableResponse.Ok , FALSE);
iStationStatus.Soll.Stop :=TRUE;
END_IF
IF NOT Safety_PRG.MediaOk AND NOT _RecipeEmergency AND NOT _RecipeCleaning THEN
iStationStatus.Soll.Stop :=TRUE;
END_IF
CASE _Step OF
0:
_LOOP := 0;
CurrentStep := 1;
_Step := _Step +1;
CheckChuckVacuum := TRUE;
IF _RecipeStandby THEN
iStationStatus.Ist.CloseOut := FALSE;
CheckChuckVacuum := FALSE;
_Step := StepRecipeStart;
ELSIF _RecipeCleaning THEN
CheckChuckVacuum := FALSE;
END_IF
1:
IF Chuck.bOutReady THEN
_Step := StepRecipeStart;
ELSE
_Step := _Step +1;
END_IF
2:
Chuck.bInInit := TRUE;
_Step := _Step +1;
3:
IF Chuck.bOutReady THEN
_Step := StepRecipeStart;
END_IF
StepRecipeStart:
_Step := _Step +1;
11:
IF TargetSet() THEN
_Step := 20;
END_IF
20:
IF StepEndCondition () THEN
_Step := StepEnd;
END_IF
//IF iStationStatus.StandbyNotAllowed AND iStationStatus.Soll.Standby THEN
// _Step := 40;
//END_IF
StepEnd:
Rezeptendebedingungen(_Step);
31:
IO.bOutMeasuringChamberRinseN2 := TRUE;
IF _RecipeCleaning OR _RecipeEmergency THEN
_Step := 90;
ELSE
_Step := 40;
END_IF
40:
IF Robot.MoveHome() THEN
_Step := 50;
END_IF
50:
IF Chuck.bOutReady THEN
Chuck.rInTargetVelocity := 0;
Chuck.rInTargetAcceleration := Config.Chuck.HomeAcceleration;
Chuck.bInStartSpin := TRUE;
Chuck.bOutReady := FALSE;
_Step := _Step +1;
END_IF
51:
IF Chuck.rOutCurrentVelocityDINT < 1 THEN
_Step := 90;
END_IF
90:
IF _RecipeStandby THEN
iCMD := CloseOutCMD;
_Step := 0;
ELSE
CheckChuckVacuum := FALSE;
_LOOP := 0;
_Step := 100;
END_IF
100:
_Step := 0;
Start := TRUE;
END_CASE
]]></ST>
</Implementation>
</Method>
<Method Name="StepEndCondition" Id="{58b2d907-3a63-45ee-adff-48bfdf7079b4}" FolderPath="START\">
<Declaration><![CDATA[METHOD StepEndCondition : BOOL
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[//IF Chuck.UsedTargetSpeed <> MaxSetSpeed(Recipe.DATA[CurrentStep].Chuck.Speed, iStation) OR
// Chuck.UsedTargetAcceleration <> MaxSetAcceleration(Recipe.DATA[CurrentStep].Chuck.Acceleration, iStation) THEN
// Chuck.StartVelocity := TRUE;
//END_IF
CASE Recipe.DATA[CurrentStep].StepEndCond OF
EndbyChuckSpeed:
IF Chuck.rOutCurrentVelocityDINT = Recipe.DATA[CurrentStep].Chuck.Speed THEN
StepEndCondition := TRUE;
END_IF
EndbyStepTime:
StepTimer(IN := TRUE, PT := LREAL_TO_TIME(Recipe.DATA[CurrentStep].StepTime*1000));
IF StepTimer.Q THEN
StepEndCondition := TRUE;
StepTimer(IN := FALSE);
END_IF
EndbyBSR:
IF BSRAxis.bOutReady THEN
StepEndCondition := TRUE;
END_IF
EndbyRobot:
IF NOT Robot.bInStartPos THEN
StepEndCondition := TRUE;
END_IF
// EndbyDChuck:
// IF DoubleRotationChuck.bOutReady THEN
// Step := StepEnd;
// END_IF
(* EndbyArm1:
IF Arm[1].bOutReady AND ABS (Arm[1].ActualPosition - Arm[1].TargetPosition) < 0.2 THEN
Step := StepEnd;
END_IF
// EndbyArm2:*)
// IF NOT Signal.Arm[2].StartPosition AND ABS (Signal.Arm[2].ActualPosition - Signal.Arm[2].TargetPosition) < 0.2 THEN
// Step := StepEnd;
// END_IF
// EndbySyringe:
// IF Syringe[1].StartDispense OR Syringe[2].StartDispense THEN
// RETURN;
// END_IF
// Step := StepEnd;
// EndbyCover:
// IF Cover.CMD = eCoverCMD.noCMD THEN
// Step := StepEnd;
// END_IF
END_CASE]]></ST>
</Implementation>
</Method>
<Method Name="Stop" Id="{590c6025-9d23-4e72-9538-ee6ba18a672e}">
<Declaration><![CDATA[METHOD Stop : BOOL
VAR_INPUT
Step : REFERENCE TO INT;
END_VAR
VAR_INST
i : USINT;
// DelayTimer : TON;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[//NozzlesCheck();
bNozzleCheck := FALSE;
ChuckChange();
CheckChuckVacuum := FALSE;
Chuck.rInTargetVelocity := 0;
DelayTimer(IN := TRUE, PT := T#100MS);
IF DelayTimer.Q THEN
DelayTimer(IN := FALSE, PT := T#100MS);
iStationStatus.Soll.Stop := FALSE;
END_IF
]]></ST>
</Implementation>
</Method>
<Method Name="SubstrateCalibration" Id="{957ed8f4-555a-4aa8-8508-0af52055ec2c}" FolderPath="SubstrateCalibration\">
<Declaration><![CDATA[METHOD SubstrateCalibration : BOOL;
VAR_INPUT
END_VAR
VAR_INST
Step : INT;
Puddle : INT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[CASE Step OF
0:
bCheckPrepoutCalibration := TRUE;
rCheckPrepoutCalibrationPosition := 0;
IF GetCenter(Puddle) THEN
Step := 10;
END_IF
10:
bCheckPrepoutCalibration := TRUE;
rCheckPrepoutCalibrationPosition := 180;
IF GetCenter(Puddle) THEN
Step := 20;
END_IF
20:
CenterCalibrated.X := Center[0].X + Center[1].X;
CenterCalibrated.X := CenterCalibrated.X /2;
CenterCalibrated.Y := Center[0].Y + Center[1].Y;
CenterCalibrated.Y := CenterCalibrated.Y /2;
ALIGNER_MAIN.SetCalibration(iStation, iStationStatus.WaferInfo[0].Size, Puddle, CenterCalibrated);
Step := 100;
100:
SubstrateCalibration := TRUE;
bCalibration := FALSE;
bCheckPrepoutCalibration := FALSE;
Step := 0;
END_CASE]]></ST>
</Implementation>
</Method>
<Method Name="TargetSet" Id="{566e8f80-d018-44b9-a06a-fa5d350c4e26}" FolderPath="START\">
<Declaration><![CDATA[METHOD TargetSet : BOOL;
VAR
Dummy : SINT;
SyringeNumber : SINT;
END_VAR
VAR
Size : USINT;
PrePosition : INT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[IF _RecipeStandby THEN
MEDIA(TargetMedia := Recipe.DATA[CurrentStep].MEDIA);
TargetSet := TRUE;
RETURN;
END_IF
IF NOT Chuck.bOutReady OR NOT BSRAxis.bOutReady OR Robot.bInStartPos THEN
RETURN;
END_IF
_StepComment := Recipe.DATA[CurrentStep].Comment;
//iStationStatus.WaferInfo[0].Size := 1;
Size := iStationStatus.WaferInfo[0].Size;
//Size := 1;
PrePosition := Recipe.DATA[CurrentStep].Robot.PrePosition;
//KUKA.sTargetPosition := Config.Robot.PrePosition[PrePosition].PrePosition[Size];
IF NOT (_RecipeCleaning OR _RecipeEmergency) THEN
Robot.rInTargetPredefinedPosition := PrePosition;
Robot.rInTargetPredefinedPositionSize := Size;
Robot.ProcessType := Recipe.ProcessType;
Robot.rOutTargetSpeed := Recipe.DATA[CurrentStep].Robot.Speed;
Robot.MoveType := eMeca500MoveType.MovePreposition;
Robot.bInStartPos := TRUE;
END_IF
//Chuck
IF Chuck.bOutReady THEN
Chuck.rInTargetVelocity := Recipe.DATA[CurrentStep].Chuck.Speed;
Chuck.rInTargetAcceleration := Recipe.DATA[CurrentStep].Chuck.Acceleration;
Chuck.bInStartSpin := TRUE;
Chuck.bOutReady := FALSE;
END_IF
PrePosition := Recipe.DATA[CurrentStep].BSR.PrePosition;
//Arm1
IF NOT (_RecipeCleaning OR _RecipeEmergency) THEN
IF BSRAxis.bOutReady THEN
BSRAxis.rInTargetPosition := Config.BSR.PrePosition[PrePosition].PrePosition[Size];
BSRAxis.rInTargetVelocity := Recipe.DATA[CurrentStep].BSR.Speed;
BSRAxis.bInStartPosition := TRUE;
BSRAxis.bOutReady := FALSE;
END_IF
END_IF
MEDIA(TargetMedia := Recipe.DATA[CurrentStep].MEDIA);
TargetSet := TRUE;]]></ST>
</Implementation>
</Method>
<Method Name="ToVisu" Id="{a4ff2ee7-db5a-4597-856a-f11b95149fcd}">
<Declaration><![CDATA[METHOD ToVisu : BOOL
VAR_INPUT
END_VAR
]]></Declaration>
<Implementation>
<ST><![CDATA[VisuSpinnerAutoRecipe REF= Recipe;
VisuSpinnerConfig REF= Config;
VisuSpinnerMain REF= THIS^;]]></ST>
</Implementation>
</Method>
<Method Name="TurnOffAllMedia" Id="{8b491112-1d4c-4f11-a9a4-de22adeb6caf}">
<Declaration><![CDATA[METHOD TurnOffAllMedia : BOOL
VAR_INPUT
END_VAR
VAR
i : INT;
END_VAR]]></Declaration>
<Implementation>
<ST><![CDATA[(*CASE iStationStatus.StationType OF
TypeCoater:
FOR i := eCoaterMedienNamen.PuddleNozzleSolvent TO eCoaterMedienNamen.BSR DO
CASE i OF
eCoaterMedienNamen.PuddleNozzleSolvent,
eCoaterMedienNamen.BowlRinsing,
eCoaterMedienNamen.NozzleRinsing,
eCoaterMedienNamen.SolventBath,
eCoaterMedienNamen.BSR,
eCoaterMedienNamen.EBR:
MediaArray[iStationStatus.iStation][i].bReferenceControl := FALSE;
END_CASE
END_FOR
(* TypeCleaner:
FOR i := eCleanerMedienNamen.FlatJetDIWater TO eCleanerMedienNamen.MotorRinsing DO
CASE i OF
eCleanerMedienNamen.FlatJetDIWater,
eCleanerMedienNamen.FlatJetDIWaterHot,
eCleanerMedienNamen.FlatJetSurfactant,
eCleanerMedienNamen.PuddleNozzleN2,
eCleanerMedienNamen.PuddleNozzleDIW,
eCleanerMedienNamen.PuddleNozzleDIWHot,
eCleanerMedienNamen.PuddleNozzleMegasonic,
eCleanerMedienNamen.PowerMegasonic,
eCleanerMedienNamen.HighPressureValve,
eCleanerMedienNamen.HighPressurePump,
eCleanerMedienNamen.BSR_DIW_HOT,
eCleanerMedienNamen.BSR_DIW,
eCleanerMedienNamen.StaticalNozzlesDIW:
MediaArray[iStationStatus.iStation][i].bReferenceControl := FALSE;
END_CASE
END_FOR*)
TypeDeveloper:
FOR i := eDeveloperMedienNamen.PuddleNozzleDEV1 TO eDeveloperMedienNamen.BSR DO
MediaArray[iStationStatus.iStation][i].bReferenceControl := FALSE;
END_FOR
(*
Developer_LeviPump[iStationStatus.iStation][1].cmd := ePumpCmd.Poff;
Developer_LeviPump[iStationStatus.iStation][2].cmd := ePumpCmd.Poff;
Developer_LeviPump[iStationStatus.iStation][3].cmd := ePumpCmd.Poff;
FOR i := 1 TO 5 DO
BufferTankHeaterSignal[i].Enable := FALSE;
END_FOR
*)
END_CASE*);
FOR i := 1 TO 32 DO
iMediaArray[i].bReferenceControl := FALSE;
END_FOR
(*CASE iStationStatus.StationType OF
TypeCleaner1:
HighPressurePump[iStationStatus.iStation].Setpoint := 0;
SpinnerBrush.bOutEnable := FALSE;
END_CASE*)
]]></ST>
</Implementation>
</Method>
</POU>
</TcPlcObject>
Reference in New Issue View Git Blame Copy Permalink