TIA Portal mit Python steuern: Mechanik und Grenzen

Deshalb gehört der Pfad nicht ins Skript, sondern in eine Abfrage: Die Registry ist die einzige Quelle, die beide Ablagen kennt — und sie ist zugleich der Weg, den Siemens für die eigene .NET-Welt empfiehlt.

1. Die Umgebung festschreiben, bevor Code entsteht

   PowerShell

   Drei Dinge entscheiden über Erfolg oder Fehlersuche, und keines davon steht im Skript: welcher Interpreter läuft, ob eine Laufzeitvorgabe in der Umgebung steht, und ob der ausführende Benutzer überhaupt hineindarf.

   umgebung.ps1PowerShell

   # Welche Interpreter sind installiert, und welcher davon ist 64 Bit?
   py -0p
   py -3.12 -c "import sys; print(sys.version); print('64 Bit:', sys.maxsize > 2**32)"
   
   # Steht eine Laufzeitvorgabe in der Umgebung? Sie schlägt die eigene Wahl im
   # Skript, sobald irgendein Modul vor der eigenen Zeile 'clr' importiert.
   $env:PYTHONNET_RUNTIME
   
   # Weg 1: die Brücke installieren.
   py -3.12 -m pip install "pythonnet==3.1.0"
   
   # Weg 2: das Siemens-Wheel aus dem Download des Beitrags 109742322 — immer mit
   # dem Interpreter installieren, der es später benutzt. Die Wheels sind an den
   # CPython-Tag gebunden; cp312 und cp313 sind nicht austauschbar.
   py -3.12 -m pip install .\install\siemens_tia_scripting-1.4.3-cp312-cp312-win_amd64.whl
   
   # Gehört der ausführende Benutzer zur nötigen Windows-Gruppe?
   net localgroup "Siemens TIA Openness"

2. Die Laufzeit wählen und die Assemblies auffindbar machen

   Python

   Die Laufzeitwahl steht als erste Anweisung, die Ergänzung des Suchpfads direkt danach — beides wie im Beispiel weiter oben. Wer den von Siemens vorgeschlagenen Weg über eine Konfigurationsdatei bevorzugt, kann das auch aus Python, muss dafür aber eine eigene, benannte Anwendungsdomäne anlegen.

   openness.configXML

   <?xml version="1.0"?>
   <!-- Beispiel für TIA Portal V20. Die Datei liegt neben dem Skript. -->
   <configuration>
     <runtime>
       <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <dependentAssembly>
           <assemblyIdentity name="Siemens.Engineering"
                             culture="neutral"
                             publicKeyToken="d29ec89bac048f84" />
           <codeBase version="20.0.0.0"
                     href="FILE://C:\Program Files\Siemens\Automation\Portal V20\PublicAPI\V20\Siemens.Engineering.dll" />
         </dependentAssembly>
       </assemblyBinding>
     </runtime>
   </configuration>

   Aus Python wirkt diese Datei nur mit einer eigenen, benannten Anwendungsdomäne — die Brücke braucht dafür einen zusätzlichen Parameter. Fehlt er, wird die Datei stillschweigend ignoriert; clr-loader begründet das damit, dass sich die Konfiguration der Wurzeldomäne nicht steuern lässt. Für V21 sind Name, Token und Pfad anzupassen.

   Für den Regelfall ist der Weg über den Suchpfad einfacher. Für ein Skript, das mehrere TIA-Stände bedienen soll, ist die Registry-Abfrage der einzig tragfähige.

3. Anhängen — und genau das treffen, was gemeint ist

   Openness

   Ab hier arbeitet man mit .NET-Objekten in Python. Zwei Eigenheiten sind sofort sichtbar: Generische Methoden brauchen den Typ in eckigen statt in spitzen Klammern, und ist eine Methode am konkreten Objekt nicht sichtbar, hilft der Umweg über das Interface. Sammlungen dagegen verhalten sich unauffällig — was sich in .NET aufzählen lässt, lässt sich in Python ganz normal durchlaufen.

   anhaengen.pyPython

   """An ein laufendes TIA Portal anhängen und genau ein benanntes Gerät greifen."""
   
   import Siemens.Engineering as tia
   import Siemens.Engineering.HW.Features as hwf
   
   
   def plc_software(geraet):
       """Liefert die Steuerungssoftware eines Geräts oder None."""
       for teil in geraet.DeviceItems:
           # Der Umweg über das Interface hilft, wenn die Methode am konkreten
           # Objekt nicht sichtbar ist. Der Typ steht in eckigen Klammern.
           anbieter = tia.IEngineeringServiceProvider(teil)
           behaelter = anbieter.GetService[hwf.SoftwareContainer]()
           if behaelter is None:
               continue
           software = behaelter.Software
           if hasattr(software, "BlockGroup"):      # die Bedienoberflächen-Seite hat die nicht
               return software
       return None
   
   
   def geraet_nach_namen(projekt, gesucht):
       """Genau ein Treffer — oder Abbruch. Eine Position ist kein Selektor."""
       treffer = [g for g in projekt.Devices if g.Name == gesucht]
       if len(treffer) != 1:
           raise LookupError(f"{len(treffer)} Geräte mit dem Namen {gesucht!r}")
       return treffer[0]
   
   
   prozesse = list(tia.TiaPortal.GetProcesses())
   if not prozesse:
       raise SystemExit("Keine laufende TIA-Portal-Instanz gefunden.")
   
   with prozesse[0].Attach() as portal:        # ab pythonnet 3.1.0
       projekt = portal.Projects[0]
       geraet = geraet_nach_namen(projekt, "PLC_Linie_1")
       software = plc_software(geraet)
       if software is None:
           raise LookupError(f"{geraet.Name} führt keine Steuerungssoftware")
   
       for baustein in software.BlockGroup.Blocks:   # .NET-Sammlung, normal durchlaufbar
           print(baustein.Name)
       # BlockGroup.Blocks erfasst nur die oberste Gruppe. Untergruppen erreicht
       # man rekursiv über BlockGroup.Groups.
   
   # Hier endet die Sitzung — das TIA Portal bleibt offen. Das ist der
   # Unterschied zwischen Loslassen und Zumachen.

   Der Ausstieg aus dem with-Block trennt die Sitzung; das TIA Portal bleibt offen. Der with-Block funktioniert ab pythonnet 3.1.0 — davor gehört an dieselbe Stelle ein try/finally mit dem Aufruf zum Freigeben. Syntaktisch geprüft, nicht gegen ein reales TIA Portal ausgeführt.

