=== FB 1275: MHMOmniSchleuse_Plus  [STL] ===
INTERFACE:
  Input:
    Schleusen_Nr : Int                                  // Aufruf für Schleuse
    ErrQuit : Bool                                      // Ablaufstörung quittieren
    B_VorSchleuse : Bool                                // Sensor Trolley fährt in Bereich
    B_InSchleuse : Bool                                 // Sensor Trolley ist in Schleuse
    B_Zähl : Bool                                       // Sensor Trolley ist imnächsten Bereich 
    B_Stau_raus : Bool                                  // Sensor Stau im Bereich rausfahren
    Start_Ok : Bool                                     // Starten ist erlauTrolley
    Antrieb_Schleuse_aktiv : Bool                       // Kreisel-Antrieb aktiv
    Antrieb_plus_aktiv : Bool                           // Kreisel-Antrieb plus aktiv
    Schleuse_geöffnet : Bool                            // Schleuse hat geöffnet
    RestZeit_Bereich_plus : Int := 999                  // Bereich +1: Restzeit bis AFS stoppt (s)
  Output:
    Y_Schleuse_Auf : Bool                               // Schleuse öffnen
    Error : Word                                        // Störungen übergeben
  InOut:
    Antrieb_Schleuse_vor : Bool                         // Schleusen-Antrieb einschalten
    Antrieb_Schleuse_start : Bool                       // Schleusen-Antrieb mit Zeit starten
    Antrieb_Schleuse_stop : Bool                        // Schleusen-Antrieb stoppen
    Antrieb_Schleuse_PS : Bool                          // Schleusen-Antrieb Energie sparen
    Antrieb_plus_vor : Bool                             // Antrieb plus einschalten
    Antrieb_plus_start : Bool                           // Antrieb plus mit Zeit starten
    hStOk : Bool                                        // Anzeige Start n. Störung aktivieren
  Static:
    SAVE : Struct
      Weichen_DB : Int                                  // Weichen-FIFO-DB
      Weichen_DW : Int                                  // Weichen-FIFO-DW
      Weiche+1 : Int                                    // Weiche +1, wo reserviert wurde
      Frei18 : Int
      Frei20 : Int
    Para : Struct                                       // Parameter
      Schleusen_DL_DB : Int                             // Einsprung Schleuse-Datenliste-DB
      Weichen_DL_DB : Int                               // Einsprung Weichen-Datenliste-DB
      Leser_DL_DB : Int                                 // Einsprung Weichen-Datenliste-DB
    Status2 : Struct
      Trolley_an_Schleuse : Bool                        // Trolley ist an Schleuse
      2.Lesung_aktiv : Bool                             // 2.Lesung erfolgt
      3.Lesung_aktiv : Bool                             // 3.Lesung erfolgt
      TrolleyPos_übergeben : Bool                       // Trolley-Pos. übergeben
      Warten_4.V : Bool                                 // Warten auf 4.V
      Weichen-Schritt : Bool                            // Schritt 13-17 aktiv (Weiche evtl. belegen)
      Trolley an Raus-Sensor : Bool                     // Trolley ist am Raus-Sensor
      Stau_an_Raus-Sensor : Bool                        // Stau an Raus-Sensor (kein Zählen mehr)
      Einfahrzeit_lernen : Bool                         // Ausfahrzeit lernen
      Telegramm_gesendet : Bool                         // Telegramm wurde in Send-FIFO eingetragen
    Schleuse : "UDLHMOmniSchleuse_Plus"                 // Statische Schleusendaten (aus DL)
    Dyn : Struct                                        // Dynamische Daten
      Status : Struct
        Trolley_fährt_in_Schleuse : Bool                // Trolley fährt in Schleuse
        Trolley_wartet_Lesung : Bool                    // Trolley wartet auf Auftrag
        Trolley_wartet_auf_Ziel-FC : Bool
        Trolley_wartet_auf_Weiche+1 : Bool
        Trolley_wartet_Bereich+1 : Bool                 // Trolley wartet auf Bereich +1
        Trolley_fährt_aus : Bool                        // Trolley fährt aus
        MindestZeit_ok : Bool                           // Schleuse ist MindestZeit geöffnet
        Trolley_draussen : Bool                         // Trolley ist ausgefahren
        Leser_triggern : Bool
        SF_angefordert : Bool
        Kein_Stop_mehr : Bool                           // Kein Stop mehr, Antrieb soll starten
        Trolley_fährt_rückwärts : Bool                  // Trolley in Schleuse rückwärts erkannt
        Weiche_geschaltet : Bool
        Trolley ausserhalb Weiche : Bool                // Trolley hat Weiche verlassen (von Weiche)
        Error_aktiv : Bool                              // Störung vorhanden
        Reset_aktiv : Bool := TRUE                      // Reset aktiv
      TrolleyID_Schleuse : DInt                         // Trolley-Nr in der Schleuse
      Trolley_EndZiel : Word                            // Trolley-EndZiel
      Trolley_ZwischenZiel : Word                       // Trolley-ZwischenZiel
      Trolley_ShopGroup : DInt                          // Trolley-ShopGroup
      Weichen_Ziel : Word                               // Weichen-Ziel (Für WeichenModul von Ziel-FC)
      TrolleyID_Eingefahren : DInt                      // Trolley-Nr von Bereich -1 gemeldet
      TrolleyID_ausgefahren : DInt                      // TrolleyID des ausgefahrenen Trolleys
      HMI : Struct
        TrolleyID_in_Schleuse : DInt                    // Trolley-Nr in Schleuse (IN:PLC, OUT:PLC)
        TrolleyID_Input : DInt                          // Trolley-Nr Input (IN:HMI, OUT:PLC)
        Schleuse_resetten : Bool                        // Schleuse resetten (IN:HMI, Out:PLC)
      Sk : "USk_ILS"                                    // Status der Schrittkette
      Leser : Struct
        IN : Struct
          xOutReadyForNewScan : Bool                    // DBX10.1: Reader ist bereit für Leseanforderung
          xOutReadingDone : Bool                        // DBX10.0: Lesevorgang abgeschlossen / Handshake raus
          xOutCodeGood : Bool                           // DBX278.0: Gute Lesung
          xOutCodeBad : Bool                            // DBX278.1: Schlechte Lesung
          nOutBarcode : DInt                            // DBD12: Trolley ID
        OUT : Struct
          xInStartReading : Bool                        // DBX4.1: Starte Lesevorgang
          xInHandshakeDone : Bool                       // DBX4.2: Handshake Daten abgeholt
          xInErrQuit : Bool                             // DBX4.4: Fehler rücksetzen
          xInReset : Bool                               // DBX4.5: Allgemeines Rücksetzen des Bausteins
      TrolleyID_unbekannt_Schleuse : DInt               // TrolleyID unbekannt (Trolley in Schleuse)
      Rueckmld : Struct
        RET_VAL_BLKMOV_Schleuse : Int                   // Rückmeldung nach BLKMOV-Aufruf
        RET_VAL_DL_Schleuse : Byte
        RET_VAL_DL_Weiche : Byte                        // Rückmeldung nach DatenOut-Aufruf
        RET_VAL_DL_Leser : Byte                         // Rückmeldung nach DatenOut-Aufruf
      Error : "UErrHMOmniSchleuse"
      Stau_Zeit : Int                                   // Sensor B_VorSep ist belegt [1s]
      Mindest_Zeit : Int                                // Sensor B_VorSep ist frei [1s]
      Leer_Zeit : Int
      Stop_Ursache : Word                               // Stop-Stelle: Nw + Position
      Vereinzelungstakte : DInt                         // Anzahl der getätigten Vereinzelungstakte
      ZwischenZiel_eingefahren : Word                   // Trolley-ZwischenZiel von Bereich -1
      Zeit_Ohne_B_In_Schleuse : Int                     // Trolley nicht an B_In_Schleuse
      Zeit_Ohne_B_Zähl : Int                            // Trolley nicht an B_Zähl
      Zeit_Ausfahren_Ohne_B_Zähl : Int                  // Trolley fährt nicht zu B_Zähl
      Raus_Trolleys : Int                               // Anzahl der Trolleys zwischen Schleuse und Raus-Sensor
      Stau_Zeit_RausSensor : Int                        // Sensor B_AusSep ist belegt [1s]
      Zurück_gemeldetes_Weichen_Ziel : Word             // Von Weiche zurück gemeldetes Weichen-Ziel
      SAVE2 : Struct
        Leser_DB : Int                                  // Weichen-FIFO-DB
        Leser_DD : DInt                                 // Weichen-FIFO-DD
      WarteZeit_PS : Int
      Restzeit_bis_Schleuse : Int
      Res200 : Array[1..11] of Int                      // Reserve
  Temp:
    Quelle : Any                                        // Zeiger, wo Rein-Daten sind
    Ueb_akt : Bool                                      // Überwachungszeit aktivieren
    Weiter : Bool                                       // Weiterschaltbedingung ist erfüllt
    Warte_neu : Bool                                    // Wartezeit neu triggern
    Warte_stop : Bool                                   // Wartezeit stoppen
    Kein_Weichenbereich +1 : Bool
    Reservierung_Weiche+1_aktiv : Bool
    Leser_Zugriff : Bool                                // Leser-Zugriff vorhanden
    LeserFC_vorhanden : Bool
    ZielFC_vorhanden : Bool
    DraussenFC_vorhanden : Bool
    TrolleyID_Bereich-1 : Bool                          // Trolley--ID von Bereich -1 gemeldet
    Trolley_draussen : Bool                             // Signal: Trolley ist draussen
    Antriebe_starten : Bool
    Einfahrzeit_nicht_bekannt : Bool
    LeserFC : Word                                      // Ziel-FC
    ZielFC : Word                                       // Ziel-FC
    DraussenFC : Word                                   // Draussen-FC
    AR1Start : DInt                                     // Startwert mit Offset 0
    AR1Zeiger : DWord                                   // Statt AR1 (ging nur bis DB-Länge <= 8191 Bytes)
  Constant:

--- NW 1: Parameter-Übergabe ---
      L      Schleusen_Nr

      L      274                                             // Einsprung Schleuse-DL
      T      Para.Schleusen_DL_DB                            // vor Aufruf übergeben!

      L      279                                             // Einsprung Weichen-DL
      T      Para.Weichen_DL_DB                              // vor Aufruf übergeben!

      L      273
      T      Para.Leser_DL_DB


--- NW 2: Anzeige OP ---
      A      ErrQuit                                         // Überwachungszeit abgelaufen quittieren
      R      Dyn.Sk.Err_Uebzeit

      L      252                                             // Bereichsstop aktiv
      AN     Dyn.Sk.Bereich_ok                               // Also: Bereichsstop / Not-Aus
      JC     w010

      L      253
      AN     Dyn.Sk.Auto_akt                                 // Keine Betriebsart
      AN     Dyn.Sk.Hand_akt
      JC     w010

      L      255                                             // Handbetrieb aktiv
      A      Dyn.Sk.Hand_akt
      JC     w010

      L      Dyn.Sk.Akt_Schritt                              // Aktiver Schritt
w010: T      Dyn.Sk.OP_Schritt


