diff --git a/bin/generate_tro_graph.bat b/bin/generate_tro_graph.bat new file mode 100644 index 0000000..3f9081c --- /dev/null +++ b/bin/generate_tro_graph.bat @@ -0,0 +1,36 @@ +@echo off +REM Erzeugt den TRO-Topologie-Graphen (DOT) aus den FB_Main.scl-Dateien +REM und rendert ihn anschliessend mit Graphviz als SVG. +REM +REM Voraussetzung: Graphviz (dot.exe) muss installiert sein, z.B. per +REM winget install --id Graphviz.Graphviz -e + +setlocal +set "SCRIPT_DIR=%~dp0" +set "REPO_DIR=%SCRIPT_DIR%.." +set "DOT_FILE=%REPO_DIR%\doc\TRO_Graph_UH01-UH05.dot" +set "SVG_FILE=%REPO_DIR%\doc\TRO_Graph_UH01-UH05.svg" + +echo Erzeuge %DOT_FILE% ... +python "%SCRIPT_DIR%generate_tro_graph.py" "%DOT_FILE%" +if errorlevel 1 ( + echo Fehler bei der Erzeugung der DOT-Datei. + exit /b 1 +) + +where dot >nul 2>nul +if errorlevel 1 ( + echo dot.exe wurde nicht gefunden. Bitte Graphviz installieren: + echo winget install --id Graphviz.Graphviz -e + exit /b 1 +) + +echo Rendere %SVG_FILE% ... +dot -Tsvg "%DOT_FILE%" -o "%SVG_FILE%" +if errorlevel 1 ( + echo Fehler beim Rendern der SVG-Datei. + exit /b 1 +) + +echo Fertig: %SVG_FILE% +endlocal diff --git a/bin/generate_tro_graph.py b/bin/generate_tro_graph.py new file mode 100644 index 0000000..548ebc4 --- /dev/null +++ b/bin/generate_tro_graph.py @@ -0,0 +1,325 @@ +# -*- coding: utf-8 -*- +"""Extrahiert den TRO-Topologie-Graphen aller 5 UH-Steuerungen aus FB_Main.scl +und erzeugt eine Graphviz-DOT-Datei. + +Prinzip: Jeder TRO-Baustein bekommt JamArea-Slots als Parameter +(arInOutJamEntr*, arInOutJamExit*, arInOutJamBypass, arInOutJamFinger). +Zwei TROs sind verbunden, wenn der Exit-Slot des einen dieselbe JamArea +referenziert wie der Entry-Slot des anderen. + +Aufruf: + python bin/generate_tro_graph.py [ausgabe.dot] + +Ohne Argument wird nach doc/TRO_Graph_UH01-UH05.dot geschrieben. +Zum Rendern als SVG anschliessend: + dot -Tsvg doc/TRO_Graph_UH01-UH05.dot -o doc/TRO_Graph_UH01-UH05.svg +""" +import re +import sys +from collections import defaultdict +from pathlib import Path + +REPO = Path(__file__).resolve().parent.parent +UHS = ["UH01", "UH02", "UH03", "UH04", "UH05"] + +decl_re = re.compile(r'^\s*(\w+)\s*(?:\{[^}]*\})?\s*:\s*"([\w.]+)"\s*;') +jamparam_re = re.compile( + r'arInOut(Jam\w+|StorageLines|CarrierStopper|CarrierExit)' + r'\s*:=\s*"([^"]+)"\.(\w+)') +call_start_re = re.compile(r'#(\w+)\s*\(') +region_re = re.compile(r'^\s*REGION\b\s*(.*)$') +endregion_re = re.compile(r'^\s*END_REGION') + + +def parse_uh(uh): + path = REPO / f"=A01+{uh}-KF00" / "Programmbausteine" / "100_Main" / "FB_Main.scl" + text = path.read_text(encoding="utf-8-sig") + text = re.sub(r'\(\*.*?\*\)', '', text, flags=re.S) # Blockkommentare + lines = [re.sub(r'//.*$', '', ln) for ln in text.splitlines()] + + # 1) Instanz-Deklarationen -> FB-Typ + types = {} + for ln in lines: + m = decl_re.match(ln) + if m: + types[m.group(1)] = m.group(2) + + # 2) Aufrufe finden inkl. REGION-Kontext + nodes = {} # inst -> dict(type, region, jams=[(role, jamref)]) + region_stack = [] + i = 0 + while i < len(lines): + ln = lines[i] + if endregion_re.match(ln): + if region_stack: + region_stack.pop() + i += 1 + continue + m = region_re.match(ln) + if m and "END_REGION" not in ln.split("REGION")[0]: + region_stack.append(m.group(1).strip()) + i += 1 + continue + m = call_start_re.search(ln) + if m and types.get(m.group(1)): + inst = m.group(1) + # Parameterblock bis zur schliessenden Klammer einsammeln + buf = ln[m.end() - 1:] + depth = 0 + j = i + done = False + while j < len(lines) and not done: + seg = lines[j] if j > i else buf + for ch in seg: + if ch == "(": + depth += 1 + elif ch == ")": + depth -= 1 + if depth == 0: + done = True + break + j += 1 + block = "\n".join([buf] + lines[i + 1:j]) + jams = [] + for jm in jamparam_re.finditer(block): + role, db, member = jm.group(1), jm.group(2), jm.group(3) + jams.append((role, f"{db}.{member}")) + if jams: + # aussagekraeftigste REGION waehlen (generische wie "CALL", + # "TRO 101 CALL", "Enable und RequestRun" ueberspringen) + region = "" + for r in reversed(region_stack): + if not re.match(r'^(.*\bCALL\b.*|Enable und RequestRun)$', + r, re.I): + region = r + break + node = nodes.setdefault(inst, { + "type": types[inst], + "region": region, + "jams": []}) + for j2 in jams: + if j2 not in node["jams"]: + node["jams"].append(j2) + i = j + continue + i += 1 + return nodes + + +def role_dir(role): + if role.startswith("JamEntr") or role in ("StorageLines", + "CarrierStopper"): + return "in" + if (role.startswith(("JamExit", "JamBypass", "JamFinger")) + or role == "CarrierExit"): + return "out" + return "?" + + +def short_jam(jamref): + # DB_JamArea0101.stJam0101_1 -> JA0101_1 + m = re.match(r"DB_JamArea(\w+)\.stJam\w+_(\w+)", jamref) + if m: + return f"JA{m.group(1)}_{m.group(2)}" + return jamref.replace("DB_", "").replace(".arLine", "") + + +def main(): + all_nodes = {} + report = [] + for uh in UHS: + nodes = parse_uh(uh) + all_nodes[uh] = nodes + report.append(f"{uh}: {len(nodes)} TRO-Knoten") + + # Kanten je UH ueber gemeinsame JamAreas + edges = defaultdict(list) # uh -> [(from, to, jam, tag)] + externals = defaultdict(list) # uh -> [(node, dir, jam, role)] + for uh, nodes in all_nodes.items(): + jam_users = defaultdict(lambda: {"in": [], "out": []}) + for inst, nd in nodes.items(): + for role, jam in nd["jams"]: + d = role_dir(role) + if d in ("in", "out"): + jam_users[jam][d].append((inst, role)) + for jam, users in sorted(jam_users.items()): + for (src, srole) in users["out"]: + tag = {"JamExit3": "Dir2", "JamExit4": "Dir3", + "JamBypass": "Bypass", "JamFinger": "Finger" + }.get(srole, "") + if users["in"]: + for (dst, drole) in users["in"]: + if dst != src: + edges[uh].append((src, dst, jam, tag)) + else: + externals[uh].append((src, "out", jam, srole)) + for (dst, drole) in users["in"]: + if not users["out"]: + externals[uh].append((dst, "in", jam, drole)) + + for uh in UHS: + report.append(f"{uh}: {len(edges[uh])} Kanten, " + f"{len(externals[uh])} offene Enden") + print("\n".join(report)) + + # Knoten ohne jede Kante? + for uh, nodes in all_nodes.items(): + connected = set() + for (s, d, _, _) in edges[uh]: + connected.add(s) + connected.add(d) + for (n, _, _, _) in externals[uh]: + connected.add(n) + iso = set(nodes) - connected + if iso: + print(f"{uh} isoliert: {sorted(iso)}") + + write_dot(all_nodes, edges, externals) + + +COLORS = { + "FB_ILS_MTRO_1Sep": ("#d4e8ff", "box"), + "FB_ILS_MTRO_1Sep_SSCC": ("#ffd4d4", "box"), + "FB_ILS_MTRO_1Sep1Swi": ("#ffe4a0", "diamond"), + "FB_ILS_MTRO_1Sep2Swi": ("#ffc060", "diamond"), + "FB_ILS_MTRO_2Sep1Swi": ("#ffe4a0", "diamond"), + "FB_ILS_MTRO_Vario": ("#e8d4f0", "parallelogram"), + "FB_ILS_MTRO_Vario_workStation": ("#c0f0f0", "parallelogram"), + "FB_EmptyCarrBuffer": ("#d4f0d4", "box3d"), +} + + +def node_style(fbtype): + for k in sorted(COLORS, key=len, reverse=True): + if fbtype.startswith(k): + return COLORS[k] + return ("#f0f0f0", "box") + + +def esc(s): + return s.replace("\\", "\\\\").replace('"', '\\"') + + +HEADER = '''\ +// ============================================================================ +// TRO-Topologie-Graph der Gesamtanlage HundM_Fortna (UH01 - UH05) +// ============================================================================ +// +// Format: Graphviz DOT (https://graphviz.org) +// Rendern z.B. mit: dot -Tsvg TRO_Graph_UH01-UH05.dot -o graph.svg +// oder online: https://dreampuf.github.io/GraphvizOnline +// +// Quelle: Automatisch extrahiert aus den FB_Main.scl der 5 Steuerungen +// (=A01+UH01-KF00 ... =A01+UH05-KF00, Ordner 100_Main). +// Erzeugt von bin/generate_tro_graph.py. +// +// Methode: Jeder TRO-Baustein (FB_ILS_MTRO_*, FB_EmptyCarrBuffer, +// FB_LoadingBoom_INBOUND) referenziert JamAreas als Parameter: +// arInOutJamEntr* / arInOutStorageLines / arInOutCarrierStopper = Eingang +// arInOutJamExit* / arInOutJamBypass / arInOutJamFinger / +// arInOutCarrierExit = Ausgang +// Zwei TROs sind verbunden, wenn der Ausgangs-Slot des einen +// dieselbe JamArea referenziert wie der Eingangs-Slot des anderen. +// Auskommentierter Code wurde ignoriert. +// +// Knoten: Ein Knoten je TRO-Instanz, Label: Name, [FB-Typ], REGION-Kommentar +// aus FB_Main. Farbe/Form nach FB-Typ: +// hellblau/Box = 1Sep (Standard-Separator) +// rot/Box = 1Sep_SSCC (SSCC-Scanner + WCS-Telegramm) +// gelb/Raute = 1Sep1Swi, 1Sep2Swi, 2Sep1Swi (Weichen) +// violett/Parallelogr.= Vario (Kettenfoerderer) +// tuerkis/Parallelogr.= Vario_workStation (manueller Arbeitsplatz) +// gruen/3D-Box = EmptyCarrBuffer (Leertablar-Puffer) +// grau = Sonstige (z.B. LoadingBoom, PinStore) +// +// Kanten: Label = JamArea-Slot (JAxxxx_y = "DB_JamAreaxxxx".stJamxxxx_y). +// Zusatz "Dir2"/"Dir3" = Weichen-Ausgang (arInOutJamExit3/4), +// Richtungsentscheidung kommt aus FC_Direction. +// Gestrichelt "Bypass" = Bypass-Spur (PinStore), +// gestrichelt "Finger" = Finger-Uebergabe eines Vario-Foerderers. +// +// EXTERN: Graue Kanten zu EXTERN-Knoten = JamAreas, die nur auf einer +// Seite belegt sind (Anlagengrenze, Uebergabe an WES/WCS, AMR +// oder andere SPS). CPU-CPU-Uebergaben zwischen den Steuerungen +// sind an den Labels "IO_Device_UHxx_TO_UHyy..." erkennbar +// (PROFINET-Direktkopplung, kein gemeinsamer JamArea-DB). +// +// Hinweis: Kanten existieren nur innerhalb einer Steuerung, da JamArea-DBs +// nicht SPS-uebergreifend geteilt werden. Der physische Fluss +// zwischen den UHs laeuft ueber die EXTERN-Uebergaben. +// +''' + + +def write_dot(all_nodes, edges, externals): + body = [] + B = body.append + B(HEADER.rstrip()) + total_n = sum(len(v) for v in all_nodes.values()) + total_e = sum(len(set(v)) for v in edges.values()) + B(f"// Umfang: {total_n} TRO-Knoten, {total_e} Verbindungen " + f"(Stand der Extraktion siehe Git-Historie)") + for uh in UHS: + B(f"// {uh}: {len(all_nodes[uh])} TROs, " + f"{len(set(edges[uh]))} Verbindungen") + B("") + B("digraph TRO_Topologie {") + B(' rankdir = "LR";') + B(' fontname = "Arial";') + B(' node [fontname="Arial", fontsize=10];') + B(' edge [fontname="Arial", fontsize=8];') + B(' label = "TRO-Topologie HundM_Fortna (UH01-UH05)";') + B(' labelloc = "t";') + B("") + for uh in UHS: + nodes = all_nodes[uh] + B(f' subgraph "cluster_{uh}" {{') + B(f' label = "{uh} (=A01+{uh}-KF00)";') + B(' style = "rounded";') + B(' color = "#888888";') + for inst in sorted(nodes): + nd = nodes[inst] + color, shape = node_style(nd["type"]) + t = nd["type"].replace("FB_ILS_MTRO_", "").replace("FB_", "") + reg = esc(nd["region"]) + B(f' "{uh}.{inst}" [label="{inst}\\n[{t}]\\n{reg}", ' + f'shape={shape}, style=filled, fillcolor="{color}"];') + # Externe Enden als ein Sammel-Knoten je Richtung + ext = externals[uh] + if any(d == "in" for (_, d, _, _) in ext): + B(f' "{uh}.EXTERN_IN" [label="EXTERN\\n(Zulauf)", ' + f'shape=ellipse, style="filled,dashed", fillcolor="#f8f8f8"];') + if any(d == "out" for (_, d, _, _) in ext): + B(f' "{uh}.EXTERN_OUT" [label="EXTERN\\n(Ablauf)", ' + f'shape=ellipse, style="filled,dashed", fillcolor="#f8f8f8"];') + seen = set() + for (s, d, jam, tag) in edges[uh]: + key = (s, d, jam, tag) + if key in seen: + continue + seen.add(key) + lbl = short_jam(jam) + (f" {tag}" if tag else "") + style = ', style=dashed' if tag in ("Bypass", "Finger") else "" + B(f' "{uh}.{s}" -> "{uh}.{d}" [label="{lbl}"{style}];') + seen = set() + for (n, d, jam, role) in ext: + key = (n, d, jam) + if key in seen: + continue + seen.add(key) + if d == "in": + B(f' "{uh}.EXTERN_IN" -> "{uh}.{n}" ' + f'[label="{short_jam(jam)}", color="#999999"];') + else: + B(f' "{uh}.{n}" -> "{uh}.EXTERN_OUT" ' + f'[label="{short_jam(jam)}", color="#999999"];') + B(" }") + B("") + B("}") + dest = Path(sys.argv[1]) if len(sys.argv) > 1 else REPO / "doc" / "TRO_Graph_UH01-UH05.dot" + dest.write_text("\n".join(body) + "\n", encoding="utf-8", newline="\n") + print("DOT geschrieben:", dest) + + +if __name__ == "__main__": + main() diff --git a/doc/TRO_Graph_UH01-UH05.dot b/doc/TRO_Graph_UH01-UH05.dot index d188e1c..dea7585 100644 --- a/doc/TRO_Graph_UH01-UH05.dot +++ b/doc/TRO_Graph_UH01-UH05.dot @@ -8,6 +8,7 @@ // // Quelle: Automatisch extrahiert aus den FB_Main.scl der 5 Steuerungen // (=A01+UH01-KF00 ... =A01+UH05-KF00, Ordner 100_Main). +// Erzeugt von bin/generate_tro_graph.py. // // Methode: Jeder TRO-Baustein (FB_ILS_MTRO_*, FB_EmptyCarrBuffer, // FB_LoadingBoom_INBOUND) referenziert JamAreas als Parameter: diff --git a/doc/TRO_Graph_UH01-UH05.svg b/doc/TRO_Graph_UH01-UH05.svg new file mode 100644 index 0000000..68fbb0f --- /dev/null +++ b/doc/TRO_Graph_UH01-UH05.svg @@ -0,0 +1,4579 @@ + + + + + + +TRO_Topologie + +TRO-Topologie HundM_Fortna (UH01-UH05) + +cluster_UH01 + +UH01  (=A01+UH01-KF00) + + +cluster_UH02 + +UH02  (=A01+UH02-KF00) + + +cluster_UH03 + +UH03  (=A01+UH03-KF00) + + +cluster_UH04 + +UH04  (=A01+UH04-KF00) + + +cluster_UH05 + +UH05  (=A01+UH05-KF00) + + + +UH01.TRO100 + +TRO100 +[1Sep] +TRO 100 (1Sep) + + + +UH01.TRO101_IN + +TRO101_IN +[1Sep] +TRO 101_IN(1Sep) + + + +UH01.TRO100->UH01.TRO101_IN + + +JA0101_1 + + + +UH01.TRO101 + + + + +TRO101 +[EmptyCarrBuffer] +TRO101 (Empty Buffer rechts) + + + +UH01.TRO112 + +TRO112 +[1Sep1Swi] +TRO 112 (1Sep1Swi) + + + +UH01.TRO101->UH01.TRO112 + + +JA0102_2 + + + +UH01.TRO101_IN->UH01.TRO101 + + +JamBuffer101 + + + +UH01.TRO102_IN + +TRO102_IN +[1Sep] +TRO 102_IN(1Sep) + + + +UH01.TRO101_IN->UH01.TRO102_IN + + +JA0101_2 + + + +UH01.TRO102 + + + + +TRO102 +[EmptyCarrBuffer] +TRO102 (Empty Buffer links) + + + +UH01.TRO107 + +TRO107 +[1Sep1Swi] +TRO 107(1Sep1Swi) + + + +UH01.TRO102->UH01.TRO107 + + +JA0102_1 + + + +UH01.TRO102_IN->UH01.TRO102 + + +JamBuffer102 + + + +UH01.TRO103 + +TRO103 +[1Sep] +TRO 103 (1Sep) + + + +UH01.TRO104 + +TRO104 +[1Sep] +TRO 104 (1Sep)+Scanner + + + +UH01.TRO103->UH01.TRO104 + + +JA0104_1 + + + +UH01.fbLoadingBoom1 + +fbLoadingBoom1 +[LoadingBoom_INBOUND] +LoadingBoom 1 + + + +UH01.TRO104->UH01.fbLoadingBoom1 + + +JA0104_2 + + + +UH01.TRO105 + +TRO105 +[1Sep_SSCC] +TRO 105 (1Sep)+Scanner + + + +UH01.TRO106 + +TRO106 +[1Sep] +TRO 106 (1Sep) + + + +UH01.TRO105->UH01.TRO106 + + +JA0106_2 + + + +UH01.TRO106->UH01.TRO112 + + +JA0102_2 + + + +UH01.TRO107->UH01.TRO103 + + +JA0103_1 + + + +UH01.TRO107->UH01.TRO112 + + +JA0102_2 Dir2 + + + +UH01.TRO108 + +TRO108 +[1Sep] +TRO 108 (1Sep) + + + +UH01.TRO109 + +TRO109 +[1Sep] +TRO 109 (1Sep)+Scanner + + + +UH01.TRO108->UH01.TRO109 + + +JA0108_1 + + + +UH01.fbLoadingBoom2 + +fbLoadingBoom2 +[LoadingBoom_INBOUND] +LoadingBoom 2 + + + +UH01.TRO109->UH01.fbLoadingBoom2 + + +JA0108_2 + + + +UH01.TRO110 + +TRO110 +[1Sep_SSCC] +TRO 110 (1Sep)+Scanner + + + +UH01.TRO111 + +TRO111 +[1Sep] +TRO 111 (1Sep) + + + +UH01.TRO110->UH01.TRO111 + + +JA0110_2 + + + +UH01.TRO113 + +TRO113 +[1Sep] +TRO 113 (1Sep)+Scanner + + + +UH01.TRO111->UH01.TRO113 + + +JA0102_3 + + + +UH01.TRO112->UH01.TRO108 + + +JA0107_1 + + + +UH01.TRO112->UH01.TRO113 + + +JA0102_3 Dir2 + + + +UH01.TRO114 + +TRO114 +[1Sep1Swi] +TRO 114 (1Sep1Switch)+Scanner + + + +UH01.TRO113->UH01.TRO114 + + +JA0102_4 + + + +UH01.TRO116 + +TRO116 +[1Sep] +TRO 116 (1Sep) + + + +UH01.TRO114->UH01.TRO116 + + +JA0102_5 Dir2 + + + +UH01.TRO115 + +TRO115 +[Vario] +TRO 115 (Vario) + + + +UH01.TRO120 + +TRO120 +[Vario] +TRO 120 (Vario) + + + +UH01.TRO115->UH01.TRO120 + + +JA4103_1 Finger + + + +UH01.TRO117 + +TRO117 +[1Sep] +TRO 117 (1Sep) + Scanner + + + +UH01.TRO116->UH01.TRO117 + + +JA0102_6 + + + +UH01.TRO117->UH01.TRO107 + + +JA0102_1 + + + +UH01.TRO121 + +TRO121 +[Vario] +TRO 121(Vario) + + + +UH01.TRO122 + +TRO122 +[1Sep] +TRO 122 (1Sep) + + + +UH01.TRO121->UH01.TRO122 + + +JA4503_2 Finger + + + +UH01.TRO123 + +TRO123 +[Vario] +TRO 123 (Vario) + + + +UH01.TRO122->UH01.TRO123 + + +JA4502_1 + + + +UH01.TRO124 + +TRO124 +[1Sep1Swi] +TRO 124 (1Sep1Switch) + + + +UH01.TRO123->UH01.TRO124 + + +JA4502_2 Finger + + + +UH01.TRO125 + +TRO125 +[1Sep] +TRO 125 (1Sep) + + + +UH01.TRO124->UH01.TRO125 + + +JA4204_2 + + + +UH01.TRO127 + +TRO127 +[Vario] +TRO 127 (Vario) + + + +UH01.TRO124->UH01.TRO127 + + +JA4501_1 Dir2 + + + +UH01.TRO126 + +TRO126 +[Vario] +TRO 126 (Vario) + + + +UH01.TRO125->UH01.TRO126 + + +JA4203_1 + + + +UH01.TRO128 + +TRO128 +[Vario] +TRO 128 (Vario) + + + +UH01.TRO127->UH01.TRO128 + + +JA4501_2 Finger + + + +UH01.TRO128->UH01.TRO100 + + +JA0100_1 Finger + + + +UH01.TRO129 + +TRO129 +[1Sep] +TRO 129 (1Sep) + + + +UH01.TRO130 + +TRO130 +[1Sep] +TRO 130 (1Sep) + + + +UH01.TRO129->UH01.TRO130 + + +JA4204_1 + + + +UH01.TRO130->UH01.TRO127 + + +JA4501_1 + + + +UH01.TRO131 + +TRO131 +[Vario] +TRO 131 (Vario) + + + +UH01.TRO133 + +TRO133 +[Vario] +TRO 133 (Vario) + + + +UH01.TRO133->UH01.TRO129 + + +JA4302_2 Finger + + + +UH01.TRO134 + +TRO134 +[Vario] +TRO 134 (Vario) + + + +UH01.TRO134->UH01.TRO131 + + +JA4403_1 Finger + + + +UH01.fbLoadingBoom1->UH01.TRO105 + + +JA0104_3 + + + +UH01.fbLoadingBoom2->UH01.TRO110 + + +JA0108_3 + + + +UH01.EXTERN_IN + +EXTERN +(Zulauf) + + + +UH01.EXTERN_IN->UH01.TRO115 + + +JA4104_1 + + + +UH01.EXTERN_IN->UH01.TRO121 + + +JA4503_1 + + + +UH01.EXTERN_IN->UH01.TRO133 + + +JA4302_1 + + + +UH01.EXTERN_IN->UH01.TRO134 + + +JA4402_1 + + + +UH02.TRO200 + +TRO200 +[Vario] +TRO 200 (Vario) + + + +UH02.TRO201 + +TRO201 +[1Sep] +TRO 201 (1Sep) + + + +UH02.TRO200->UH02.TRO201 + + +JA1109_2 Finger + + + +UH02.TRO202 + +TRO202 +[1Sep1Swi] +TRO 202 (1Sep1Switch)+Scanner(BX2103) + + + +UH02.TRO201->UH02.TRO202 + + +JA1102_1 + + + +UH02.TRO211 + +TRO211 +[PinStore_Auto] +Aufruf: TRO211 + + + +UH02.TRO202->UH02.TRO211 + + +JA1101_1 Dir2 + + + +UH02.TRO214 + +TRO214 +[PinStore_Auto] +Aufruf: TRO214 + + + +UH02.TRO202->UH02.TRO214 + + +JA1102_2 + + + +UH02.TRO203 + +TRO203 +[1Sep1Swi] +TRO 203 (1Sep1Switch) + Scanner (BX2111) + + + +UH02.TRO204 + +TRO204 +[1Sep1Swi] +TRO 204(1Sep1Switch) + Scanner(BX2112) + + + +UH02.TRO203->UH02.TRO204 + + +JA1103_2 Dir2 + + + +UH02.TRO209 + +TRO209 +[Vario] +TRO 209 (Vario) + + + +UH02.TRO203->UH02.TRO209 + + +JA1105_1 + + + +UH02.TRO207 + +TRO207 +[1Sep] +TRO 207(1Sep) + + + +UH02.TRO204->UH02.TRO207 + + +JA1104_3 Dir2 + + + +UH02.TRO212 + +TRO212 +[Vario] +TRO 212 (Vario) + + + +UH02.TRO204->UH02.TRO212 + + +JA1106_1 + + + +UH02.TRO205 + +TRO205 +[1Sep1Swi] +TRO 205 (1Sep1Switch) + Scanner(BX2114) + + + +UH02.TRO206 + +TRO206 +[1Sep1Swi] +TRO 206 (1Sep1Switch)+Scanner(BX2113) + + + +UH02.TRO205->UH02.TRO206 + + +JA1104_2 + + + +UH02.TRO218 + +TRO218 +[Vario] +TRO 218 (Vario) + + + +UH02.TRO205->UH02.TRO218 + + +JA1108_1 Dir2 + + + +UH02.TRO206->UH02.TRO207 + + +JA1104_3 + + + +UH02.TRO215 + +TRO215 +[Vario] +TRO 215 (Vario) + + + +UH02.TRO206->UH02.TRO215 + + +JA1107_1 Dir2 + + + +UH02.EXTERN_OUT + +EXTERN +(Ablauf) + + + +UH02.TRO207->UH02.EXTERN_OUT + + +IO_Device_UH02_TO_UH01.stCARRIER_INFO + + + +UH02.TRO208 + +TRO208 +[PinStore_Auto] +Aufruf: TRO208 + + + +UH02.TRO208->UH02.TRO203 + + +JA1103_1 + + + +UH02.TRO210 + +TRO210 +[1Sep] +TRO 210 (1Sep) + + + +UH02.TRO209->UH02.TRO210 + + +JA1105_2 Finger + + + +UH02.TRO210->UH02.TRO208 + + +JA1101_2 + + + +UH02.TRO211->UH02.TRO204 + + +JA1103_2 + + + +UH02.TRO211->UH02.TRO208 + + +JA1101_2 Bypass + + + +UH02.TRO213 + +TRO213 +[1Sep] +TRO 213 (1Sep) + + + +UH02.TRO212->UH02.TRO213 + + +JA1106_2 Finger + + + +UH02.TRO213->UH02.TRO211 + + +JA1101_1 + + + +UH02.TRO214->UH02.TRO206 + + +JA1104_2 + + + +UH02.TRO217 + +TRO217 +[PinStore_Auto] +Aufruf: TRO217 + + + +UH02.TRO214->UH02.TRO217 + + +JA1102_3 Bypass + + + +UH02.TRO216 + +TRO216 +[1Sep] +TRO 216 (1Sep) + + + +UH02.TRO215->UH02.TRO216 + + +JA1107_2 Finger + + + +UH02.TRO216->UH02.TRO214 + + +JA1102_2 + + + +UH02.TRO217->UH02.TRO205 + + +JA1104_1 + + + +UH02.TRO219 + +TRO219 +[1Sep] +TRO 219(1Sep) + + + +UH02.TRO218->UH02.TRO219 + + +JA1108_2 Finger + + + +UH02.TRO219->UH02.TRO217 + + +JA1102_3 + + + +UH02.TRO220 + +TRO220 +[Vario] +TRO 220 (Vario) + + + +UH02.TRO221 + +TRO221 +[1Sep] +TRO 221 (1Sep) + + + +UH02.TRO220->UH02.TRO221 + + +JA1209_2 Finger + + + +UH02.TRO222 + +TRO222 +[1Sep1Swi] +TRO 222 (1Sep1Switch)+Scanner(BX2121) + + + +UH02.TRO221->UH02.TRO222 + + +JA1202_1 + + + +UH02.TRO231 + +TRO231 +[PinStore_Auto] +Aufruf: TRO231 + + + +UH02.TRO222->UH02.TRO231 + + +JA1201_1 Dir2 + + + +UH02.TRO234 + +TRO234 +[PinStore_Auto] +Aufruf: TRO234 + + + +UH02.TRO222->UH02.TRO234 + + +JA1202_2 + + + +UH02.TRO223 + +TRO223 +[1Sep1Swi] +TRO 223 (1Sep1Switch)+Scanner(BX2126) + + + +UH02.TRO224 + +TRO224 +[1Sep1Swi] +TRO 224 (1Sep1Switch)+Scanner(BX2127) + + + +UH02.TRO223->UH02.TRO224 + + +JA1203_2 Dir2 + + + +UH02.TRO229 + +TRO229 +[Vario] +TRO 229 (Vario) + + + +UH02.TRO223->UH02.TRO229 + + +JA1205_1 + + + +UH02.TRO227 + +TRO227 +[1Sep] +TRO 227 (1Sep) + + + +UH02.TRO224->UH02.TRO227 + + +JA1204_3 Dir2 + + + +UH02.TRO232 + +TRO232 +[Vario] +TRO 232 (Vario) + + + +UH02.TRO224->UH02.TRO232 + + +JA1206_1 + + + +UH02.TRO225 + +TRO225 +[1Sep1Swi] +TRO 225(1Sep1Switch)+Scanner(BX2129) + + + +UH02.TRO226 + +TRO226 +[1Sep1Swi] +TRO 226 (1Sep1Switch)+Scanner(BX2128) + + + +UH02.TRO225->UH02.TRO226 + + +JA1204_2 + + + +UH02.TRO238 + +TRO238 +[Vario] +TRO 238 (Vario) + + + +UH02.TRO225->UH02.TRO238 + + +JA1208_1 Dir2 + + + +UH02.TRO226->UH02.TRO227 + + +JA1204_3 + + + +UH02.TRO235 + +TRO235 +[Vario] +TRO 235 (Vario) + + + +UH02.TRO226->UH02.TRO235 + + +JA1207_1 Dir2 + + + +UH02.TRO227->UH02.EXTERN_OUT + + +IO_Device_UH02_TO_UH01.stCARRIER_INFO_1 + + + +UH02.TRO228 + +TRO228 +[PinStore_Auto] +Aufruf: TRO228 + + + +UH02.TRO228->UH02.TRO223 + + +JA1203_1 + + + +UH02.TRO230 + +TRO230 +[1Sep] +TRO 230 (1Sep) + + + +UH02.TRO229->UH02.TRO230 + + +JA1205_2 Finger + + + +UH02.TRO230->UH02.TRO228 + + +JA1201_2 + + + +UH02.TRO231->UH02.TRO224 + + +JA1203_2 + + + +UH02.TRO231->UH02.TRO228 + + +JA1201_2 Bypass + + + +UH02.TRO233 + +TRO233 +[1Sep] +TRO 233 (1Sep) + + + +UH02.TRO232->UH02.TRO233 + + +JA1206_2 Finger + + + +UH02.TRO233->UH02.TRO231 + + +JA1201_1 + + + +UH02.TRO234->UH02.TRO226 + + +JA1204_2 + + + +UH02.TRO237 + +TRO237 +[PinStore_Auto] +Aufruf: TRO237 + + + +UH02.TRO234->UH02.TRO237 + + +JA1202_3 Bypass + + + +UH02.TRO236 + +TRO236 +[1Sep] +TRO 236 (1Sep) + + + +UH02.TRO235->UH02.TRO236 + + +JA1207_2 Finger + + + +UH02.TRO236->UH02.TRO234 + + +JA1202_2 + + + +UH02.TRO237->UH02.TRO225 + + +JA1204_1 + + + +UH02.TRO239 + +TRO239 +[1Sep] +TRO 239 (1Sep) + + + +UH02.TRO238->UH02.TRO239 + + +JA1208_2 Finger + + + +UH02.TRO239->UH02.TRO237 + + +JA1202_3 + + + +UH02.TRO240 + +TRO240 +[Vario] +TRO 240 (Vario) + + + +UH02.TRO241 + +TRO241 +[1Sep] +TRO 241(1Sep) + + + +UH02.TRO240->UH02.TRO241 + + +JA1309_2 Finger + + + +UH02.TRO242 + +TRO242 +[1Sep1Swi] +TRO 242 (1Sep1Switch)+Scanner(BX2130) + + + +UH02.TRO241->UH02.TRO242 + + +JA1304_1 + + + +UH02.TRO251 + +TRO251 +[PinStore_Auto] +Aufruf: TRO251 + + + +UH02.TRO242->UH02.TRO251 + + +JA1303_1 + + + +UH02.TRO254 + +TRO254 +[PinStore_Auto] +Aufruf: TRO254 + + + +UH02.TRO242->UH02.TRO254 + + +JA1304_2 Dir2 + + + +UH02.TRO243 + +TRO243 +[1Sep1Swi] +TRO 243 (1Sep1Switch)+Scanner(BX3137) + + + +UH02.TRO244 + +TRO244 +[1Sep1Swi] +TRO 244 (1Sep1Switch)+Scanner(BX2136) + + + +UH02.TRO243->UH02.TRO244 + + +JA1301_2 + + + +UH02.TRO249 + +TRO249 +[Vario] +TRO 249 (Vario) + + + +UH02.TRO243->UH02.TRO249 + + +JA1305_1 Dir2 + + + +UH02.TRO252 + +TRO252 +[Vario] +TRO 252 (Vario) + + + +UH02.TRO244->UH02.TRO252 + + +JA1306_1 Dir2 + + + +UH02.TRO244->UH02.EXTERN_OUT + + +JA1302_3 + + + +UH02.TRO245 + +TRO245 +[1Sep1Swi] +TRO 245 (1Sep1Switch)+Scanner(BX2138) + + + +UH02.TRO246 + +TRO246 +[1Sep1Swi] +TRO 246 (1Sep1Switch)+Scanner(BX2137) + + + +UH02.TRO245->UH02.TRO246 + + +JA1302_2 Dir2 + + + +UH02.TRO258 + +TRO258 +[Vario] +TRO 258 (Vario) + + + +UH02.TRO245->UH02.TRO258 + + +JA1308_1 + + + +UH02.TRO255 + +TRO255 +[Vario] +TRO 255 (Vario) + + + +UH02.TRO246->UH02.TRO255 + + +JA1307_1 + + + +UH02.TRO246->UH02.EXTERN_OUT + + +JA1302_3 + + + +UH02.TRO247 + +TRO247 +[1Sep] +TRO 247(1Sep) + + + +UH02.TRO247->UH02.EXTERN_OUT + + +IO_Device_UH02_TO_UH01.stCARRIER_INFO_2 + + + +UH02.TRO248 + +TRO248 +[PinStore_Auto] +Aufruf: TRO248 + + + +UH02.TRO248->UH02.TRO243 + + +JA1301_1 + + + +UH02.TRO250 + +TRO250 +[1Sep] +TRO 250 (1Sep) + + + +UH02.TRO249->UH02.TRO250 + + +JA1305_2 Finger + + + +UH02.TRO250->UH02.TRO248 + + +JA1303_2 + + + +UH02.TRO251->UH02.TRO244 + + +JA1301_2 + + + +UH02.TRO251->UH02.TRO248 + + +JA1303_2 Bypass + + + +UH02.TRO253 + +TRO253 +[1Sep] +TRO 253 (1Sep) + + + +UH02.TRO252->UH02.TRO253 + + +JA1306_2 Finger + + + +UH02.TRO253->UH02.TRO251 + + +JA1303_1 + + + +UH02.TRO254->UH02.TRO246 + + +JA1302_2 + + + +UH02.TRO257 + +TRO257 +[PinStore_Auto] +Aufruf: TRO257 + + + +UH02.TRO254->UH02.TRO257 + + +JA1304_3 Bypass + + + +UH02.TRO256 + +TRO256 +[1Sep] +TRO 256 (1Sep) + + + +UH02.TRO255->UH02.TRO256 + + +JA1307_2 Finger + + + +UH02.TRO256->UH02.TRO254 + + +JA1304_2 + + + +UH02.TRO257->UH02.TRO245 + + +JA1302_1 + + + +UH02.TRO259 + +TRO259 +[1Sep] +TRO 259 (1Sep) + + + +UH02.TRO258->UH02.TRO259 + + +JA1308_2 Finger + + + +UH02.TRO259->UH02.TRO257 + + +JA1304_3 + + + +UH02.TRO260 + +TRO260 +[Vario] +TRO 260 (Vario) + Scanner (BX2115) + + + +UH02.TRO261 + +TRO261 +[1Sep] +TRO 261 (1Sep) + + + +UH02.TRO260->UH02.TRO261 + + +JA1601_2 Finger + + + +UH02.TRO274 + +TRO274 +[1Sep] +TRO 274 (1Sep) + + + +UH02.TRO261->UH02.TRO274 + + +JA1110_2 + + + +UH02.TRO262 + +TRO262 +[Vario] +TRO 262 (Vario) + Scanner (BX2109) + + + +UH02.TRO263 + +TRO263 +[1Sep] +TRO 263 (1Sep) + + + +UH02.TRO262->UH02.TRO263 + + +JA1501_2 Finger + + + +UH02.TRO266 + +TRO266 +[1Sep] +TRO 266(1Sep) + + + +UH02.TRO263->UH02.TRO266 + + +JA1110_3 + + + +UH02.TRO264 + +TRO264 +[Vario] +TRO 264 (Vario) + Scanner (BX2108) + + + +UH02.TRO265 + +TRO265 +[1Sep] +TRO 265 (1Sep) + + + +UH02.TRO264->UH02.TRO265 + + +JA1401_2 Finger + + + +UH02.TRO267 + +TRO267 +[1Sep2Swi] +TRO 267 (1Sep2Switch)+Scanner(BX2100) + + + +UH02.TRO265->UH02.TRO267 + + +JA1110_4 + + + +UH02.TRO266->UH02.TRO267 + + +JA1110_4 + + + +UH02.TRO275 + +TRO275 +[1Sep] +TRO 275 (1Sep) + + + +UH02.TRO267->UH02.TRO275 + + +JA1110_5 Dir3 + + + +UH02.TRO268 + +TRO268 +[1Sep2Swi] +TRO 268 (1Sep2Switch)+Scanner(BX2101) + + + +UH02.TRO269 + +TRO269 +[1Sep] +TRO 269 (1Sep)+Scanner (BX2102) + + + +UH02.TRO268->UH02.TRO269 + + +JA1110_1 Dir3 + + + +UH02.TRO269->UH02.TRO274 + + +JA1110_2 + + + +UH02.TRO270 + +TRO270 +[Vario] +TRO 270 (Vario) + + + +UH02.TRO272 + +TRO272 +[Vario] +TRO 272 (Vario) + + + +UH02.TRO274->UH02.TRO266 + + +JA1110_3 + + + +UH02.TRO275->UH02.TRO268 + + +JA1110_6 + + + +UH02.EXTERN_IN + +EXTERN +(Zulauf) + + + +UH02.EXTERN_IN->UH02.TRO200 + + +JA1109_1 + + + +UH02.EXTERN_IN->UH02.TRO208 + + +Storage1.1.1 + + + +UH02.EXTERN_IN->UH02.TRO211 + + +Storage1.1.2 + + + +UH02.EXTERN_IN->UH02.TRO214 + + +Storage1.1.3 + + + +UH02.EXTERN_IN->UH02.TRO217 + + +Storage1.1.4 + + + +UH02.EXTERN_IN->UH02.TRO220 + + +JA1209_1 + + + +UH02.EXTERN_IN->UH02.TRO228 + + +Storage1.2.1 + + + +UH02.EXTERN_IN->UH02.TRO231 + + +Storage1.2.2 + + + +UH02.EXTERN_IN->UH02.TRO234 + + +Storage1.2.3 + + + +UH02.EXTERN_IN->UH02.TRO237 + + +Storage1.2.4 + + + +UH02.EXTERN_IN->UH02.TRO240 + + +JA1309_1 + + + +UH02.EXTERN_IN->UH02.TRO248 + + +Storage1.3.1 + + + +UH02.EXTERN_IN->UH02.TRO251 + + +Storage1.3.2 + + + +UH02.EXTERN_IN->UH02.TRO254 + + +Storage1.3.3 + + + +UH02.EXTERN_IN->UH02.TRO257 + + +Storage1.3.4 + + + +UH02.EXTERN_IN->UH02.TRO260 + + +JA1601_1 + + + +UH02.EXTERN_IN->UH02.TRO262 + + +JA1501_1 + + + +UH02.EXTERN_IN->UH02.TRO264 + + +JA1401_1 + + + +UH02.EXTERN_IN->UH02.TRO270 + + +JA4701_1 + + + +UH02.EXTERN_IN->UH02.TRO272 + + +JA1801_1 + + + +UH03.TRO300 + +TRO300 +[Vario] +TRO 300 (Vario) + + + +UH03.TRO302 + +TRO302 +[Vario] +TRO 302 (Vario) + + + +UH03.TRO300->UH03.TRO302 + + +JA4101_1 Finger + + + +UH03.TRO301 + +TRO301 +[1Sep] +TRO 301(1Sep) + + + +UH03.TRO301->UH03.TRO302 + + +JA4101_1 + + + +UH03.TRO311 + +TRO311 +[1Sep] +TRO 311 (1Sep)+Scanner(BX3101) + + + +UH03.TRO302->UH03.TRO311 + + +JA4101_2 Finger + + + +UH03.TRO303 + +TRO303 +[Vario] +TRO 303 (Vario) + + + +UH03.TRO305 + +TRO305 +[Vario] +TRO 305 (Vario) + + + +UH03.TRO303->UH03.TRO305 + + +JA4201_1 Finger + + + +UH03.TRO304 + +TRO304 +[1Sep] +TRO 304(1Sep) + + + +UH03.TRO304->UH03.TRO305 + + +JA4201_1 + + + +UH03.TRO312 + +TRO312 +[1Sep] +TRO 312 (1Sep)+Scanner(BX3100) + + + +UH03.TRO305->UH03.TRO312 + + +JA4201_2 Finger + + + +UH03.TRO306 + +TRO306 +[Vario] +TRO 306 (Vario) + + + +UH03.TRO307 + +TRO307 +[Vario] +TRO 307 (Vario) + + + +UH03.TRO308 + +TRO308 +[Vario] +TRO 308 (Vario) + + + +UH03.TRO309 + +TRO309 +[1Sep] +TRO 309 (1Sep) + + + +UH03.TRO308->UH03.TRO309 + + +JA2111_2 Finger + + + +UH03.TRO386 + +TRO386 +[1Sep] +TRO 386 (1Sep) - kam später dazu + + + +UH03.TRO309->UH03.TRO386 + + +JA2110_5 + + + +UH03.TRO310 + +TRO310 +[1Sep] +TRO 310 (1Sep)+Scanner (BX3102) + + + +UH03.TRO313 + +TRO313 +[1Sep1Swi] +TRO 313 (1Sep1Switch)+Scanner(BX3103) + + + +UH03.TRO310->UH03.TRO313 + + +JA2110_2 + + + +UH03.TRO311->UH03.TRO313 + + +JA2110_2 + + + +UH03.TRO312->UH03.TRO313 + + +JA2110_2 + + + +UH03.TRO314 + +TRO314 +[1Sep1Swi] +TRO 314 (1Sep1Switch)+Scanner(BX3104) + + + +UH03.TRO313->UH03.TRO314 + + +JA2110_3 Dir2 + + + +UH03.TRO316 + +TRO316 +[1Sep] +TRO 316 (1Sep) + + + +UH03.TRO313->UH03.TRO316 + + +JA2112_1 + + + +UH03.TRO315 + +TRO315 +[1Sep] +TRO 315 (1Sep) + + + +UH03.TRO314->UH03.TRO315 + + +JA2110_4 Dir2 + + + +UH03.TRO339 + +TRO339 +[1Sep1Swi] +TRO 339 (1Sep1Switch)+Scanner(BX3120) + + + +UH03.TRO314->UH03.TRO339 + + +JA2202_1 + + + +UH03.TRO317 + +TRO317 +[1Sep1Swi] +TRO 317 (1Sep1Switch)+Scanner(BX3105) + + + +UH03.TRO315->UH03.TRO317 + + +JA2102_1 + + + +UH03.TRO361 + +TRO361 +[1Sep1Swi] +TRO 361 (1Sep1Switch)+Scanner(BX3131) + + + +UH03.TRO316->UH03.TRO361 + + +JA2304_1 + + + +UH03.TRO318 + +TRO318 +[1Sep1Swi] +TRO 318 (1Sep1Switch) + Scanner(BX3106) + + + +UH03.TRO317->UH03.TRO318 + + +JA2102_2 + + + +UH03.EXTERN_OUT + +EXTERN +(Ablauf) + + + +UH03.TRO317->UH03.EXTERN_OUT + + +IO_Device_UH03_TO_UH01.stCarrierL2toL1 + + + +UH03.TRO330 + +TRO330 +[PinStore_Auto] +Aufruf: TRO330 + + + +UH03.TRO318->UH03.TRO330 + + +JA2101_1 Dir2 + + + +UH03.TRO333 + +TRO333 +[PinStore_Auto] +Aufruf: TRO333 + + + +UH03.TRO318->UH03.TRO333 + + +JA2102_3 + + + +UH03.TRO319 + +TRO319 +[1Sep1Swi] +TRO 319 (1Sep1Switch) + Scanner (BX3111) + + + +UH03.TRO320 + +TRO320 +[1Sep1Swi] +TRO 320 (1Sep1Switch) + Scanner(BX3112) + + + +UH03.TRO319->UH03.TRO320 + + +JA2103_2 Dir2 + + + +UH03.TRO328 + +TRO328 +[Vario] +TRO 328 (Vario) + + + +UH03.TRO319->UH03.TRO328 + + +JA2105_1 + + + +UH03.TRO323 + +TRO323 +[1Sep] +TRO 323 (1Sep) + + + +UH03.TRO320->UH03.TRO323 + + +JA2104_3 Dir2 + + + +UH03.TRO331 + +TRO331 +[Vario] +TRO 331 (Vario) + + + +UH03.TRO320->UH03.TRO331 + + +JA2106_1 + + + +UH03.TRO321 + +TRO321 +[1Sep1Swi] +TRO 321 (1Sep1Switch) + Scanner(BX3114) + + + +UH03.TRO322 + +TRO322 +[1Sep1Swi] +TRO 322 (1Sep1Switch)+Scanner(BX3113) + + + +UH03.TRO321->UH03.TRO322 + + +JA2104_2 + + + +UH03.TRO337 + +TRO337 +[Vario] +TRO 337 (Vario) + + + +UH03.TRO321->UH03.TRO337 + + +JA2108_1 Dir2 + + + +UH03.TRO322->UH03.TRO323 + + +JA2104_3 + + + +UH03.TRO334 + +TRO334 +[Vario] +TRO 334 (Vario) + + + +UH03.TRO322->UH03.TRO334 + + +JA2107_1 Dir2 + + + +UH03.TRO326 + +TRO326 +[1Sep] +TRO 326 (1Sep) + + + +UH03.TRO323->UH03.TRO326 + + +JA2104_4 + + + +UH03.TRO324 + +TRO324 +[Vario] +TRO 324 (Vario) + + + +UH03.TRO325 + +TRO325 +[1Sep] +TRO 325 (1Sep) + + + +UH03.TRO324->UH03.TRO325 + + +JA2109_2 Finger + + + +UH03.TRO325->UH03.TRO326 + + +JA2104_4 + + + +UH03.TRO326->UH03.EXTERN_OUT + + +IO_Device_UH03_TO_UH01.stCARRIER_INFO + + + +UH03.TRO327 + +TRO327 +[PinStore_Auto] +Aufruf: TRO327 + + + +UH03.TRO327->UH03.TRO319 + + +JA2103_1 + + + +UH03.TRO329 + +TRO329 +[1Sep] +TRO 329 (1Sep) + + + +UH03.TRO328->UH03.TRO329 + + +JA2105_2 Finger + + + +UH03.TRO329->UH03.TRO327 + + +JA2101_2 + + + +UH03.TRO330->UH03.TRO320 + + +JA2103_2 + + + +UH03.TRO330->UH03.TRO327 + + +JA2101_2 Bypass + + + +UH03.TRO332 + +TRO332 +[1Sep] +TRO 332 (1Sep) + + + +UH03.TRO331->UH03.TRO332 + + +JA2106_2 Finger + + + +UH03.TRO332->UH03.TRO330 + + +JA2101_1 + + + +UH03.TRO333->UH03.TRO322 + + +JA2104_2 + + + +UH03.TRO336 + +TRO336 +[PinStore_Auto] +Aufruf: TRO336 + + + +UH03.TRO333->UH03.TRO336 + + +JA2102_4 Bypass + + + +UH03.TRO335 + +TRO335 +[1Sep] +TRO 335 (1Sep) + + + +UH03.TRO334->UH03.TRO335 + + +JA2107_2 Finger + + + +UH03.TRO335->UH03.TRO333 + + +JA2102_3 + + + +UH03.TRO336->UH03.TRO321 + + +JA2104_1 + + + +UH03.TRO336->UH03.EXTERN_OUT + + +JA2102_5 + + + +UH03.TRO338 + +TRO338 +[1Sep] +TRO 338 (1Sep) + + + +UH03.TRO337->UH03.TRO338 + + +JA2108_2 Finger + + + +UH03.TRO338->UH03.TRO336 + + +JA2102_4 + + + +UH03.TRO340 + +TRO340 +[1Sep1Swi] +TRO 340 (1Sep1Switch)+Scanner(BX3121) + + + +UH03.TRO339->UH03.TRO340 + + +JA2202_2 + + + +UH03.TRO339->UH03.EXTERN_OUT + + +IO_Device_UH03_TO_UH01.stCarrierL2toL1_2 + + + +UH03.TRO352 + +TRO352 +[PinStore_Auto] +Aufruf: TRO352 + + + +UH03.TRO340->UH03.TRO352 + + +JA2201_1 Dir2 + + + +UH03.TRO355 + +TRO355 +[PinStore_Auto] +Aufruf: TRO355 + + + +UH03.TRO340->UH03.TRO355 + + +JA2202_3 + + + +UH03.TRO341 + +TRO341 +[1Sep1Swi] +TRO 341 (1Sep1Switch)+Scanner(BX3126) + + + +UH03.TRO342 + +TRO342 +[1Sep1Swi] +TRO 342 (1Sep1Switch)+Scanner(BX3127) + + + +UH03.TRO341->UH03.TRO342 + + +JA2203_2 Dir2 + + + +UH03.TRO350 + +TRO350 +[Vario] +TRO 350 (Vario) + + + +UH03.TRO341->UH03.TRO350 + + +JA2205_1 + + + +UH03.TRO345 + +TRO345 +[1Sep] +TRO 345 (1Sep) + + + +UH03.TRO342->UH03.TRO345 + + +JA2204_3 Dir2 + + + +UH03.TRO353 + +TRO353 +[Vario] +TRO 353 (Vario) + + + +UH03.TRO342->UH03.TRO353 + + +JA2206_1 + + + +UH03.TRO343 + +TRO343 +[1Sep1Swi] +TRO 343 (1Sep1Switch)+Scanner(BX3129) + + + +UH03.TRO344 + +TRO344 +[1Sep1Swi] +TRO 344 (1Sep1Switch)+Scanner(BX3128) + + + +UH03.TRO343->UH03.TRO344 + + +JA2204_2 + + + +UH03.TRO359 + +TRO359 +[Vario] +TRO 359 (Vario) + + + +UH03.TRO343->UH03.TRO359 + + +JA2208_1 Dir2 + + + +UH03.TRO344->UH03.TRO345 + + +JA2204_3 + + + +UH03.TRO356 + +TRO356 +[Vario] +TRO 356 (Vario) + + + +UH03.TRO344->UH03.TRO356 + + +JA2207_1 Dir2 + + + +UH03.TRO348 + +TRO348 +[1Sep] +TRO 348 (1Sep) + + + +UH03.TRO345->UH03.TRO348 + + +JA2204_4 + + + +UH03.TRO346 + +TRO346 +[Vario] +TRO 346 (Vario) + + + +UH03.TRO347 + +TRO347 +[1Sep] +TRO 347 (1Sep) + + + +UH03.TRO346->UH03.TRO347 + + +JA2209_2 Finger + + + +UH03.TRO347->UH03.TRO348 + + +JA2204_4 + + + +UH03.TRO348->UH03.EXTERN_OUT + + +IO_Device_UH03_TO_UH01.stCARRIER_INFO_1 + + + +UH03.TRO349 + +TRO349 +[PinStore_Auto] +Aufruf: TRO349 + + + +UH03.TRO349->UH03.TRO341 + + +JA2203_1 + + + +UH03.TRO351 + +TRO351 +[1Sep] +TRO 351 (1Sep) + + + +UH03.TRO350->UH03.TRO351 + + +JA2205_2 Finger + + + +UH03.TRO351->UH03.TRO349 + + +JA2201_2 + + + +UH03.TRO352->UH03.TRO342 + + +JA2203_2 + + + +UH03.TRO352->UH03.TRO349 + + +JA2201_2 Bypass + + + +UH03.TRO354 + +TRO354 +[1Sep] +TRO 354 (1Sep) + + + +UH03.TRO353->UH03.TRO354 + + +JA2206_2 Finger + + + +UH03.TRO354->UH03.TRO352 + + +JA2201_1 + + + +UH03.TRO355->UH03.TRO344 + + +JA2204_2 + + + +UH03.TRO358 + +TRO358 +[PinStore_Auto] +Aufruf: TRO358 + + + +UH03.TRO355->UH03.TRO358 + + +JA2202_4 Bypass + + + +UH03.TRO357 + +TRO357 +[1Sep] +TRO 357 (1Sep) + + + +UH03.TRO356->UH03.TRO357 + + +JA2207_2 Finger + + + +UH03.TRO357->UH03.TRO355 + + +JA2202_3 + + + +UH03.TRO358->UH03.TRO343 + + +JA2204_1 + + + +UH03.TRO358->UH03.EXTERN_OUT + + +JA2202_5 + + + +UH03.TRO360 + +TRO360 +[1Sep] +TRO 360 (1Sep) + + + +UH03.TRO359->UH03.TRO360 + + +JA2208_2 Finger + + + +UH03.TRO360->UH03.TRO358 + + +JA2202_4 + + + +UH03.TRO362 + +TRO362 +[1Sep1Swi] +TRO 362 (1Sep1Switch)+Scanner(BX3132) + + + +UH03.TRO361->UH03.TRO362 + + +JA2304_2 Dir2 + + + +UH03.TRO361->UH03.EXTERN_OUT + + +IO_Device_UH03_TO_UH01.stCarrierL2toL1_3 + + + +UH03.TRO374 + +TRO374 +[PinStore_Auto] +Aufruf: TRO374 + + + +UH03.TRO362->UH03.TRO374 + + +JA2303_1 + + + +UH03.TRO377 + +TRO377 +[PinStore_Auto] +Aufruf: TRO377 + + + +UH03.TRO362->UH03.TRO377 + + +JA2304_3 Dir2 + + + +UH03.TRO363 + +TRO363 +[1Sep1Swi] +TRO 363 (1Sep1Switch)+Scanner(BX3137) + + + +UH03.TRO364 + +TRO364 +[1Sep1Swi] +TRO 364 (1Sep1Switch)+Scanner(BX3138) + + + +UH03.TRO363->UH03.TRO364 + + +JA2301_2 + + + +UH03.TRO372 + +TRO372 +[Vario] +TRO 372 (Vario) + + + +UH03.TRO363->UH03.TRO372 + + +JA2305_1 Dir2 + + + +UH03.TRO367 + +TRO367 +[1Sep] +TRO 367 (1Sep) + + + +UH03.TRO364->UH03.TRO367 + + +JA2302_3 + + + +UH03.TRO375 + +TRO375 +[Vario] +TRO 375 (Vario) + + + +UH03.TRO364->UH03.TRO375 + + +JA2306_1 Dir2 + + + +UH03.TRO365 + +TRO365 +[1Sep1Swi] +TRO 365 (1Sep1Switch)+Scanner(BX3140) + + + +UH03.TRO366 + +TRO366 +[1Sep1Swi] +TRO 366 (1Sep1Switch)+Scanner(BX3139) + + + +UH03.TRO365->UH03.TRO366 + + +JA2302_2 Dir2 + + + +UH03.TRO381 + +TRO381 +[Vario] +TRO 381 (Vario) + + + +UH03.TRO365->UH03.TRO381 + + +JA2308_1 + + + +UH03.TRO366->UH03.TRO367 + + +JA2302_3 Dir2 + + + +UH03.TRO378 + +TRO378 +[Vario] +TRO 378 (Vario) + + + +UH03.TRO366->UH03.TRO378 + + +JA2307_1 + + + +UH03.TRO370 + +TRO370 +[1Sep] +TRO 370 (1Sep) + + + +UH03.TRO367->UH03.TRO370 + + +JA2302_4 + + + +UH03.TRO368 + +TRO368 +[Vario] +TRO 368 (Vario, from Lvl1) + + + +UH03.TRO369 + +TRO369 +[1Sep] +TRO 369 (1Sep) + + + +UH03.TRO368->UH03.TRO369 + + +JA2309_2 Finger + + + +UH03.TRO369->UH03.TRO370 + + +JA2302_4 + + + +UH03.TRO370->UH03.EXTERN_OUT + + +IO_Device_UH03_TO_UH01.stCARRIER_INFO_2 + + + +UH03.TRO371 + +TRO371 +[PinStore_Auto] +Aufruf: TRO371 + + + +UH03.TRO371->UH03.TRO363 + + +JA2301_1 + + + +UH03.TRO373 + +TRO373 +[1Sep] +TRO 373 (1Sep) + + + +UH03.TRO372->UH03.TRO373 + + +JA2305_2 Finger + + + +UH03.TRO373->UH03.TRO371 + + +JA2303_2 + + + +UH03.TRO374->UH03.TRO364 + + +JA2301_2 + + + +UH03.TRO374->UH03.TRO371 + + +JA2303_2 Bypass + + + +UH03.TRO376 + +TRO376 +[1Sep] +TRO 376 (1Sep) + + + +UH03.TRO375->UH03.TRO376 + + +JA2306_2 Finger + + + +UH03.TRO376->UH03.TRO374 + + +JA2303_1 + + + +UH03.TRO377->UH03.TRO366 + + +JA2302_2 + + + +UH03.TRO380 + +TRO380 +[PinStore_Auto] +Aufruf: TRO380 + + + +UH03.TRO377->UH03.TRO380 + + +JA2304_4 Bypass + + + +UH03.TRO379 + +TRO379 +[1Sep] +TRO 379 (1Sep) + + + +UH03.TRO378->UH03.TRO379 + + +JA2307_2 Finger + + + +UH03.TRO379->UH03.TRO377 + + +JA2304_3 + + + +UH03.TRO380->UH03.TRO365 + + +JA2302_1 + + + +UH03.TRO382 + +TRO382 +[1Sep] +TRO 382 (1Sep) + + + +UH03.TRO381->UH03.TRO382 + + +JA2308_2 Finger + + + +UH03.TRO382->UH03.TRO380 + + +JA2304_4 + + + +UH03.TRO386->UH03.TRO310 + + +JA2110_1 + + + +UH03.EXTERN_IN + +EXTERN +(Zulauf) + + + +UH03.EXTERN_IN->UH03.TRO300 + + +JA4102_1 + + + +UH03.EXTERN_IN->UH03.TRO301 + + +JA4102_2 + + + +UH03.EXTERN_IN->UH03.TRO303 + + +JA4202_1 + + + +UH03.EXTERN_IN->UH03.TRO304 + + +JA4202_2 + + + +UH03.EXTERN_IN->UH03.TRO306 + + +JA4301_1 + + + +UH03.EXTERN_IN->UH03.TRO307 + + +JA4401_1 + + + +UH03.EXTERN_IN->UH03.TRO308 + + +JA2111_1 + + + +UH03.EXTERN_IN->UH03.TRO324 + + +JA2109_1 + + + +UH03.EXTERN_IN->UH03.TRO327 + + +Storage2.1.1 + + + +UH03.EXTERN_IN->UH03.TRO330 + + +Storage2.1.2 + + + +UH03.EXTERN_IN->UH03.TRO333 + + +Storage2.1.3 + + + +UH03.EXTERN_IN->UH03.TRO336 + + +Storage2.1.4 + + + +UH03.EXTERN_IN->UH03.TRO346 + + +JA2209_1 + + + +UH03.EXTERN_IN->UH03.TRO349 + + +Storage2.2.1 + + + +UH03.EXTERN_IN->UH03.TRO352 + + +Storage2.2.2 + + + +UH03.EXTERN_IN->UH03.TRO355 + + +Storage2.2.3 + + + +UH03.EXTERN_IN->UH03.TRO358 + + +Storage2.2.4 + + + +UH03.EXTERN_IN->UH03.TRO368 + + +JA2309_1 + + + +UH03.EXTERN_IN->UH03.TRO371 + + +Storage2.3.1 + + + +UH03.EXTERN_IN->UH03.TRO374 + + +Storage2.3.2 + + + +UH03.EXTERN_IN->UH03.TRO377 + + +Storage2.3.3 + + + +UH03.EXTERN_IN->UH03.TRO380 + + +Storage2.3.4 + + + +UH04.TRO400 + +TRO400 +[Vario] +TRO 400 (Vario) + + + +UH04.TRO401 + +TRO401 +[Vario] +TRO 401 (Vario) + + + +UH04.TRO400->UH04.TRO401 + + +JA4001_1 Finger + + + +UH04.TRO402 + +TRO402 +[1Sep] +TRO 402 (1Sep) (Vor Brandschutztor) + + + +UH04.TRO401->UH04.TRO402 + + +JA4001_2 Finger + + + +UH04.TRO403 + +TRO403 +[Vario] +TRO 403 (Vario) + + + +UH04.TRO402->UH04.TRO403 + + +JA4002_1 + + + +UH04.TRO404 + +TRO404 +[1Sep] +TRO 404 (1Sep) + + + +UH04.TRO403->UH04.TRO404 + + +JA4002_2 Finger + + + +UH04.TRO424 + +TRO424 +[1Sep] +TRO 424 (1Sep) vor Behangskontrolle + + + +UH04.TRO404->UH04.TRO424 + + +JA4003_8 + + + +UH04.TRO405 + +TRO405 +[1Sep1Swi] +TRO 405 (1Sep1Switch) + Scanner (BX4100) + Behangskontrolle + + + +UH04.TRO406 + +TRO406 +[1Sep] +TRO 406 (1Sep) + Scanner (BX4101) + + + +UH04.TRO405->UH04.TRO406 + + +JA4003_2 Dir2 + + + +UH04.TRO407 + +TRO407 +[1Sep1Swi] +TRO 407 (1Sep1Switch) + Scanner (BX4102) + + + +UH04.TRO406->UH04.TRO407 + + +JA4003_3 + + + +UH04.TRO408 + +TRO408 +[Vario] +TRO 408 (Vario) + + + +UH04.TRO407->UH04.TRO408 + + +JA4004_1 + + + +UH04.TRO410 + +TRO410 +[1Sep1Swi] +TRO 410 (1Sep1Switch) + Scanner (BX4104) + + + +UH04.TRO407->UH04.TRO410 + + +JA4003_4 Dir2 + + + +UH04.TRO421 + +TRO421 +[Vario_workStation] +TRO 421 (Vario) + + + +UH04.TRO408->UH04.TRO421 + + +JA4004_2 Finger + + + +UH04.TRO409 + +TRO409 +[1Sep] +TRO 409 (1Sep) + + + +UH04.TRO409->UH04.TRO410 + + +JA4003_4 + + + +UH04.TRO411 + +TRO411 +[Vario] +TRO 411 (Vario) + + + +UH04.TRO410->UH04.TRO411 + + +JA4006_1 + + + +UH04.TRO413 + +TRO413 +[1Sep1Swi] +TRO 413(1Sep1Switch)+Scanner(BX4106) + + + +UH04.TRO410->UH04.TRO413 + + +JA4003_5 Dir2 + + + +UH04.TRO422 + +TRO422 +[Vario_workStation] +TRO 422 (Vario) + + + +UH04.TRO411->UH04.TRO422 + + +JA4006_2 Finger + + + +UH04.TRO412 + +TRO412 +[1Sep] +TRO 412 (1Sep) + + + +UH04.TRO412->UH04.TRO413 + + +JA4003_5 + + + +UH04.TRO414 + +TRO414 +[Vario] +TRO 414 (Vario) + + + +UH04.TRO413->UH04.TRO414 + + +JA4008_1 + + + +UH04.TRO416 + +TRO416 +[1Sep] +TRO 416 (1Sep) + Beladeprüfung + + + +UH04.TRO413->UH04.TRO416 + + +JA4003_6 Dir2 + + + +UH04.TRO423 + +TRO423 +[Vario_workStation] +TRO 423 (Vario) + + + +UH04.TRO414->UH04.TRO423 + + +JA4008_2 Finger + + + +UH04.TRO415 + +TRO415 +[1Sep] +TRO 415 (1Sep) + + + +UH04.TRO415->UH04.TRO416 + + +JA4003_6 + + + +UH04.TRO417 + +TRO417 +[1Sep] +TRO 417 (1Sep) + + + +UH04.TRO416->UH04.TRO417 + + +JA4003_7 + + + +UH04.TRO417->UH04.TRO424 + + +JA4003_8 + + + +UH04.TRO418 + +TRO418 +[Vario] +TRO 418 (Vario) + + + +UH04.TRO420 + +TRO420 +[Vario] +TRO 420 (Vario) + + + +UH04.TRO418->UH04.TRO420 + + +JA4011_1 Finger + + + +UH04.EXTERN_OUT + +EXTERN +(Ablauf) + + + +UH04.TRO421->UH04.EXTERN_OUT + + +JA4005_1 + + + +UH04.TRO422->UH04.TRO412 + + +JA4007_1 Finger + + + +UH04.TRO423->UH04.TRO415 + + +JA4009_1 Finger + + + +UH04.TRO424->UH04.TRO405 + + +JA4003_1 + + + +UH04.EXTERN_IN + +EXTERN +(Zulauf) + + + +UH04.EXTERN_IN->UH04.TRO400 + + +JA4000_1 + + + +UH04.EXTERN_IN->UH04.TRO418 + + +JA4010_1 + + + +UH05.TRO500 + +TRO500 +[Vario] +TRO 500 (Vario) - Stand: Vorbereitet für Umbau! + + + +UH05.TRO530 + +TRO530 +[Vario] +TRO 530 (Vario) + + + +UH05.TRO500->UH05.TRO530 + + +JA5001_2 Finger + + + +UH05.TRO501 + +TRO501 +[1Sep] +TRO 501 (1Sep) + Scanner (BX5101) + + + +UH05.TRO504 + +TRO504 +[1Sep] +TRO 504 (1Sep) + + + +UH05.TRO501->UH05.TRO504 + + +JA5002_1 + + + +UH05.TRO502 + +TRO502 +[Vario] +TRO 502 (Vario) - Stand: Vorbereitet für Umbau! + + + +UH05.TRO531 + +TRO531 +[Vario] +TRO 531 (Vario) + + + +UH05.TRO502->UH05.TRO531 + + +JA5000_2 Finger + + + +UH05.TRO503 + +TRO503 +[1Sep] +TRO 503 (1Sep)+ Scanner (BX5100) + + + +UH05.TRO503->UH05.TRO504 + + +JA5002_1 + + + +UH05.TRO505 + +TRO505 +[1Sep1Swi] +TRO 505 (1Sep1Switch) + Scanner (BX5102) + + + +UH05.TRO504->UH05.TRO505 + + +JA5002_2 + + + +UH05.TRO506 + +TRO506 +[Vario] +TRO 506 (Vario) + + + +UH05.TRO505->UH05.TRO506 + + +JA5003_1 + + + +UH05.TRO510 + +TRO510 +[1Sep1Swi] +TRO 510 (1Sep1Switch) + Scanner (BX5104) + + + +UH05.TRO505->UH05.TRO510 + + +JA5002_3 Dir2 + + + +UH05.TRO507 + +TRO507 +[1Sep] +TRO 507 (1Sep) + + + +UH05.TRO506->UH05.TRO507 + + +JA5003_2 Finger + + + +UH05.TRO508 + +TRO508 +[Vario] +TRO 508 (Vario)+Scanner(BX5103) + + + +UH05.TRO507->UH05.TRO508 + + +JA5004_1 + + + +UH05.EXTERN_OUT + +EXTERN +(Ablauf) + + + +UH05.TRO508->UH05.EXTERN_OUT + + +JA5004_2 + + + +UH05.TRO509 + +TRO509 +[1Sep] +TRO 509 (1Sep) + + + +UH05.TRO509->UH05.TRO510 + + +JA5002_3 + + + +UH05.TRO511 + +TRO511 +[1Sep] +TRO 511 (1Sep) + + + +UH05.TRO510->UH05.TRO511 + + +JA5005_1 + + + +UH05.TRO514 + +TRO514 +[1Sep1Swi] +TRO 514 (1Sep1Switch) + Scanner (BX5106) + + + +UH05.TRO510->UH05.TRO514 + + +JA5002_4 Dir2 + + + +UH05.TRO512 + +TRO512 +[Vario] +TRO 512 (Vario)+Scanner(BX5105) + + + +UH05.TRO511->UH05.TRO512 + + +JA5005_2 + + + +UH05.TRO512->UH05.EXTERN_OUT + + +JA5005_3 + + + +UH05.TRO513 + +TRO513 +[1Sep] +TRO 513 (1Sep) + + + +UH05.TRO513->UH05.TRO514 + + +JA5002_4 + + + +UH05.TRO515 + +TRO515 +[1Sep] +TRO 515 (1Sep) + + + +UH05.TRO514->UH05.TRO515 + + +JA5006_1 + + + +UH05.TRO518 + +TRO518 +[1Sep1Swi] +TRO 518 (1Sep1Switch) + Scanner (BX5108) + + + +UH05.TRO514->UH05.TRO518 + + +JA5002_5 Dir2 + + + +UH05.TRO516 + +TRO516 +[Vario] +TRO 516(Vario)+Scanner(BX5107) + + + +UH05.TRO515->UH05.TRO516 + + +JA5006_2 + + + +UH05.TRO516->UH05.EXTERN_OUT + + +JA5006_3 + + + +UH05.TRO517 + +TRO517 +[1Sep] +TRO 517 (1Sep) + + + +UH05.TRO517->UH05.TRO518 + + +JA5002_5 + + + +UH05.TRO519 + +TRO519 +[1Sep] +TRO 519 (1Sep) + + + +UH05.TRO518->UH05.TRO519 + + +JA5007_1 + + + +UH05.TRO522 + +TRO522 +[1Sep1Swi] +TRO 522 (1Sep1Switch) + Scanner (BX5110) + + + +UH05.TRO518->UH05.TRO522 + + +JA5002_6 Dir2 + + + +UH05.TRO520 + +TRO520 +[Vario] +TRO 520 (Vario)+Scanner(BX5109) + + + +UH05.TRO519->UH05.TRO520 + + +JA5007_2 + + + +UH05.TRO520->UH05.EXTERN_OUT + + +JA5007_3 + + + +UH05.TRO521 + +TRO521 +[1Sep] +TRO 521(1Sep) + + + +UH05.TRO521->UH05.TRO522 + + +JA5002_6 + + + +UH05.TRO523 + +TRO523 +[1Sep] +TRO 523 (1Sep) + + + +UH05.TRO522->UH05.TRO523 + + +JA5008_1 + + + +UH05.TRO526 + +TRO526 +[1Sep] +TRO 526 (1Sep) + Scanner (BX5112) + + + +UH05.TRO522->UH05.TRO526 + + +JA5002_7 Dir2 + + + +UH05.TRO524 + +TRO524 +[Vario] +TRO 524 (Vario)+Scanner(BX5231) + + + +UH05.TRO523->UH05.TRO524 + + +JA5008_2 + + + +UH05.TRO524->UH05.EXTERN_OUT + + +JA5008_3 + + + +UH05.TRO525 + +TRO525 +[1Sep] +TRO 525(1Sep) + + + +UH05.TRO525->UH05.TRO526 + + +JA5002_7 + + + +UH05.TRO527 + +TRO527 +[1Sep1Swi] +TRO 527 (1Sep1Switch) + + + +UH05.TRO526->UH05.TRO527 + + +JA5002_8 + + + +UH05.TRO528 + +TRO528 +[1Sep] +TRO 528 (1Sep) + + + +UH05.TRO527->UH05.TRO528 + + +JA5002_9 Dir2 + + + +UH05.TRO529 + +TRO529 +[1Sep] +TRO 529 (1Sep) + Scanner (BX5113) + + + +UH05.TRO528->UH05.TRO529 + + +JA5002_10 + + + +UH05.TRO529->UH05.TRO504 + + +JA5002_1 + + + +UH05.TRO530->UH05.TRO501 + + +JA5001_3 Finger + + + +UH05.TRO531->UH05.TRO503 + + +JA5000_3 Finger + + + +UH05.EXTERN_IN + +EXTERN +(Zulauf) + + + +UH05.EXTERN_IN->UH05.TRO500 + + +JA5001_1 + + + +UH05.EXTERN_IN->UH05.TRO502 + + +JA5000_1 + + +