FUNCTION_BLOCK "FB_ILS_STRO_Switch"
{ S7_Optimized_Access := 'TRUE' }
VERSION : 0.1
   VAR_INPUT 
      stInSettings : "SettingsSwitch" := (T#3s, (), (), (), (), (), (), (), (), (), (), (), (), (), ());
      stInSenExit3 : "UDT_Sensor";   // Sensor Input Exit 3
      stInSenExit4 : "UDT_Sensor";   // Sensor Input Exit 4
      nInMainTroNo : UInt;   // Nummer des MainTro
      nInSetSwitch : USInt;   // 0: Es bleibt hier alles so wie es ist! | 1: E1->A3 | 2: E1->A4 | 3: E2->A3 | 4: E2->A4
      nInSwitchNo : USInt;   // Nummer des Switch
      nInActNoInSwitch : USInt;   // Anzahl der BT die unterwegs sind von MainTRO gemeldet
      xInBtInside : Bool;   // Signal von Main TRO dass mind. ein BT "innerhalb der Weiche" ist
      xInErrorQuit : Bool;   // Error-Quit durch MainTro
      xInSftyOk : Bool;   // Safetyeingang
      xInAllRdyToStart : Bool;   // Eingang Anlage bereit
      xInCarouselRun : Bool;   // Carousel im Zustand Run
      xInCancel : Bool;   // Abbruchsignal durch MFR von MainTRO durchgeschleift
      nInNextCarr : USInt;
      xInReqFinished : Bool;   // Info für Switch von MainTRO dass dieser fertig ist
      xInDeqExternal : Bool;
      tCarrierTransit : Time := T#2s;   // Zeit, wie lange Carrier durch die Weiche braucht
   END_VAR

   VAR_OUTPUT 
      stOutMfr : "S2MSwitch";   // Interface für MFR
      stOutMainTro : "IntfSwitch";   // Interface MainTRO
      arOutFifo : Array[1..6] of USInt;
      xOutSwEntrTo1 : Bool;   // Switch Entrance to 1
      xOutSwEntrTo2 : Bool;   // Switch Entrance to 2
      xOutSwExTo3 : Bool;   // Switch Exit to 3
      xOutSwExTo4 : Bool;   // Switch Exit to 4
      nOutActCarrLeave : USInt;   // Idx des Bt der die Weiche als letztes verlassen hat
      nOutActCarrLeaveWrongDir : USInt;
      xOutBtLeftSwitch : Bool;   // Bt hat Weiche verlassen
      xOutBtLeftSwitchWrongDir : Bool;
      xOutPermSigOutSen3 : Bool;
      xOutPermSigOutSen4 : Bool;
   END_VAR

   VAR_IN_OUT 
      stInOutMachineState : "UDT_MainState";
      xInOutEnq : Bool;
      stInOutHMI : "UDT_UnloadingStation";
   END_VAR

   VAR 
      fbSetAlarmAndLog : Array[0..1] of "FB_SetAlarmAndLog";
      fbStateManager : "FB_StateManager";
   END_VAR
   VAR RETAIN
      tOnTransitTimer {InstructionName := 'TON_TIME'; LibVersion := '1.0'} : TON_TIME;   // Timer der meldet wenn zu lange auf den BT am Ausgang gewartet wird
      nState : Int;
      xEntr1 : Bool;   // Eingangsweiche zu Eingang 1
      xEntr2 : Bool;   // Eingangsweiche zu Eingang 2
      xExit3 : Bool;   // Ausgangsweiche zu Ausgang 3
      xExit4 : Bool;   // Ausgangsweiche zu Ausgang 4
   END_VAR
   VAR 
      xStartMotor : Bool;
      xSwEntrState : Bool;   // 0: Eingangsweiche geht auf Eingang 1 | 1: Eingangsweiche geht auf Eingang 2
      xSwExState : Bool;   // 0: Ausgangsweiche geht auf Ausgang 3 | 1: Ausgangsweiche geht auf Ausgang 4
   END_VAR
   VAR RETAIN
      CountBTExit3 {InstructionName := 'CTU_UDINT'; LibVersion := '1.0'} : CTU_UDINT;   // Instanz-CTU
      CountBTExit4 {InstructionName := 'CTU_UDINT'; LibVersion := '1.0'} : CTU_UDINT;   // Instanz-CTU
      xCountUpExit3 : Bool;   // Flag
      xCountUpExit4 : Bool;   // Flag
      nCounterExit3 : UDInt;   // Zähler am Ausgang 3 vom Switch
      nCounterExit4 : UDInt;   // Zähler am Ausgang 4 vom Switch
      xTransitFlagState : Bool;   // Wird für Erfassung des Flankenwechsels der BT-Anzahl im Transit benötigt
      xSignalLongEx3 : Bool;   // LongSignal an Ausgang 3
      xSignalVeryLongEx3 : Bool;   // LongSignal an Ausgang 4
      xSignalLongEx4 : Bool;   // VeryLongSignal an Ausgang 3
      xSignalVeryLongEx4 : Bool;   // VeryLongSignal an Ausgang 4
      xTooEarlyTrigUnconf : Bool;   // Trigger für die Zeitmessung des Too-Early-Signals bei Unconfirmed
   END_VAR
   VAR 
      xTooEarlyTrigConf : Bool;   // Trigger für die Zeitmessung des Too-Early-Signals bei Confirmed
   END_VAR
   VAR RETAIN
      tTooEarlyTimerUnconf {InstructionName := 'TON_TIME'; LibVersion := '1.0'} : TON_TIME;   // Timer für Too-Early-Signal Unconfirmed
   END_VAR
   VAR 
      tTooEarlyTimerConf {InstructionName := 'TON_TIME'; LibVersion := '1.0'} : TON_TIME;   // Timer für Too-Early-Signal Confirmed
   END_VAR
   VAR RETAIN
      arCarrFifo : Array[1..6] of USInt;   // Weichen-FIFO 
      nCarrIdxLeave : USInt;   // Carrier (Index) der als nächster aus FIFO verschwindet
      constInitialItem : USInt := 0;
      xDeqSwitchFIFO : Bool;
      xSwitchWrongDir : Bool;
   END_VAR
   VAR 
      xEnq : Bool;
   END_VAR
   VAR RETAIN
      xPermSigSen3 : Bool;
      xPermSigSen4 : Bool;
   END_VAR

   VAR_TEMP 
      tmpStateWatch : Int;
      tmpSetError : Bool;
      tmpSetWarning : Bool;
      tmpActUnivTon : Bool;   // Trigger für Universal-Timer des StateManagers zur Verwendung in Schrittkette.
      tmpTransitFlagChange : Bool;   // Temp Bit für Flankenwechsel der BT-Anzahl im Transit
   END_VAR

   VAR CONSTANT 
      cStep_Off : Int := 0;
      cStep_Undefined : Int := 100;
      cStep_WaitForReq : Int := 200;
      cStep_WaitForCar : Int := 400;
      cStep_Switch1To3 : Int := 700;
      cStep_1To3OkWaitForTransit : Int := 750;
      cStep_1To3OkWaitForChange : Int := 800;
      cStep_Switch1To4 : Int := 900;
      cStep_1To4OkWaitForTransit : Int := 950;
      cStep_1To4OkWaitForChange : Int := 1000;
      cStep_2To3OkWaitForTransit : Int := 1150;
      cStep_2To3OkWaitForChange : Int := 1200;
      cStep_2To4OkWaitForTransit : Int := 1350;
      cStep_2To4OkWaitForChange : Int := 1400;
      cStep_Switch2To3 : Int := 1100;
      cStep_Switch2To4 : Int := 1300;
   END_VAR


BEGIN
	(* 
	SPS => MFR: Signal CARR (erfolgreiches Abbiegen an einer Weiche am Pinband??)
	
	SysFehler werden von Separator geprüft, nicht hier!
	Unterscheiden, je nach dem ob alter oder neuer Switch: Ein- und Ausgang schalten oder nur Ausgang?
	Unreserve-Funktion bei detektierter Fehlschaltung
	Funktionen einfach:
	-   links oder rechts schalten
	Funktionen detaillierter:
	-   HFS-ON, System-Fehler werden nicht geprüft, weil diese von Separator geprüft werden.
	-   TRO-Kommunikation Bearbeiten 
	-   Motoren starten und prüfen ob drehen.
	-   In-Switch schalten, falls vorhanden
	-   Switch schalten falls notwendig
	-   Verlassen-Sensor Signal  weiterbuchen
	-   Verlassen-Sensor LongSignal Bearbeiten
	-   Fehlschaltung detektieren und Bearbeiten  dorthin Buchen  in  die ursprüngliche Richtung Unreserve Aufrufen
	-   Es kommt oft vor, dass die Quellen und dass die Verlassen-Sensoren von der Weiche ungleich weit entfernt sind.  unterschiedliche Jam-Timeouts.
	Fehler Fälle:
	a)  LongSensorSignal
	b)  Switch Jam-Timeout: BT ist an den Verlassen-Sensor nicht angekommen
	c)  Fehlschaltung
	d)  Too early OutSensor-Signal
	e)  Verlassen-Sensor immer AN
	*)
	
	// IntfInOutCarousel3  "IntfCarousel"  Interface für Carousel am Ausgang 3     ->     rausgenommen
	// IntfInOutCarousel4  "IntfCarousel"  Interface für Carousel am Ausgang 4     ->     rausgenommen
	
	
	REGION Schrittkette
	    //UNTERSCHIED ALTE WEICHE NEUE WEICHE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	    CASE #nState OF
	            
	        #cStep_Off:
	            
	            REGION 0: Off
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := FALSE;
	                
	                #stOutMainTro.nStatus := "SwiState_OffEStop" - (5 * BOOL_TO_INT(#xInSftyOk));
	                
	                
	                ////////// Timer ///////////
	                
	                //////// Transition ////////
	            END_REGION
	        #cStep_Undefined:
	            
	            REGION 100: Undefined
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := FALSE;
	                
	                #stOutMainTro.nStatus := "SwiState_Init";//2;
	                
	                
	                ////////// Timer ///////////
	                
	                //////// Transition ////////
	                IF #fbStateManager.tOutTimeInStep > #stInSettings.tSwitchSignal THEN
	                    #nState := #cStep_WaitForReq;//0200;
	                END_IF;
	            END_REGION
	            #cStep_WaitForReq:
	            
	            REGION 200: Wait for Req
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := FALSE;
	                
	                #stOutMainTro.nStatus := "SwiState_WaitForReq";//3;
	                
	                
	                ////////// Timer ///////////
	                
	                //////// Transition ////////
	                IF #nInSetSwitch = 1 OR #nInSetSwitch = 2 OR #nInSetSwitch = 3 OR #nInSetSwitch = 4 THEN
	                    #nState := #cStep_WaitForCar;//400;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_WaitForCar:
	            
	            REGION 400: Wait for Carousel
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := FALSE;
	                
	                //#xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_WaitForCarousel";//4;
	                
	                ////////// Timer ///////////
	                
	                //////// Transition ////////
	                IF #xInCarouselRun THEN
	                    //#IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 AND #fbStateManager.tOutTimeInStep < T#10s THEN
	                    
	                    IF #nInSetSwitch = 1 THEN
	                        #nState := #cStep_Switch1To3;//700;
	                    ELSIF #nInSetSwitch = 2 THEN
	                        #nState := #cStep_Switch1To4;//900;
	                    ELSIF #nInSetSwitch = 3 THEN
	                        #nState := #cStep_Switch2To3;//1100;
	                    ELSIF #nInSetSwitch = 4 THEN
	                        #nState := #cStep_Switch2To4;//1300;
	                    END_IF;
	                    
	                ELSIF #nInSetSwitch = 0 THEN
	                    
	                    #nState := #cStep_WaitForReq;//200;
	                    
	                END_IF;
	                
	            END_REGION
	            
	            
	            #cStep_Switch1To3:
	            
	            REGION 700: Switch Entr1 -> Ex3 
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := TRUE;
	                #xEntr2 := FALSE;
	                #xExit3 := TRUE;
	                #xExit4 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_ChangeSwitch";//5;
	                #stOutMainTro.xStatusIn := FALSE;
	                #stOutMainTro.xStatusOut := FALSE;
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                
	                IF #fbStateManager.tOutTimeInStep > T#150ms THEN
	                    #nState := #cStep_1To3OkWaitForTransit;//750;
	                ELSIF #stInSettings.xSwitchFixed THEN
	                    #nState := #cStep_1To3OkWaitForChange;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_1To3OkWaitForTransit:
	            
	            REGION =>      750: Entr1 -> Ex3 ok, wait for Transit 
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := TRUE;
	                #xEntr2 := FALSE;
	                #xExit3 := TRUE;
	                #xExit4 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_NotConfirmed";//6;
	                #stOutMainTro.xStatusIn := FALSE;
	                #stOutMainTro.xStatusOut := FALSE;
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                //Switch Jam-Timeout: BT ist an den Verlassen-Sensor nicht angekommen. Auch too early!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	               // IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)AND
	                    IF #stInSenExit3.xDirectEdgeNeg AND #stInSettings.xPluggedExSen3 THEN
	                    #xCountUpExit3 := TRUE;
	                    #nState := #cStep_1To3OkWaitForChange;//800;
	                    // ELSIF #stInSenExit4.xDirectEdgePos AND #stInSettings.xPluggedExSen4 THEN
	                    //     #nState := #cStep_ErrorSenUnexpected;//-100;
	                ELSIF (#fbStateManager.tOutTimeInStep > #tCarrierTransit) AND NOT #stInSettings.xPluggedExSen3 THEN
	                    #xCountUpExit3 := TRUE;
	                    #nState := #cStep_1To3OkWaitForChange;
	                ELSIF #fbStateManager.tOutTimeInStep > T#15000ms THEN
	                    #nState := #cStep_WaitForReq;//200;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_1To3OkWaitForChange:
	            
	            REGION =>      800: Entr1 -> Ex3 ok, wait for Change 
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := TRUE;
	                #xEntr2 := FALSE;
	                #xExit3 := TRUE;
	                #xExit4 := FALSE;
	                #xCountUpExit3 := FALSE;
	                
	                //#xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_Confirmed";//7;
	                #stOutMainTro.xStatusIn := FALSE;
	                #stOutMainTro.xStatusOut := FALSE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)THEN
	                    
	                    IF #nInSetSwitch = 2 THEN
	                        #nState := #cStep_Switch1To4;//900;
	                    ELSIF #nInSetSwitch = 3 THEN
	                        #nState := #cStep_Switch2To3;//1100;
	                    ELSIF #nInSetSwitch = 4 THEN
	                        #nState := #cStep_Switch2To4;//1300;
	                    END_IF;
	                    
	                END_IF;
	                
	                // IF #fbStateManager.tOutTimeInStep > T#30s THEN
	                //     #nState := #cStep_WaitForReq;//200;
	                // END_IF;
	                
	            END_REGION
	            
	            
	            #cStep_Switch1To4:
	            
	            REGION 900: Switch Entr1 -> Ex4
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := TRUE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := TRUE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_ChangeSwitch";//5;
	                #stOutMainTro.xStatusIn := FALSE;
	                #stOutMainTro.xStatusOut := TRUE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #fbStateManager.tOutTimeInStep > T#150ms THEN
	                    #nState := #cStep_1To4OkWaitForTransit;//950;
	                ELSIF #stInSettings.xSwitchFixed THEN
	                    #nState := #cStep_1To4OkWaitForChange;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_1To4OkWaitForTransit:
	            
	            REGION =>      950: Entr1 -> Ex4 ok, wait for Transit 
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := TRUE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := TRUE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_NotConfirmed";//6;
	                #stOutMainTro.xStatusIn := FALSE;
	                #stOutMainTro.xStatusOut := TRUE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                //Switch Jam-Timeout: BT ist an den Verlassen-Sensor nicht angekommen. Auch too early!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	              //  IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)AND
	                    IF #stInSenExit4.xDirectEdgeNeg AND #stInSettings.xPluggedExSen4 THEN
	                    #xCountUpExit4 := TRUE;
	                    #nState := #cStep_1To4OkWaitForChange;//1000;
	                    // ELSIF #stInSenExit3.xDirectEdgePos AND #stInSettings.xPluggedExSen3 THEN
	                    //         #nState := #cStep_ErrorSenUnexpected;//-100;
	                ELSIF (#fbStateManager.tOutTimeInStep > #tCarrierTransit) AND NOT #stInSettings.xPluggedExSen4 THEN
	                    #xCountUpExit4 := TRUE;
	                    #nState := #cStep_1To4OkWaitForChange;
	                ELSIF #fbStateManager.tOutTimeInStep > T#15000ms THEN
	                    #nState := #cStep_WaitForReq;//200;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_1To4OkWaitForChange:
	            
	            REGION =>     1000: Entr1 -> Ex4 ok, wait for Change 
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := TRUE;
	                #xEntr2 := FALSE;
	                #xExit3 := FALSE;
	                #xExit4 := TRUE;
	                #xCountUpExit4 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_Confirmed";//7;
	                #stOutMainTro.xStatusIn := FALSE;
	                #stOutMainTro.xStatusOut := TRUE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)THEN
	                    
	                    IF #nInSetSwitch = 1 THEN
	                        #nState := #cStep_Switch1To3;//700;
	                    ELSIF #nInSetSwitch = 3 THEN
	                        #nState := #cStep_Switch2To3;//1100;
	                    ELSIF #nInSetSwitch = 4 THEN
	                        #nState := #cStep_Switch2To4;//1300;
	                    END_IF;
	                    
	                END_IF;
	                
	                // IF #fbStateManager.tOutTimeInStep > T#30s THEN
	                //     #nState := #cStep_WaitForReq;//200;
	                // END_IF;
	                
	            END_REGION
	            
	            
	            #cStep_Switch2To3:
	            
	            REGION 1100: Switch Entr2 -> Ex3
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := TRUE;
	                #xExit3 := TRUE;
	                #xExit4 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_ChangeSwitch";//5;
	                #stOutMainTro.xStatusIn := TRUE;
	                #stOutMainTro.xStatusOut := FALSE;
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #fbStateManager.tOutTimeInStep > T#150ms THEN
	                    #nState := #cStep_2To3OkWaitForTransit;//1150;
	                ELSIF #stInSettings.xSwitchFixed THEN
	                    #nState := #cStep_2To3OkWaitForChange;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_2To3OkWaitForTransit:
	            
	            REGION =>      1150: Entr2 -> Ex3 ok, wait for Transit
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := TRUE;
	                #xExit3 := TRUE;
	                #xExit4 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_NotConfirmed";//6;
	                #stOutMainTro.xStatusIn := TRUE;
	                #stOutMainTro.xStatusOut := FALSE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                //Switch Jam-Timeout: BT ist an den Verlassen-Sensor nicht angekommen. Auch too early!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	                //     IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)AND
	                IF #stInSenExit3.xDirectEdgeNeg AND #stInSettings.xPluggedExSen3 THEN
	                    #xCountUpExit3 := TRUE;
	                    #nState := #cStep_2To3OkWaitForChange;//1200;
	                    // ELSIF #stInSenExit4.xDirectEdgePos AND #stInSettings.xPluggedExSen4 THEN
	                    //     #nState := #cStep_ErrorSenUnexpected;//-100;
	                ELSIF (#fbStateManager.tOutTimeInStep > #tCarrierTransit) AND NOT #stInSettings.xPluggedExSen3 THEN
	                    #xCountUpExit3 := TRUE;
	                    #nState := #cStep_2To3OkWaitForChange;
	                ELSIF #fbStateManager.tOutTimeInStep > T#15000ms THEN
	                    #nState := #cStep_WaitForReq;//200;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_2To3OkWaitForChange:
	            
	            REGION =>      1200: Entr2 -> Ex3 ok, wait for Change
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := TRUE;
	                #xExit3 := TRUE;
	                #xExit4 := FALSE;
	                #xCountUpExit3 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_Confirmed";//7;
	                #stOutMainTro.xStatusIn := TRUE;
	                #stOutMainTro.xStatusOut := FALSE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)THEN
	                    
	                    IF #nInSetSwitch = 1 THEN
	                        #nState := #cStep_Switch1To3;//700;
	                    ELSIF #nInSetSwitch = 2 THEN
	                        #nState := #cStep_Switch1To4;//900;
	                    ELSIF #nInSetSwitch = 4 THEN
	                        #nState := #cStep_Switch2To4;//1300;
	                    END_IF;
	                    
	                END_IF;
	                
	                // IF #fbStateManager.tOutTimeInStep > T#30s THEN
	                //     #nState := #cStep_WaitForReq;//200;
	                // END_IF;
	                
	            END_REGION
	            
	            #cStep_Switch2To4:
	            
	            REGION 1300: Switch Entr2 -> Ex4
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := TRUE;
	                #xExit3 := FALSE;
	                #xExit4 := TRUE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_ChangeSwitch";//5;
	                #stOutMainTro.xStatusIn := TRUE;
	                #stOutMainTro.xStatusOut := TRUE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #fbStateManager.tOutTimeInStep > T#150ms THEN
	                    #nState := #cStep_2To4OkWaitForTransit;//1350;
	                ELSIF #stInSettings.xSwitchFixed THEN
	                    #nState := #cStep_2To4OkWaitForChange;
	                END_IF;
	                
	            END_REGION
	            
	            #cStep_2To4OkWaitForTransit:
	            
	            REGION =>      1350: Entr2 -> Ex4 ok, wait for Transit
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := TRUE;
	                #xExit3 := FALSE;
	                #xExit4 := TRUE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_NotConfirmed";//6;
	                #stOutMainTro.xStatusIn := TRUE;
	                #stOutMainTro.xStatusOut := TRUE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                //Switch Jam-Timeout: BT ist an den Verlassen-Sensor nicht angekommen. Auch too early!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	           //     IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)AND
	                    IF #stInSenExit4.xDirectEdgeNeg AND #stInSettings.xPluggedExSen4 THEN
	                    #xCountUpExit4 := TRUE;
	                    #nState := #cStep_2To4OkWaitForChange;//1400;
	                    // ELSIF #stInSenExit3.xDirectEdgePos AND #stInSettings.xPluggedExSen3 THEN
	                    //     #nState := #cStep_ErrorSenUnexpected;//-100;
	                ELSIF (#fbStateManager.tOutTimeInStep > #tCarrierTransit) AND NOT #stInSettings.xPluggedExSen4 THEN
	                    #xCountUpExit4 := TRUE;
	                    #nState := #cStep_2To4OkWaitForChange;
	                ELSIF #fbStateManager.tOutTimeInStep > T#15000ms THEN
	                    #nState := #cStep_WaitForReq;//200;
	                END_IF;
	                
	            END_REGION
	            #cStep_2To4OkWaitForChange:
	            
	            REGION =>      1400: Entr2 -> Ex4 ok, wait for Change
	                ///////// Ausgänge /////////
	                
	                ///////// Statics //////////
	                #xEntr1 := FALSE;
	                #xEntr2 := TRUE;
	                #xExit3 := FALSE;
	                #xExit4 := TRUE;
	                #xCountUpExit4 := FALSE;
	                
	                // #xStartMotor := #xInCarouselRun;
	                
	                #stOutMainTro.nStatus := "SwiState_Confirmed";//7;
	                #stOutMainTro.xStatusIn := TRUE;
	                #stOutMainTro.xStatusOut := TRUE;
	                
	                
	                ////////// Timer ///////////
	                #tmpActUnivTon := FALSE;
	                //////// Transition ////////
	                IF #xInCarouselRun (* #IntfInOutCarousel3.nStatus = 4 AND #IntfInOutCarousel4.nStatus = 4 *)THEN
	                    
	                    IF #nInSetSwitch = 1 THEN
	                        #nState := #cStep_Switch1To3;//700;
	                    ELSIF #nInSetSwitch = 2 THEN
	                        #nState := #cStep_Switch1To4;//900;
	                    ELSIF #nInSetSwitch = 3 THEN
	                        #nState := #cStep_Switch2To3;//1100;
	                    END_IF;
	                    
	                END_IF;
	                
	                // IF #fbStateManager.tOutTimeInStep > T#30s THEN
	                //     #nState := #cStep_WaitForReq;//200;
	                // END_IF;
	                
	            END_REGION
	            
	            
	            // #cStep_ErrorSenUnexpected:
	            
	            //     REGION -100: Error: Unexpected Sensor
	            //         ///////// Ausgänge /////////
	            
	            //         ///////// Statics //////////
	            //         #xEntr1 := FALSE;
	            //         #xEntr2 := FALSE;
	            //         #xExit3 := FALSE;
	            //         #xExit4 := FALSE;
	            //         /////////  Timer  //////////
	            
	            //         //////// Transition ////////
	            //         IF #fbStateManager.tOutTimeInStep > T#10s THEN
	            //             #nState := #cStep_WaitForReq;//200;
	            //         END_IF;
	            
	            //     END_REGION
	            // #cStep_ErrorSenTime:
	            
	            //     REGION -200: Error: Sensor/Timer
	            //         ///////// Ausgänge /////////
	            
	            //         ///////// Statics //////////
	            //         #xEntr1 := FALSE;
	            //         #xEntr2 := FALSE;
	            //         #xExit3 := FALSE;
	            //         #xExit4 := FALSE;
	            //         /////////  Timer  //////////
	            
	            //         //////// Transition ////////
	            //         IF #fbStateManager.tOutTimeInStep > T#10s THEN
	            //             #nState := #cStep_WaitForReq;//200;
	            //         END_IF;
	            
	            //     END_REGION
	        ELSE
	            ;
	    END_CASE;
	END_REGION
	
	// FIFO macht ohne Out-Sensoren nicht wirklich Sinn, kein Mehrwert
	REGION Weichenbereich - FIFO
	    
	    // IF #fbSwitchFifo.dequeueDone OR #xInCancel THEN
	    //     #xDeqSwitchFIFO := FALSE;
	    // ELSIF (#nInSetSwitch = 1 OR #nInSetSwitch = 3) AND #stInSenExit3.xDirectEdgeNeg AND #xDeqSwitchFIFO AND NOT #fbSwitchFifo.isEmpty THEN        // Deq auf leeren FIFO nicht erlaubt!
	    //     #xDeqSwitchFIFO := FALSE;
	    // ELSIF (#nInSetSwitch = 2 OR #nInSetSwitch = 4) AND #stInSenExit4.xDirectEdgeNeg AND #xDeqSwitchFIFO AND NOT #fbSwitchFifo.isEmpty THEN     // Deq auf leeren FIFO nicht erlaubt!
	    //     #xDeqSwitchFIFO := FALSE;
	    // ELSIF (#nInSetSwitch = 1 OR #nInSetSwitch = 3) AND (#stInSenExit3.xDirectEdgeNeg OR #xInDeqExternal) AND NOT #fbSwitchFifo.isEmpty THEN        // Deq auf leeren FIFO nicht erlaubt!
	    //     #xDeqSwitchFIFO := true;
	    // ELSIF (#nInSetSwitch = 2 OR #nInSetSwitch = 4) AND (#stInSenExit4.xDirectEdgeNeg OR #xInDeqExternal) AND NOT #fbSwitchFifo.isEmpty THEN     // Deq auf leeren FIFO nicht erlaubt!
	    //     #xDeqSwitchFIFO := true;
	    // END_IF;
	    
	    // #fbSwitchFifo(enqueue := #xInOutEnq,
	    //               dequeue := #xDeqSwitchFIFO,
	    //               clear := #xInCancel,
	    //               initialItem := #constInitialItem,
	    //               isEmpty => #stOutMainTro.xFifoEmpty,
	    //               itemIn := #nInNextCarr,
	    //               buffer := #arCarrFifo,
	    //               itemOut := #nCarrIdxLeave);
	    
	    // IF #fbSwitchFifo.enqueueDone OR #xInCancel THEN
	    //     #xInOutEnq := 0;
	    // END_IF;
	    
	    // IF #fbSwitchFifo.dequeueDone OR #xInCancel THEN
	    //     #xDeqSwitchFIFO := FALSE;
	    // END_IF;
	    
	END_REGION
	
	// Handlen wir mit Scannern/CarrGlobCorrection
	REGION Wrong Direction
	    
	    // // Wrong Direction, MainTRO als falsch gefahren melden, siehe unten
	    
	    // IF (#nInSetSwitch = 1 OR #nInSetSwitch = 3) AND #fbSwitchFifo.elementCount > 0 AND (#nState = 750 OR #nState = 800 OR #nState = 1150 OR #nState = 1200) THEN
	    //     #xSwitchWrongDir := #stInSenExit4.xDirectEdgePos;
	    // ELSIF (#nInSetSwitch = 2 OR #nInSetSwitch = 4) AND #fbSwitchFifo.elementCount > 0 AND #nInMainTroNo <> 245 AND #nInMainTroNo <> 247 AND (#nState = 950 OR #nState = 1000 OR #nState = 1350 OR #nState = 1400) THEN
	    //     #xSwitchWrongDir := #stInSenExit3.xDirectEdgePos;
	    // END_IF;
	    
	END_REGION ;
	
	REGION StateManager
	    
	    #fbStateManager.stInSettings.nStartState := #cStep_Undefined;
	    #fbStateManager.stInSettings.xActUnivTOn := TRUE;
	    #fbStateManager.stInSettings.xRestartAtStartState := FALSE;
	    #fbStateManager(xInFunctionEnabled := #stInOutMachineState.xRunning, // AND #xInSftyOk,
	                    xInReset := #xInCancel,
	                    xInRunUnivTOn := #tmpActUnivTon,
	                    nInOutState := #nState);
	END_REGION
	
	REGION Überwachung BT verlässt Weiche nicht
	    //Während BT >0 durch die Weiche unterwegs sind, wird ermittelt ob sich diese Anzahl ändert. Bei einer Änderung des Wertes wird eine Zeit gestoppt um ggf. zu melden dass dies zu lange dauert.
	    //Wenn also welche unterwegs sind, ist alles in Ordnung wenn sich an der Anzahl was ändert bzw. wenn diese Anzahl Null wird.
	    
	    // #tmpTransitFlagChange := #fbSwitchFifo.elementCount.%X0; //Das LSB der INT-Zahl wird abgefragt um zu ermitteln ob es einen Zahl-Wechsel gibt Bit true = ungerade Zahl / Bit false = gerade Zahl
	    
	    // #tOnTransitTimer(IN := (#fbSwitchFifo.elementCount > 0 AND (#tmpTransitFlagChange = #xTransitFlagState)) OR "FirstScan",
	    //                  PT := #stInSettings.tTransitEx);
	    
	    // #xTransitFlagState := #tmpTransitFlagChange; //tmp-Variable ist bei einem Flankenwechsel für einen Zyklus anders als die Static, und erst hier unten gleich der Static.
	    
	END_REGION
	
	//Gibts nicht
	REGION Dauersignal Verlassen Sensor überprüfen 
	    
	    // IF #stInSenExit3.xDirectSensor AND
	    //     #stInSenExit3.tDirectChangeLast > T#2s
	    // THEN
	    //     #xPermSigSen3 := TRUE;
	    // ELSIF NOT #stInSenExit3.xDirectSensor (*AND
	    //      #stInSenExit3.tDirectChangeLast > T#1500ms *)THEN
	    //     #xPermSigSen3 := FALSE;
	    // END_IF;
	    
	    // IF #stInSenExit4.xDirectSensor AND
	    //     #stInSenExit4.tDirectChangeLast > T#2s
	    // THEN
	    //     #xPermSigSen4 := TRUE;
	    // ELSIF NOT #stInSenExit4.xDirectSensor (*AND
	    //      #stInSenExit4.tDirectChangeLast > T#1500ms *)THEN
	    //     #xPermSigSen4 := FALSE;
	    // END_IF;
	    
	    
	END_REGION
	
	REGION Alarm
	    // Error
	    #fbSetAlarmAndLog[0].stSettings.nType := 1;
	    #fbSetAlarmAndLog[0].stSettings.nNoMaxErrors := 5;
	    #fbSetAlarmAndLog[0].stSettings.sFctnName := CONCAT(IN1 := 'Switch ', IN2 := "FC_Uint2TroString_1"(#nInMainTroNo), IN3 := '.', IN4 := "FC_usint2String_1"(#stInSettings.nSwitchNo));
	    #fbSetAlarmAndLog[0](xInAlarm := #tmpSetError,
	                         stInOutControlUnitCabinet:=#stInOutMachineState);
	    
	    // Warning
	    #fbSetAlarmAndLog[1].stSettings.nType := 2;
	    #fbSetAlarmAndLog[1].stSettings.nNoMaxErrors := 5;
	    #fbSetAlarmAndLog[1].stSettings.sFctnName := CONCAT(IN1 := 'Switch ', IN2 := "FC_Uint2TroString_1"(#nInMainTroNo), IN3 := '.', IN4 := "FC_usint2String_1"(#stInSettings.nSwitchNo));
	    #fbSetAlarmAndLog[1](stInOutControlUnitCabinet:=#stInOutMachineState,
	                         xInAlarm := #tmpSetWarning);
	END_REGION
	
	//Nicht möglich
	REGION BT Zählen
	    
	    // #CountBTExit3(CU := #fbSwitchFifo.elementCount > 0 AND (((#nState = 750 OR #nState = 800) AND #stInSenExit3.xDirectEdgeNeg) OR ((#nState = 1150 OR #nState = 1200) AND #stInSenExit3.xDirectEdgeNeg)),//#xCountUpExit3,,
	    //               PV := 1,
	    //               CV => #nCounterExit3);
	    
	    // #CountBTExit4(CU := #fbSwitchFifo.elementCount > 0 AND (((#nState = 950 OR #nState = 1000) AND (#stInSenExit4.xDirectEdgeNeg OR (#stInSettings.nSwitchNo = "cSwi103.1" AND #stInSenExit4.xDirectEdgePos))) OR ((#nState = 1350 OR #nState = 1400) AND #stInSenExit4.xDirectEdgeNeg)),//#xCountUpExit4,
	    //               PV := 1,
	    //               CV => #nCounterExit4);
	    
	END_REGION
	
	//who dis
	REGION Long-Signal erfassen
	    
	    // IF #fbSwitchFifo.elementCount > 0 AND #stInSenExit3.xDirectSensor AND #stInSenExit3.tDirectChangeLast > #stInSettings.tSenLong THEN
	    //     #xSignalLongEx3 := TRUE;
	    // ELSIF (* #xInReqFinished *)#stInSenExit3.xDirectEdgePos THEN
	    //     #xSignalLongEx3 := FALSE;
	    // END_IF;
	    
	    // IF #fbSwitchFifo.elementCount > 0 AND #stInSenExit3.xDirectSensor AND #stInSenExit3.tDirectChangeLast > #stInSettings.tSenVeryLong THEN
	    //     #xSignalVeryLongEx3 := TRUE;
	    // ELSIF (* #xInReqFinished *)#stInSenExit3.xDirectEdgePos THEN
	    //     #xSignalVeryLongEx3 := FALSE;
	    // END_IF;
	    
	    // IF #fbSwitchFifo.elementCount > 0 AND #stInSenExit4.xDirectSensor AND #stInSenExit4.tDirectChangeLast > #stInSettings.tSenLong THEN
	    //     #xSignalLongEx4 := TRUE;
	    // ELSIF (* #xInReqFinished *)#stInSenExit4.xDirectEdgePos THEN
	    //     #xSignalLongEx4 := FALSE;
	    // END_IF;
	    
	    // IF #fbSwitchFifo.elementCount > 0 AND #stInSenExit4.xDirectSensor AND #stInSenExit4.tDirectChangeLast > #stInSettings.tSenVeryLong THEN
	    //     #xSignalVeryLongEx4 := TRUE;
	    // ELSIF (* #xInReqFinished *)#stInSenExit4.xDirectEdgePos THEN
	    //     #xSignalVeryLongEx4 := FALSE;
	    // END_IF;
	    
	    
	END_REGION
	
	//wtf
	REGION Too-Early-Signal erfassen
	    
	    // IF #fbSwitchFifo.elementCount = 1 AND (#nState = 750 OR #nState = 950 OR #nState = 1150 OR #nState = 1350) THEN
	    //     #xTooEarlyTrigUnconf := true;
	    // ELSIF #xInReqFinished (* OR (#nState = 800 OR #nState = 1000 OR #nState = 1200 OR #nState = 1400) *)THEN
	    //     #xTooEarlyTrigUnconf := FALSE;
	    // END_IF;
	    
	    // IF #fbSwitchFifo.elementCount = 1 AND NOT #xTooEarlyTrigUnconf THEN
	    //     #xTooEarlyTrigConf := true;
	    // ELSIF #xInReqFinished THEN
	    //     #xTooEarlyTrigConf := FALSE;
	    // END_IF;
	    
	    #tTooEarlyTimerUnconf(IN := #xTooEarlyTrigUnconf OR "FirstScan",
	                          PT := T#20s);
	    // #tTooEarlyTimerConf(IN := #xTooEarlyTrigConf OR "FirstScan",
	    //                       PT := T#5s);
	END_REGION ;
	
	REGION Ausgänge schreiben
	    
	    REGION MFR
	        #stOutMfr.xStatusInSwitch := NOT #xEntr1 AND #xEntr2;
	        #stOutMfr.xStatusOutSwitch := NOT #xExit3 AND #xExit4;
	        // #stOutMfr.xTrolleyInSwitch := #fbSwitchFifo.elementCount > 0;
	        #stOutMfr.xTransportRdy := "cTodoFalse";
	        #stOutMfr.xError := #tOnTransitTimer.Q;
	        #stOutMfr.xBtNotLeaving := #tOnTransitTimer.Q;
	        #stOutMfr.xSenOut3 := #stInSenExit3.xDirectSensor;
	        #stOutMfr.xSenOut4 := #stInSenExit4.xDirectSensor;
	        #stOutMfr.xEx3Long := #xSignalLongEx3; //True sobald Zeit des Sensorsignals minimal höher als beim normalen Durchfahren
	        #stOutMfr.xEx4Long := #xSignalLongEx4; //True sobald Zeit des Sensorsignals minimal höher als beim normalen Durchfahren
	        #stOutMfr.xEx3VeryLong := #xSignalVeryLongEx3; //True sobald Sensorsignal länger als X anliegt
	        #stOutMfr.xEx4VeryLong := #xSignalVeryLongEx4; //True sobald Sensorsignal länger als X anliegt
	        
	        IF #tTooEarlyTimerUnconf.ET < T#1500ms AND (((#nInSetSwitch = 1 OR #nInSetSwitch = 3) AND #stInSenExit3.xDirectEdgePos) OR ((#nInSetSwitch = 2 OR #nInSetSwitch = 4) AND #stInSenExit4.xDirectEdgePos)) THEN
	            #stOutMfr.xSenTooEarly := FALSE;//TRUE -> für performancetest rausgemacht!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	        ELSIF #xInReqFinished THEN
	            #stOutMfr.xSenTooEarly := FALSE;
	        ELSE //auch nur vorübergehend hinzugefügt!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	            #stOutMfr.xSenTooEarly := FALSE;
	        END_IF;
	        
	        // IF #tTooEarlyTimerConf.ET < T#5s AND (((#nInSetSwitch = 1 OR #nInSetSwitch = 3) AND #stInSenExit3.xDirectEdgePos) OR ((#nInSetSwitch = 2 OR #nInSetSwitch = 4) AND #stInSenExit4.xDirectEdgePos)) THEN
	        //     #stOutMfr.Bit13 := TRUE;
	        // ELSIF #xInReqFinished THEN
	        //     #stOutMfr.Bit13 := FALSE;
	        // END_IF;
	        #stOutMfr.xJam := #xPermSigSen3 OR (#xPermSigSen4 AND #nInMainTroNo <> 183);
	        #stOutMfr.Bit14 := "cTodoFalse";
	        #stOutMfr.Bit15 := "cTodoFalse";
	        
	    END_REGION
	    
	    REGION MainTRO
	        
	        #stOutMainTro.nCounterExit3 := #nCounterExit3;
	        #stOutMainTro.nCounterExit4 := #nCounterExit4;
	        // #stOutMainTro.xSen3Long := #fbSwitchFifo.elementCount > 0 AND #stInSenExit3.xDirectSensor AND #stInSenExit3.tDirectChangeLast > #stInSettings.tSenLong;
	        // // #stOutMainTro.xSen3VeryLong := #xSignalVeryLongEx3;
	        // #stOutMainTro.xSen4Long := #fbSwitchFifo.elementCount > 0 AND #stInSenExit4.xDirectSensor AND #stInSenExit4.tDirectChangeLast > #stInSettings.tSenLong;
	        // // #stOutMainTro.xSen4VeryLong := #xSignalVeryLongEx4;
	        // #stOutMainTro.nFifoElementCount := #fbSwitchFifo.elementCount;
	        
	        #arOutFifo := #arCarrFifo; //Fifo Array zur Info an MainTRO übergeben 
	        
	    END_REGION
	    
	    
	    REGION Output
	        
	        // #Status.nCounterExit3 := 123;               Status oben in Schrittkette
	        // #Status.nCounterExit4 := 123;
	        // #Status.nStatus := 123;
	        // #Status.nError := 123;
	        // #Status.xStatusIn := #nState = 1150 OR #nState = 1200 OR #nState = 1350 OR #nState = 1400;
	        // #Status.xStatusOut := #nState = 950 OR #nState = 1000 OR #nState = 1350 OR #nState = 1400;
	        // #Status.xJamAtExit3 := "cTodoFALSE";
	        // #Status.xJamAtExit4 := "cTodoFALSE";
	        #xOutSwEntrTo1 := #xEntr1;
	        #xOutSwEntrTo2 := #xEntr2;
	        #xOutSwExTo3 := #xExit3;
	        #xOutSwExTo4 := #xExit4;
	        #nOutActCarrLeave := #nCarrIdxLeave;
	        // #nOutActCarrLeaveWrongDir := #nCarrIdxLeave;
	        // #xOutBtLeftSwitch := #fbSwitchFifo.dequeueDone;//#xDeqSwitchFIFO;
	        #xOutBtLeftSwitchWrongDir := #xSwitchWrongDir;
	        #xOutPermSigOutSen3 := #xPermSigSen3;
	        #xOutPermSigOutSen4 := #xPermSigSen4;
	        
	        
	    END_REGION
	    
	    
	END_REGION
	
	REGION Visu
	    REGION Status
	        IF NOT #stOutMfr.#xError THEN // Keine Fehler 
	            IF #stInOutHMI.xEnableControl THEN
	                #stInOutHMI.bStatus := 3;
	            ELSE
	                CASE #nState OF
	                    0,100:
	                        #stInOutHMI.bStatus := 0; // NOT_AVAILABLE
	                    200, 400, 700, 750, 800, 900, 950, 1000, 1100, 1150, 1200, 1300, 1350, 1400:
	                        #stInOutHMI.bStatus := 1; // AVAILABLE
	                    ELSE  //Fallback
	                        #stInOutHMI.bStatus := 0; // NOT AVAILABLE
	                END_CASE;
	            END_IF;
	        ELSE // Fehler
	            #stInOutHMI.bStatus := 2; // ERROR
	        END_IF;
	    END_REGION
	    
	    REGION Modes
	        // Int16 Bit-codiert
	        #stInOutHMI.nMode.%X0 := (#nState = 0); // The device is turned off
	        #stInOutHMI.nMode.%X1 := (#nState = 10) OR (#nState = 20) OR (#nState = 30) OR (#nState = 40); // The device is turned on
	        #stInOutHMI.nMode.%X2 := #stInOutHMI.xEnableControl;
	        #stInOutHMI.nMode.%X3 := FALSE; //NIU
	        #stInOutHMI.nMode.%X10 := #stOutMfr.xError; // Timeout Error
	    END_REGION
	    
	    REGION Handbetrieb
	        IF #stInOutHMI.xEnableControl THEN
	            IF #stInSettings.nTo1Destinations = 3 THEN
	                #xOutSwExTo3 := #stInOutHMI.xSetSwitch;
	            ELSIF
	                #stInSettings.nTo1Destinations = 4 THEN
	                #xOutSwExTo4 := #stInOutHMI.xSetSwitch;
	            END_IF;
	        ELSE
	            IF #stInSettings.nTo1Destinations = 3 THEN
	                #stInOutHMI.xSetSwitch := #xOutSwExTo3;
	            ELSIF
	                #stInSettings.nTo1Destinations = 4 THEN
	                #stInOutHMI.xSetSwitch := #xOutSwExTo4;
	            END_IF;
	        END_IF;
	    END_REGION
	    
	    REGION Weichenstellung 
	        IF #stInSettings.nTo1Destinations = 3 THEN
	            #stInOutHMI.xInHome := NOT #xOutSwExTo3;
	            #stInOutHMI.xInWork := #xOutSwExTo3;
	        ELSIF #stInSettings.nTo1Destinations = 4 THEN
	            #stInOutHMI.xInHome := NOT #xOutSwExTo4;
	            #stInOutHMI.xInWork := #xOutSwExTo4;
	        END_IF;
	    END_REGION
	
	END_REGION 
END_FUNCTION_BLOCK