--- NW 3: Out-Bits zum Zurücksetzen ---
      SET
      R      Y_Schleuse_Auf

      SET                                                    // Jeden Zyklus neu
      R      Dyn.Status.Trolley_wartet_Lesung
      R      Dyn.Status."Trolley_wartet_auf_Ziel-FC"
      R      Dyn.Status."Trolley_wartet_auf_Weiche+1"
      R      Dyn.Status."Trolley_wartet_Bereich+1"
      R      Dyn.Status."Trolley_fährt_aus"
      R      Dyn.Status.Trolley_draussen
      R      Leser_Zugriff
      R      Status2."Weichen-Schritt"

      A      Dyn.Sk.Reset_Akt
      =      Dyn.Status.Reset_aktiv


--- NW 4: HMI-Zeug ---
// Von HMI:
      A      Dyn.HMI.Schleuse_resetten
      R      Dyn.HMI.Schleuse_resetten                       // von HMI
      S      Dyn.Sk.Reset                                    // SK zurücksetzen

      L      Dyn.HMI.TrolleyID_Input                         // Wird direkt im Programm verwertet (s.u.)

// An HMI:
ToHMI: L      Dyn.TrolleyID_Schleuse
      T      Dyn.HMI.TrolleyID_in_Schleuse


--- NW 5: Schrittkette zurücksetzen ---
      A      ErrQuit                                         // Überwachungszeit abgelaufen quittieren
      R      Dyn.Sk.Err_Uebzeit

      AN     Dyn.Sk.Reset                                    // SK zurücksetzen
      JC     en04

// Schrittkette zurücksetzen:
      L      0                                               // Schritt 0: Warten
      T      Dyn.Sk.Akt_Schritt
      T      Dyn.Raus_Trolleys

      L      0                                               // Zeitwert löschen
      T      Dyn.Sk.Terr_Zelle
      T      Dyn.Sk.Tok_Zelle

      SET
      R      Dyn.Error.Err_BLKMov                            // Error bei Block kopieren
      R      Dyn.Sk.Reset                                    // SK zurücksetzen
      R      Dyn.Sk.Err_Schritt                              // Undefinierter Schritt
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      R      Status2.Telegramm_gesendet
      S      Dyn.Sk.Reset_Akt                                // Reset ist aktiv

      SET
      R      Dyn.Error.Schleuse_DL                           // Schleuse-Datenliste fehlerhaft
      R      Dyn.Error.Undef_Schleuse                        // undefinierter Schleuse
      R      Dyn.Error.Err_Trolley_nicht_in_Schleuse         // Trolley fährt nicht in Schleuse
      R      Dyn.Error.Err_Uebzeit                           // Überwachungzeit ist abgelaufen
      R      Dyn.Error.Err_Schritt                           // Schritt-Nummer ist nicht definiert
      R      Dyn.Error.Err_Stau_Einfahrt
      R      Dyn.Error.Err_BLKMov
      R      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus
      R      Dyn.Error.Err_Raus_Sensor                       // Raus-/Belade-Sensor wird nicht erreicht (oder dauernd aktiv)!
      R      Dyn.Error.Err_Ziel                              // kein Ziel angegeben
      R      Dyn.Error.Err_Weichen_DL                        // Weichen-Datenliste fehlerhaft
      R      Dyn.Error.Err_Undef_Weiche                      // undefinierte Weiche
      R      Dyn.Error.Err_Weiche_belegt                     // Weiche bleibt belegt
      R      Dyn.Error.Err_Kein_LeseErgebnis
      R      Dyn.Error.Err_Leser_nicht_bereit

      L      0
      T      Dyn.SAVE2.Leser_DB
      L      DINT#0
      T      Dyn.SAVE2.Leser_DD
      T      Dyn.Leser.IN.nOutBarcode

// Defaultwerte übergeben:
      L      0                                               // Damit statische Werte neu aus Datenbank geholt werden !
      T      Schleuse.Schleusen_Nr                           // Nummer des Schleuses

      JU     RET

en04: NOP 0


--- NW 6: Störungen nach Außen übergeben ---
      L      0
      T      "MW200"

      A      Dyn.Error.Schleuse_DL                           // Schleuse-Datenliste fehlerhaft
      =      "M200.0"
      A      Dyn.Error.Undef_Schleuse                        // undefinierter Schleuse
      =      "M200.1"
      A      Dyn.Error.Err_Trolley_nicht_in_Schleuse         // Trolley fährt nicht in Schleuse
      =      "M200.2"
      A      Dyn.Sk.Err_Uebzeit
      =      Dyn.Error.Err_Uebzeit                           // Überwachungzeit ist abgelaufen
      =      "M200.3"
      NEG
      R      Dyn.Sk.Err_Uebzeit_AnzOk
      A      Dyn.Sk.Err_Schritt
      =      Dyn.Error.Err_Schritt                           // Schritt-Nummer ist nicht definiert
      =      "M200.4"
      A      Dyn.Error.Err_Stau_Einfahrt
      AN     B_InSchleuse
      AN     Y_Schleuse_Auf
      =      "M200.5"
      A      Dyn.Error.Err_BLKMov                            // Error bei Block kopieren
      =      "M200.6"
      A      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus
      =      "M200.7"
      A      Dyn.Error.Err_Raus_Sensor                       // Raus-/Belade-Sensor wird nicht erreicht (oder dauernd aktiv)!
      =      "M201.0"
      A      Dyn.Error.Err_Ziel                              // Trolley-Ziel nicht bekannt
      =      "M201.1"
      A      Dyn.Error.Err_Weichen_DL                        // Weichen-Datenliste fehlerhaft
      =      "M201.2"
      A      Dyn.Error.Err_Undef_Weiche                      // undefinierte Weiche
      =      "M201.3"
      A      Dyn.Error.Err_Weiche_belegt                     // Weiche bleibt belegt
      =      "M201.4"
      A      Dyn.Error.Err_Kein_LeseErgebnis
      =      "M201.5"
      A      Dyn.Error.Err_Leser_nicht_bereit
      =      "M201.6"
      A      Dyn.Error.Barcode_nicht_bekannt
      =      "M201.7"

// Andere Meldung als Überwachungszeit aktiv ?:
      L      "MW200"
      L      2#1111_0111_1111_1111
      AW
      L      2#0000_0000_0000_0000                           // Andere Meldung als Üb.zeit aktiv ?
      <>I                                                    // Ja !
      ON     Dyn.Sk.Err_Uebzeit_AnzOk                        // Störung anzeigen ok, da 2.Zyklus aktiv !
      R      "M200.3"                                        // Üb.Zeit-Meldung nicht an PC senden

      A      Dyn.Sk.Err_Uebzeit
      S      Dyn.Sk.Err_Uebzeit_AnzOk                        // Störung anzeigen ok, da 2.Zyklus aktiv !

      L      "MW200"
      T      Error                                           // Schnittstelle nach Außen

// Störung vorhanden:
      L      0
      <>I                                                    // Ja !
      =      Dyn.Status.Error_aktiv
      S      hStOk

// Antrieb stoppen:
      A(
      ON     Dyn.Sk.Auto_akt                                 // SystemVoraussetzungen fehlen
      O      Dyn.Sk.Hand_akt
      ON     Dyn.Sk.Bereich_ok
      )
      S      Antrieb_Schleuse_stop                           // Antrieb stoppen

// Störungen pro Zyklus neu erzeugen:
      SET
      R      Dyn.Error.Schleuse_DL                           // Schleuse-Datenliste fehlerhaft
      R      Dyn.Error.Undef_Schleuse                        // undefinierter Schleuse
// /      R     #Dyn.Error.Err_Trolley_nicht_in_Schleuse//Trolley fährt nicht in Schleuse
// /      R     #Dyn.Error.Err_Uebzeit      //Überwachungzeit ist abgelaufen
      R      Dyn.Error.Err_Schritt                           // Schritt-Nummer ist nicht definiert
// /      R     #Dyn.Error.Err_Stau_Einfahrt//Betriebsart ist nicht möglich
      R      Dyn.Error.Err_BLKMov
// /      R     #Dyn.Error.Err_Trolley_raus//Trolley fährt nicht aus
// /      R     #Dyn.Error.Err_Raus_Sensor//Raus-/Belade-Sensor wird nicht erreicht (oder dauernd aktiv)!
      R      Dyn.Error.Err_Ziel                              // Trolley-Ziel nicht bekannt
      R      Dyn.Error.Err_Weichen_DL                        // Weichen-Datenliste fehlerhaft
      R      Dyn.Error.Err_Undef_Weiche                      // undefinierte Weiche
      R      Dyn.Error.Err_Weiche_belegt                     // Weiche bleibt belegt
// /      R     #Dyn.Error.Err_Kein_LeseErgebnis
// /      R     #Dyn.Error.Err_Leser_nicht_bereit
      R      Dyn.Error.Barcode_nicht_bekannt

      AN     Dyn.Sk.Err_Uebzeit
      R      Dyn.Error.Err_Trolley_nicht_in_Schleuse         // Trolley fährt nicht in Schleuse
      R      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus


--- NW 7: Statische Schleuse-Parameter holen ---
      L      Schleuse.Schleusen_Nr                           // Nummer des Schleuses
      L      Schleusen_Nr                                    // Aufruf-Parameter
      ==I                                                    // Identisch ?
      R      Dyn.Error.Schleuse_DL                           // Schleusedatenbank fehlerhaft
      R      Dyn.Error.Undef_Schleuse                        // undefinierter Schleuse
      JC     en06                                            // Ja !

      T      "MW200"                                         // Search-Daten