4. Jede Änderung einklammern

   Projekt

   Ein Lesezugriff darf abbrechen. Ein Schreibzugriff nicht: Bricht ein Lauf mitten in einer Schleife über zweihundert Bausteine ab, sind hundertdreißig im Projekt und der Rest nicht — und niemand weiß hinterher, welche.

   Drei Vorkehrungen gehören deshalb zusammen: eine Transaktion, die auf jedem Ausnahmepfad zurückgerollt wird; ein Archiv des Projekts, bevor überhaupt etwas importiert wird; und das bewusste Setzen der Importoption, statt sich auf die Voreinstellung zu verlassen.

   transaktion.pyPython

   """Änderungen einklammern — Ausschnitt, mit dem Siemens-Paket TIA Scripting Python.
   
   Vorausgesetzt sind ein geöffnetes `projekt`, die gewählte Steuerung `plc`, die
   übernommene Verbindung `portal`, `ts` als importiertes Paket und `quelle` als
   Wurzelverzeichnis der Importdateien.
   """
   
   # Zuerst das Netz, dann der Sprung: vor dem Import ein Archiv des Projekts
   # anlegen (projekt.archive).
   
   projekt.start_transaction(
       undo_text="Variablentabellen aus der I/O-Liste",
       dialog_text="Import läuft …",
   )
   try:
       plc.import_plc_tags(
           import_root_directory=quelle,
           # Den Parameter gibt es erst ab V1.4.3; unter älteren Ständen entfällt er.
           import_options=ts.Enums.GeneralImportOptions.Override,
       )
   
       ergebnis = plc.compile_software()
       fehler = ergebnis.get_errors()                   # ab V1.4.3 ein Ergebnisobjekt
       if fehler:
           raise RuntimeError(" | ".join(fehler))
   
       projekt.end_transaction(rollback=False)
   except Exception:
       projekt.end_transaction(rollback=True)           # auf JEDEM Ausnahmepfad
       raise
   finally:
       portal.detach()      # übernommene Instanz loslassen.
       # Die Schließen-Funktion würde dem Kollegen das TIA Portal zumachen.

   Zwei Brüche zwischen den Ständen des Siemens-Pakets: Das Übersetzen liefert ab V1.4.3 ein Ergebnisobjekt, davor einen Wahrheitswert, bei dem wahr für es-gab-Fehler stand — die alte Prüfung ist unter dem neuen Stand immer erfüllt. Auf der Bedienoberflächen-Seite gilt die umgekehrte Logik auch in V1.4.3 weiter. Und: Die dokumentierte Voreinstellung der Importoptionen überschreibt Gleichnamiges ohne Rückfrage.

   Eine Transaktion macht dabei nur das rückrollbar, was die Schnittstelle selbst zurücknehmen kann. Sie ersetzt das Archiv nicht.

5. Den unbeaufsichtigten Lauf vorbereiten

   Betrieb

   Ein Skript, das neben dem geöffneten TIA Portal im Notizbuch läuft, ist etwas anderes als eines, das nachts durchläuft. Was den Unterschied ausmacht:

   • Rückfragen abfangen. Openness kennt Ereignisse für Meldungen und für Rückfragen. Ohne registrierte Behandlung bleibt ein unbeaufsichtigtes Skript an der ersten Rückfrage stehen, bis jemand am Rechner klickt.
   • Zeitgrenzen großzügig setzen. Siemens hält fest, dass der erste Openness-Aufruf länger dauert als jeder folgende. Eine Messung aus einem einzigen Aufruf führt in die Irre.
   • Optionspakete abgleichen. Jedes im Projekt verwendete Optionspaket und jede Hardware-Unterstützung muss auch auf dem ausführenden Rechner installiert sein — sonst scheitert schon das Öffnen des Projekts.
   • Den Ausfall sichtbar machen. Wenn der nächtliche Lauf ausbleibt, muss das jemand merken. Sonst fehlen im Nachweis Wochen, und niemand kann sagen, ab wann.

Die Wahl entscheidet sich weniger an der Aufgabe als an der Frage, wer das Ergebnis später startet.

Die beiden ersten Fälle sind keine Empfehlung, sondern eine Feststellung: Dort fehlen die Methoden, und kein Kniff auf der Python-Seite ändert daran etwas.

Für Massenänderungen an Variablentabellen führt Siemens in den eigenen Beispielen genau diesen Weg vor — Export, Bearbeitung der XML-Datei, Import — und stellt ihn dem Einzelzugriff auf das Objektmodell gegenüber.