Samer AyadiandClaude Opus 5.5
7ec2b88b79
Sensor und Stopper jeder Lagerlinie (und des Pin-Separators) kommen aus der E-Planung wie bei den Separatorbloecken (scl_context._sep_namen); die Zaehlung der eingesetzten Namen beruecksichtigt die Linien. Dazu die ID-Datei cfg/mubea_tro_ids.ini und .gitignore fuer lokale Claude-Code- Einstellungen. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
650 lines
23 KiB
Python
650 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
scl_context.py - Render-Kontext fuer das FB_Main-Geruest.
|
|
|
|
Schritt 2 aus doc/SCL_Templates.md: alles, was scl_skeleton aus der TRO-JSON
|
|
*ableitet*, steht hier - Reihenfolge, Bauteilbloecke, Staubereiche,
|
|
Weichenziele, Namen. Die Ausgabe (heute die emit_*-Funktionen, spaeter die
|
|
Templates in lib/scl_templates/) liest nur noch diesen Kontext und rechnet
|
|
nichts mehr selbst.
|
|
|
|
Schichten:
|
|
|
|
model.py TroDocument (die TRO-JSON)
|
|
scl_context.py TroDocument -> SclFile <- hier
|
|
scl_skeleton.py SclFile -> SCL-Text
|
|
|
|
Namen (Separator-, Weichen-, MainTro-Nummer, Adressen ...) sind ein
|
|
:class:`SclName`: Wert plus Merker, ob er noch aus der E-Planung kommen muss.
|
|
Ohne E-Planung sind alle Platzhalter ``todo=True``. Mit einer Zuordnung aus
|
|
lib/e_planning.py (``eplan``) werden Separator-Sensor und Stopperventil der
|
|
zugeordneten Separatoren eingesetzt und ``todo`` geloescht; alles andere
|
|
bleibt offen. Die Namensregeln aus Schritt 4 (cfg/scl_naming.ini) arbeiten
|
|
spaeter genauso: Wert ersetzen, Merker loeschen.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from collections import deque
|
|
from datetime import datetime
|
|
from typing import TYPE_CHECKING
|
|
|
|
from pydantic import BaseModel, ConfigDict, Field
|
|
|
|
from model import JamArea, TroBase, TroDocument
|
|
from tro_catalog import TroItem
|
|
|
|
if TYPE_CHECKING:
|
|
from e_planning import EplanDocument
|
|
|
|
__all__ = [
|
|
"TODO",
|
|
"SclName",
|
|
"SclSeparator",
|
|
"SclSwitch",
|
|
"SclSwitchExit",
|
|
"SclScanner",
|
|
"SclJam",
|
|
"SclSscc",
|
|
"SclWorkStation",
|
|
"SclStoreLine",
|
|
"SclStore",
|
|
"SclTro",
|
|
"SclFile",
|
|
"build_context",
|
|
"flow_order",
|
|
"reachable_via",
|
|
]
|
|
|
|
TODO = "TODO(E-Planung)"
|
|
|
|
_CONFIG = ConfigDict(extra="forbid")
|
|
|
|
|
|
class SclName(BaseModel):
|
|
"""Ein Name/eine Adresse in der SCL und ob er noch offen ist."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
value: str
|
|
# True: Platzhalter, muss aus der E-Planung kommen -> TODO-Kommentar
|
|
todo: bool = True
|
|
|
|
|
|
def _offen(platzhalter: str) -> SclName:
|
|
return SclName(value=platzhalter, todo=True)
|
|
|
|
|
|
def _bekannt(wert: str) -> SclName:
|
|
return SclName(value=wert, todo=False)
|
|
|
|
|
|
# Rolle in e_planning.ini -> wie der Name in der SCL geschrieben wird
|
|
# (Sensor als Konstante der DB_Inputs-Sensorliste, Ventil als Variable)
|
|
_SENSOR = "cIn{bmk}"
|
|
_VENTIL = "{bmk}"
|
|
|
|
|
|
class SclSeparator(BaseModel):
|
|
"""Ein stInSeparator<n>-Block."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
n: int
|
|
# Separatornummer aus dem Layout ("?" wenn der Typ mehr Separatoren hat
|
|
# als im Layout gefunden wurden)
|
|
layout: str
|
|
no: SclName
|
|
sensor: SclName
|
|
stopper: SclName
|
|
# Teilesensor (stSenPart) - nur in Templates, deren Referenz ihn hat (1Sep2Swi)
|
|
part_sensor: SclName
|
|
|
|
|
|
class SclSwitchExit(BaseModel):
|
|
"""Ein Abgang eines Weichen-TRO und die darueber erreichbaren TROs."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
via: str
|
|
targets: list[str]
|
|
|
|
|
|
class SclSwitch(BaseModel):
|
|
"""Ein stInSwitch<n>-Block plus sein FC_Direction-Aufruf."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
n: int
|
|
no: SclName
|
|
valve: SclName
|
|
# None: mehrere Weichen teilen sich die Abgaenge - Aufteilung ist eine
|
|
# Planungsentscheidung und wird nicht geraten
|
|
to1_destinations: int | None
|
|
# Ziel von nOutDirection, z. B. "#TRO07.nInDirection" bzw. "...nInDirection2"
|
|
direction_target: str
|
|
# Staubereich, dessen erster Traeger in FC_Direction ausgewertet wird
|
|
jam_db: SclName
|
|
|
|
|
|
class SclScanner(BaseModel):
|
|
"""Ein stInBarcodeReader-Block ("" als Suffix, wenn es nur einen gibt).
|
|
|
|
Die Cognex-Verdrahtung (nur in den Templates): ``interface`` ist der
|
|
Schluessel in #arCognexInterface (z. B. "cScannerBX2100"), ``tag`` der
|
|
Praefix der Hardware-Symbole ("bx2100-TriggerReady" ...), ``hw_results``
|
|
das Ergebnis-Symbol der Kamera.
|
|
"""
|
|
|
|
model_config = _CONFIG
|
|
|
|
n: int
|
|
suffix: str
|
|
interface: SclName
|
|
tag: SclName
|
|
hw_results: SclName
|
|
|
|
|
|
class SclJam(BaseModel):
|
|
"""Ein Staubereich am Ein- oder Ausgang (JamEntr<n> / JamExit<n>).
|
|
|
|
Ein Eingang ist ein Staubereich des TRO selbst (TroDocument.jamAreas), ein
|
|
Ausgang der Eingangs-Staubereich des Nachfolgers.
|
|
"""
|
|
|
|
model_config = _CONFIG
|
|
|
|
n: int
|
|
# Kennung aus der TRO-JSON (J<Separator>); "" am Ausgang zu einer Station
|
|
jam_id: str = ""
|
|
# Eingang: die Vorgaenger, Ausgang: der Nachfolger - als Text fuer den
|
|
# Kommentar, SYSn als Station markiert
|
|
neighbour: str
|
|
db: SclName
|
|
# Stausensor des Ausgangs (stInSenJam<n>); None an Eingaengen
|
|
sensor: SclName | None = None
|
|
# Traeger-Array und Staudaten des Bereichs - im Normalfall <db>.arCarrier
|
|
# bzw. <db>.stData; an Uebergaben auch eigene Variablen (#arCarrierHandover...)
|
|
carriers: SclName
|
|
data: SclName
|
|
|
|
@property
|
|
def title(self) -> str:
|
|
"""Fuer den Kommentar: 'Staubereich J0003' (ohne Kennung nur 'Staubereich')."""
|
|
return f"Staubereich {self.jam_id}" if self.jam_id else "Staubereich"
|
|
|
|
|
|
class SclSscc(BaseModel):
|
|
"""SSCC-Scanner eines 1Sep_SSCC: zweite Kamera, Endmessung, HMI-Anzeige."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
# interface ist hier die Struktur selbst (z. B. "#stCognexIntfTro105")
|
|
scanner: SclScanner
|
|
end_sensor: SclName
|
|
# Schluessel der HMI-Anzeige, z. B. "SSCC1107"
|
|
hmi: SclName
|
|
|
|
|
|
class SclWorkStation(BaseModel):
|
|
"""Arbeitsplatz eines Vario_workStation."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
station_sensor: SclName
|
|
station_release: SclName
|
|
loaded_error_sensor: SclName
|
|
|
|
|
|
class SclStoreLine(BaseModel):
|
|
"""Eine Speicherlinie eines PinStore_Auto (arInSep[n])."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
n: int
|
|
# Separatornummer der Linie aus dem Layout
|
|
layout: str
|
|
jam_length: SclName
|
|
sensor: SclName
|
|
jam_sensor: SclName
|
|
stopper: SclName
|
|
|
|
|
|
class SclStore(BaseModel):
|
|
"""Alles fuer ein automatisches Pin-Lager (PinStore_Auto)."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
encoder: SclName
|
|
dest: SclName
|
|
conv_stations: SclName
|
|
stations_max: SclName
|
|
threshold: SclName
|
|
reference_sensor: SclName
|
|
station: SclName
|
|
quit_local: SclName
|
|
test_target: SclName
|
|
run_in: SclName
|
|
run_out: SclName
|
|
db: SclName
|
|
removal: SclName
|
|
conv_db: SclName
|
|
# Einschleus-Separator (Pin) - aus dem Layout, wenn tro_flow einen
|
|
# steuernden Separator vor den Linien gefunden hat, sonst "?"
|
|
pin_layout: str
|
|
pin_sensor: SclName
|
|
pin_stopper: SclName
|
|
# Eine Linie je Speicherbahn im Layout (nicht die 19 aus dem Katalog)
|
|
lines: list[SclStoreLine]
|
|
|
|
@property
|
|
def title(self) -> str:
|
|
"""Fuer den Kommentar: 'Staubereich J0003' (ohne Kennung nur 'Staubereich')."""
|
|
return f"Staubereich {self.jam_id}" if self.jam_id else "Staubereich"
|
|
|
|
|
|
class SclTro(BaseModel):
|
|
"""Alles, was eine REGION fuer einen TRO braucht."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
id: str
|
|
# Nummernteil der ID, wie geschrieben ("TRO01" -> "01"); "" ohne Ziffern
|
|
nr: str
|
|
type: str
|
|
fb: str
|
|
region_title: str
|
|
layout_separators: list[str]
|
|
position: tuple[float, float] | None
|
|
predecessors: list[str]
|
|
successors: list[str]
|
|
confidence: str
|
|
|
|
separators: list[SclSeparator]
|
|
switches: list[SclSwitch]
|
|
switch_exits: list[SclSwitchExit]
|
|
has_vario: bool
|
|
# Vario-Sensoren in Aufrufreihenfolge (Parametername -> Sensor); leer ohne Vario
|
|
vario_sensors: dict[str, SclName]
|
|
scanners: list[SclScanner]
|
|
storage_lines: int
|
|
jam_entries: list[SclJam]
|
|
jam_exits: list[SclJam]
|
|
|
|
main_tro: SclName
|
|
safety: SclName
|
|
release: str
|
|
motor_protection: SclName
|
|
vario_motor: SclName
|
|
machine_state: SclName
|
|
# Nur in den Templates (Referenz-Aufrufstellen), nicht im generischen Aufbau:
|
|
# UDT des Prioritaetsmanagers ("udt_TRO107") und ob Richtung 2 Vorrang hat
|
|
priority_udt: SclName
|
|
prio_dir2: SclName
|
|
# Kreisel-Freigabe (xInCarouselRun1). Ob ein TRO am Kreisel liegt, steht
|
|
# nicht in der TRO-JSON - deshalb immer offen (doc/SCL_Templates.md §6).
|
|
carousel_run: SclName
|
|
|
|
# -- nur fuer die Templates (Referenz-Aufrufstellen, doc/SCL_Templates.md §6)
|
|
# Einziger Staubereich am Ein-/Ausgang fuer FBs ohne Nummerierung
|
|
# (Vario: JamEntr/JamFinger, PinStore: JamEntr/JamExit): der erste
|
|
# Vorgaenger bzw. Nachfolger, sonst ein offener Platzhalter
|
|
jam_in: SclJam
|
|
jam_out: SclJam
|
|
error_quit: SclName
|
|
automatic: SclName
|
|
# Vario: stInSettings.xIsBorner (Bedeutung mit SPS klaeren)
|
|
is_border: SclName
|
|
# Station fuer FC_CARR_GLOB_CORRECTION (1Sep_SSCC, PinStore_Auto)
|
|
correction_station: SclName
|
|
sscc: SclSscc | None = None
|
|
work_station: SclWorkStation | None = None
|
|
store: SclStore | None = None
|
|
|
|
@property
|
|
def has_scanner(self) -> bool:
|
|
return bool(self.scanners)
|
|
|
|
|
|
class SclFile(BaseModel):
|
|
"""Kontext der ganzen Datei: Kopf und die TROs in Fliessrichtung."""
|
|
|
|
model_config = _CONFIG
|
|
|
|
source: str
|
|
created: str
|
|
start_reason: str
|
|
tros: list[SclTro] = Field(default_factory=list)
|
|
# Zuordnung zur E-Planung, aus der Namen eingesetzt wurden ("" = keine)
|
|
eplan_source: str = ""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Graph
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def flow_order(tros: list[TroBase], start_id: str = "") -> tuple[list[TroBase], str]:
|
|
"""TROs in Fliessrichtung sortieren.
|
|
|
|
Startpunkt ist ein TRO ohne Vorgaenger - also die Stelle, an der Material
|
|
in die Anlage kommt. Solange Be-/Entladestation fehlen, ist der Fluss ein
|
|
geschlossener Kreis und es gibt keinen solchen TRO; dann muss der Kreis
|
|
irgendwo aufgetrennt werden. Das ist eine willkuerliche Wahl, deshalb wird
|
|
sie zurueckgegeben und im Kopf der SCL vermerkt (und laesst sich mit
|
|
--start ueberschreiben). Nicht erreichte TROs haengt die Funktion hinten
|
|
an, damit nie einer verlorengeht.
|
|
"""
|
|
nach_id = {t.tro_id: t for t in tros}
|
|
ohne_vorgaenger = sorted(t.tro_id for t in tros if not t.predecessors)
|
|
# Materialeingang ueber eine Station (SYSn von tro_flow.py): der TRO, den
|
|
# sie speist, ist der natuerliche Anfang - auch wenn er zusaetzlich einen
|
|
# TRO-Vorgaenger hat (Kreisel-Umlauf).
|
|
eingaenge = sorted({
|
|
t.tro_id for t in tros
|
|
for vor in t.predecessors if vor not in nach_id
|
|
})
|
|
|
|
if start_id and start_id in nach_id:
|
|
start, grund = [start_id], "per --start gesetzt"
|
|
elif ohne_vorgaenger:
|
|
start, grund = ohne_vorgaenger, "TRO ohne Vorgaenger (Materialeingang)"
|
|
elif eingaenge:
|
|
stationen = sorted({
|
|
vor for i in eingaenge for vor in nach_id[i].predecessors
|
|
if vor not in nach_id
|
|
})
|
|
start = eingaenge
|
|
grund = f"Materialeingang ueber {', '.join(stationen)}"
|
|
else:
|
|
start = [min(nach_id)]
|
|
grund = ("Kreislauf ohne Eingang - willkuerlich aufgetrennt; sobald "
|
|
"Be-/Entladestation im Export stehen, ergibt sich der Anfang")
|
|
|
|
gesehen: list[str] = []
|
|
queue = deque(start)
|
|
while queue:
|
|
tro_id = queue.popleft()
|
|
if tro_id in gesehen:
|
|
continue
|
|
gesehen.append(tro_id)
|
|
for nxt in nach_id[tro_id].successors if tro_id in nach_id else []:
|
|
# SYSn (Materialausgang) ist kein TRO - keine REGION, keine Instanz.
|
|
if nxt in nach_id and nxt not in gesehen:
|
|
queue.append(nxt)
|
|
for tro_id in sorted(nach_id):
|
|
if tro_id not in gesehen:
|
|
gesehen.append(tro_id)
|
|
return [nach_id[i] for i in gesehen], grund
|
|
|
|
|
|
def reachable_via(start: str, first: str, tros: dict[str, TroBase]) -> list[str]:
|
|
"""Welche TROs sind ueber diesen Abgang erreichbar?
|
|
|
|
Das ist die Zielliste eines Weichenabgangs: von `first` aus weiterlaufen,
|
|
ohne ueber die Weiche selbst zurueckzugehen. Genau die Information, die
|
|
FC_Direction braucht, um zu entscheiden - und sie steht im Graphen.
|
|
"""
|
|
gesehen: set[str] = set()
|
|
queue = deque([first])
|
|
while queue:
|
|
node = queue.popleft()
|
|
if node in gesehen or node == start:
|
|
continue
|
|
gesehen.add(node)
|
|
if node in tros:
|
|
queue.extend(tros[node].successors)
|
|
return sorted(gesehen)
|
|
|
|
|
|
def _nachbar(node: str, alle: dict[str, TroBase]) -> str:
|
|
"""Nachbar fuer Kommentare; SYSn als Station kenntlich machen."""
|
|
return node if node in alle else f"{node} (Station, kein TRO)"
|
|
|
|
|
|
def _region_title(tro: TroBase) -> str:
|
|
seps = ", ".join(tro.separators)
|
|
teile = f" Sep {seps}" if seps else ""
|
|
return f"{tro.tro_id} ({tro.type_name}){teile}"
|
|
|
|
|
|
def _nummer(tro_id: str) -> str:
|
|
treffer = re.search(r"(\d+)$", tro_id)
|
|
return treffer.group(1) if treffer else ""
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Kontext bauen
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _scanner(n: int, suffix: str, interface: str = "cScanner____") -> SclScanner:
|
|
return SclScanner(
|
|
n=n, suffix=suffix, interface=_offen(interface), tag=_offen("bx____"),
|
|
hw_results=_offen("BX____~Ergebnisse_\u2013_64_Bytes_1"),
|
|
)
|
|
|
|
|
|
def _jam(n: int, neighbour: str, jam_db: str, sensor: SclName | None = None,
|
|
jam_id: str = "") -> SclJam:
|
|
return SclJam(
|
|
n=n, jam_id=jam_id, neighbour=neighbour, db=_offen(jam_db), sensor=sensor,
|
|
carriers=_offen(f"{jam_db}.arCarrier"), data=_offen(f"{jam_db}.stData"),
|
|
)
|
|
|
|
|
|
def _store(tro: TroBase, eplan: EplanDocument | None = None) -> SclStore:
|
|
"""PinStore_Auto: eine Linie je Speicherbahn (Host) des Layouts.
|
|
|
|
tro_flow legt die Separatoren als [steuernde ..., Linien ...] ab; die
|
|
Linien sind die letzten len(hosts). Fehlen Hosts (fremde JSON), zaehlt
|
|
jeder Separator als Linie. Sensor und Stopper jeder Linie (und des
|
|
Pin-Separators, falls tro_flow einen gefunden hat) kommen aus der
|
|
E-Planung wie bei den Separatorbloecken.
|
|
"""
|
|
hosts = list(getattr(tro, "hosts", []) or [])
|
|
seps = list(tro.separators)
|
|
anzahl = len(hosts) if 0 < len(hosts) <= len(seps) else len(seps)
|
|
steuer, linien = seps[:len(seps) - anzahl], seps[len(seps) - anzahl:]
|
|
pin_sensor, pin_stopper = _sep_namen(steuer[0], eplan) if steuer else (
|
|
_offen("cInBG____"), _offen("MB____"))
|
|
zeilen = []
|
|
for n, sep in enumerate(linien, start=1):
|
|
sensor, stopper = _sep_namen(sep, eplan)
|
|
zeilen.append(SclStoreLine(n=n, layout=sep,
|
|
jam_length=_offen('"cStorage____ExitJam"'),
|
|
sensor=sensor, jam_sensor=_offen("cInBG____"),
|
|
stopper=stopper))
|
|
return SclStore(
|
|
encoder=_offen("#fbEncoder____"),
|
|
dest=_offen("cDest____"),
|
|
conv_stations=_offen("cHooksSorterMaxPin____"),
|
|
stations_max=_offen("cStationsMax____"),
|
|
threshold=_offen("cNoPositionsBlock____"),
|
|
reference_sensor=_offen("cInBG____"),
|
|
station=_offen("____"),
|
|
quit_local=_offen('"SF____"'),
|
|
test_target=_offen('"IBN".nTestTarget____'),
|
|
run_in=_offen("#fbSortConv____.xOutConveyorFullSpeed"),
|
|
run_out=_offen("#fbExitConv____.xOutConveyorFullSpeed"),
|
|
db=_offen('"DB_Storage____"'),
|
|
removal=_offen('"DB_HandshakeStorage".Str_StorageRemoval.'
|
|
'arrudt_StorageRemovalHandshakeTROsLvl1[____]'),
|
|
conv_db=_offen('"DB_ConveyorStations".stConveyorStations____'),
|
|
pin_layout=", ".join(steuer) or "?",
|
|
pin_sensor=pin_sensor,
|
|
pin_stopper=pin_stopper,
|
|
lines=zeilen,
|
|
)
|
|
|
|
|
|
def _sep_namen(layout: str, eplan: EplanDocument | None) -> tuple[SclName, SclName]:
|
|
"""Sensor und Stopperventil eines Layout-Separators aus der E-Planung.
|
|
|
|
Gilt fuer die Separatorbloecke (stInSeparator<n>) und genauso fuer die
|
|
Linien eines PinStore_Auto - beide sind Separatoren im Layout. Ohne
|
|
Zuordnung bleiben beide offen.
|
|
"""
|
|
rollen = eplan.for_layout(layout) if eplan is not None and layout != "?" else {}
|
|
sensor = rollen.get("sensor")
|
|
stopper = rollen.get("stopper")
|
|
return (_bekannt(_SENSOR.format(bmk=sensor.bmk)) if sensor else _offen("cInBG____"),
|
|
_bekannt(_VENTIL.format(bmk=stopper.bmk)) if stopper else _offen("MB____"))
|
|
|
|
|
|
def _separator(i: int, layout: str, eplan: EplanDocument | None) -> SclSeparator:
|
|
sensor, stopper = _sep_namen(layout, eplan)
|
|
return SclSeparator(
|
|
n=i,
|
|
layout=layout,
|
|
no=_offen("cSep_____"),
|
|
sensor=sensor,
|
|
stopper=stopper,
|
|
# Teilesensor kennt die E-Planung-Bruecke noch nicht - offen
|
|
part_sensor=_offen("cInBG____"),
|
|
)
|
|
|
|
|
|
def _entries(tro: TroBase, eigene: list[JamArea],
|
|
alle: dict[str, TroBase], jam_db: str) -> list[SclJam]:
|
|
"""Ein JamEntr je eigenem Staubereich - nicht je Vorgaenger: mehrere
|
|
Vorgaenger fahren in denselben Staubereich ein (Referenzen UH01-UH05)."""
|
|
eingaenge = []
|
|
for area in eigene:
|
|
von = ", ".join(_nachbar(v, alle) for v in area.predecessors) or "-"
|
|
if area.note:
|
|
von = f"{von} ({area.note})"
|
|
eingaenge.append(_jam(area.entry, von, jam_db, jam_id=area.jam_id))
|
|
return eingaenge
|
|
|
|
|
|
def _exit_area(tro_id: str, nach: str,
|
|
bereiche: dict[str, list[JamArea]]) -> str:
|
|
"""Kennung des Staubereichs, in den tro_id beim Nachfolger einfaehrt."""
|
|
ziel = bereiche.get(nach, [])
|
|
passend = [a for a in ziel if tro_id in a.predecessors] or ziel
|
|
return passend[0].jam_id if passend else ""
|
|
|
|
|
|
def _tro_context(tro: TroBase, alle: dict[str, TroBase],
|
|
eplan: EplanDocument | None = None,
|
|
bereiche: dict[str, list[JamArea]] | None = None) -> SclTro:
|
|
items = tro.items
|
|
n_sep = items.get(TroItem.SEPARATOR, 1)
|
|
n_swi = items.get(TroItem.SWITCH, 0)
|
|
n_scan = items.get(TroItem.SCANNER, 0)
|
|
tro_id = tro.tro_id
|
|
jam_db = '"DB_JamArea____".stJam____'
|
|
bereiche = bereiche or {}
|
|
|
|
separators = [
|
|
_separator(i, tro.separators[i - 1] if i <= len(tro.separators) else "?", eplan)
|
|
for i in range(1, n_sep + 1)
|
|
]
|
|
switches = [
|
|
SclSwitch(
|
|
n=j,
|
|
no=_offen("cSwi_____"),
|
|
valve=_offen("MB____"),
|
|
# Eine Weiche bedient alle Abgaenge - direkt ableitbar.
|
|
to1_destinations=len(tro.successors) if n_swi == 1 else None,
|
|
direction_target=(f"#{tro_id}.nInDirection" if n_swi == 1
|
|
else f"#{tro_id}.nInDirection{j}"),
|
|
jam_db=_offen(jam_db),
|
|
)
|
|
for j in range(1, n_swi + 1)
|
|
]
|
|
has_vario = bool(items.get(TroItem.VARIO_DRIVE))
|
|
vario_sensors = {
|
|
name: _offen("cInBG____")
|
|
for name in ("stSenCarrInPos", "stSenFinger", "stSenLastPos", "stSenJam")
|
|
} if has_vario else {}
|
|
switch_exits = [
|
|
SclSwitchExit(via=abgang, targets=reachable_via(tro_id, abgang, alle))
|
|
for abgang in tro.successors
|
|
] if n_swi else []
|
|
# Staubereiche aus der TRO-JSON (jamAreas): Eingaenge sind die eigenen
|
|
# (ein JamEntr je eigenem Staubereich, nicht je Vorgaenger), Ausgaenge die
|
|
# Eingaenge der Nachfolger. Der DB-Name braucht die Foerderernummer aus der
|
|
# Hardwareplanung und bleibt offen.
|
|
jam_entries = _entries(tro, bereiche.get(tro_id, []), alle, jam_db)
|
|
jam_exits = [
|
|
_jam(n, _nachbar(nach, alle), jam_db, sensor=_offen("cInBG____"),
|
|
jam_id=_exit_area(tro_id, nach, bereiche))
|
|
for n, nach in enumerate(tro.successors, start=2)
|
|
]
|
|
|
|
return SclTro(
|
|
id=tro_id,
|
|
nr=_nummer(tro_id),
|
|
type=tro.type_name,
|
|
fb=tro.fb_block or "FB_UNBEKANNT",
|
|
region_title=_region_title(tro),
|
|
layout_separators=list(tro.separators),
|
|
position=(tro.x, tro.y) if tro.position else None,
|
|
predecessors=list(tro.predecessors),
|
|
successors=list(tro.successors),
|
|
confidence=tro.confidence,
|
|
separators=separators,
|
|
switches=switches,
|
|
switch_exits=switch_exits,
|
|
has_vario=has_vario,
|
|
vario_sensors=vario_sensors,
|
|
scanners=[
|
|
_scanner(i, "" if n_scan == 1 else str(i))
|
|
for i in range(1, n_scan + 1)
|
|
],
|
|
storage_lines=items.get(TroItem.STORAGE_LINE, 0),
|
|
jam_entries=jam_entries,
|
|
jam_exits=jam_exits,
|
|
main_tro=_offen("cMainTro____"),
|
|
safety=_offen('"DB_InterfaceSafety".stFromSafety.EStopMain.Q'),
|
|
release=f'"DB_TRO_TEST".{tro_id}',
|
|
motor_protection=_offen('"FC____"'),
|
|
vario_motor=_offen("MA____"),
|
|
# Schaltschrank ist anlagenspezifisch ("...OF1" in der Referenz)
|
|
machine_state=_offen("#stInOutControlUnitCabinet"),
|
|
priority_udt=_offen("udt_____"),
|
|
# Vorschlag aus der Referenz TRO107, Prioritaet bleibt Planungsentscheidung
|
|
prio_dir2=_offen("TRUE"),
|
|
carousel_run=_offen("#fbCarousel____.xOutConveyorFullSpeed"),
|
|
# dasselbe Objekt wie der erste Ein-/Ausgang: ein Name, den die
|
|
# Namensregeln dort setzen, gilt damit auch hier
|
|
jam_in=jam_entries[0] if jam_entries else _jam(1, "-", jam_db),
|
|
jam_out=jam_exits[0] if jam_exits else _jam(2, "-", jam_db),
|
|
error_quit=_offen('"SF____"'),
|
|
automatic=_offen("#t_automatik"),
|
|
is_border=_offen("TRUE"),
|
|
correction_station=_offen("0"),
|
|
sscc=(SclSscc(scanner=_scanner(1, "SSCC", "#stCognexIntf____"),
|
|
end_sensor=_offen("cInBG____"), hmi=_offen("SSCC____"))
|
|
if items.get(TroItem.SSCC) else None),
|
|
work_station=(SclWorkStation(station_sensor=_offen("cInBG____"),
|
|
station_release=_offen('#"rTrig_Workstation ____".CLK'),
|
|
loaded_error_sensor=_offen("cInBG____"))
|
|
if items.get(TroItem.WORK_STATION) else None),
|
|
store=_store(tro, eplan) if items.get(TroItem.STORAGE_LINE) else None,
|
|
)
|
|
|
|
|
|
def build_context(document: TroDocument, source: str, start_id: str = "",
|
|
created: str | None = None,
|
|
eplan: EplanDocument | None = None) -> SclFile:
|
|
"""TroDocument -> SclFile (TROs in Fliessrichtung).
|
|
|
|
eplan: Zuordnung Layout -> E-Planung (e_planning.py); ohne sie bleiben
|
|
alle Namen offen und die Ausgabe ist die bisherige.
|
|
"""
|
|
alle = {t.tro_id: t for t in document.tros}
|
|
bereiche: dict[str, list[JamArea]] = {}
|
|
for area in document.jam_areas_or_derived():
|
|
bereiche.setdefault(area.tro, []).append(area)
|
|
geordnet, startgrund = flow_order(document.tros, start_id)
|
|
return SclFile(
|
|
source=source,
|
|
created=created or datetime.now().strftime("%Y-%m-%d %H:%M"),
|
|
start_reason=startgrund,
|
|
tros=[_tro_context(t, alle, eplan, bereiche) for t in geordnet],
|
|
eplan_source=(f"{eplan.eplan_file} (Zuordnung vom {eplan.created})"
|
|
if eplan is not None else ""),
|
|
)
|