CALL FC "DatenOut" (SSDB:=Para.Schleusen_DL_DB, SSDW:=0, PARA:=WORD#16#0000, SEARCHDATEN:=P#M200.0, RE_VAL:="MB199", OUTDATEN:=P#M220.0, Position:="MW196")

      L      "MB199"
      T      Dyn.Rueckmld.RET_VAL_DL_Schleuse                // Rückmeldung bei Datenbank-Zugriff (Gefälle-DL)

      JBI    G_Ok

      A      "M199.0"
      JCN    w060

      SET
      =      Dyn.Error.Schleuse_DL                           // Schleusedatenbank fehlerhaft

      L      16#A061
      T      Dyn.Stop_Ursache

      JU     RET

w060: SET
      S      Dyn.Error.Undef_Schleuse                        // undefinierter Schleuse

      L      16#A062
      T      Dyn.Stop_Ursache

      JU     RET

// Kennung + Datenbytes
G_Ok: SET
      R      Dyn.Error.Schleuse_DL                           // Gefälledatenbank fehlerhaft
      R      Dyn.Error.Undef_Schleuse                        // undefinierte Gefällestrecke

      L      16#1004                                         // Kennung 10 + Word=04
      T      LW0                                             // Any-Kennung, Datentyp
      L      20                                              // Datenwords speichern
      T      LW2                                             // Wiederholungen

// Quelle-Pointer erzeugen:
      L      0                                               // Bei Merker = 0 !
      T      LW4                                             // DB_Nummer
      L      220                                             // Adresse
      SLD    3
      L      16#8300_0000                                    // Kennung: Merker
      OD
      T      LD6                                             // Kennung, Adresse

CALL SYS "BLKMOV" (SRCBLK:=Quelle, RET_VAL:=Dyn.Rueckmld.RET_VAL_BLKMOV_Schleuse, DSTBLK:=Schleuse)   // Datenliste-Daten speichern | #Ziel

      L      16#A063
      T      Dyn.Stop_Ursache

      L      Dyn.Rueckmld.RET_VAL_BLKMOV_Schleuse            // Rückmeldung
      L      0                                               // Fehler vorhanden ?
      <>I                                                    // Ja !
      =      Dyn.Error.Err_BLKMov                            // Error bei Block kopieren
      JC     RET

      L      Schleuse.Schleusen_Typ                          // Schleusetyp = 1275 (HM-Schleuse Plus)
      L      1275                                            // Dieser Aufruf-FB ?
      ==I                                                    // Ja !
      JC     w061

      SET
      S      Dyn.Error.Undef_Schleuse                        // undefinierter Schleuse

      L      0                                               // Schleuse ungültig !
      T      Schleuse.Schleusen_Nr                           // Nummer des Schleuses

      L      16#A064
      T      Dyn.Stop_Ursache

      JU     RET

// Defaultwerte übergeben:
w061: NOP 0

      JU     RET

en06: NOP 0


--- NW 8: Einsprung Weiche plus ermitteln ---
      L      SAVE.Weichen_DB                                 // Weichen-FIFO-DB
      L      0                                               // Einsprung-Zeiger bekannt ?
      >I                                                     // Ja !
      R      "Kein_Weichenbereich +1"
      JC     En08

      L      Schleuse.RausWeichen_Nr                         // Nr. der vorhandenen Weiche
      T      "MW200"                                         // Search-Daten
      L      0                                               // angegeben ?
      ==I                                                    // Nein !
      =      "Kein_Weichenbereich +1"
      R      Dyn.Error.Err_Undef_Weiche                      // undefinierte Weiche
      JC     En08

CALL FC "DatenOut" (SSDB:=Para.Weichen_DL_DB, SSDW:=0, PARA:=WORD#16#0000, SEARCHDATEN:=P#M200.0, RE_VAL:="MB199", OUTDATEN:=P#M220.0, Position:="MW196")

      L      "MB199"
      T      Dyn.Rueckmld.RET_VAL_DL_Weiche                  // Rückmeldung bei Datenbank-Zugriff (Weiche-DL)

      JBI    W_Ok

      A      "M199.0"
      =      Dyn.Error.Err_Weichen_DL                        // Weichen-Datenliste fehlerhaft
      JC     En08

      SET
      S      Dyn.Error.Err_Undef_Weiche                      // undefinierte Weiche

      JU     En08

W_Ok: L      "MW224"
      T      SAVE.Weichen_DB                                 // Weichen-FIFO-DB
      L      0                                               // sinnvoller Wert ?
      <=I                                                    // Nein !
      S      Dyn.Error.Err_Undef_Weiche                      // undefinierte Weiche
      JC     En08

      L      "MW226"
      T      SAVE.Weichen_DW                                 // Weichen-FIFO-DW

En08: NOP 0


--- NW 9: Trolley in Schleuse entprellen ---
      A      B_InSchleuse
      JC     B_ok

      AN     Status2.Trolley_an_Schleuse
      ON     "1s-Impuls"
      JC     Xn08

      L      Dyn.Zeit_Ohne_B_In_Schleuse
      +      1                                               // Zeit ohne Sensor +1s
      T      Dyn.Zeit_Ohne_B_In_Schleuse

      L      3                                               // Nach ca. 3s
      <I
      JC     Xn08

      SET
      R      Status2.Trolley_an_Schleuse

B_ok: L      0
      T      Dyn.Zeit_Ohne_B_In_Schleuse

Xn08: NOP 0


--- NW 10: Antrieb starten / stoppen / Schleuse geöffnet ---
// Antrieb zusätzlich starten:
      A      ErrQuit                                         // Überwachungszeit abgelaufen quittieren
      O      "Schleuse_geöffnet"
      S      Antrieb_Schleuse_start                          // Antrieb starten
      S      Antrieb_plus_start                              // Kreisel-Antrieb plus starten

      A      "Schleuse_geöffnet"
      R      Dyn.Status."Trolley_fährt_in_Schleuse"

      L      Dyn.Raus_Trolleys
      L      0                                               // Trolles unterwegs?
      >I                                                     // Ja!
      AN     Status2."Stau_an_Raus-Sensor"                   // Stau an Raus-Sensor
      O
      A      B_VorSchleuse                                   // //
      AN     Dyn.Error.Err_Stau_Einfahrt                     // //
      O      "Schleuse_geöffnet"
      =      Antriebe_starten

      A      Antriebe_starten
// /      UN    #Dyn.Error.Err_Trolley_raus//Trolley fährt nicht aus
      A(
      O      Dyn.Status.Weiche_geschaltet                    // Weiche ist aktiv
      O      "Kein_Weichenbereich +1"
      )
      A      Schleuse.Parameter_allg.Antrieb_Plus_vorhanden
      S      Antrieb_plus_vor                                // Antrieb plus einschalten

      A      Antriebe_starten
// /      UN    #Dyn.Error.Err_Trolley_raus//Trolley fährt nicht aus
      A(
      O      Dyn.Status.Weiche_geschaltet                    // Weiche ist aktiv
      O      "Kein_Weichenbereich +1"
      )
      A(
      O      Antrieb_plus_aktiv
      ON     Schleuse.Parameter_allg.Antrieb_Plus_vorhanden
      )
      S      Antrieb_Schleuse_vor                            // Antrieb einschalten

// Trolley ist in Schleuse und wartet
      A      Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      AN     "Schleuse_geöffnet"                             // Trolley soll ausfahren
      A(
      ON     B_VorSchleuse
      O      Dyn.Error.Err_Stau_Einfahrt
      )
      AN     Dyn.Status.Kein_Stop_mehr                       // Wird in Schritt 2 gesetzt
      O
      A      "Schleuse_geöffnet"                             // Trolley soll ausfahren
      A      Schleuse.Parameter_allg.Antrieb_Plus_vorhanden
      AN     Antrieb_plus_aktiv
      JC     Warten

      L      0
      T      Dyn.WarteZeit_PS

      JU     NwE10

Warten: L      Dyn.WarteZeit_PS
      L      3                                               // ca. 3s rum ?
      <I                                                     // Nein!
      JC     Takt

      T      Dyn.WarteZeit_PS                                // Zeit einfrieren

      SET
      S      Antrieb_Schleuse_PS                             // Antrieb in Energie sparen schalten

      JU     NwE10

Takt: AN     "1s-Impuls"
      JC     NwE10

      L      Dyn.WarteZeit_PS
      +      1
      T      Dyn.WarteZeit_PS

NwE10: NOP 0


--- NW 11: Plus: Trolley ist an Zähl-/Stau-Sensor ---
      A      Dyn.Status."Trolley ausserhalb Weiche"          // Rückmeldung von Weiche +1
      AN     "Kein_Weichenbereich +1"                        // Also Weiche +1
      O      "B_Zähl"
      =      Trolley_draussen

      A      Trolley_draussen
      JC     B_Raus

      AN     Status2."Trolley an Raus-Sensor"
      AN     Status2."Stau_an_Raus-Sensor"
      ON     "100ms-Impuls"
      ON     Dyn.Sk.Bereich_ok
      JC     En10

      L      Dyn."Zeit_Ohne_B_Zähl"
      +      1                                               // Zeit ohne Sensor +100ms
      T      Dyn."Zeit_Ohne_B_Zähl"

// B-Raus lange genug frei?:
      L      10                                              // Nach ca. 1s
      >=I
      AN     Status2."Stau_an_Raus-Sensor"
      JC     RDel

      CAC
      L      200                                             // Nach ca. 20s
      >=I
      JC     RDel

      JU     En10

RDel: SET
      R      Status2."Trolley an Raus-Sensor"
      L      0
      T      Dyn."Zeit_Ohne_B_Zähl"
      T      Dyn.Stau_Zeit_RausSensor

// War Stau?:
      A      Status2."Stau_an_Raus-Sensor"
      R      Status2."Stau_an_Raus-Sensor"
      JCN    DelRT

      L      0                                               // Bisher gefahrene Trolleys löschen
      T      Dyn.Raus_Trolleys
      T      Dyn."Zeit_Ohne_B_Zähl"
      T      Dyn.Stau_Zeit_RausSensor

// Im Weichenbereich noch Trolleys unterwegs?:
DelRT: L      Dyn.Raus_Trolleys
      L      0
      >I
      O      "Kein_Weichenbereich +1"
      JC     En10

// Weiche+1 löschen:
      L      0
      T      SAVE."Weiche+1"                                 // Hier wurde reserviert (Im Weichenmodul wird dann Reservierung gelöscht!)

      JU     En10

B_Raus: L      0
      T      Dyn."Zeit_Ohne_B_Zähl"
      T      Dyn."Zeit_Ausfahren_Ohne_B_Zähl"

// Einmalig:
      AN     Status2."Trolley an Raus-Sensor"
      S      Status2."Trolley an Raus-Sensor"                // Raus-Sensor ausgewertet
      JCN    Xn10                                            // Negierter Sprung

      L      Dyn.Raus_Trolleys
      +      -1                                              // Ausgefahrene Trolleys -1
      T      Dyn.Raus_Trolleys

      L      0
      >=I
      JC     Xn10

      T      Dyn.Raus_Trolleys                               // Minimum übergeben

// Stau an B_Raus:
Xn10: AN     "100ms-Impuls"
      O      Status2."Stau_an_Raus-Sensor"
      JC     En10

      L      Dyn.Stau_Zeit_RausSensor
      +      1                                               // StauZeit +1
      T      Dyn.Stau_Zeit_RausSensor

      L      90                                              // Nach ca. 9s
      >=I
      JCN    En10                                            // Negierter Sprung

      L      0                                               // Zeit löschen
      T      Dyn.Stau_Zeit_RausSensor

      SET
      S      Status2."Stau_an_Raus-Sensor"

En10: NOP 0


--- NW 12: Plus: Trolley fährt nicht bis Zähl-Sensor ---
      L      Dyn.Raus_Trolleys
      L      0                                               // Trolles unterwegs?
      ==I                                                    // Nein!
      O      Trolley_draussen                                // Sensor wurde erreicht
      O      "Schleuse_geöffnet"                             // Dann Üb.zeit von Sk
      O      Dyn.Status.Reset_aktiv
      JC     RTTD

      AN     Antrieb_Schleuse_aktiv
      O
      AN     Antrieb_plus_aktiv
      A      Schleuse.Parameter_allg.Antrieb_Plus_vorhanden
      ON     "1s-Impuls"
      O      Dyn.Error.Err_Raus_Sensor                       // Trolley fährt nicht aus
      JC     En12

      L      Dyn."Zeit_Ausfahren_Ohne_B_Zähl"
      +      1
      T      Dyn."Zeit_Ausfahren_Ohne_B_Zähl"

// Trolley fährt nicht bis Zähl-Sensor!:
      L      Schleuse."Übzeit_aus_Schleuse"
      >=I
      S      Dyn.Error.Err_Raus_Sensor                       // Trolley fährt nicht aus
      JCN    En12                                            // Negierter Sprung!

      L      Dyn.Raus_Trolleys
      +      -1
      T      Dyn.Raus_Trolleys

      JU     En12

RTTD: L      0
      T      Dyn."Zeit_Ausfahren_Ohne_B_Zähl"

      SET
      R      Dyn.Error.Err_Raus_Sensor                       // Trolley fährt nicht aus

En12: NOP 0


--- NW 13: Einfahrzeit lernen ---
      L      Schleuse.EinfahrZeit
      L      0                                               // Ausfahrzeit bekannt ?
      ==I                                                    // Nein !
      O      Status2.Einfahrzeit_lernen
      =      Einfahrzeit_nicht_bekannt
      A      Einfahrzeit_nicht_bekannt
      A      B_VorSchleuse                                   // Stauklappe bei Einfahrt
      A      Antrieb_Schleuse_aktiv
      AN     B_InSchleuse
      AN     "Schleuse_geöffnet"
      S      Status2.Einfahrzeit_lernen

      A      B_InSchleuse
      AN     "Schleuse_geöffnet"
      R      Status2.Einfahrzeit_lernen

      A      Status2.Einfahrzeit_lernen
      S      Antrieb_Schleuse_vor                            // Antrieb einschalten

      AN     Status2.Einfahrzeit_lernen
      ON     Antrieb_Schleuse_aktiv
      ON     "1s-Impuls"
      JC     NoEFZ

      L      Schleuse.EinfahrZeit
      +      1
      T      Schleuse.EinfahrZeit

NoEFZ: NOP 0


--- NW 14: PS deaktivieren, da Trolley einfährt ---
      A      Einfahrzeit_nicht_bekannt                       // Also bekannt
      JC     En14

// Neuer Trolley fährt ein:
      A      B_VorSchleuse
      JCN    Wait                                            // Negierter Sprung

      L      Schleuse.EinfahrZeit
      T      Dyn.Restzeit_bis_Schleuse

// Restzeit zurück zählen:
Wait: AN     Antrieb_Schleuse_aktiv
      O      "Schleuse_geöffnet"
      ON     "1s-Impuls"
      JC     X014

      L      Dyn.Restzeit_bis_Schleuse
      +      -1
      T      Dyn.Restzeit_bis_Schleuse

      L      0
      >I
      JC     X014

      T      Dyn.Restzeit_bis_Schleuse                       // Minimum übergeben

// Trolley fährt noch ein:
X014: L      Dyn.Restzeit_bis_Schleuse
      L      0                                               // Restzeit vorhanden?
      >I                                                     // Ja !
      AN     B_InSchleuse
      AN     "Schleuse_geöffnet"
      S      Antrieb_Schleuse_vor                            // Antrieb einschalten (dadurch wird PS-Modus deaktiviert)

En14: NOP 0


--- NW 15: Spezial-FCs vorhanden? ---
      L      Schleuse.Leser_FC
      T      LeserFC
      L      0                                               // Parameter vorhanden ?
      >I                                                     // Ja!
      =      LeserFC_vorhanden

      L      Schleuse.Ziel_FC
      T      ZielFC
      L      0                                               // Parameter vorhanden ?
      >I                                                     // Ja!
      =      ZielFC_vorhanden

      L      Schleuse.Draussen_FC
      T      DraussenFC
      L      0                                               // Parameter vorhanden ?
      >I                                                     // Ja!
      =      DraussenFC_vorhanden


--- NW 16: Error: Stau Bereich-Eingang ---
// TrolleyID zum Einfahren gemeldet / Trolley fährt in Bereich:
      L      Dyn.TrolleyID_Eingefahren                       // Eintrag von Weiche -1
      L      DINT#0                                          // angegeben ?
      <>D                                                    // Ja !
      =      "TrolleyID_Bereich-1"
      A      "TrolleyID_Bereich-1"
      O      B_VorSchleuse
      S      Dyn.Status."Trolley_fährt_in_Schleuse"

// Antrieb einschalten:
      A      B_VorSchleuse
      AN     B_InSchleuse
      AN     "Schleuse_geöffnet"
      S      Antrieb_Schleuse_vor

      A      B_VorSchleuse
      S      Antrieb_Schleuse_start

// Sensor bei Bereichs-Einfahrt bleibt belegt?:
      AN     B_VorSchleuse                                   // Sensor Trolley fährt in Bereich (kein Stau !)
      O      "Schleuse_geöffnet"
      R      Dyn.Error.Err_Stau_Einfahrt                     // Stau bei Einfahrt
      JC     X120                                            // StauZeit neu aufziehen

      AN     "1s-Impuls"
      O
      A      Schleuse.Parameter_allg.Antrieb_vorhanden
      AN     Antrieb_Schleuse_aktiv
      O      Dyn.Error.Err_Stau_Einfahrt                     // Zeit bereits abgelaufen
      JC     Xn12

      L      Dyn.Stau_Zeit                                   // Sensor B_VorSep ist belegt [1s]
      +      +1
      T      Dyn.Stau_Zeit                                   // Sensor B_VorSep ist belegt [1s]

      L      20                                              // Stau-Zeit erreicht ?
      >=I                                                    // Ja !
      S      Dyn.Error.Err_Stau_Einfahrt                     // Stau bei Einfahrt (Quittierung oder Sensor=0, wegen Bürstenantrieb
      JCN    Xn12

X120: L      0                                               // Zeiten löschen
      T      Dyn.Stau_Zeit                                   // Sensor B_VorSep ist belegt [1s]

Xn12: NOP 0


--- NW 17: Schleuse: Mindestzeit geöffnet/frei ---
      L      Dyn.Sk.Akt_Schritt
      L      3                                               // AusSchleusen aktiv?
      <I                                                     // Nein!
      O(
      CAC
      L      6                                               // Mindestzeit ok?
      >I                                                     // Nein!
      )
// /      O     #B_InSchleuse        //Sensor Trolley in Schleuse vorhanden
      ON     "Schleuse_geöffnet"
      R      Dyn.Status.MindestZeit_ok
      JC     X130                                            // FreiZeit neu aufziehen

      A      Schleuse.Parameter_allg.Antrieb_vorhanden
      AN     Antrieb_Schleuse_aktiv
      O
      A      Schleuse.Parameter_allg.Antrieb_Plus_vorhanden
      AN     Antrieb_plus_aktiv
      O      Dyn.Status.MindestZeit_ok                       // Zeit bereits abgelaufen
      ON     "1s-Impuls"
      JC     Xn13

      L      Dyn.Mindest_Zeit                                // Sensor B_im_Sep ist frei [1s]
      +      +1
      T      Dyn.Mindest_Zeit                                // Sensor B_im_Sep ist frei [1s]

      L      Schleuse.Mindeszeit_Schleuse_geoeffnet          // Mindest-Zeit erreicht ?
      >=I                                                    // Ja !
      S      Dyn.Status.MindestZeit_ok
      JCN    Xn13

X130: L      0                                               // Zeiten löschen
      T      Dyn.Mindest_Zeit                                // Sensor B_im_Sep ist frei [1s]

Xn13: NOP 0


--- NW 18: Einsprung Leser ermitteln ---
      L      Dyn.SAVE2.Leser_DB                              // Leser-FIFO-DB
      L      0                                               // Einsprung-Zeiger bekannt ?
      >I                                                     // Ja !
      S      Leser_Zugriff                                   // Leser-Zugriff vorhanden
      JC     En08L

      L      Schleuse.Leser_ID                               // Nr. des vorhandenen Lesers
      T      "MW200"                                         // Search-Daten
      L      0                                               // angegeben ?
      ==I                                                    // Nein !
      JC     En08L

CALL FC "DatenOut" (SSDB:=Para.Leser_DL_DB, SSDW:=0, PARA:=WORD#16#0000, SEARCHDATEN:=P#M200.0, RE_VAL:="MB199", OUTDATEN:=P#M220.0, Position:="MW196")

      L      "MB199"
      T      Dyn.Rueckmld.RET_VAL_DL_Leser                   // Rückmeldung bei Datenbank-Zugriff (Leser-DL)

      JBI    W_OkL

      SET
      S      Dyn.Error.Err_Leser_nicht_bereit                // Leser-Datenliste fehlerhaft

      JU     En08L

W_OkL: L      "MW222"                                        // Rein-FIFO-DB
      T      Dyn.SAVE2.Leser_DB                              // Leser-FIFO-DB
      L      0                                               // sinnvoller Wert ?
      <=I                                                    // Nein !
      S      Dyn.Error.Err_Leser_nicht_bereit                // undefinierter Leser
      JC     En08L

      L      "MD224"
      T      Dyn.SAVE2.Leser_DD                              // Leser-FIFO-DD

      SET
      R      Dyn.Error.Err_Leser_nicht_bereit                // undefinierter Leser
      S      Leser_Zugriff                                   // Leser-Zugriff vorhanden

En08L: NOP 0


--- NW 19: Reservierung bei Weiche plus noch aktiv? Nachtriggern ---
      A      "Kein_Weichenbereich +1"
      R      "Reservierung_Weiche+1_aktiv"
      JC     Y11E

      OPN    DB[SAVE.Weichen_DB]                             // FABE+ -DB öffnen

      L      SAVE.Weichen_DW
      ITD
      T      AR1Start                                        // Startwert mit Offset 0

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#78
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      DBW [AR1Zeiger]                                 // Schleuse -1 (DBW 78)
      L      Schleusen_Nr                                    // Diese Schleuse ?
      ==I                                                    // Ja !
      =      "Reservierung_Weiche+1_aktiv"

// Mindestzeit nachtriggern: (nach Weiche +1)
      AN     "Schleuse_geöffnet"
      JC     Y11E

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#71
      SLD    3
      L      3                                               // Damit DBX_Bit 3
      OD
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      SET
      =      DBX [AR1Zeiger]                                 // Mindestzeit nachtriggern (71.2)

Y11E: NOP 0


--- NW 20: Leser-Einheit managen (Inputs holen) ---
      AN     Leser_Zugriff
      ON     Schleuse.Parameter_allg.Leser_eingebaut
      R      Dyn.Status.Leser_triggern                       // für Status-Anzeige
      JC     NoLeser

// Leserdaten holen:
      OPN    DB[Dyn.SAVE2.Leser_DB]                          // Leser -DB öffnen

      L      Dyn.SAVE2.Leser_DD
      T      AR1Start                                        // Startwert mit Offset 0

// Offset 10:
      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#10
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      DBB [AR1Zeiger]
      T      "MB200"
      A      "M200.0"
      =      Dyn.Leser.IN.xOutReadingDone
      A      "M200.1"
      =      Dyn.Leser.IN.xOutReadyForNewScan

// Offset 274:
      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#274
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      DBB [AR1Zeiger]
      T      "MB200"
      A      "M200.0"
      =      Dyn.Leser.IN.xOutCodeGood
      A      "M200.1"
      =      Dyn.Leser.IN.xOutCodeBad

// Offset 12:
      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#12
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      DBD [AR1Zeiger]
      T      Dyn.Leser.IN.nOutBarcode

NoLeser: NOP 0


--- NW 21: Schrittkette anhalten ---
      A      Dyn.Sk.Auto_akt                                 // Automatik ist aktiv
      A      Dyn.Sk.Bereich_ok
      CLR

      JU     en08_Mig                                        // Schrittkette nicht anhalten !

      SET
      R      Dyn.Sk.Err_Uebzeit                              // Störungen löschen
      R      Dyn.Sk.Err_Schritt

      L      0                                               // Zeitwerte löschen
      T      Dyn.Sk.Terr_Zelle
      T      Dyn.Sk.Tok_Zelle

      JU     RET

en08_Mig: NOP 0


--- NW 22: Trolley wurde zurück gezogen ---
      L      Dyn.Sk.Akt_Schritt
      L      10                                              // Trolley schon unterwegs ?
      <I                                                     // Ja !
      O(
      CAC
      L      12                                              // Trolley schon unterwegs ?
      >I                                                     // Ja !
      )
      O      Status2.Trolley_an_Schleuse                     // Trolley ist noch in Schleuse
      O      "Schleuse_geöffnet"
      JC     TrolleyOk

      SET
      S      Antrieb_Schleuse_start
      S      Dyn.Leser.OUT.xInReset

      L      0                                               // Neubeginn
      T      Dyn.Sk.Akt_Schritt

      AN     Schleuse.Parameter_allg.Leser_eingebaut         // Falls kein Leser verbaut Daten behalten (falls von Bereich-1 gemeldet)
      JC     TrolleyOk

      T      Dyn.Trolley_ZwischenZiel

      L      DINT#0
      T      Dyn.TrolleyID_Schleuse

TrolleyOk: NOP 0


--- NW 23: Sprungverteiler  ---
      L      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll
      L      -1                                              // angegeben ?
      ==I                                                    // Nein !
      JC     NEU

      CAC                                                    // Neuen Schritt übergeben
      T      Dyn.Sk.Akt_Schritt

      L      -1                                              // Urzustand
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

NEU:  SET
      R      Warte_neu                                       // Wartezeit neutriggern
      R      Warte_stop                                      // Wartezeit stoppen

      L      Dyn.Sk.Akt_Schritt
      JL     Ende
      JU     s000                                            // Schritt 0
      JU     s001                                            // Schritt 1
      JU     s002                                            // Schritt 2
      JU     s003                                            // Schritt 3
      JU     s004                                            // Schritt 4
      JU     s005                                            // Schritt 5
      JU     s006                                            // Schritt 6
      JU     s007                                            // Schritt 7
      JU     s008                                            // Schritt 8
      JU     s009                                            // Schritt 9
      JU     s010                                            // Schritt 10
      JU     s011                                            // Schritt 11
      JU     s012                                            // Schritt 12
      JU     s013                                            // Schritt 13
      JU     s014                                            // Schritt 14
      JU     s015                                            // Schritt 15
      JU     s016                                            // Schritt 16
      JU     s017                                            // Schritt 17
      JU     s018                                            // Schritt 18
      JU     s019                                            // Schritt 19
      JU     s020                                            // Schritt 20
      JU     s021                                            // Schritt 21
      JU     s022                                            // Schritt 22
      JU     s023                                            // Schritt 23
      JU     s024                                            // Schritt 24
      JU     s025                                            // Schritt 25
      JU     s026                                            // Schritt 26
      JU     s027                                            // Schritt 27
      JU     s028                                            // Schritt 28
      JU     s029                                            // Schritt 29
      JU     s030                                            // Schritt 30
Ende: S      Dyn.Sk.Err_Schritt                              // Undefinierter Schritt

      L      16#A131
      T      Dyn.Stop_Ursache

      JU     RET

Neu_Mig: A      Dyn.Sk.Err_Uebzeit
      JCN    Sk

      L      16#A132
      T      Dyn.Stop_Ursache

      JU     RET

Sk:   T      Dyn.Sk.Akt_Schritt

      L      0                                               // Zeitwerte löschen
      T      Dyn.Sk.Terr_Zelle
      T      Dyn.Sk.Tok_Zelle

      JU     NEU

// Nicht programmierte Schritte:
// s000: SPA   Ende
// s001: SPA   Ende
// s002: SPA   Ende
s003: JU     Ende
s004: JU     Ende
// s005: SPA   Ende
// s006: SPA   Ende
// s007: SPA   Ende
s008: JU     Ende
// s009: SPA   Ende
// s010: SPA   Ende
// s011: SPA   Ende
// s012: SPA   Ende
// s013: SPA   Ende
// s014: SPA   Ende
// s015: SPA   Ende
// s016: SPA   Ende
// s017: SPA   Ende
s018: JU     Ende
s019: JU     Ende
// s020: SPA   Ende
// s021: SPA   Ende
s022: JU     Ende
s023: JU     Ende
s024: JU     Ende
s025: JU     Ende
s026: JU     Ende
s027: JU     Ende
s028: JU     Ende
s029: JU     Ende
s030: JU     Ende


--- NW 24: Schritt X: Reserve            ---
      SET                                                    // Weiterschaltbedingung
      =      Weiter

// Schrittaktionen:
      SET

      L      16#B001
      T      Dyn.Stop_Ursache

      A      Weiter                                          // Weiterschaltbedingung ist erfüllt
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      L      0                                               // Angabe der Wartezeit (*10ms)
      JC     Plus                                            // Nächsten Schritt starten

      L      1                                               // Weiter mit Schritt 1
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET
      A      Dyn.Sk.Auto_akt                                 // Automatik ist aktiv
      A      Dyn.Sk.Bereich_ok
      =      Ueb_akt                                         // Überwachungszeit aktivieren
      L      50                                              // Angabe der Überwachungszeit (*1s)
      JU     tueb                                            // Überwachungszeit

      JU     RET


--- NW 25: Schritt 0: Warten auf Trolley ---
s000: SET                                                    // Weiterschaltbedingung
      A      B_InSchleuse                                    // Trolley im Schleuse erkannt
      A      Dyn.Sk.Auto_akt                                 // Automatik ist aktiv
      A      Dyn.Sk.Bereich_ok
      =      Weiter

// Trolley-Schleusendaten löschen:
      L      DINT#0
      T      Dyn.TrolleyID_Schleuse
      T      Dyn.Trolley_ShopGroup

      L      0
      T      Dyn.Trolley_EndZiel
      T      Dyn.Weichen_Ziel

// HMI-Zeug:
      L      DINT#0
      T      Dyn.HMI.TrolleyID_Input

      A      Dyn.Sk.Reset_Akt                                // Reset ist aktiv
      L      20                                              // Weiter mit Schritt 20
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

// Schrittaktionen:
      SET
      R      Dyn.Error.Err_Leser_nicht_bereit
      R      Dyn.Error.Err_Kein_LeseErgebnis
      R      Dyn.Status.SF_angefordert
      R      Status2."TrolleyPos_übergeben"
      R      Status2.Telegramm_gesendet

      A      Weiter                                          // Weiterschaltbedingung ist erfüllt
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      L      50                                              // Angabe der Wartezeit (*10ms)
      JC     Plus                                            // Nächsten Schritt starten

      L      16#B001
      T      Dyn.Stop_Ursache

      A      Dyn.Status."Trolley_fährt_in_Schleuse"
      AN     B_InSchleuse
      S      Antrieb_Schleuse_vor                            // Antrieb einschalten
      JC     S000A

      SET
      R      Dyn.Sk.Err_Uebzeit

      L      16#B000
      T      Dyn.Stop_Ursache

      JU     RET

// Überwachungszeit starten:
S000A: A      Dyn.Status."Trolley_fährt_in_Schleuse"
      AN     B_InSchleuse                                    // Trolley im Schleuse erkannt
      A(
      O      Antrieb_Schleuse_aktiv
      ON     Schleuse.Parameter_allg.Antrieb_vorhanden
      )
      =      Ueb_akt                                         // Überwachungszeit aktivieren

      A      Dyn.Sk.Err_Uebzeit
      R      Dyn.Sk.Err_Uebzeit
      S      Dyn.Error.Err_Trolley_nicht_in_Schleuse
      R      Dyn.Status."Trolley_fährt_in_Schleuse"

      L      Schleuse."Übzeit_in_Schleuse"

      JU     tueb                                            // Überwachungszeit


--- NW 26: Schritt 1: Trolley ist in Schleuse / Leser ? / Daten vorhanden ? ---
s001: NOP 0
// Schrittaktionen:
      A      B_InSchleuse
      S      Status2.Trolley_an_Schleuse

      AN     Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      A      Schleuse.Parameter_allg.Leser_eingebaut
      L      0                                               // Weiter mit Schritt 0
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

// Zwischen-Ziel von Bereich -1 vorhanden?:
      L      Dyn.ZwischenZiel_eingefahren
      L      0                                               // Zwischenziel von Bereich -1 vorhanden!
      ==I                                                    // Nein !
      O      Schleuse.Parameter_allg.Leser_eingebaut         // Dann werden Daten neu ermittelt!
      JC     X001

// Daten von Bereich -1 übergeben:
      L      Dyn.ZwischenZiel_eingefahren
      T      Dyn.Trolley_ZwischenZiel
      L      0
      T      Dyn.ZwischenZiel_eingefahren

      L      Dyn.TrolleyID_Eingefahren
      T      Dyn.TrolleyID_Schleuse
      L      DINT#0
      T      Dyn.TrolleyID_Eingefahren

      L      12                                              // Weiter mit Schritt 12
      JU     Neu_Mig                                         // Bei diesem Schritt weiter

X001: L      0
      T      Dyn.Trolley_ZwischenZiel

// Leser vorhanden:
      A      Schleuse.Parameter_allg.Leser_eingebaut
      R      Dyn.Error.Err_Kein_LeseErgebnis
      L      9                                               // Weiter mit Schritt 9 (Leser bereit)
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

// Trolleydaten vorhanden ?: (Übergabe von Bereich -1)
      L      Dyn.TrolleyID_Eingefahren
      T      Dyn.TrolleyID_Schleuse
      L      DINT#0                                          // Daten vorhanden ?
      <>D                                                    // Ja !
      L      11                                              // Weiter mit Schritt 11  (Trolleydaten lesen)
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

// Ziel-FC vorhanden ?:
      A      ZielFC_vorhanden
      L      12                                              // Weiter mit Schritt 12 (Ziel-FC)
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      L      14                                              // Weiter mit Schritt 14 (Weichenbereich +1 vorhanden)
      JU     Neu_Mig                                         // Bei diesem Schritt weiter


--- NW 27: Schritt 2: Ausfahren ok ? ---
s002: NOP 0

// Schrittaktionen:
      AN     Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      L      0                                               // Weiter mit Schritt 0
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

// Anlage aus oder Störung:
      L      16#B021
      T      Dyn.Stop_Ursache

      AN     Dyn.Sk.Auto_akt                                 // Automatik ist aktiv
      ON     Dyn.Sk.Bereich_ok                               // Bereich ist gestört
      JC     RET

// Starten erlaubt Trolley ?:
      L      16#B022
      T      Dyn.Stop_Ursache

      AN     Start_Ok                                        // Starten ist erlaubt
      JC     RET

// Stau im Bereich +1:
      L      16#B023
      T      Dyn.Stop_Ursache

      SET
      S      Dyn.Status."Trolley_wartet_Bereich+1"

      A      B_Stau_raus                                     // Sensor Stau im Bereich rausfahren
      JC     RET

// B_Aus_Schleuse aktiv:
      L      16#B024
      T      Dyn.Stop_Ursache

      A(
      L      Dyn.Raus_Trolleys
      L      0                                               // Trolleys schon unterwegs?
      <>I                                                    // Ja!
      O(
      L      Schleuse.MaxRausTrolleys
      L      1                                               // Nur einer darf ausfahren ?
      ==I                                                    // Ja !
      )
      )
      A      Status2."Trolley an Raus-Sensor"
      O      Status2."Stau_an_Raus-Sensor"
      JC     RET

// Raus-Weiche bereit?:
      L      16#B028
      T      Dyn.Stop_Ursache

      A(
      L      Dyn.Weichen_Ziel
      L      Dyn."Zurück_gemeldetes_Weichen_Ziel"
      <>I                                                    // Nicht identisch !
      ON     Dyn.Status.Weiche_geschaltet                    // Rückmeldung von Weiche +1
      )
      AN     "Kein_Weichenbereich +1"                        // Also Weiche +1
      L      15
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

// Zu viele Raus-Trolleys unterwegs:
      L      16#B027
      T      Dyn.Stop_Ursache

      L      Dyn.Raus_Trolleys                               // Gestartete Trolleys
      L      Schleuse.MaxRausTrolleys                        // Erlaubte Anzahl gestarteter Trolleys
      >=I
      JC     RET

// Antriebe aktivieren / aktiv ?:
      A      Schleuse.Parameter_allg.Antrieb_Plus_vorhanden  // Schleuse an weiterem Antrieb (Weiche)
      S      Antrieb_plus_vor                                // Antrieb plus einschalten

      A(
      O      Antrieb_plus_aktiv                              // Kreisel-Antrieb plus aktiv
      ON     Schleuse.Parameter_allg.Antrieb_Plus_vorhanden  // Schleuse an weiterem Antrieb (Weiche)
      )
      S      Antrieb_Schleuse_vor                            // Antrieb einschalten

      L      16#B026
      T      Dyn.Stop_Ursache

      AN     Antrieb_plus_aktiv                              // Kreisel-Antrieb plus aktiv
      A      Schleuse.Parameter_allg.Antrieb_Plus_vorhanden  // Schleuse an weiterem Antrieb (Weiche)
      JC     RET

      AN     Antrieb_Schleuse_aktiv                          // Kreisel-Antrieb aktiv
      A      Schleuse.Parameter_allg.Antrieb_vorhanden       // Schleuse an angetriebener Strecke
      =      Dyn.Status.Kein_Stop_mehr
      JC     RET

      L      Dyn.Raus_Trolleys
      +      1                                               // Gestartete Trolleys + 1
      T      Dyn.Raus_Trolleys

      L      5                                               // Nur 1 langes Signal!
      JC     Neu_Mig                                         // Bei diesem Schritt weiter


--- NW 28: Schritt 5: Trolley fährt aus ?       ---
s005: SET                                                    // Weiterschaltbedingung
      AN     B_InSchleuse                                    // Sensor Trolley ist in Schleuse
      A(
      O      Antrieb_Schleuse_aktiv                          // Kreisel-Antrieb aktiv
      ON     Schleuse.Parameter_allg.Antrieb_vorhanden       // Schleuse an angetriebener Strecke
      )
      A(
      O      Antrieb_plus_aktiv
      ON     Schleuse.Parameter_allg.Antrieb_Plus_vorhanden
      )
      =      Weiter

// Schrittaktionen:
      SET
      S      Y_Schleuse_Auf                                  // Schleuse öffnen
      S      Dyn.Status."Trolley_fährt_aus"

// Antriebe:
// siehe Nw10

// B in Schleuse aktiv:
      A      B_InSchleuse                                    // Sensor Trolley ist in Schleuse
      JCN    X050                                            // Negierter Sprung

      L      0
      T      Dyn.Sk.Tok_Zelle

// Trolley ist draussen mit 5s-Verzögerung:
X050: A      Weiter                                          // Weiterschaltbedingung ist erfüllt
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      R      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus
      L      300
      JC     Plus                                            // Nächsten Schritt starten

// Trolley fährt nicht raus!:
      A      Dyn.Sk.Err_Uebzeit
      S      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus

      L      16#B051
      T      Dyn.Stop_Ursache

      A      Antrieb_Schleuse_aktiv
      ON     Schleuse.Parameter_allg.Antrieb_vorhanden       // Schleuse an angetriebener Strecke
      =      Ueb_akt                                         // Überwachungszeit aktivieren
      L      Schleuse."Übzeit_aus_Schleuse"                  // Angabe der Überwachungszeit (*1s)
      JU     tueb                                            // Überwachungszeit


--- NW 29: Schritt 6: Schleuse Mindestzeit geöffnet ?       ---
s006: SET                                                    // Weiterschaltbedingung
      A      Dyn.Status.MindestZeit_ok
      AN     B_InSchleuse                                    // Sensor Trolley in Schleuse vorhanden
      =      Weiter
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      R      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus

// Schrittaktionen:
// Gezählt wird in NW11

      SET
      S      Y_Schleuse_Auf                                  // Schleuse öffnen
      S      Dyn.Status."Trolley_fährt_aus"

// Erneutes Signal von B in Schleuse ?:
      A      B_InSchleuse                                    // Sensor Trolley in Schleuse vorhanden
      JCN    X060                                            // Negierter Sprung

      L      5
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

      L      0                                               // Mindest-Zeit neu starten
      T      Dyn.Mindest_Zeit                                // Sensor B_im_Sep ist frei [1s]
      SET
      R      Dyn.Status.MindestZeit_ok                       // Zeit bereits abgelaufen

      JU     RET

// Antriebe:
// siehe Nw10
X060: A      Weiter
      L      0
      JC     X006                                            // Nächsten Schritt starten

      L      16#B061
      T      Dyn.Stop_Ursache

// Trolley fährt nicht raus!:
      A      Dyn.Sk.Err_Uebzeit
      S      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus

      A      Antrieb_Schleuse_aktiv
      ON     Schleuse.Parameter_allg.Antrieb_vorhanden       // Schleuse an angetriebener Strecke
      =      Ueb_akt                                         // Überwachungszeit aktivieren
      L      Schleuse."Übzeit_aus_Schleuse"                  // Angabe der Überwachungszeit (*1s)
      JU     tueb                                            // Überwachungszeit

// Trolley hat Schleuse verlassen:
X006: SET
      S      Dyn.Status.Trolley_draussen                     // 1 Zyklus
      R      Dyn.Status."Trolley_fährt_in_Schleuse"
      R      Status2.Telegramm_gesendet

      L      Dyn.Vereinzelungstakte
      +      DINT#1                                          // Vereinzelungen +1
      T      Dyn.Vereinzelungstakte

// Draussen-FC ?:
      AN     DraussenFC_vorhanden
      JC     NoFC                                            // Bei diesem Schritt weiter

      L      Schleusen_Nr                                    // Schleusen-Nr.
      T      "MW190"
      L      Dyn.Trolley_ShopGroup                           // Shop-Gruppe
      T      "MD182"                                         // übergeben

      L      Dyn.Weichen_Ziel
      T      "MW198"                                         // Weichenziel

      UC     DB[DraussenFC]                                  // z.Bsp. Daten anpassen

NoFC: L      7                                               // Weiter mit Schritt 7
      JU     Neu_Mig                                         // Bei diesem Schritt weiter


--- NW 30: Schritt 7: Fertig        ---
s007: SET                                                    // Weiterschaltbedingung

// Schrittaktionen:
      JU     ENDE_Mig


--- NW 31: Schritt 9: Lese-Einheit bereit?         ---
s009: SET                                                    // Weiterschaltbedingung
      L      Dyn.Leser.IN.nOutBarcode
      L      DINT#0
      ==D
      A      Dyn.Leser.IN.xOutReadyForNewScan
      AN     Dyn.Leser.IN.xOutReadingDone
      AN     Dyn.Leser.IN.xOutCodeGood
      AN     Dyn.Leser.IN.xOutCodeBad
      =      Weiter
      R      Dyn.Error.Err_Leser_nicht_bereit

// Schrittaktionen:
      AN     Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      A      Schleuse.Parameter_allg.Leser_eingebaut
      R      Dyn.Error.Err_Leser_nicht_bereit
      L      0                                               // Weiter mit Schritt 0
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      A      Weiter
      =      Dyn.Leser.OUT.xInStartReading                   // Leser triggern
      L      0                                               // Angabe der Wartezeit (*10ms)
      JC     Plus                                            // Nächsten Schritt starten

// Leser nicht bereit:
      A      Dyn.Leser.IN.xOutReadingDone                    // Falls altes Handshake noch gewollt
      O      Dyn.Leser.IN.xOutCodeGood
      O      Dyn.Leser.IN.xOutCodeBad
      S      Dyn.Leser.OUT.xInHandshakeDone

      A      Dyn.Sk.Err_Uebzeit
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      S      Dyn.Error.Err_Leser_nicht_bereit
      S      Dyn.Leser.OUT.xInErrQuit                        // Vielleicht hilft es

      A      Dyn.Error.Err_Leser_nicht_bereit
      A      ErrQuit                                         // Mit Quittierung dann zusätzlich reset!
      S      Dyn.Leser.OUT.xInReset

// HMI-TrolleyID bei Leser nicht bereit:
      L      Dyn.HMI.TrolleyID_Input
      L      DINT#0
      <>D                                                    // Ja!
      A      Dyn.Error.Err_Leser_nicht_bereit
      L      0                                               // Angabe der Wartezeit (*10ms)
      JC     Plus                                            // Nächsten Schritt starten

      SET
      =      Ueb_akt                                         // Überwachungszeit aktivieren
      L      5                                               // Angabe der Überwachungszeit (*1s)
      JU     tueb                                            // Überwachungszeit


--- NW 32: Schritt 10: Warten auf Leseeinheit            ---
s010: SET                                                    // Weiterschaltbedingung
      A      Dyn.Leser.IN.xOutReadingDone
      A      Dyn.Leser.IN.xOutCodeGood
      AN     Dyn.Leser.IN.xOutCodeBad
      =      Weiter
      R      Dyn.Error.Err_Kein_LeseErgebnis

// Schrittaktionen:
      AN     Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      A      Schleuse.Parameter_allg.Leser_eingebaut
      L      0                                               // Weiter mit Schritt 0
      R      Dyn.Error.Err_Kein_LeseErgebnis
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET
      R      Dyn.Leser.OUT.xInStartReading                   // Leseeinheit triggern

      A      Weiter
      S      Dyn.Leser.OUT.xInHandshakeDone
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      JC     X010

      SET
      S      Dyn.Status.Trolley_wartet_Lesung

      A      Dyn.Error.Err_Leser_nicht_bereit                // von Schritt 9
      JC     LX

      A      Dyn.Sk.Err_Uebzeit
      O      Dyn.Leser.IN.xOutCodeBad
      S      Dyn.Leser.OUT.xInHandshakeDone
      JC     L2                                              // Erst bei 3.Fehllesung Error!

      L      16#B101
      T      Dyn.Stop_Ursache

      SET
      =      Ueb_akt                                         // Überwachungszeit aktivieren

      L      10                                              // Angabe der Überwachungszeit (*1s)
      JU     tueb                                            // Überwachungszeit

L2:   A      Status2."2.Lesung_aktiv"                        // Erst bei 3.Fehllesung Error!
      JC     L3

      SET
      S      Status2."2.Lesung_aktiv"
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !

      L      9
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

      JU     RET

L3:   A      Status2."3.Lesung_aktiv"                        // //Erst bei 3.Fehllesung Error!
      JC     LX

      SET
      S      Status2."3.Lesung_aktiv"
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !

      L      9
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

      JU     RET

// Nach 3.Fehl-Lesung erst Leserfehler!
LX:   SET
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      S      Dyn.Error.Err_Kein_LeseErgebnis
      JU     NoLesung

// Leserdaten übergeben:
X010: L      Dyn.Leser.IN.nOutBarcode
      T      Dyn.TrolleyID_Schleuse

      L      DINT#0                                          // Unbekannt ?
      ==D                                                    // Ja !
      O(
      CAC
      L      DINT#-1                                         // Fehl-Lesung?
      ==D                                                    // Ja !
      )
      S      Dyn.Error.Err_Kein_LeseErgebnis
      L      9                                               // Weiter mit Schritt 9 (Leser bereit)
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      L      11                                              // Weiter mit Schritt 11
      JU     Neu_Mig                                         // Bei diesem Schritt weiter

// Lesefehler:
NoLesung: NOP 0
// HMI-Eingabe?:
// HMI-TrolleyID:
      L      Dyn.HMI.TrolleyID_Input
      T      Dyn.TrolleyID_Schleuse
      <>D                                                    // Ja!
      L      0                                               // Angabe der Wartezeit (*10ms)
      R      Dyn.Error.Err_Kein_LeseErgebnis
      R      Dyn.Error.Err_Leser_nicht_bereit                // von Schritt 9
      JC     Plus                                            // Nächsten Schritt starten

// Leser-FC aufrufen:
No_HMIa: AN     LeserFC_vorhanden
      JC     NoLFC

      L      Schleusen_Nr                                    // Schleusen-Nr.
      T      "MW190"                                         // übergeben
      L      Dyn.Trolley_ZwischenZiel                        // Übergabe von Leser-Aufruf
      T      "MW196"

      A      Dyn.Error.Err_Kein_LeseErgebnis
      =      "M180.0"
      SET
      R      "M180.1"

      UC     DB[LeserFC]                                     // Beeinflussung der Fehllesung

      L      16#B102
      T      Dyn.Stop_Ursache

      L      "MW196"                                         // Zwischenziel übergeben
      T      Dyn.Trolley_ZwischenZiel                        // Übergabe von Leser-Aufruf
      L      0                                               // Übergeben ?
      <>I                                                    // Ja!
      L      12                                              // Weiter mit Schritt 12
      R      Dyn.Error.Err_Kein_LeseErgebnis
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

NoLFC: L      9
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

      JU     RET


--- NW 33: Schritt 11: Trolleydaten aus DL lesen ---
s011: L      DINT#0
      T      Dyn.TrolleyID_Eingefahren                       // Eintrag von Weiche -1

      L      Dyn.Trolley_ZwischenZiel                        // /

      L      Dyn.TrolleyID_Schleuse
      T      "MD220"

CALL FC "DatenOut" (SSDB:=Schleuse.Gesamt_Trolley_DL, SSDW:=0, PARA:=16#0000, SEARCHDATEN:=P#M220.0, RE_VAL:="MB199", OUTDATEN:=DB1011.DBX0.0, Position:="MW196")   // Eintrag lesen

      L      16#B111
      T      Dyn.Stop_Ursache

      AN     "M199.7"
      =      Dyn.Error.Barcode_nicht_bekannt
      JC     UnbekanntBC

// Relevanten Trolleydaten auslesen:
      L      "TrolleyDL_OutDaten".OUTDaten.EndZiel
      T      Dyn.Trolley_EndZiel

// ZwischenZiel nicht überschreiben:
      L      Dyn.Trolley_ZwischenZiel
      L      0                                               // Schon bekannt ?
      <>I                                                    // Ja !
      JC     NixZZ

      L      "TrolleyDL_OutDaten".OUTDaten.ZwischenZiel
      T      Dyn.Trolley_ZwischenZiel

NixZZ: L      "TrolleyDL_OutDaten".OUTDaten.ShopGroup
      T      Dyn.Trolley_ShopGroup

      L      0                                               // Angabe der Wartezeit (*10ms)
      JU     Plus                                            // Nächsten Schritt starten

// Unbekannter Trolley:
UnbekanntBC: NOP 0
// HMI-Eingabe?:

// Leser-FC aufrufen:
Nix_HMI: AN     LeserFC_vorhanden
      JC     Nix_LFC

      L      Schleusen_Nr                                    // Schleusen-Nr.
      T      "MW190"                                         // übergeben
      L      Dyn.TrolleyID_Schleuse
      T      "MD192"
      L      Dyn.Trolley_ZwischenZiel
      T      "MW196"

      A      Dyn.Error.Barcode_nicht_bekannt
      =      "M180.1"
      SET
      R      "M180.0"

      UC     DB[LeserFC]                                     // Beeinflussung der Weiterfahrt bei nicht bekanntem Trolley

      L      "MW196"                                         // ZwischenZiel übergeben
      T      Dyn.Trolley_ZwischenZiel                        // Übergabe von Leser-Aufruf
      L      0                                               // Übergeben ?
      <>I                                                    // Ja!
      L      12                                              // Weiter mit Schritt 12
      R      Dyn.Error.Err_Kein_LeseErgebnis
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

Nix_LFC: JU     RET


--- NW 34: Schritt 12: Ziel-FC ---
s012: NOP 0

// Schrittaktionen:
      AN     Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      A      Schleuse.Parameter_allg.Leser_eingebaut
      AN     "Schleuse_geöffnet"
      L      0                                               // Weiter mit Schritt 0
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET
      S      Dyn.Status."Trolley_wartet_auf_Ziel-FC"

      AN     ZielFC_vorhanden
      R      Dyn.Status."Trolley_wartet_auf_Ziel-FC"
      L      13                                              // Weiter mit Schritt 13
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET                                                    // Rückmeldungen erst mal resetten
      R      "M180.6"                                        // Weiterfahrt von Ziel-FC erlaubt
      L      Schleusen_Nr                                    // Schleusen-Nr.
      T      "MW190"                                         // übergeben
      L      Dyn.Trolley_ShopGroup                           // Shop-Gruppe
      T      "MD182"                                         // übergeben
      L      Dyn.Trolley_EndZiel                             // End-Ziel
      T      "MW194"                                         // übergeben
      L      Dyn.Trolley_ZwischenZiel
      T      "MW196"                                         // übergeben
      L      0                                               // Erst mal nullen
      T      "MW198"                                         // Weichenziel

      UC     DB[ZielFC]                                      // Beeinflussung der Weiterfahrt

      L      16#B122
      T      Dyn.Stop_Ursache

// Spezial-Fall bei Übergabe an Sorter / Turm (M180.6 wird nie im Ziel-FC gesetzt!)
// aber anderer Partner hat Schleuse extern geöffnet:
      A      "Schleuse_geöffnet"
      AN     "M180.6"                                        // Weiterfahrt von Ziel-FC erlaubt
      AN     Status2."TrolleyPos_übergeben"                  // Nur einmalig
      S      Status2."TrolleyPos_übergeben"
      JCN    Normal                                          // Negierter Sprung

      L      Dyn.Vereinzelungstakte
      +      DINT#1                                          // Vereinzelungen +1
      T      Dyn.Vereinzelungstakte

CALL FC "Trolley_DL_Neue_Pos" (Gesamt_Trolley_DL:=Schleuse.Gesamt_Trolley_DL, TrolleyID:=Dyn.TrolleyID_Schleuse, Position:=Schleuse.Leser_ID, ShopGroup:=Dint#0, Err:="M199.0")

// Draussen-FC ?:
      AN     DraussenFC_vorhanden
      JC     RET                                             // Bei diesem Schritt weiter

      L      Schleusen_Nr                                    // Schleusen-Nr.
      T      "MW190"

      UC     DB[DraussenFC]                                  // z.Bsp. Daten anpassen

      JU     RET

Normal: A      "M180.6"                                      // Weiterfahrt von Ziel-FC erlaubt
      JC     X012

      AN     Schleuse.Parameter_allg.Leser_eingebaut
      JC     RET

      L      11
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

      JU     RET

X012: L      "MW196"                                         // zurückschreiben, falls verändert
      T      Dyn.Trolley_ZwischenZiel

      L      "MW198"                                         // Weichenziel übergeben
      T      Dyn.Weichen_Ziel

      L      13                                              // Weiter mit Schritt 13
      JU     Neu_Mig                                         // Bei diesem Schritt weiter


--- NW 35: Schritt 13: Schleusen-Position zurückschreiben ---
s013: NOP 0

// Schrittaktionen:
      SET
      S      Status2."Weichen-Schritt"

// Neue Position an Gesamt-Trolley-DL übergeben:
CALL FC "Trolley_DL_Neue_Pos" (Gesamt_Trolley_DL:=Schleuse.Gesamt_Trolley_DL, TrolleyID:=Dyn.TrolleyID_Schleuse, Position:=Schleuse.Leser_ID, ShopGroup:=DInt#0, Err:="M199.0")   // für nichts verändern

      L      0                                               // Angabe der Wartezeit (*10ms)
      JU     Plus                                            // Nächsten Schritt starten


--- NW 36: Schritt 14: Weichenbereich +1 vorhanden ---
s014: NOP 0

// Schrittaktionen:
// Weichenbereich +1 vorhanden?:
      A      "Kein_Weichenbereich +1"
      L      2                                               // Weiter mit Schritt 2 (Ausfahren ok?)
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET
      S      Status2."Weichen-Schritt"

      L      0                                               // Angabe der Wartezeit (*10ms)
      JU     Plus                                            // Nächsten Schritt starten


--- NW 37: Schritt 15: Weichenbereich raus bereit ?           ---
s015: NOP 0

// Schrittaktionen:
      AN     Status2.Trolley_an_Schleuse                     // Trolley im Schleuse erkannt
      L      0                                               // Weiter mit Schritt 0
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET
      S      Status2."Weichen-Schritt"

      L      Dyn.Weichen_Ziel
      L      0                                               // Bekannt ?
      <>I                                                    // Ja !
      JC     X15A

      L      12                                              // Ziel-FC ?
      T      Dyn.Sk.Neu_Schritt                              // Schritt, der im nächsten Zyklus aktiv werden soll

      L      16#B154
      T      Dyn.Stop_Ursache

      JU     RET

X15A: SET
      S      Dyn.Status."Trolley_wartet_auf_Weiche+1"

      L      16#B155
      T      Dyn.Stop_Ursache

      L      SAVE.Weichen_DB                                 // Weichen-DB
      L      0                                               // Einsprung-Zeiger bekannt ?
      >I                                                     // Ja !
      JC     S015A

      L      16#B150
      T      Dyn.Stop_Ursache

      JU     RET

// Weichendaten auslesen:
S015A: L      SAVE.Weichen_DW
      ITD
      T      AR1Start                                        // Startwert mit Offset 0

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#70
      SLD    3
      L      0                                               // Damit DBX70.0
      OD
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      16#B152
      T      Dyn.Stop_Ursache

      OPN    DB[SAVE.Weichen_DB]                             // FABE+ -DB öffnen

      AN     DBX [AR1Zeiger]                                 // Weichenbereich frei ? (DBX70.0)
      JC     S015B

      L      16                                              // Weiter mit Schritt 16 (Daten an Weiche übergeben)
      JU     Neu_Mig                                         // Bei diesem Schritt weiter

// Reservierung noch diese Schleuse ?:
S015B: L      AR1Start                                       // Startwert mit Offset 0
      +      DINT#78
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      OPN    DB[SAVE.Weichen_DB]                             // FABE+ -DB öffnen

      L      DBW [AR1Zeiger]                                 // Schleuse -1 (DBW 78)
      L      Schleusen_Nr                                    // Diese Schleuse ?
      <>I                                                    // Nein !
      JC     RET                                             // Warten !

// Dasselbe Weichen-Ziel ?:
      L      Dyn.Weichen_Ziel                                // Gewolltes Ziel
      L      Dyn."Zurück_gemeldetes_Weichen_Ziel"            // Aktuell im Weichenbereich aktives Ziel
      <>I                                                    // Sind nicht identisch !
      JC     RET                                             // Warten !

      L      16                                              // Weiter mit Schritt 16 (Daten an Weiche übergeben)
      JU     Neu_Mig                                         // Bei diesem Schritt weiter


--- NW 38: Schritt 16: Daten an Rausweiche übergeben ---
s016: NOP 0

// Schrittaktionen:
      SET
      S      Status2."Weichen-Schritt"

// Daten für Eintrag vorbereiten:
      OPN    DB[SAVE.Weichen_DB]                             // FABE+ -DB öffnen

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#72
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      Dyn.TrolleyID_Schleuse
      T      DBD [AR1Zeiger]                                 // Trolley-ID (DBD 72)

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#76
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      Dyn.Weichen_Ziel
      T      DBW [AR1Zeiger]                                 // Weichenziel (DBW 76)

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#80
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      Dyn.Trolley_ZwischenZiel
      T      DBW [AR1Zeiger]                                 // Zwischenziel (DBW 80)

      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#78
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      Schleusen_Nr
      T      DBW [AR1Zeiger]                                 // Schleuse -1 (DBW 78)

      SET
      S      "Reservierung_Weiche+1_aktiv"                   // Weiche nicht mehr angemeldet (da erst im nächsten Zyklus)

      L      Schleuse.RausWeichen_Nr                         // Nr. der vorhandenen Weiche
      T      SAVE."Weiche+1"                                 // Hier wurde reserviert

      L      17                                              // Weiter mit Schritt 17 (Hat Weiche geschaltet ?)
      JU     Neu_Mig                                         // Bei diesem Schritt weiter


--- NW 39: Schritt 17: Hat Rausweiche geschaltet ? ---
s017: NOP 0

// Schrittaktionen:
      SET
      S      Status2."Weichen-Schritt"

// Weiche +1 noch mit dieser Schleuse aktiv ?:
      AN     "Reservierung_Weiche+1_aktiv"                   // Weiche nicht mehr angemeldet
      L      14                                              // Weiter mit Schritt 14
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      SET
      S      Dyn.Status."Trolley_wartet_auf_Weiche+1"

      L      16#B170
      T      Dyn.Stop_Ursache

      L      Dyn.Weichen_Ziel                                // Gewolltes Ziel
      L      Dyn."Zurück_gemeldetes_Weichen_Ziel"            // Aktuell im Weichenbereich aktives Ziel
      ==I                                                    // Sind identisch !
      A      Dyn.Status.Weiche_geschaltet                    // Rückmeldung von Weiche +1
      L      2                                               // Weiter mit Schritt 2 (Ausfahren ok?)
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      L      16#B171
      T      Dyn.Stop_Ursache

      JU     RET


--- NW 40: Schritt 20: Schleuse resetten (Wartezeit) ---
s020: A      B_InSchleuse                                    // Weiterschaltbedingung
      =      Weiter                                          // Weiterschaltbedingung ist erfüllt

// Schrittaktionen:
      SET                                                    // ELS in Grundstellung fahren
      S      Antrieb_Schleuse_vor                            // Antrieb einschalten
      S      Antrieb_Schleuse_start                          // Antrieb starten

      A      Weiter
      O      Dyn.Sk.Err_Uebzeit
      R      Dyn.Sk.Err_Uebzeit                              // Sofort weiter !
      L      21                                              // Weiter mit Schritt 21
      JC     Neu_Mig                                         // Bei diesem Schritt weiter

      L      16#B201
      T      Dyn.Stop_Ursache

      SET
      =      Ueb_akt                                         // Überwachungszeit aktivieren
      L      Schleuse.Wartezeit_bis_leer                     // Angabe der Überwachungszeit (*1s)
      JU     tueb                                            // Überwachungszeit


--- NW 41: Schritt 21: Reset ist zu Ende ---
s021: SET
      R      Dyn.Sk.Reset_Akt                                // Reset ist aktiv
      R      Status2."TrolleyPos_übergeben"
      R      Dyn.Error.Err_Trolley_nicht_in_Schleuse         // Trolley fährt nicht in Schleuse
      R      Dyn.Error.Err_Uebzeit                           // Überwachungzeit ist abgelaufen
      R      Dyn.Error.Err_Stau_Einfahrt                     // Betriebsart ist nicht möglich
      R      Dyn.Error.Err_Trolley_raus                      // Trolley fährt nicht aus
      R      Dyn.Status."Trolley_fährt_in_Schleuse"

      L      0
      T      SAVE.Weichen_DB
      T      SAVE.Weichen_DW
      T      SAVE."Weiche+1"                                 // Dadurch wird in Weiche Reservierung gelöscht
      T      Dyn.Raus_Trolleys
      T      Dyn.Stau_Zeit                                   // Sensor B_VorSep ist belegt [1s]
      T      Dyn.Mindest_Zeit                                // Sensor B_VorSep ist frei [1s]

      SET
      S      Dyn.Status.Trolley_draussen

      JU     ENDE_Mig                                        // Neubeginn


--- NW 42: Schrittkette beenden ---
ENDE_Mig: L      0                                           // Schritt 0: Warten
      T      Dyn.Sk.Akt_Schritt

      L      0                                               // Zeitwert löschen
      T      Dyn.Sk.Terr_Zelle
      T      Dyn.Sk.Tok_Zelle
      T      Dyn.ZwischenZiel_eingefahren

      L      DINT#0
      T      Dyn.TrolleyID_Eingefahren                       // Eintrag von Weiche -1
      T      Dyn.TrolleyID_Schleuse                          // Daten übergeben
      T      Dyn.Trolley_ZwischenZiel
      T      Dyn.Trolley_EndZiel
      T      Dyn.Weichen_Ziel

      SET
      R      Dyn.Sk.Err_Uebzeit
      R      Dyn.Status."Trolley_fährt_rückwärts"
      R      Dyn.Error.Err_Kein_LeseErgebnis
      R      Status2."2.Lesung_aktiv"
      R      Status2."3.Lesung_aktiv"
      R      Status2."TrolleyPos_übergeben"
      R      Status2.Telegramm_gesendet

// HMI-Zeug:
      L      DINT#0
      T      Dyn.HMI.TrolleyID_Input

      JU     RET


--- NW 43: Nächsten Schritt aktivieren ---
Plus: T      Dyn.Sk.T_ok                                     // Wartezeit übergeben

      A      Dyn.Sk.Err_Uebzeit                              // Störung noch nicht quittiert
      JC     RET

      L      0                                               // keine Wartezeit ?
      ==I                                                    // Ja ! -> sofort weiter
      JC     w220

      AN     Warte_neu                                       // Wartezeit neutriggern
      JC     W220_Mig

      L      0
      T      Dyn.Sk.Tok_Zelle                                // Wartezeit

W220_Mig: A      Warte_stop                                  // Wartezeit stoppen
      JC     RET

      L      Dyn.Sk.Tok_Zelle
      L      "MW4"                                           // Wartezeit +10ms
      +I
      T      Dyn.Sk.Tok_Zelle                                // Wartezeit
      L      Dyn.Sk.T_ok                                     // abgelaufen ?
      <I                                                     // Nein !
      JC     RET

w220: L      Dyn.Sk.Akt_Schritt
      +      1                                               // Schritt +1
      T      Dyn.Sk.Akt_Schritt

      L      0                                               // Zeitwerte löschen
      T      Dyn.Sk.Terr_Zelle
      T      Dyn.Sk.Tok_Zelle

      JU     RET


--- NW 44: Überwachungszeit kontrollieren ---
tueb: A      Ueb_akt
      =      Dyn.Sk.Ueb_akt                                  // Für Statuskontrolle

      T      Dyn.Sk.T_Err                                    // Für Statuskontrolle
      L      Dyn.Sk.Terr_Zelle                               // Maximalzeit
      >I                                                     // abgelaufen ?
      AN     Dyn.Sk.Err_Uebzeit
      JC     en24                                            // Nein !

      A      Ueb_akt                                         // Überwachungszeit aktivieren
      S      Dyn.Sk.Err_Uebzeit

      L      0                                               // Zeitwert löschen
      T      Dyn.Sk.Terr_Zelle

      JU     RET

en24: NOP 0

--- NW 45: Überwachungszeit +1 ---
      AN     Dyn.Sk.Ueb_akt                                  // Schrittaktion ist aktiv
      ON     "1s-Impuls"
      JC     RET

      L      Dyn.Sk.Terr_Zelle
      +      1                                               // Üb.zeit +1s
      T      Dyn.Sk.Terr_Zelle

      JU     RET


--- NW 46: Return ---
RET:  NOP 0
// Weichen -R ückmeldung löschen:
      SET
      R      Dyn.Status.Weiche_geschaltet
      R      Dyn.Status."Trolley ausserhalb Weiche"

      L      0
      T      Dyn."Zurück_gemeldetes_Weichen_Ziel"


--- NW 47: Leser-Einheit managen (Outputs schreiben) ---
      AN     Leser_Zugriff
      ON     Schleuse.Parameter_allg.Leser_eingebaut
      JC     NixLeser

// Leserdaten schreiben:
      OPN    DB[Dyn.SAVE2.Leser_DB]                          // Leser -DB öffnen

      L      Dyn.SAVE2.Leser_DD
      T      AR1Start                                        // Startwert mit Offset 0

// Offset 4:
      L      AR1Start                                        // Startwert mit Offset 0
      +      DINT#4
      SLD    3
      T      AR1Zeiger                                       // Statt Dyn.Bereichsstop (ging nur bis DB-Länge <= 8191 Bytes)

      L      DBB [AR1Zeiger]                                 // Aktuelle Werte holen
      T      "MB200"

      A      Dyn.Leser.OUT.xInStartReading
      =      "M200.1"
      A      Dyn.Leser.OUT.xInHandshakeDone
      R      Dyn.Leser.OUT.xInHandshakeDone
      =      "M200.2"
      A      Dyn.Leser.OUT.xInErrQuit
      R      Dyn.Leser.OUT.xInErrQuit
      =      "M200.4"
      A      Dyn.Leser.OUT.xInReset
      R      Dyn.Leser.OUT.xInReset
      =      "M200.5"

      L      "MB200"
      T      DBB [AR1Zeiger]                                 // Veränderte Werte zurück schreiben

NixLeser: NOP 0


--- NW 48: Ende ---
      BE

