
PROGRAM _INIT
	
	RTInfo_0(enable:=1);
	Wartezeit_OPCUA := 1100;
	gMerker_Tisch_1_RFID_UID_STR := '0';
	gMerker_Tisch_2_RFID_UID_STR := '0';
	gMerker_Tisch_3_RFID_UID_STR := '0';
	gMerker_Tisch_4_RFID_UID_STR := '0';
	gMerker_Tisch_5_RFID_UID_STR := '0';
	gMerker_Tisch_6_RFID_UID_STR := '0';
	gMerker_Tisch_7_RFID_UID_STR := '0';
	gMerker_Tisch_8_RFID_UID_STR := '0';
	 
END_PROGRAM

PROGRAM _CYCLIC

//**********************************	Tisch 1		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_1_RFID_Vorhanden := gTisch_1_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *) //Cech-Comment: Wenn dieses Bit gesetzt ist, dann ist ein Datenträger im LEsebereich
	
	
	//Cech-Comment: Diese zehn Integer-Werte sind im Balluff-Manual MAN_BIS_M_4XX_045_... Kap.9.2 S48 beschrieben
	// Die TAG-UID wird automatisch nach einem TAG-PResent vom Lesekopf ausgelesen und in das LEseregister geschrieben; da braucht kein LEsebefehl ausgegeben werden
	IF gMerker_Tisch_1_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_1_RFID_Write[1] := 1;(* Befehl Datenträger lesen *) 
		gTisch_1_RFID_Write[2] := 0;
		gTisch_1_RFID_Write[3] := 0;
		gTisch_1_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_1_RFID_Write[5] := 0;
		gTisch_1_RFID_Write[6] := 0;
		gTisch_1_RFID_Write[7] := 0;
		gTisch_1_RFID_Write[8] := 0;
		gTisch_1_RFID_Write[9] := 1;
		gTisch_1_RFID_Write[0].0 := TRUE; (*Cech: Bit0: nuer Auftrag an Reader, Bit2:Reset, Bit5:Kopfabschaltung, Bit6: Toggeln für längere Abfragen/Aufträge, wenn SPS bereit ist, weitere Daten zu übernehmen*)
	END_IF
	   
	(* Schreiben *)	
	
	(* Befehlsdaten *)
	IF gMerker_neuen_Befehl_schreiben = TRUE THEN
		gTisch_1_RFID_Write[1] := 2;  (* Datenträger beschreiben *)
		gTisch_1_RFID_Write[2] := 0;  (* Daten *)
		gTisch_1_RFID_Write[3] := 0;  (* Daten *)
		gTisch_1_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_1_RFID_Write[5] := 0;  (* Daten *)
		gTisch_1_RFID_Write[6] := 0;  (* Daten *)
		gTisch_1_RFID_Write[7] := 0;  (* Daten *)
		gTisch_1_RFID_Write[8] := 0;  (* Daten *)
		gTisch_1_RFID_Write[0].0 := TRUE; (* neuer Auftrag steht an *)
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_1_alles_nullen = TRUE THEN
		gTisch_1_RFID_Write[1] := 0;
		gTisch_1_RFID_Write[2] := 0;
		gTisch_1_RFID_Write[3] := 0;
		gTisch_1_RFID_Write[4] := 0;  
		gTisch_1_RFID_Write[5] := 0;
		gTisch_1_RFID_Write[6] := 0;
		gTisch_1_RFID_Write[7] := 0; 
		gTisch_1_RFID_Write[8] := 0;
		gTisch_1_RFID_Write[0] := 0;
	END_IF
	
	gTisch_1_RFID_Write[9] := gTisch_1_RFID_Write[0];
	
	CASE Tisch_1_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_1_RFID_Read[0] = 129 AND gTisch_1_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde, dann liefert der TAG automatisch die UID zurück
				gMerker_Debug_Test_Counter_RFID := 00; 		//Cech-Comment: eingefügt für TEstzwecke
															//				gMerker_Tisch_1_RFID_UID[0] := gTisch_1_RFID_Read[1];
															//				gMerker_Tisch_1_RFID_UID[1] := gTisch_1_RFID_Read[2];
															//				gMerker_Tisch_1_RFID_UID[2] := gTisch_1_RFID_Read[3];
															//				gMerker_Tisch_1_RFID_UID[3] := gTisch_1_RFID_Read[4];
															//				gMerker_Tisch_1_RFID_UID[4] := gTisch_1_RFID_Read[5];
															//				gMerker_Tisch_1_RFID_UID[5] := gTisch_1_RFID_Read[6];
															//				gMerker_Tisch_1_RFID_UID[6] := gTisch_1_RFID_Read[7];
															//				gMerker_Tisch_1_RFID_UID[7] := gTisch_1_RFID_Read[8];
															//				gMerker_Tisch_1_RFID_UID_STRARR[0] := USINT_TO_STRING (gTisch_1_RFID_Read[1]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[1] := USINT_TO_STRING (gTisch_1_RFID_Read[2]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[2] := USINT_TO_STRING (gTisch_1_RFID_Read[3]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[3] := USINT_TO_STRING (gTisch_1_RFID_Read[4]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[4] := USINT_TO_STRING (gTisch_1_RFID_Read[5]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[5] := USINT_TO_STRING (gTisch_1_RFID_Read[6]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[6] := USINT_TO_STRING (gTisch_1_RFID_Read[7]);
															//				gMerker_Tisch_1_RFID_UID_STRARR[7] := USINT_TO_STRING (gTisch_1_RFID_Read[8]);
				gMerker_Tisch_1_STRING_HELPER := '';
				gMerker_Tisch_1_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_1_STRING_HELPER := USINT_TO_STRING (gTisch_1_RFID_Read[i]);
					IF LEN(gMerker_Tisch_1_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_1_STRING_HELPER := CONCAT('00', gMerker_Tisch_1_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_1_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_1_STRING_HELPER := CONCAT('0', gMerker_Tisch_1_STRING_HELPER);
					END_IF;
					gMerker_Tisch_1_RFID_UID_STR := CONCAT( gMerker_Tisch_1_RFID_UID_STR, gMerker_Tisch_1_STRING_HELPER );
				END_FOR
				Tisch_1_RFID := 5;
			END_IF
//Cech-Implement-Ende
			
		5:	IF gMerker_Tisch_1_RFID_Vorhanden  = TRUE AND gMerker_Tisch_1_RFID_Reset = FALSE (*AND gMerker_Tisch_1_lesen_fertig = FALSE*) THEN
				gMerker_Debug_Test_Counter_RFID := 05; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_Tisch_1_Auftrag_Lesen := TRUE;
				Tisch_1_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_1 := lWarten_RFID_Fehler_Tisch_1 + (RTInfo_0.cycle_time/1000);
			IF gTisch_1_RFID_Read[0] = 135 THEN		//135 : 1000 0111 / Cech-Comment: Bit: 0...Tag im Lesebereich, 1...Auftragsbearbeitung läuft, 2...Auftrag fehlerlos beendet, 3...Auftrag fehlerhaft bearbeitet, 5...Wenn toggelt: Sensor bereit, weitere Daten zu übermitteln, 6...Sensor abgeschaltet, 7...Sensor bereit
				gMerker_Debug_Test_Counter_RFID := 10; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_RFID_Value_Tisch_1 := gTisch_1_RFID_Read[1];
				//			gMerker_RFID_Tisch_1_gelesen := TRUE;
				//			gMerker_Tisch_1_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_1 := 0;
				Tisch_1_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_1 >= 5000 AND gTisch_1_RFID_Read[0] <> 135 THEN	//Wenn nach 5s noch keine fehlerfreie Rückmeldung vom LEser gekommen ist, dann wird der Leser resetiert und alles wieder rückgesetzt ab 100: 
				gMerker_Debug_Test_Counter_RFID := 11; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_Tisch_1_Auftrag_Lesen := FALSE;
				gMerker_Tisch_1_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_1 := 0;
				Tisch_1_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_1 <> 0 THEN		//ungleich 0 von gTisch_1_RFID_Read[1] bedeutet einen Fehlercode; ohne Fehler muss das 00h sein
				gMerker_Debug_Test_Counter_RFID := 15; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_RFID_Tisch_1_gelesen := TRUE;
				gMerker_Tisch_1_lesen_fertig := TRUE;
				Tisch_1_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_1 = 0 THEN		//kein Fehler beim Lesen
				gMerker_Debug_Test_Counter_RFID := 16; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_RFID_Tisch_1_gelesen := FALSE;
				gMerker_Tisch_1_lesen_fertig := FALSE;
				Tisch_1_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_1 := lWarten_fuer_OPCUA_Tisch_1 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_1_RFID_Vorhanden = FALSE AND gTisch_1.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_1 >= Wartezeit_OPCUA THEN
				gMerker_Debug_Test_Counter_RFID := 20; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_Tisch_1_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_1 := 0;
				gTisch_1_RFID_Write[0] := 4;		//SW-Reset des RFID-Sensors
				gMerker_Tisch_1_RFID_UID_STR := '0';
				Tisch_1_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_1_RFID_Read[0] = 0 THEN
				gMerker_Debug_Test_Counter_RFID := 30; 		//Cech-Comment: eingefügt für TEstzwecke
				gTisch_1_RFID_Write[0] := 0;
				Tisch_1_RFID := 0;
			END_IF
		
		100:			//Hier geht es weiter, wenn die Daten fehlerfrei empfangen wurden
			IF gMerker_Tisch_1_Auftrag_Lesen = FALSE AND gMerker_Tisch_1_RFID_Reset = TRUE THEN
				gMerker_Debug_Test_Counter_RFID := 100; 		//Cech-Comment: eingefügt für TEstzwecke
				gTisch_1_RFID_Write[0] := 4;		//SW-Reset des RFID-Sensors
				gMerker_RFID_Value_Tisch_1 := 0;
				gMerker_Tisch_1_RFID_UID_STR := '0';
				Tisch_1_RFID := 110;
			END_IF
		
		110:
			IF gTisch_1_RFID_Read[0] = 0 THEN
				gMerker_Debug_Test_Counter_RFID := 110; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_Tisch_1_alles_nullen := TRUE;
				Tisch_1_RFID := 120;
			END_IF
		
		120:
			IF gTisch_1_RFID_Write[0] = 0 AND gTisch_1_RFID_Write[1] = 0 AND gTisch_1_RFID_Write[2] = 0 AND gTisch_1_RFID_Write[3] = 0 AND gTisch_1_RFID_Write[4] = 0 AND gTisch_1_RFID_Write[5] = 0 AND gTisch_1_RFID_Write[6] = 0 AND gTisch_1_RFID_Write[7] = 0 AND gTisch_1_RFID_Write[8] = 0 AND gTisch_1_RFID_Write[9] = 0 THEN
				gMerker_Debug_Test_Counter_RFID := 120; 		//Cech-Comment: eingefügt für TEstzwecke
				gMerker_Tisch_1_alles_nullen := FALSE;
				gMerker_Tisch_1_RFID_Reset := FALSE;
				Tisch_1_RFID := 0;
			END_IF			
				
	END_CASE
	
	
	// SCHREIBEN AUF ALLE GLEICH
	
		CASE RFID_Schreiben OF
			
			0:
			IF gMerker_Tisch_1_RFID_Vorhanden = TRUE AND gMerker_OPCUA_Schreibauftrag = TRUE AND gMerker_Tisch_1_lesen_fertig = TRUE THEN
				gTisch_1_RFID_Write[0] := 4;		// Kopf-Reset
				RFID_Schreiben := 10;
			END_IF
			
			10:	
			IF gTisch_1_RFID_Read[0] = 0 THEN
				gMerker_Tisch_1_alles_nullen := TRUE;
				RFID_Schreiben := 20;
			END_IF			
				
			20:
			IF gTisch_1_RFID_Write[0] = 0 AND gTisch_1_RFID_Write[1] = 0 AND gTisch_1_RFID_Write[2] = 0 AND gTisch_1_RFID_Write[3] = 0 AND gTisch_1_RFID_Write[4] = 0 AND gTisch_1_RFID_Write[5] = 0 AND gTisch_1_RFID_Write[6] = 0 AND gTisch_1_RFID_Write[7] = 0 AND gTisch_1_RFID_Write[8] = 0 AND gTisch_1_RFID_Write[9] = 0 THEN
				gMerker_Tisch_1_alles_nullen := FALSE;
				gMerker_neuen_Befehl_schreiben := TRUE;
				RFID_Schreiben := 30;
			END_IF
			
			30: 
			IF gTisch_1_RFID_Read[0] = 163 THEN				//163 : 10100011  betriebsbereit; toggelbit zeigt an dass Kopf bereit weitere Daten zu übermitteln; Auftrag erkannt und entgegengenommen; Datenträger im Lesebereich;
				gMerker_neuen_Befehl_schreiben := FALSE;	
				gMerker_Tisch_1_alles_nullen := TRUE;
				RFID_Schreiben := 40;
			END_IF
			
			40:
			IF gTisch_1_RFID_Write[0] = 0 AND gTisch_1_RFID_Write[1] = 0 AND gTisch_1_RFID_Write[2] = 0 AND gTisch_1_RFID_Write[3] = 0 AND gTisch_1_RFID_Write[4] = 0 AND gTisch_1_RFID_Write[5] = 0 AND gTisch_1_RFID_Write[6] = 0 AND gTisch_1_RFID_Write[7] = 0 AND gTisch_1_RFID_Write[8] = 0 AND gTisch_1_RFID_Write[9] = 0 THEN
				gMerker_Tisch_1_alles_nullen := FALSE;
				gTisch_1_RFID_Write[1] := gMerker_OPCUA_Seriennummer_Test;
				gTisch_1_RFID_Write[2] := 0;
				gTisch_1_RFID_Write[3] := 0;
				gTisch_1_RFID_Write[4] := 0;  
				gTisch_1_RFID_Write[5] := 0;
				gTisch_1_RFID_Write[6] := 0;
				gTisch_1_RFID_Write[7] := 0; 
				gTisch_1_RFID_Write[8] := 0;
				gTisch_1_RFID_Write[0] := 65;  //65: 0100 0001  das obere Bit zeigt an, durch Toggelung, dass die Linien-SPS bereit ist, Daten vom Kopf zu empfangen
				RFID_Schreiben := 50;
			END_IF
					
			50:
			IF gTisch_1_RFID_Read[0] = 167 THEN				//167 1010 0111, Kopf bereit;Kopf bereit für neue Daten; Auftrag ohne Fehler beendet; Auftrag erkannt und entgegengenommen; Datenträger im LEsebereich des Kopfes
				gMerker_Tisch_1_alles_nullen := TRUE;
				RFID_Schreiben := 60;
			END_IF
						
			60:
			IF gTisch_1_RFID_Write[0] = 0 AND gTisch_1_RFID_Write[1] = 0 AND gTisch_1_RFID_Write[2] = 0 AND gTisch_1_RFID_Write[3] = 0 AND gTisch_1_RFID_Write[4] = 0 AND gTisch_1_RFID_Write[5] = 0 AND gTisch_1_RFID_Write[6] = 0 AND gTisch_1_RFID_Write[7] = 0 AND gTisch_1_RFID_Write[8] = 0 AND gTisch_1_RFID_Write[9] = 0 THEN
				gMerker_Tisch_1_alles_nullen := FALSE;
				gMerker_OPCUA_Schreibauftrag := FALSE;
				gMerker_Tisch_1_lesen_fertig := FALSE;
	//			gMerker_Tisch_1_Auftrag_Lesen := TRUE;
				RFID_Schreiben := 0; // war 70
			END_IF
									
//			70:
//			IF gMerker_Tisch_1_RFID_Vorhanden = FALSE THEN
//	//			gMerker_Tisch_1_Auftrag_Lesen := FALSE;
//				RFID_Schreiben := 0;
//			END_IF	
									
		END_CASE

	//**********************************	Tisch 2		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_2_RFID_Vorhanden := gTisch_2_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_2_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_2_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_2_RFID_Write[2] := 0;
		gTisch_2_RFID_Write[3] := 0;
		gTisch_2_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_2_RFID_Write[5] := 0;
		gTisch_2_RFID_Write[6] := 0;
		gTisch_2_RFID_Write[7] := 0;
		gTisch_2_RFID_Write[8] := 0;
		gTisch_2_RFID_Write[9] := 1;
		gTisch_2_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_2_alles_nullen = TRUE THEN
		gTisch_2_RFID_Write[1] := 0;
		gTisch_2_RFID_Write[2] := 0;
		gTisch_2_RFID_Write[3] := 0;
		gTisch_2_RFID_Write[4] := 0;  
		gTisch_2_RFID_Write[5] := 0;
		gTisch_2_RFID_Write[6] := 0;
		gTisch_2_RFID_Write[7] := 0; 
		gTisch_2_RFID_Write[8] := 0;
		gTisch_2_RFID_Write[0] := 0;
	END_IF
	
	gTisch_2_RFID_Write[9] := gTisch_2_RFID_Write[0];
	
	CASE Tisch_2_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_2_RFID_Read[0] = 129 AND gTisch_2_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_2_STRING_HELPER := '';
				gMerker_Tisch_2_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_2_STRING_HELPER := USINT_TO_STRING (gTisch_2_RFID_Read[i]);
					IF LEN(gMerker_Tisch_2_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_2_STRING_HELPER := CONCAT('00', gMerker_Tisch_2_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_2_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_2_STRING_HELPER := CONCAT('0', gMerker_Tisch_2_STRING_HELPER);
					END_IF;
					gMerker_Tisch_2_RFID_UID_STR := CONCAT( gMerker_Tisch_2_RFID_UID_STR, gMerker_Tisch_2_STRING_HELPER );
				END_FOR
				Tisch_2_RFID := 5;
			END_IF
//Cech-Implement-Ende

		5:	IF gMerker_Tisch_2_RFID_Vorhanden  = TRUE AND gTisch_2.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_2_RFID_Reset = FALSE (*AND gMerker_Tisch_2_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_2_Auftrag_Lesen := TRUE;
				Tisch_2_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_2 := lWarten_RFID_Fehler_Tisch_2 + (RTInfo_0.cycle_time/1000);
			IF gTisch_2_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_2 := gTisch_2_RFID_Read[1];
				//			gMerker_RFID_Tisch_2_gelesen := TRUE;
				//			gMerker_Tisch_2_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_2 := 0;
				Tisch_2_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_2 >= 5000 AND gTisch_2_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_2_Auftrag_Lesen := FALSE;
				gMerker_Tisch_2_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_2 := 0;
				Tisch_2_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_2 <> 0 THEN
				gMerker_RFID_Tisch_2_gelesen := TRUE;
				gMerker_Tisch_2_lesen_fertig := TRUE;
				Tisch_2_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_2 = 0 THEN
				gMerker_RFID_Tisch_2_gelesen := FALSE;
				gMerker_Tisch_2_lesen_fertig := FALSE;
				Tisch_2_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_2 := lWarten_fuer_OPCUA_Tisch_2 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_2_RFID_Vorhanden = FALSE AND gTisch_2.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_2 >= Wartezeit_OPCUA THEN
				gMerker_Tisch_2_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_2 := 0;
				gTisch_2_RFID_Write[0] := 4;
				gMerker_Tisch_2_RFID_UID_STR := '0';
				Tisch_2_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_2_RFID_Read[0] = 0 THEN
				gTisch_2_RFID_Write[0] := 0;
				Tisch_2_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_2_Auftrag_Lesen = FALSE AND gMerker_Tisch_2_RFID_Reset = TRUE THEN
				gTisch_2_RFID_Write[0] := 4;
				gMerker_RFID_Value_Tisch_2 := 0;
				Tisch_2_RFID := 110;
				gMerker_Tisch_2_RFID_UID_STR := '0';
			END_IF
		
		110:
			IF gTisch_2_RFID_Read[0] = 0 THEN
				gMerker_Tisch_2_alles_nullen := TRUE;
				Tisch_2_RFID := 120;
			END_IF
		
		120:
			IF gTisch_2_RFID_Write[0] = 0 AND gTisch_2_RFID_Write[1] = 0 AND gTisch_2_RFID_Write[2] = 0 AND gTisch_2_RFID_Write[3] = 0 AND gTisch_2_RFID_Write[4] = 0 AND gTisch_2_RFID_Write[5] = 0 AND gTisch_2_RFID_Write[6] = 0 AND gTisch_2_RFID_Write[7] = 0 AND gTisch_2_RFID_Write[8] = 0 AND gTisch_2_RFID_Write[9] = 0 THEN
				gMerker_Tisch_2_alles_nullen := FALSE;
				gMerker_Tisch_2_RFID_Reset := FALSE;
				Tisch_2_RFID := 0;
			END_IF			
				
	END_CASE
	

//**********************************	Tisch 3		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_3_RFID_Vorhanden := gTisch_3_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_3_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_3_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_3_RFID_Write[2] := 0;
		gTisch_3_RFID_Write[3] := 0;
		gTisch_3_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_3_RFID_Write[5] := 0;
		gTisch_3_RFID_Write[6] := 0;
		gTisch_3_RFID_Write[7] := 0;
		gTisch_3_RFID_Write[8] := 0;
		gTisch_3_RFID_Write[9] := 1;
		gTisch_3_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_3_alles_nullen = TRUE THEN
		gTisch_3_RFID_Write[1] := 0;
		gTisch_3_RFID_Write[2] := 0;
		gTisch_3_RFID_Write[3] := 0;
		gTisch_3_RFID_Write[4] := 0;  
		gTisch_3_RFID_Write[5] := 0;
		gTisch_3_RFID_Write[6] := 0;
		gTisch_3_RFID_Write[7] := 0; 
		gTisch_3_RFID_Write[8] := 0;
		gTisch_3_RFID_Write[0] := 0;
	END_IF
	
	gTisch_3_RFID_Write[9] := gTisch_3_RFID_Write[0];
	
	CASE Tisch_3_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_3_RFID_Read[0] = 129 AND gTisch_3_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_3_STRING_HELPER := '';
				gMerker_Tisch_3_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_3_STRING_HELPER := USINT_TO_STRING (gTisch_3_RFID_Read[i]);
					IF LEN(gMerker_Tisch_3_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_3_STRING_HELPER := CONCAT('00', gMerker_Tisch_3_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_3_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_3_STRING_HELPER := CONCAT('0', gMerker_Tisch_3_STRING_HELPER);
					END_IF;
					gMerker_Tisch_3_RFID_UID_STR := CONCAT( gMerker_Tisch_3_RFID_UID_STR, gMerker_Tisch_3_STRING_HELPER );
				END_FOR
				Tisch_3_RFID := 5;
			END_IF
//Cech-Implement-Ende		

		5:	IF gMerker_Tisch_3_RFID_Vorhanden  = TRUE AND gTisch_3.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_3_RFID_Reset = FALSE (*AND gMerker_Tisch_3_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_3_Auftrag_Lesen := TRUE;
				Tisch_3_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_3 := lWarten_RFID_Fehler_Tisch_3 + (RTInfo_0.cycle_time/1000);
			IF gTisch_3_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_3 := gTisch_3_RFID_Read[1];
				//			gMerker_RFID_Tisch_3_gelesen := TRUE;
				//			gMerker_Tisch_3_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_3 := 0;
				Tisch_3_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_3 >= 5000 AND gTisch_3_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_3_Auftrag_Lesen := FALSE;
				gMerker_Tisch_3_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_3 := 0;
				Tisch_3_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_3 <> 0 THEN
				gMerker_RFID_Tisch_3_gelesen := TRUE;
				gMerker_Tisch_3_lesen_fertig := TRUE;
				Tisch_3_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_3 = 0 THEN
				gMerker_RFID_Tisch_3_gelesen := FALSE;
				gMerker_Tisch_3_lesen_fertig := FALSE;
				Tisch_3_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_3 := lWarten_fuer_OPCUA_Tisch_3 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_3_RFID_Vorhanden = FALSE AND gTisch_3.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_3 >= Wartezeit_OPCUA THEN
				gMerker_Tisch_3_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_3 := 0;
				gTisch_3_RFID_Write[0] := 4;
				gMerker_Tisch_3_RFID_UID_STR := '0';
				Tisch_3_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_3_RFID_Read[0] = 0 THEN
				gTisch_3_RFID_Write[0] := 0;
				Tisch_3_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_3_Auftrag_Lesen = FALSE AND gMerker_Tisch_3_RFID_Reset = TRUE THEN
				gTisch_3_RFID_Write[0] := 4;
				gMerker_RFID_Value_Tisch_3 := 0;
				gMerker_Tisch_3_RFID_UID_STR := '0';
				Tisch_3_RFID := 110;
			END_IF
		
		110:
			IF gTisch_3_RFID_Read[0] = 0 THEN
				gMerker_Tisch_3_alles_nullen := TRUE;
				Tisch_3_RFID := 120;
			END_IF
		
		120:
			IF gTisch_3_RFID_Write[0] = 0 AND gTisch_3_RFID_Write[1] = 0 AND gTisch_3_RFID_Write[2] = 0 AND gTisch_3_RFID_Write[3] = 0 AND gTisch_3_RFID_Write[4] = 0 AND gTisch_3_RFID_Write[5] = 0 AND gTisch_3_RFID_Write[6] = 0 AND gTisch_3_RFID_Write[7] = 0 AND gTisch_3_RFID_Write[8] = 0 AND gTisch_3_RFID_Write[9] = 0 THEN
				gMerker_Tisch_3_alles_nullen := FALSE;
				gMerker_Tisch_3_RFID_Reset := FALSE;
				Tisch_3_RFID := 0;
			END_IF			
				
	END_CASE
	
	//**********************************	Tisch 4		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_4_RFID_Vorhanden := gTisch_4_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_4_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_4_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_4_RFID_Write[2] := 0;
		gTisch_4_RFID_Write[3] := 0;
		gTisch_4_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_4_RFID_Write[5] := 0;
		gTisch_4_RFID_Write[6] := 0;
		gTisch_4_RFID_Write[7] := 0;
		gTisch_4_RFID_Write[8] := 0;
		gTisch_4_RFID_Write[9] := 1;
		gTisch_4_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_4_alles_nullen = TRUE THEN
		gTisch_4_RFID_Write[1] := 0;
		gTisch_4_RFID_Write[2] := 0;
		gTisch_4_RFID_Write[3] := 0;
		gTisch_4_RFID_Write[4] := 0;  
		gTisch_4_RFID_Write[5] := 0;
		gTisch_4_RFID_Write[6] := 0;
		gTisch_4_RFID_Write[7] := 0; 
		gTisch_4_RFID_Write[8] := 0;
		gTisch_4_RFID_Write[0] := 0;
	END_IF
	
	gTisch_4_RFID_Write[9] := gTisch_4_RFID_Write[0];
	
	CASE Tisch_4_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_4_RFID_Read[0] = 129 AND gTisch_4_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_4_STRING_HELPER := '';
				gMerker_Tisch_4_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_4_STRING_HELPER := USINT_TO_STRING (gTisch_4_RFID_Read[i]);
					IF LEN(gMerker_Tisch_4_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_4_STRING_HELPER := CONCAT('00', gMerker_Tisch_4_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_4_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_4_STRING_HELPER := CONCAT('0', gMerker_Tisch_4_STRING_HELPER);
					END_IF;
					gMerker_Tisch_4_RFID_UID_STR := CONCAT( gMerker_Tisch_4_RFID_UID_STR, gMerker_Tisch_4_STRING_HELPER );
				END_FOR
				Tisch_4_RFID := 5;
			END_IF
//Cech-Implement-Ende		
		
		5:	IF gMerker_Tisch_4_RFID_Vorhanden  = TRUE AND gTisch_4.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_4_RFID_Reset = FALSE (*AND gMerker_Tisch_4_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_4_Auftrag_Lesen := TRUE;
				Tisch_4_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_4 := lWarten_RFID_Fehler_Tisch_4 + (RTInfo_0.cycle_time/1000);
			IF gTisch_4_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_4 := gTisch_4_RFID_Read[1];
				//			gMerker_RFID_Tisch_4_gelesen := TRUE;
				//			gMerker_Tisch_4_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_4 := 0;
				Tisch_4_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_4 >= 5000 AND gTisch_4_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_4_Auftrag_Lesen := FALSE;
				gMerker_Tisch_4_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_4 := 0;
				Tisch_4_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_4 <> 0 THEN
				gMerker_RFID_Tisch_4_gelesen := TRUE;
				gMerker_Tisch_4_lesen_fertig := TRUE;
				Tisch_4_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_4 = 0 THEN
				gMerker_RFID_Tisch_4_gelesen := FALSE;
				gMerker_Tisch_4_lesen_fertig := FALSE;
				Tisch_4_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_4 := lWarten_fuer_OPCUA_Tisch_4 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_4_RFID_Vorhanden = FALSE AND gTisch_4.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_4 >= Wartezeit_OPCUA THEN
				gMerker_Tisch_4_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_4 := 0;
				gTisch_4_RFID_Write[0] := 4;
				gMerker_Tisch_4_RFID_UID_STR := '0';
				Tisch_4_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_4_RFID_Read[0] = 0 THEN
				gTisch_4_RFID_Write[0] := 0;
				Tisch_4_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_4_Auftrag_Lesen = FALSE AND gMerker_Tisch_4_RFID_Reset = TRUE THEN
				gTisch_4_RFID_Write[0] := 4;
				gMerker_RFID_Value_Tisch_4 := 0;
				gMerker_Tisch_4_RFID_UID_STR := '0';
				Tisch_4_RFID := 110;
			END_IF
		
		110:
			IF gTisch_4_RFID_Read[0] = 0 THEN
				gMerker_Tisch_4_alles_nullen := TRUE;
				Tisch_4_RFID := 120;
			END_IF
		
		120:
			IF gTisch_4_RFID_Write[0] = 0 AND gTisch_4_RFID_Write[1] = 0 AND gTisch_4_RFID_Write[2] = 0 AND gTisch_4_RFID_Write[3] = 0 AND gTisch_4_RFID_Write[4] = 0 AND gTisch_4_RFID_Write[5] = 0 AND gTisch_4_RFID_Write[6] = 0 AND gTisch_4_RFID_Write[7] = 0 AND gTisch_4_RFID_Write[8] = 0 AND gTisch_4_RFID_Write[9] = 0 THEN
				gMerker_Tisch_4_alles_nullen := FALSE;
				gMerker_Tisch_4_RFID_Reset := FALSE;
				Tisch_4_RFID := 0;
			END_IF			
				
	END_CASE
	
	//**********************************	Tisch 5		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_5_RFID_Vorhanden := gTisch_5_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_5_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_5_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_5_RFID_Write[2] := 0;
		gTisch_5_RFID_Write[3] := 0;
		gTisch_5_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_5_RFID_Write[5] := 0;
		gTisch_5_RFID_Write[6] := 0;
		gTisch_5_RFID_Write[7] := 0;
		gTisch_5_RFID_Write[8] := 0;
		gTisch_5_RFID_Write[9] := 1;
		gTisch_5_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_5_alles_nullen = TRUE THEN
		gTisch_5_RFID_Write[1] := 0;
		gTisch_5_RFID_Write[2] := 0;
		gTisch_5_RFID_Write[3] := 0;
		gTisch_5_RFID_Write[4] := 0;  
		gTisch_5_RFID_Write[5] := 0;
		gTisch_5_RFID_Write[6] := 0;
		gTisch_5_RFID_Write[7] := 0; 
		gTisch_5_RFID_Write[8] := 0;
		gTisch_5_RFID_Write[0] := 0;
	END_IF
	
	gTisch_5_RFID_Write[9] := gTisch_5_RFID_Write[0];
	
	CASE Tisch_5_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_5_RFID_Read[0] = 129 AND gTisch_5_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_5_STRING_HELPER := '';
				gMerker_Tisch_5_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_5_STRING_HELPER := USINT_TO_STRING (gTisch_5_RFID_Read[i]);
					IF LEN(gMerker_Tisch_5_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_5_STRING_HELPER := CONCAT('00', gMerker_Tisch_5_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_5_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_5_STRING_HELPER := CONCAT('0', gMerker_Tisch_5_STRING_HELPER);
					END_IF;
					gMerker_Tisch_5_RFID_UID_STR := CONCAT( gMerker_Tisch_5_RFID_UID_STR, gMerker_Tisch_5_STRING_HELPER );
				END_FOR
				Tisch_5_RFID := 5;
			END_IF
//Cech-Implement-Ende		
		
		5:	IF gMerker_Tisch_5_RFID_Vorhanden  = TRUE AND gTisch_5.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_5_RFID_Reset = FALSE (*AND gMerker_Tisch_5_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_5_Auftrag_Lesen := TRUE;
				Tisch_5_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_5 := lWarten_RFID_Fehler_Tisch_5 + (RTInfo_0.cycle_time/1000);
			IF gTisch_5_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_5 := gTisch_5_RFID_Read[1];
				//			gMerker_RFID_Tisch_5_gelesen := TRUE;
				//			gMerker_Tisch_5_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_5 := 0;
				Tisch_5_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_5 >= 5000 AND gTisch_5_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_5_Auftrag_Lesen := FALSE;
				gMerker_Tisch_5_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_5 := 0;
				Tisch_5_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_5 <> 0 THEN
				gMerker_RFID_Tisch_5_gelesen := TRUE;
				gMerker_Tisch_5_lesen_fertig := TRUE;
				Tisch_5_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_5 = 0 THEN
				gMerker_RFID_Tisch_5_gelesen := FALSE;
				gMerker_Tisch_5_lesen_fertig := FALSE;
				Tisch_5_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_5 := lWarten_fuer_OPCUA_Tisch_5 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_5_RFID_Vorhanden = FALSE AND gTisch_5.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_5 >= Wartezeit_OPCUA THEN
				gMerker_Tisch_5_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_5 := 0;
				gTisch_5_RFID_Write[0] := 4;
				gMerker_Tisch_5_RFID_UID_STR := '0';
				Tisch_5_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_5_RFID_Read[0] = 0 THEN
				gTisch_5_RFID_Write[0] := 0;
				Tisch_5_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_5_Auftrag_Lesen = FALSE AND gMerker_Tisch_5_RFID_Reset = TRUE THEN
				gTisch_5_RFID_Write[0] := 4;
				gMerker_RFID_Value_Tisch_5 := 0;
				gMerker_Tisch_5_RFID_UID_STR := '0';
				Tisch_5_RFID := 110;
			END_IF
		
		110:
			IF gTisch_5_RFID_Read[0] = 0 THEN
				gMerker_Tisch_5_alles_nullen := TRUE;
				Tisch_5_RFID := 120;
			END_IF
		
		120:
			IF gTisch_5_RFID_Write[0] = 0 AND gTisch_5_RFID_Write[1] = 0 AND gTisch_5_RFID_Write[2] = 0 AND gTisch_5_RFID_Write[3] = 0 AND gTisch_5_RFID_Write[4] = 0 AND gTisch_5_RFID_Write[5] = 0 AND gTisch_5_RFID_Write[6] = 0 AND gTisch_5_RFID_Write[7] = 0 AND gTisch_5_RFID_Write[8] = 0 AND gTisch_5_RFID_Write[9] = 0 THEN
				gMerker_Tisch_5_alles_nullen := FALSE;
				gMerker_Tisch_5_RFID_Reset := FALSE;
				Tisch_5_RFID := 0;
			END_IF			
				
	END_CASE
	
	//**********************************	Tisch 6		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_6_RFID_Vorhanden := gTisch_6_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_6_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_6_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_6_RFID_Write[2] := 0;
		gTisch_6_RFID_Write[3] := 0;
		gTisch_6_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_6_RFID_Write[5] := 0;
		gTisch_6_RFID_Write[6] := 0;
		gTisch_6_RFID_Write[7] := 0;
		gTisch_6_RFID_Write[8] := 0;
		gTisch_6_RFID_Write[9] := 1;
		gTisch_6_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_6_alles_nullen = TRUE THEN
		gTisch_6_RFID_Write[1] := 0;
		gTisch_6_RFID_Write[2] := 0;
		gTisch_6_RFID_Write[3] := 0;
		gTisch_6_RFID_Write[4] := 0;  
		gTisch_6_RFID_Write[5] := 0;
		gTisch_6_RFID_Write[6] := 0;
		gTisch_6_RFID_Write[7] := 0; 
		gTisch_6_RFID_Write[8] := 0;
		gTisch_6_RFID_Write[0] := 0;
	END_IF
	
	gTisch_6_RFID_Write[9] := gTisch_6_RFID_Write[0];
	
	CASE Tisch_6_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_6_RFID_Read[0] = 129 AND gTisch_6_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_6_STRING_HELPER := '';
				gMerker_Tisch_6_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_6_STRING_HELPER := USINT_TO_STRING (gTisch_6_RFID_Read[i]);
					IF LEN(gMerker_Tisch_6_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_6_STRING_HELPER := CONCAT('00', gMerker_Tisch_6_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_6_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_6_STRING_HELPER := CONCAT('0', gMerker_Tisch_6_STRING_HELPER);
					END_IF;
					gMerker_Tisch_6_RFID_UID_STR := CONCAT( gMerker_Tisch_6_RFID_UID_STR, gMerker_Tisch_6_STRING_HELPER );
				END_FOR
				Tisch_6_RFID := 5;
			END_IF
//Cech-Implement-Ende		
		
		5:	IF gMerker_Tisch_6_RFID_Vorhanden  = TRUE AND gTisch_6.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_6_RFID_Reset = FALSE AND gMerker_block_RFID_read_Tisch_6 = FALSE (*AND gMerker_Tisch_6_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_6_Auftrag_Lesen := TRUE;
				Tisch_6_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_6 := lWarten_RFID_Fehler_Tisch_6 + (RTInfo_0.cycle_time/1000);
			IF gTisch_6_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_6 := gTisch_6_RFID_Read[1];
				//			gMerker_RFID_Tisch_6_gelesen := TRUE;
				//			gMerker_Tisch_6_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_6 := 0;
				Tisch_6_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_6 >= 5000 AND gTisch_6_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_6_Auftrag_Lesen := FALSE;
				gMerker_Tisch_6_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_6 := 0;
				Tisch_6_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_6 <> 0 THEN
				gMerker_RFID_Tisch_6_gelesen := TRUE;
				gMerker_Tisch_6_lesen_fertig := TRUE;
				Tisch_6_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_6 = 0 THEN
				gMerker_RFID_Tisch_6_gelesen := FALSE;
				gMerker_Tisch_6_lesen_fertig := FALSE;
				Tisch_6_RFID := 100;
			END_IF				
			
		20: (* lWarten_fuer_OPCUA_Tisch_6 := lWarten_fuer_OPCUA_Tisch_6 + (RTInfo_0.cycle_time/1000) ;*)
			IF gMerker_Tisch_6_RFID_Vorhanden = FALSE (* gTisch_6.Inputs.Vor_Stopper = FALSE *) AND gTisch_6.Inputs.Nach_Stopper = TRUE (* AND lWarten_fuer_OPCUA_Tisch_6 >= Wartezeit_OPCUA *) THEN
				gMerker_Tisch_6_Auftrag_Lesen := FALSE;
	//			gMerker_RFID_Value_Tisch_6 := 0;
				gTisch_6_RFID_Write[0] := 4;
				gMerker_Tisch_6_RFID_UID_STR := '0';
				Tisch_6_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_6_RFID_Read[0] = 0 THEN
				gTisch_6_RFID_Write[0] := 0;
				Tisch_6_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_6_Auftrag_Lesen = FALSE AND gMerker_Tisch_6_RFID_Reset = TRUE THEN
				gTisch_6_RFID_Write[0] := 4;
		//		gMerker_RFID_Value_Tisch_6 := 0;
				gMerker_Tisch_6_RFID_UID_STR := '0';
				Tisch_6_RFID := 110;
			END_IF
		
		110:
			IF gTisch_6_RFID_Read[0] = 0 THEN
				gMerker_Tisch_6_alles_nullen := TRUE;
				Tisch_6_RFID := 120;
			END_IF
		
		120:
			IF gTisch_6_RFID_Write[0] = 0 AND gTisch_6_RFID_Write[1] = 0 AND gTisch_6_RFID_Write[2] = 0 AND gTisch_6_RFID_Write[3] = 0 AND gTisch_6_RFID_Write[4] = 0 AND gTisch_6_RFID_Write[5] = 0 AND gTisch_6_RFID_Write[6] = 0 AND gTisch_6_RFID_Write[7] = 0 AND gTisch_6_RFID_Write[8] = 0 AND gTisch_6_RFID_Write[9] = 0 THEN
				gMerker_Tisch_6_alles_nullen := FALSE;
				gMerker_Tisch_6_RFID_Reset := FALSE;
				Tisch_6_RFID := 0;
			END_IF			
				
	END_CASE
	
	//**********************************	Tisch 7		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_7_RFID_Vorhanden := gTisch_7_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_7_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_7_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_7_RFID_Write[2] := 0;
		gTisch_7_RFID_Write[3] := 0;
		gTisch_7_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_7_RFID_Write[5] := 0;
		gTisch_7_RFID_Write[6] := 0;
		gTisch_7_RFID_Write[7] := 0;
		gTisch_7_RFID_Write[8] := 0;
		gTisch_7_RFID_Write[9] := 1;
		gTisch_7_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_7_alles_nullen = TRUE THEN
		gTisch_7_RFID_Write[1] := 0;
		gTisch_7_RFID_Write[2] := 0;
		gTisch_7_RFID_Write[3] := 0;
		gTisch_7_RFID_Write[4] := 0;  
		gTisch_7_RFID_Write[5] := 0;
		gTisch_7_RFID_Write[6] := 0;
		gTisch_7_RFID_Write[7] := 0; 
		gTisch_7_RFID_Write[8] := 0;
		gTisch_7_RFID_Write[0] := 0;
	END_IF
	
	gTisch_7_RFID_Write[9] := gTisch_7_RFID_Write[0];
	
	CASE Tisch_7_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_7_RFID_Read[0] = 129 AND gTisch_7_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_7_STRING_HELPER := '';
				gMerker_Tisch_7_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_7_STRING_HELPER := USINT_TO_STRING (gTisch_7_RFID_Read[i]);
					IF LEN(gMerker_Tisch_7_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_7_STRING_HELPER := CONCAT('00', gMerker_Tisch_7_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_7_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_7_STRING_HELPER := CONCAT('0', gMerker_Tisch_7_STRING_HELPER);
					END_IF;
					gMerker_Tisch_7_RFID_UID_STR := CONCAT( gMerker_Tisch_7_RFID_UID_STR, gMerker_Tisch_7_STRING_HELPER );
				END_FOR
				Tisch_7_RFID := 5;
			END_IF
//Cech-Implement-Ende		
				
		5:	IF gMerker_Tisch_7_RFID_Vorhanden  = TRUE AND gTisch_7.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_7_RFID_Reset = FALSE (*AND gMerker_Tisch_7_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_7_Auftrag_Lesen := TRUE;
				Tisch_7_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_7 := lWarten_RFID_Fehler_Tisch_7 + (RTInfo_0.cycle_time/1000);
			IF gTisch_7_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_7 := gTisch_7_RFID_Read[1];
				//			gMerker_RFID_Tisch_7_gelesen := TRUE;
				//			gMerker_Tisch_7_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_7 := 0;
				Tisch_7_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_7 >= 5000 AND gTisch_7_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_7_Auftrag_Lesen := FALSE;
				gMerker_Tisch_7_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_7 := 0;
				Tisch_7_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_7 <> 0 THEN
				gMerker_RFID_Tisch_7_gelesen := TRUE;
				gMerker_Tisch_7_lesen_fertig := TRUE;
				Tisch_7_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_7 = 0 THEN
				gMerker_RFID_Tisch_7_gelesen := FALSE;
				gMerker_Tisch_7_lesen_fertig := FALSE;
				Tisch_7_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_7 := lWarten_fuer_OPCUA_Tisch_7 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_7_RFID_Vorhanden = FALSE AND gTisch_7.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_7 >= Wartezeit_OPCUA THEN
				gMerker_Tisch_7_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_7 := 0;
				gTisch_7_RFID_Write[0] := 4;
				gMerker_Tisch_7_RFID_UID_STR := '0';
				Tisch_7_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_7_RFID_Read[0] = 0 THEN
				gTisch_7_RFID_Write[0] := 0;
				Tisch_7_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_7_Auftrag_Lesen = FALSE AND gMerker_Tisch_7_RFID_Reset = TRUE THEN
				gTisch_7_RFID_Write[0] := 4;
				gMerker_RFID_Value_Tisch_7 := 0;
				gMerker_Tisch_7_RFID_UID_STR := '0';
				Tisch_7_RFID := 110;
			END_IF
		
		110:
			IF gTisch_7_RFID_Read[0] = 0 THEN
				gMerker_Tisch_7_alles_nullen := TRUE;
				Tisch_7_RFID := 120;
			END_IF
		
		120:
			IF gTisch_7_RFID_Write[0] = 0 AND gTisch_7_RFID_Write[1] = 0 AND gTisch_7_RFID_Write[2] = 0 AND gTisch_7_RFID_Write[3] = 0 AND gTisch_7_RFID_Write[4] = 0 AND gTisch_7_RFID_Write[5] = 0 AND gTisch_7_RFID_Write[6] = 0 AND gTisch_7_RFID_Write[7] = 0 AND gTisch_7_RFID_Write[8] = 0 AND gTisch_7_RFID_Write[9] = 0 THEN
				gMerker_Tisch_7_alles_nullen := FALSE;
				gMerker_Tisch_7_RFID_Reset := FALSE;
				Tisch_7_RFID := 0;
			END_IF			
				
	END_CASE
	
	//**********************************	Tisch 8		***********************************************
	
	(* Lesen *)

	gMerker_Tisch_8_RFID_Vorhanden := gTisch_8_RFID_Read[0].0; (* Auslesen ob Chip vor Lesekopf *)
	
	IF gMerker_Tisch_8_Auftrag_Lesen = TRUE THEN
		//			gMerker_Lesen_Fertig := FALSE;
		gTisch_8_RFID_Write[1] := 1;(* Befehl Datenträger lesen *)
		gTisch_8_RFID_Write[2] := 0;
		gTisch_8_RFID_Write[3] := 0;
		gTisch_8_RFID_Write[4] := 8;  (* Anzahl Bytes Lowbytes *)
		gTisch_8_RFID_Write[5] := 0;
		gTisch_8_RFID_Write[6] := 0;
		gTisch_8_RFID_Write[7] := 0;
		gTisch_8_RFID_Write[8] := 0;
		gTisch_8_RFID_Write[9] := 1;
		gTisch_8_RFID_Write[0].0 := TRUE;
	END_IF
		
	(* Write Variable nullen *)
	
	IF gMerker_Tisch_8_alles_nullen = TRUE THEN
		gTisch_8_RFID_Write[1] := 0;
		gTisch_8_RFID_Write[2] := 0;
		gTisch_8_RFID_Write[3] := 0;
		gTisch_8_RFID_Write[4] := 0;  
		gTisch_8_RFID_Write[5] := 0;
		gTisch_8_RFID_Write[6] := 0;
		gTisch_8_RFID_Write[7] := 0; 
		gTisch_8_RFID_Write[8] := 0;
		gTisch_8_RFID_Write[0] := 0;
	END_IF
	
	gTisch_8_RFID_Write[9] := gTisch_8_RFID_Write[0];
	
	CASE Tisch_8_RFID OF
//Cech-Implement-Beginn: Hier soll die UID aus dem TAg nach Tag-Present rausgeholt und auf 8Byte-Array gMerker_Tisch_1_RFID_UID übergeben werden, damit die UID für Centurio über Opc-Ua übergeben werden kannn
		0:	IF gTisch_8_RFID_Read[0] = 129 AND gTisch_8_RFID_Write[0].0 = FALSE THEN //Cech-Comment: Wenn der TAG im Lesebereich ist und der Lesekopf betriebsbereit ist ( Read[0] = 1000 0001 ), aber noch kein Lesebefehl ausgegeben wurde
				gMerker_Tisch_8_STRING_HELPER := '';
				gMerker_Tisch_8_RFID_UID_STR := '';
				FOR i := 1 TO 8 DO
					gMerker_Tisch_8_STRING_HELPER := USINT_TO_STRING (gTisch_8_RFID_Read[i]);
					IF LEN(gMerker_Tisch_8_STRING_HELPER) = 1 THEN 			//Cech-Comment: Wenn der String nur 1 ZEichen ist, muss mit 2 Nullen links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_8_STRING_HELPER := CONCAT('00', gMerker_Tisch_8_STRING_HELPER); 
					ELSIF LEN(gMerker_Tisch_8_STRING_HELPER) = 2 THEN 			//Cech-Comment: Wenn der String nur 2 Zeichen ist, muss mit 1 Null links verlängert werden, sonst wird ID verstümmelt und ist dadurch nicht mehr eindeutig über alle 8 Bytes der UID
						gMerker_Tisch_8_STRING_HELPER := CONCAT('0', gMerker_Tisch_8_STRING_HELPER);
					END_IF;

					gMerker_Tisch_8_RFID_UID_STR := CONCAT( gMerker_Tisch_8_RFID_UID_STR, gMerker_Tisch_8_STRING_HELPER );
				END_FOR
				Tisch_8_RFID := 5;
			END_IF
//Cech-Implement-Ende		
		
		5:	IF gMerker_Tisch_8_RFID_Vorhanden  = TRUE AND gTisch_8.Inputs.Vor_Stopper = TRUE AND gMerker_Tisch_8_RFID_Reset = FALSE (*AND gMerker_Tisch_8_lesen_fertig = FALSE*) THEN
				gMerker_Tisch_8_Auftrag_Lesen := TRUE;
				Tisch_8_RFID := 10;
			END_IF
		
		10: lWarten_RFID_Fehler_Tisch_8 := lWarten_RFID_Fehler_Tisch_8 + (RTInfo_0.cycle_time/1000);
			IF gTisch_8_RFID_Read[0] = 135 THEN
				gMerker_RFID_Value_Tisch_8 := gTisch_8_RFID_Read[1];
				//			gMerker_RFID_Tisch_8_gelesen := TRUE;
				//			gMerker_Tisch_8_lesen_fertig := TRUE;
				lWarten_RFID_Fehler_Tisch_8 := 0;
				Tisch_8_RFID := 15;
			ELSIF lWarten_RFID_Fehler_Tisch_8 >= 5000 AND gTisch_8_RFID_Read[0] <> 135 THEN
				gMerker_Tisch_8_Auftrag_Lesen := FALSE;
				gMerker_Tisch_8_RFID_Reset := TRUE;
				lWarten_RFID_Fehler_Tisch_8 := 0;
				Tisch_8_RFID := 100;
			END_IF
		
		15:
			IF gMerker_RFID_Value_Tisch_8 <> 0 THEN
				gMerker_RFID_Tisch_8_gelesen := TRUE;
				gMerker_Tisch_8_lesen_fertig := TRUE;
				Tisch_8_RFID := 20;
			ELSIF gMerker_RFID_Value_Tisch_8 = 0 THEN
				gMerker_RFID_Tisch_8_gelesen := FALSE;
				gMerker_Tisch_8_lesen_fertig := FALSE;
				Tisch_8_RFID := 100;
			END_IF				
			
		20: lWarten_fuer_OPCUA_Tisch_8 := lWarten_fuer_OPCUA_Tisch_8 + (RTInfo_0.cycle_time/1000);
			IF gMerker_Tisch_8_RFID_Vorhanden = FALSE AND gTisch_8.Inputs.Vor_Stopper = FALSE AND lWarten_fuer_OPCUA_Tisch_8 >= Wartezeit_OPCUA THEN
				gMerker_Tisch_8_Auftrag_Lesen := FALSE;
				gMerker_RFID_Value_Tisch_8 := 0;
				gTisch_8_RFID_Write[0] := 4;
				gMerker_Tisch_8_RFID_UID_STR := '0';
				Tisch_8_RFID := 30;
			END_IF
		
		30: 
			IF gTisch_8_RFID_Read[0] = 0 THEN
				gTisch_8_RFID_Write[0] := 0;
				Tisch_8_RFID := 0;
			END_IF
		
		100:
			IF gMerker_Tisch_8_Auftrag_Lesen = FALSE AND gMerker_Tisch_8_RFID_Reset = TRUE THEN
				gTisch_8_RFID_Write[0] := 4;
				gMerker_RFID_Value_Tisch_8 := 0;
				gMerker_Tisch_8_RFID_UID_STR := '0';
				Tisch_8_RFID := 110;
			END_IF
		
		110:
			IF gTisch_8_RFID_Read[0] = 0 THEN
				gMerker_Tisch_8_alles_nullen := TRUE;
				Tisch_8_RFID := 120;
			END_IF
		
		120:
			IF gTisch_8_RFID_Write[0] = 0 AND gTisch_8_RFID_Write[1] = 0 AND gTisch_8_RFID_Write[2] = 0 AND gTisch_8_RFID_Write[3] = 0 AND gTisch_8_RFID_Write[4] = 0 AND gTisch_8_RFID_Write[5] = 0 AND gTisch_8_RFID_Write[6] = 0 AND gTisch_8_RFID_Write[7] = 0 AND gTisch_8_RFID_Write[8] = 0 AND gTisch_8_RFID_Write[9] = 0 THEN
				gMerker_Tisch_8_alles_nullen := FALSE;
				gMerker_Tisch_8_RFID_Reset := FALSE;
				Tisch_8_RFID := 0;
			END_IF			
				
	END_CASE
	
	OPCUA_TEST_1;
	
	OPCUATEST2;
	
	OPCUATEST3;
	
	
	
END_PROGRAM

PROGRAM _EXIT
	(* Insert code here *)
	 
END_PROGRAM

