Schoenenberger_Systeme_GmbH/HundM_awl
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bin Ordner mit setenv.bat angelegt. Skript zum Konvertieren der .xml Dateien in .awl in lib verschoben

Browse Source
This commit is contained in:
Michael Stangl
2026-07-08 09:28:30 +02:00
parent 52bcd08879
commit b41b7306ad
8 changed files with 661 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SCL-Export/README.md
+17 -4
View File
@@ -85,7 +85,20 @@ ersetzen (Aufrufer und Instanz-DBs bleiben gültig, neu übersetzen genügt).
## Werkzeug
`tools/stlxml2awl.py` wandelt die SimaticML-XML-Exporte (`StatementList`) in
lesbaren AWL-Text um (`python stlxml2awl.py <baustein.xml>`), inkl. Interface,
Netzwerktitel, Sprungmarken und Kommentaren — Grundlage für die
Massenkonvertierung der restlichen ~230 Bausteine.
`lib/stlxml2awl.py` (Projektwurzel) wandelt die SimaticML-XML-Exporte
(`StatementList`) in lesbaren AWL-Text um, inkl. Interface, Netzwerktitel,
Sprungmarken und Kommentaren — Grundlage für die Massenkonvertierung der
restlichen ~230 Bausteine. Aufruf über `bin/xmls2awl.bat`:
```
bin\xmls2awl.bat <baustein.xml> [<baustein2.xml> ...] REM einzelne Dateien
bin\xmls2awl.bat --dir <verzeichnis> REM rekursiv alle .xml -> .awl
```
Je `.xml` wird die `.awl` daneben abgelegt. Nicht-Baustein-Exporte (UDTs,
Tag-Tabellen) werden übersprungen. Zusätzlich schätzt das Skript pro Baustein
anhand von Sprung-/Label-Anzahl, registerindirekten Zugriffen und bekannten
Namensmustern eine der drei Aufwandskategorien (A/B/C, siehe oben) und
schreibt ein Log (`log/stlxml2awl_<Zeitstempel>.log`, mit `--log <pfad>`
überschreibbar) mit allen Bausteinen der Kategorien B/C sowie Fehlern — das
ist die Priorisierungsliste für die manuelle Nacharbeit.
SCL-Export/tools/stlxml2awl.py
-249
View File
@@ -1,249 +0,0 @@
#!/usr/bin/env python3
"""Wandelt TIA-Openness SimaticML XML (StatementList) in lesbaren AWL-Text um."""
import re
import sys
import xml.etree.ElementTree as ET
NS_IF = "{http://www.siemens.com/automation/Openness/SW/Interface/v5}"
NS_SL = "{http://www.siemens.com/automation/Openness/SW/NetworkSource/StatementList/v5}"
TOKEN_MAP = {
"A_BRACK": "A(", "O_BRACK": "O(", "AN_BRACK": "AN(", "ON_BRACK": "ON(",
"X_BRACK": "X(", "XN_BRACK": "XN(", "BRACKET": ")",
"NE_I": "<>I", "EQ_I": "==I", "GT_I": ">I", "LT_I": "<I", "GE_I": ">=I", "LE_I": "<=I",
"NE_D": "<>D", "EQ_D": "==D", "GT_D": ">D", "LT_D": "<D", "GE_D": ">=D", "LE_D": "<=D",
"NE_R": "<>R", "EQ_R": "==R", "GT_R": ">R", "LT_R": "<R", "GE_R": ">=R", "LE_R": "<=R",
"ADD_I": "+I", "SUB_I": "-I", "MUL_I": "*I", "DIV_I": "/I",
"ADD_D": "+D", "SUB_D": "-D", "MUL_D": "*D", "DIV_D": "/D",
"ADD_R": "+R", "SUB_R": "-R", "MUL_R": "*R", "DIV_R": "/R",
"ADD": "+", "NOP_0": "NOP 0", "NOP_1": "NOP 1",
"TAR2_ACCU1": "TAR2", "TAR1_ACCU1": "TAR1",
"LAR1_ACCU1": "LAR1", "LAR2_ACCU1": "LAR2",
"OPEN_DB": "OPN", "OPEN_DI": "OPN",
"EMPTY_LINE": "", "COMMENT": "//", "Assign": "=",
}
def fmt_symbol(access):
parts = []
for comp in access.findall(f"./{NS_SL}Symbol/{NS_SL}Component"):
name = comp.get("Name")
token = name if re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name) else f'"{name}"'
idx = [fmt_access(a) for a in comp.findall(f"{NS_SL}Access")]
if idx:
token += "[" + ",".join(idx) + "]"
if comp.get("SliceAccessModifier"):
token += "." + comp.get("SliceAccessModifier")
parts.append(token)
sym = ".".join(parts)
if access.get("Scope") == "GlobalVariable" and parts and not parts[0].startswith('"'):
sym = f'"{parts[0][1:-1] if parts[0].startswith(chr(34)) else parts[0]}"' + (
"." + ".".join(parts[1:]) if len(parts) > 1 else "")
return sym
def fmt_address(addr):
area = addr.get("Area")
typ = addr.get("Type")
bit = int(addr.get("BitOffset", 0))
blk = addr.get("BlockNumber")
width = {"Bool": 1, "Byte": 8, "Word": 16, "DWord": 32, "Int": 16, "DInt": 32}.get(typ, 0)
sizech = {1: "", 8: "B", 16: "W", 32: "D"}.get(width, "?")
areach = {"Local": "L", "Memory": "M", "Input": "I", "Output": "Q", "DB": "DB", "DI": "DI",
"Timer": "T", "Counter": "C", "PeripheryInput": "PI", "PeripheryOutput": "PQ"}.get(area, area)
if area in ("DB", "DI"):
pre = f"DB{blk}." if blk else ""
core = f"{pre}{'DBX' if width == 1 else 'DB' + sizech}{bit // 8}"
elif area == "Timer":
return f"T {bit}"
elif area == "Counter":
return f"C {bit}"
else:
core = f"{areach}{sizech}{bit // 8}"
if width == 1:
core += f".{bit % 8}"
return core
def fmt_indirect(ind):
width = ind.get("Width")
area = ind.get("Area")
reg = ind.get("Register", "")
inner = [fmt_access(a) for a in ind.findall(f"{NS_SL}Access")]
const = ind.find(f"{NS_SL}Constant")
off = ""
if const is not None:
off = const.findtext(f"{NS_SL}ConstantValue", "")
if width == "Block": # OPN DB[var]
return f"DB[{inner[0]}]" if inner else f"DB[{off}]"
sizech = {"Bit": "X", "Byte": "B", "Word": "W", "Double": "D", "DWord": "D"}.get(width, "?")
areach = {"DB": "DB", "DI": "DI", "Local": "L", "Memory": "M", "Input": "I", "Output": "Q"}.get(area, area or "")
base = f"{areach}{sizech}" if areach not in ("DB", "DI") else f"{areach}{sizech}"
if reg: # registerindirekt
return f"{base} [{reg},{off}]"
if inner: # speicherindirekt
return f"{base} [{inner[0]}]"
return f"{base} [{off}]"
def fmt_access(access):
scope = access.get("Scope")
if scope in ("LocalVariable", "GlobalVariable", "LocalConstant", "GlobalConstant"):
return fmt_symbol(access)
if scope in ("LiteralConstant", "TypedConstant"):
c = access.find(f"{NS_SL}Constant")
val = c.findtext(f"{NS_SL}ConstantValue", "") if c is not None else ""
typ = c.findtext(f"{NS_SL}ConstantType", "") if c is not None else ""
pref = {"Word": "W#16#", "DWord": "DW#16#", "Time": "", "S5Time": "", "Byte": "B#16#"}
if typ in ("Word", "DWord", "Byte") and not val.startswith(("2#", "16#", "W#", "DW#", "B#")):
return pref[typ] + val
return val
if scope == "AddressConstant":
c = access.find(f"{NS_SL}Constant")
return "P#" + c.findtext(f"{NS_SL}ConstantValue", "") if c is not None else "P#?"
if scope == "Address":
addr = access.find(f"{NS_SL}Address")
if addr is not None:
return fmt_address(addr)
ind = access.find(f"{NS_SL}Indirect")
if ind is not None:
return fmt_indirect(ind)
return "?ADDR?"
if scope == "Label":
lab = access.find(f"{NS_SL}Label")
return lab.get("Name") if lab is not None else "?LBL?"
if scope == "LabelDefinition":
lab = access.find(f"{NS_SL}Label")
return (lab.get("Name") + ":") if lab is not None else "?LBL?:"
if scope == "Statusword":
return access.find(f"{NS_SL}Statusword").get("Name", "?SW?")
if scope == "Call":
ci = access.find(f"{NS_SL}CallInfo")
if ci is None:
ins = access.find(f"{NS_SL}Instruction")
name = ins.get("Name")
params = []
for p in ins.findall(f"{NS_SL}Parameter"):
pa = p.find(f"{NS_SL}Access")
params.append(f"{p.get('Name')}:={fmt_access(pa) if pa is not None else '?'}")
return f"CALLINFO SYS \"{name}\" (" + ", ".join(params) + ")"
name, btype = ci.get("Name"), ci.get("BlockType")
inst = ci.find(f"{NS_SL}Instance")
s = f'"{name}"'
if inst is not None:
s += " , " + fmt_symbol(inst)
params = []
for p in ci.findall(f"{NS_SL}Parameter"):
pa = p.find(f"{NS_SL}Access")
params.append(f"{p.get('Name')}:={fmt_access(pa) if pa is not None else '?'}")
if params:
s += " (" + ", ".join(params) + ")"
return f"CALLINFO {btype} {s}"
return f"?{scope}?"
def render_statement(st):
label = ""
ld = st.find(f"{NS_SL}LabelDeclaration/{NS_SL}Label")
if ld is not None:
label = ld.get("Name") + ": "
toks = st.findall(f"{NS_SL}StlToken")
accesses = st.findall(f"{NS_SL}Access")
comments = []
for lc in st.iter(f"{NS_SL}LineComment"):
t = lc.findtext(f"{NS_SL}Text", "")
if t:
comments.append(t)
for cm in st.findall(f"{NS_SL}Comment"):
t = cm.findtext(f"{NS_SL}Text", "")
if t:
comments.append(t)
if not toks:
if label:
return label.rstrip()
return "// " + " | ".join(comments) if comments else ""
tok = toks[0].get("Text")
mn = TOKEN_MAP.get(tok, tok)
if tok == "EMPTY_LINE":
return label.rstrip() if label else ""
if tok == "COMMENT":
return "// " + " | ".join(comments)
ops = []
for a in accesses:
f = fmt_access(a)
if f.startswith("CALLINFO"):
return f"{label}CALL {f[9:]}" + (" // " + " | ".join(comments) if comments else "")
ops.append(f)
line = f"{label:6s}{mn:6s} " + ", ".join(ops)
if comments:
line = f"{line:60s} // " + " | ".join(comments)
return line.rstrip()
def render_interface(root):
out = []
for sec in root.iter(f"{NS_IF}Section"):
members = sec.findall(f"{NS_IF}Member")
out.append(f" {sec.get('Name')}:")
for m in members:
out.extend(render_member(m, 4))
return out
def render_member(m, indent):
out = []
cm = m.find(f"{NS_IF}Comment/{NS_IF}MultiLanguageText")
sv = m.findtext(f"{NS_IF}StartValue")
line = " " * indent + f"{m.get('Name')} : {m.get('Datatype')}"
if sv:
line += f" := {sv}"
if cm is not None and cm.text:
line = f"{line:55s} // {cm.text}"
out.append(line)
for sub in m.findall(f"{NS_IF}Member"):
out.extend(render_member(sub, indent + 2))
return out
def main(path):
s = open(path, encoding="utf-8").read()
root = ET.fromstring(s)
blk = None
for tag in ("FB", "FC", "OB", "GlobalDB", "InstanceDB"):
blk = root.find(f".//SW.Blocks.{tag}")
if blk is not None:
btype = tag
break
attrs = blk.find("AttributeList")
name = attrs.findtext("Name")
num = attrs.findtext("Number")
lang = attrs.findtext("ProgrammingLanguage")
print(f"=== {btype} {num}: {name} [{lang}] ===")
iface = attrs.find("Interface")
if iface is not None:
secs = iface.find(f"{NS_IF}Sections")
if secs is not None:
print("INTERFACE:")
for line in render_interface(secs):
print(line)
nwno = 0
for cu in blk.iter("SW.Blocks.CompileUnit"):
nwno += 1
title = ""
for mt in cu.iter("MultilingualTextItem"):
al = mt.find("AttributeList")
if al is not None and al.findtext("Culture") == "de-DE" and al.findtext("Text"):
title = al.findtext("Text")
break
print(f"\n--- NW {nwno}: {title} ---")
src = cu.find(f".//{NS_SL}StatementList")
if src is None:
print(" (kein STL-Quelltext)")
continue
for st in src.findall(f"{NS_SL}StlStatement"):
print(render_statement(st))
if __name__ == "__main__":
for p in sys.argv[1:]:
main(p)
bin/activate_venv.bat
+20
View File
@@ -0,0 +1,20 @@
@echo off
REM ================================================================
REM HundM_Fortna - Python Virtual Environment aktivieren
REM ================================================================
call "%~dp0setenv.bat"
if not exist "%PROJECT%\.venv" (
echo FEHLER: Virtual environment nicht gefunden.
echo Bitte zuerst bin\install_py.bat ausfuehren.
exit /b 1
)
call "%PROJECT%\.venv\Scripts\activate.bat"
echo Virtuelle Umgebung aktiviert.
echo Python-Version:
python --version
echo.
echo Installierte Pakete:
pip list
bin/get_cmd.bat
+7
View File
@@ -0,0 +1,7 @@
@echo off
REM ================================================================
REM HundM_Fortna - Shell mit gesetzten Umgebungsvariablen oeffnen
REM ================================================================
call "%~dp0setenv.bat"
start cmd /k "echo HundM_Fortna Umgebung aktiv. && echo PROJECT=%PROJECT%"
bin/install_py.bat
+21
View File
@@ -0,0 +1,21 @@
@echo off
REM ================================================================
REM HundM_Fortna - Python Virtual Environment einrichten
REM ================================================================
call "%~dp0setenv.bat"
if not exist "%PROJECT%\.venv" (
echo Initialisiere Python virtual environment...
py -m venv "%PROJECT%\.venv" --upgrade-deps
echo Erfolgreich.
call "%PROJECT%\.venv\Scripts\activate.bat"
echo Installiere erforderliche Python Packages...
pip install -r "%PROJECT%\requirements.txt" -q
echo Erfolgreich.
deactivate
) else (
echo .venv existiert bereits - Abbruch.
echo Zum Neuaufsetzen .venv loeschen und install_py.bat erneut ausfuehren.
)
bin/setenv.bat
+56
View File
@@ -0,0 +1,56 @@
@echo off
REM ================================================================
REM HundM_Fortna - Umgebungsvariablen Setup
REM ================================================================
echo Setting up environment variables for HundM_Fortna ...
REM Basis-Projektpfad (Elternordner von bin\)
set "PROJECT=%~dp0.."
if "%PROJECT:~-6%"=="bin\.." set "PROJECT=%PROJECT:~0,-6%"
if "%PROJECT:~-1%"=="\" set "PROJECT=%PROJECT:~0,-1%"
REM Pfade fuer die Komponenten
set "PV_BIN=%PROJECT%\bin"
set "PV_LIB=%PROJECT%\lib"
set "PV_CFG=%PROJECT%\cfg"
set "PV_DATA=%PROJECT%\data"
set "PV_DOC=%PROJECT%\doc"
set "PV_TESTS=%PROJECT%\tests"
REM PYTHONPATH um PV_LIB erweitern (nur wenn noch nicht enthalten)
if not defined PYTHONPATH (
set "PYTHONPATH=%PV_LIB%"
) else (
echo.%PYTHONPATH% | find /i "%PV_LIB%" >nul || set "PYTHONPATH=%PYTHONPATH%;%PV_LIB%"
)
REM Ueberladen von Umgebungsvariablen durch _setenv.bat
REM (z.B. PV_DATA auf einen Netzlaufwerk-Pfad umbiegen)
if exist "%~dp0_setenv.bat" (
echo Lade lokale Umgebungseinstellungen aus _setenv.bat...
call "%~dp0_setenv.bat"
)
REM Ordner erstellen falls sie nicht existieren
if not exist "%PV_BIN%" mkdir "%PV_BIN%"
if not exist "%PV_LIB%" mkdir "%PV_LIB%"
if not exist "%PV_CFG%" mkdir "%PV_CFG%"
if not exist "%PV_DATA%" mkdir "%PV_DATA%"
if not exist "%PV_TESTS%" mkdir "%PV_TESTS%"
REM Umgebungsvariablen anzeigen
echo.
echo ================================================================
echo PROJECT = %PROJECT%
echo PV_BIN = %PV_BIN%
echo PV_LIB = %PV_LIB%
echo PV_CFG = %PV_CFG%
echo PV_DATA = %PV_DATA%
echo PV_LOG = %PV_LOG%
echo PV_RESULTS = %PV_RESULTS%
echo PV_EXAMPLES = %PV_EXAMPLES%
echo PV_TESTS = %PV_TESTS%
echo PYTHONPATH = %PYTHONPATH%
echo ================================================================
echo.
bin/xmls2awl.bat
+19
View File
@@ -0,0 +1,19 @@
@echo off
REM ================================================================
REM Konvertiert die xml Dateien in awl Dateien
REM
REM ================================================================
call "%~dp0setenv.bat"
REM .venv bevorzugen, sonst System-Python
set "PYTHON=python"
if exist "%PROJECT%\.venv\Scripts\python.exe" (
set "PYTHON=%PROJECT%\.venv\Scripts\python.exe"
)
"%PYTHON%" "%PV_LIB%\stlxml2awl.py" %*
if errorlevel 1 (
echo FEHLER: stlxml2awl.py wurde mit Fehler beendet.
exit /b 1
)
lib/stlxml2awl.py
+521
View File
@@ -0,0 +1,521 @@
#!/usr/bin/env python3
"""Wandelt TIA-Openness SimaticML XML (StatementList) in lesbaren AWL-Text um."""
import argparse
import datetime
import re
import sys
from pathlib import Path
import xml.etree.ElementTree as ET
NS_IF = "{http://www.siemens.com/automation/Openness/SW/Interface/v5}"
NS_SL = "{http://www.siemens.com/automation/Openness/SW/NetworkSource/StatementList/v5}"
TOKEN_MAP = {
"A_BRACK": "A(", "O_BRACK": "O(", "AN_BRACK": "AN(", "ON_BRACK": "ON(",
"X_BRACK": "X(", "XN_BRACK": "XN(", "BRACKET": ")",
"NE_I": "<>I", "EQ_I": "==I", "GT_I": ">I", "LT_I": "<I", "GE_I": ">=I", "LE_I": "<=I",
"NE_D": "<>D", "EQ_D": "==D", "GT_D": ">D", "LT_D": "<D", "GE_D": ">=D", "LE_D": "<=D",
"NE_R": "<>R", "EQ_R": "==R", "GT_R": ">R", "LT_R": "<R", "GE_R": ">=R", "LE_R": "<=R",
"ADD_I": "+I", "SUB_I": "-I", "MUL_I": "*I", "DIV_I": "/I",
"ADD_D": "+D", "SUB_D": "-D", "MUL_D": "*D", "DIV_D": "/D",
"ADD_R": "+R", "SUB_R": "-R", "MUL_R": "*R", "DIV_R": "/R",
"ADD": "+", "NOP_0": "NOP 0", "NOP_1": "NOP 1",
"TAR2_ACCU1": "TAR2", "TAR1_ACCU1": "TAR1",
"LAR1_ACCU1": "LAR1", "LAR2_ACCU1": "LAR2",
"OPEN_DB": "OPN", "OPEN_DI": "OPN",
"EMPTY_LINE": "", "COMMENT": "//", "Assign": "=",
}
def fmt_symbol(access):
parts = []
for comp in access.findall(f"./{NS_SL}Symbol/{NS_SL}Component"):
name = comp.get("Name")
token = name if re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name) else f'"{name}"'
idx = [fmt_access(a) for a in comp.findall(f"{NS_SL}Access")]
if idx:
token += "[" + ",".join(idx) + "]"
if comp.get("SliceAccessModifier"):
token += "." + comp.get("SliceAccessModifier")
parts.append(token)
sym = ".".join(parts)
if access.get("Scope") == "GlobalVariable" and parts and not parts[0].startswith('"'):
sym = f'"{parts[0][1:-1] if parts[0].startswith(chr(34)) else parts[0]}"' + (
"." + ".".join(parts[1:]) if len(parts) > 1 else "")
return sym
def fmt_address(addr):
area = addr.get("Area")
typ = addr.get("Type")
bit = int(addr.get("BitOffset", 0))
blk = addr.get("BlockNumber")
width = {"Bool": 1, "Byte": 8, "Word": 16, "DWord": 32, "Int": 16, "DInt": 32}.get(typ, 0)
sizech = {1: "", 8: "B", 16: "W", 32: "D"}.get(width, "?")
areach = {"Local": "L", "Memory": "M", "Input": "I", "Output": "Q", "DB": "DB", "DI": "DI",
"Timer": "T", "Counter": "C", "PeripheryInput": "PI", "PeripheryOutput": "PQ"}.get(area, area)
if area in ("DB", "DI"):
pre = f"DB{blk}." if blk else ""
core = f"{pre}{'DBX' if width == 1 else 'DB' + sizech}{bit // 8}"
elif area == "Timer":
return f"T {bit}"
elif area == "Counter":
return f"C {bit}"
else:
core = f"{areach}{sizech}{bit // 8}"
if width == 1:
core += f".{bit % 8}"
return core
def fmt_indirect(ind):
width = ind.get("Width")
area = ind.get("Area")
reg = ind.get("Register", "")
inner = [fmt_access(a) for a in ind.findall(f"{NS_SL}Access")]
const = ind.find(f"{NS_SL}Constant")
off = ""
if const is not None:
off = const.findtext(f"{NS_SL}ConstantValue", "")
if width == "Block": # OPN DB[var]
return f"DB[{inner[0]}]" if inner else f"DB[{off}]"
sizech = {"Bit": "X", "Byte": "B", "Word": "W", "Double": "D", "DWord": "D"}.get(width, "?")
areach = {"DB": "DB", "DI": "DI", "Local": "L", "Memory": "M", "Input": "I", "Output": "Q"}.get(area, area or "")
base = f"{areach}{sizech}" if areach not in ("DB", "DI") else f"{areach}{sizech}"
if reg: # registerindirekt
return f"{base} [{reg},{off}]"
if inner: # speicherindirekt
return f"{base} [{inner[0]}]"
return f"{base} [{off}]"
def fmt_access(access):
scope = access.get("Scope")
if scope in ("LocalVariable", "GlobalVariable", "LocalConstant", "GlobalConstant"):
return fmt_symbol(access)
if scope in ("LiteralConstant", "TypedConstant"):
c = access.find(f"{NS_SL}Constant")
val = c.findtext(f"{NS_SL}ConstantValue", "") if c is not None else ""
typ = c.findtext(f"{NS_SL}ConstantType", "") if c is not None else ""
pref = {"Word": "W#16#", "DWord": "DW#16#", "Time": "", "S5Time": "", "Byte": "B#16#"}
if typ in ("Word", "DWord", "Byte") and not val.startswith(("2#", "16#", "W#", "DW#", "B#")):
return pref[typ] + val
return val
if scope == "AddressConstant":
c = access.find(f"{NS_SL}Constant")
return "P#" + c.findtext(f"{NS_SL}ConstantValue", "") if c is not None else "P#?"
if scope == "Address":
addr = access.find(f"{NS_SL}Address")
if addr is not None:
return fmt_address(addr)
ind = access.find(f"{NS_SL}Indirect")
if ind is not None:
return fmt_indirect(ind)
return "?ADDR?"
if scope == "Label":
lab = access.find(f"{NS_SL}Label")
return lab.get("Name") if lab is not None else "?LBL?"
if scope == "LabelDefinition":
lab = access.find(f"{NS_SL}Label")
return (lab.get("Name") + ":") if lab is not None else "?LBL?:"
if scope == "Statusword":
return access.find(f"{NS_SL}Statusword").get("Name", "?SW?")
if scope == "Call":
ci = access.find(f"{NS_SL}CallInfo")
if ci is None:
ins = access.find(f"{NS_SL}Instruction")
name = ins.get("Name")
params = []
for p in ins.findall(f"{NS_SL}Parameter"):
pa = p.find(f"{NS_SL}Access")
params.append(f"{p.get('Name')}:={fmt_access(pa) if pa is not None else '?'}")
return f"CALLINFO SYS \"{name}\" (" + ", ".join(params) + ")"
name, btype = ci.get("Name"), ci.get("BlockType")
inst = ci.find(f"{NS_SL}Instance")
s = f'"{name}"'
if inst is not None:
s += " , " + fmt_symbol(inst)
params = []
for p in ci.findall(f"{NS_SL}Parameter"):
pa = p.find(f"{NS_SL}Access")
params.append(f"{p.get('Name')}:={fmt_access(pa) if pa is not None else '?'}")
if params:
s += " (" + ", ".join(params) + ")"
return f"CALLINFO {btype} {s}"
return f"?{scope}?"
def render_statement(st):
label = ""
ld = st.find(f"{NS_SL}LabelDeclaration/{NS_SL}Label")
if ld is not None:
label = ld.get("Name") + ": "
toks = st.findall(f"{NS_SL}StlToken")
accesses = st.findall(f"{NS_SL}Access")
comments = []
for lc in st.iter(f"{NS_SL}LineComment"):
t = lc.findtext(f"{NS_SL}Text", "")
if t:
comments.append(t)
for cm in st.findall(f"{NS_SL}Comment"):
t = cm.findtext(f"{NS_SL}Text", "")
if t:
comments.append(t)
if not toks:
if label:
return label.rstrip()
return "// " + " | ".join(comments) if comments else ""
tok = toks[0].get("Text")
mn = TOKEN_MAP.get(tok, tok)
if tok == "EMPTY_LINE":
return label.rstrip() if label else ""
if tok == "COMMENT":
return "// " + " | ".join(comments)
ops = []
for a in accesses:
f = fmt_access(a)
if f.startswith("CALLINFO"):
return f"{label}CALL {f[9:]}" + (" // " + " | ".join(comments) if comments else "")
ops.append(f)
line = f"{label:6s}{mn:6s} " + ", ".join(ops)
if comments:
line = f"{line:60s} // " + " | ".join(comments)
return line.rstrip()
def render_interface(root):
out = []
for sec in root.iter(f"{NS_IF}Section"):
members = sec.findall(f"{NS_IF}Member")
out.append(f" {sec.get('Name')}:")
for m in members:
out.extend(render_member(m, 4))
return out
def render_member(m, indent):
out = []
cm = m.find(f"{NS_IF}Comment/{NS_IF}MultiLanguageText")
sv = m.findtext(f"{NS_IF}StartValue")
line = " " * indent + f"{m.get('Name')} : {m.get('Datatype')}"
if sv:
line += f" := {sv}"
if cm is not None and cm.text:
line = f"{line:55s} // {cm.text}"
out.append(line)
for sub in m.findall(f"{NS_IF}Member"):
out.extend(render_member(sub, indent + 2))
return out
def parse_block(path):
text = path.read_text(encoding="utf-8")
root = ET.fromstring(text)
for tag in ("FB", "FC", "OB", "GlobalDB", "InstanceDB"):
blk = root.find(f".//SW.Blocks.{tag}")
if blk is not None:
return blk, tag
return None, None
def render_block(blk, btype):
out = []
attrs = blk.find("AttributeList")
name = attrs.findtext("Name")
num = attrs.findtext("Number")
lang = attrs.findtext("ProgrammingLanguage")
out.append(f"=== {btype} {num}: {name} [{lang}] ===")
iface = attrs.find("Interface")
if iface is not None:
secs = iface.find(f"{NS_IF}Sections")
if secs is not None:
out.append("INTERFACE:")
out.extend(render_interface(secs))
nwno = 0
for cu in blk.iter("SW.Blocks.CompileUnit"):
nwno += 1
title = ""
for mt in cu.iter("MultilingualTextItem"):
al = mt.find("AttributeList")
if al is not None and al.findtext("Culture") == "de-DE" and al.findtext("Text"):
title = al.findtext("Text")
break
out.append(f"\n--- NW {nwno}: {title} ---")
src = cu.find(f".//{NS_SL}StatementList")
if src is None:
out.append(" (kein STL-Quelltext)")
continue
for st in src.findall(f"{NS_SL}StlStatement"):
out.append(render_statement(st))
return out, name, num
# ---------------------------------------------------------------------------
# Komplexitaets-Analyse / Kategorisierung
#
# Kategorie A: einfache Verknuepfungslogik, nahezu mechanische 1:1-Uebersetzung
# Kategorie B: Ablaufsteuerung mit vielen Sprüngen, Kontrollfluss muss zu
# IF/CASE rekonstruiert werden
# Kategorie C: Pointer-/Indirektzugriffe (registerindirekte Adressierung),
# hoechster Aufwand, Registeremulation nicht sinnvoll
# ---------------------------------------------------------------------------
JUMP_TOKENS = {
"JU", "JC", "JCN", "JL", "JP", "JBI", "JNBI",
"JZ", "JN", "JM", "JMZ", "JPZ", "JO", "JOS", "JUO", "LOOP",
}
INDIRECT_CALL_TOKENS = {"UC", "CC"}
POINTER_ARITH_TOKENS = {
"LAR1_ACCU1", "LAR2_ACCU1", "TAR1_ACCU1", "TAR2_ACCU1", "ADDAR1", "ADDAR2",
}
def _pat(p):
return re.compile(p, re.IGNORECASE)
# Namensmuster aus der Projekt-Klassifizierung (bekannte Bausteingruppen)
C_NAME_PATTERNS = [
_pat(r"^Daten\w*$"),
_pat(r"^Fifo"),
_pat(r"^DBMOV$"),
_pat(r"(^|[\\/])Logistik([\\/]|$)"),
_pat(r"(^|[\\/])SS_Host([\\/]|$)"),
_pat(r"(^|[\\/])Visualisierung([\\/]|$)"),
]
B_NAME_PATTERNS = [
_pat(r"^MHM"),
_pat(r"_Bereich$"),
_pat(r"_OmniFahren$"),
_pat(r"_Ziel_FC$"),
]
A_NAME_PATTERNS = [
_pat(r"^MZylinder$"),
_pat(r"^MSensoren$"),
_pat(r"^MBlinken$"),
_pat(r"^MAntrieb_"),
_pat(r"(^|[\\/])Basics[_\\/]"),
_pat(r"^Set_(Input|Output)$"),
]
def classify_by_name(xml_path):
stem = xml_path.stem
full = str(xml_path)
for patterns, cat in ((C_NAME_PATTERNS, "C"), (B_NAME_PATTERNS, "B"), (A_NAME_PATTERNS, "A")):
for pat in patterns:
if pat.search(stem) or pat.search(full):
return cat
return None
class Complexity:
def __init__(self):
self.jumps = 0
self.labels = 0
self.indirect_calls = 0
self.register_indirect = 0
self.pointer_arith = 0
self.networks = 0
@property
def has_pointer_signal(self):
return self.register_indirect > 0 or self.pointer_arith > 0
@property
def has_branch_signal(self):
return self.indirect_calls > 0
def analyze_complexity(blk):
c = Complexity()
c.networks = sum(1 for _ in blk.iter("SW.Blocks.CompileUnit"))
for st in blk.iter(f"{NS_SL}StlStatement"):
toks = st.findall(f"{NS_SL}StlToken")
if toks:
text = toks[0].get("Text")
if text in JUMP_TOKENS:
c.jumps += 1
if text in INDIRECT_CALL_TOKENS:
c.indirect_calls += 1
if text in POINTER_ARITH_TOKENS:
c.pointer_arith += 1
if st.find(f"{NS_SL}LabelDeclaration") is not None:
c.labels += 1
for ind in blk.iter(f"{NS_SL}Indirect"):
if ind.get("Register"):
c.register_indirect += 1
return c
def classify(xml_path, complexity):
if complexity.has_pointer_signal:
return "C", f"registerindirekte Adressierung ({complexity.register_indirect}x Indirect, {complexity.pointer_arith}x AR-Arithmetik)"
name_cat = classify_by_name(xml_path)
if name_cat == "C":
return "C", "Namensmuster (Daten*/Fifo*/DBMOV/Logistik/SS_Host/Visualisierung)"
if complexity.has_branch_signal:
return "B", f"{complexity.indirect_calls}x indirekter Aufruf (UC/CC) - CASE-Verteiler noetig"
if name_cat == "B":
return "B", "Namensmuster (HM-Module/_Bereich/_OmniFahren/_Ziel_FC)"
if name_cat == "A":
return "A", "Namensmuster (einfache Verknuepfungslogik)"
return "A", "kein Namensmuster erkannt, keine Pointer-/Sprungauffaelligkeiten"
class NotABlockError(Exception):
"""XML enthaelt keinen SW.Blocks-Export (z.B. UDT, Tag-Tabelle)."""
class ConversionResult:
def __init__(self, xml_path, awl_path, btype, name, num, complexity, category, reason):
self.xml_path = xml_path
self.awl_path = awl_path
self.btype = btype
self.name = name
self.num = num
self.complexity = complexity
self.category = category
self.reason = reason
def convert_file(xml_path):
blk, btype = parse_block(xml_path)
if blk is None:
raise NotABlockError("kein SW.Blocks-Element gefunden (kein Baustein-Export)")
lines, name, num = render_block(blk, btype)
awl_path = xml_path.with_suffix(".awl")
awl_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
complexity = analyze_complexity(blk)
category, reason = classify(xml_path, complexity)
return ConversionResult(xml_path, awl_path, btype, name, num, complexity, category, reason)
# ---------------------------------------------------------------------------
# CLI / Massenkonvertierung
# ---------------------------------------------------------------------------
def find_xml_files(directory):
return sorted(Path(directory).rglob("*.xml"))
def default_log_path():
project_root = Path(__file__).resolve().parent.parent
log_dir = project_root / "log"
log_dir.mkdir(parents=True, exist_ok=True)
ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
return log_dir / f"stlxml2awl_{ts}.log"
def _format_result_line(r):
c = r.complexity
stats = (f"Sprünge={c.jumps} Labels={c.labels} IndirekteAufrufe={c.indirect_calls} "
f"RegisterIndirekt={c.register_indirect} AR-Arithmetik={c.pointer_arith} NW={c.networks}")
return (f"{r.btype:10s} {str(r.num or ''):>5s} {r.name or '':30s} [{stats}]\n"
f" Grund: {r.reason}\n"
f" Pfad : {r.xml_path}")
def write_log(log_path, results, skipped, errors):
log_path.parent.mkdir(parents=True, exist_ok=True)
lines = []
ts = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
lines.append(f"STL -> AWL Konvertierung ({ts})")
lines.append("=" * 70)
lines.append("")
lines.append(f"Konvertiert : {len(results)}")
lines.append(f"Uebersprungen (kein Baustein) : {len(skipped)}")
lines.append(f"Fehler : {len(errors)}")
lines.append("")
by_cat = {"A": [], "B": [], "C": []}
for r in results:
by_cat[r.category].append(r)
lines.append(f"Kategorie A (einfache Verknuepfungslogik) : {len(by_cat['A'])}")
lines.append(f"Kategorie B (Ablaufsteuerung/Sprungmarken) : {len(by_cat['B'])}")
lines.append(f"Kategorie C (Pointer-/Indirektzugriffe) : {len(by_cat['C'])}")
lines.append("")
lines.append("Hinweis: automatische Einschaetzung anhand Codeanalyse (registerindirekte")
lines.append("Zugriffe, indirekte Aufrufe) und bekannter Namensmuster. Ersetzt keine")
lines.append("fachliche Pruefung, dient als Priorisierungshilfe fuer die Massenkonvertierung.")
lines.append("")
if by_cat["C"]:
lines.append("-" * 70)
lines.append(f"Kategorie C - Pointer-/Indirektzugriffe: MANUELLE UEBERARBEITUNG NOETIG ({len(by_cat['C'])})")
lines.append("-" * 70)
for r in sorted(by_cat["C"], key=lambda r: str(r.xml_path)):
lines.append(_format_result_line(r))
lines.append("")
if by_cat["B"]:
lines.append("-" * 70)
lines.append(f"Kategorie B - Ablaufsteuerung/viele Sprungmarken: REVIEW ERFORDERLICH ({len(by_cat['B'])})")
lines.append("-" * 70)
for r in sorted(by_cat["B"], key=lambda r: str(r.xml_path)):
lines.append(_format_result_line(r))
lines.append("")
if errors:
lines.append("-" * 70)
lines.append(f"Fehler bei der Konvertierung ({len(errors)})")
lines.append("-" * 70)
for path, exc in errors:
lines.append(f"{path}: {exc}")
lines.append("")
if skipped:
lines.append("-" * 70)
lines.append(f"Uebersprungen ({len(skipped)}, kein Baustein-Export, z.B. UDT/Tag-Tabelle)")
lines.append("-" * 70)
for path in skipped:
lines.append(str(path))
lines.append("")
log_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
def main(argv=None):
parser = argparse.ArgumentParser(
description="Wandelt TIA-Openness SimaticML XML (StatementList) in lesbaren AWL-Text um.")
parser.add_argument("files", nargs="*", type=Path, help="Einzelne XML-Dateien")
parser.add_argument("--dir", "--directory", dest="directory", type=Path,
help="Verzeichnis rekursiv nach .xml-Dateien durchsuchen und alle konvertieren")
parser.add_argument("--log", type=Path,
help="Pfad der Log-Datei (Default: <Projekt>/log/stlxml2awl_<Zeitstempel>.log)")
args = parser.parse_args(argv)
targets = list(args.files)
if args.directory:
targets.extend(find_xml_files(args.directory))
if not targets:
parser.error("keine XML-Dateien angegeben (Pfade und/oder --dir)")
results, skipped, errors = [], [], []
for xml_path in targets:
try:
result = convert_file(xml_path)
results.append(result)
print(f"OK [{result.category}] {xml_path} -> {result.awl_path.name}")
except NotABlockError:
skipped.append(xml_path)
except Exception as exc:
errors.append((xml_path, exc))
print(f"FEHLER {xml_path}: {exc}", file=sys.stderr)
log_path = args.log or default_log_path()
write_log(log_path, results, skipped, errors)
print()
print(f"{len(results)} konvertiert, {len(skipped)} uebersprungen, {len(errors)} Fehler.")
print(f"Kategorie A/B/C: "
f"{sum(1 for r in results if r.category == 'A')}/"
f"{sum(1 for r in results if r.category == 'B')}/"
f"{sum(1 for r in results if r.category == 'C')}")
print(f"Log: {log_path}")
return 1 if errors else 0
if __name__ == "__main__":
sys.exit(main())