Transcript

Projekte über Skripte automatisieren

Systemhandbuch

Ausdruck der Online-Hilfe

1

Liesmich 2Was ist neu in Openness V13 SP1? 3Hinweise zum Hochrüsten auf Openness V13 SP1 4

Einführung 5

Konfigurationen 6

Grundlagen 7

Public API 8

Export/Import 9

Rechtliche HinweiseWarnhinweiskonzept

Dieses Handbuch enthält Hinweise, die Sie zu Ihrer persönlichen Sicherheit sowie zur Vermeidung von Sachschäden beachten müssen. Die Hinweise zu Ihrer persönlichen Sicherheit sind durch ein Warndreieck hervorgehoben, Hinweise zu alleinigen Sachschäden stehen ohne Warndreieck. Je nach Gefährdungsstufe werden die Warnhinweise in abnehmender Reihenfolge wie folgt dargestellt.

GEFAHRbedeutet, dass Tod oder schwere Körperverletzung eintreten wird, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden.

WARNUNGbedeutet, dass Tod oder schwere Körperverletzung eintreten kann, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden.

VORSICHTbedeutet, dass eine leichte Körperverletzung eintreten kann, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden.

ACHTUNGbedeutet, dass Sachschaden eintreten kann, wenn die entsprechenden Vorsichtsmaßnahmen nicht getroffen werden.Beim Auftreten mehrerer Gefährdungsstufen wird immer der Warnhinweis zur jeweils höchsten Stufe verwendet. Wenn in einem Warnhinweis mit dem Warndreieck vor Personenschäden gewarnt wird, dann kann im selben Warnhinweis zusätzlich eine Warnung vor Sachschäden angefügt sein.

Qualifiziertes PersonalDas zu dieser Dokumentation zugehörige Produkt/System darf nur von für die jeweilige Aufgabenstellung qualifiziertem Personal gehandhabt werden unter Beachtung der für die jeweilige Aufgabenstellung zugehörigen Dokumentation, insbesondere der darin enthaltenen Sicherheits- und Warnhinweise. Qualifiziertes Personal ist auf Grund seiner Ausbildung und Erfahrung befähigt, im Umgang mit diesen Produkten/Systemen Risiken zu erkennen und mögliche Gefährdungen zu vermeiden.

Bestimmungsgemäßer Gebrauch von Siemens-ProduktenBeachten Sie Folgendes:

WARNUNGSiemens-Produkte dürfen nur für die im Katalog und in der zugehörigen technischen Dokumentation vorgesehenen Einsatzfälle verwendet werden. Falls Fremdprodukte und -komponenten zum Einsatz kommen, müssen diese von Siemens empfohlen bzw. zugelassen sein. Der einwandfreie und sichere Betrieb der Produkte setzt sachgemäßen Transport, sachgemäße Lagerung, Aufstellung, Montage, Installation, Inbetriebnahme, Bedienung und Instandhaltung voraus. Die zulässigen Umgebungsbedingungen müssen eingehalten werden. Hinweise in den zugehörigen Dokumentationen müssen beachtet werden.

MarkenAlle mit dem Schutzrechtsvermerk ® gekennzeichneten Bezeichnungen sind eingetragene Marken der Siemens AG. Die übrigen Bezeichnungen in dieser Schrift können Marken sein, deren Benutzung durch Dritte für deren Zwecke die Rechte der Inhaber verletzen kann.

HaftungsausschlussWir haben den Inhalt der Druckschrift auf Übereinstimmung mit der beschriebenen Hard- und Software geprüft. Dennoch können Abweichungen nicht ausgeschlossen werden, so dass wir für die vollständige Übereinstimmung keine Gewähr übernehmen. Die Angaben in dieser Druckschrift werden regelmäßig überprüft, notwendige Korrekturen sind in den nachfolgenden Auflagen enthalten.

Siemens AGDivision Digital FactoryPostfach 48 4890026 NÜRNBERGDEUTSCHLAND

Ⓟ 05/2015 Änderungen vorbehalten

Copyright © Siemens AG .Alle Rechte vorbehalten

Inhaltsverzeichnis

1 ......................................................................................................................................................................9

2 Liesmich.....................................................................................................................................................11

3 Was ist neu in Openness V13 SP1?..........................................................................................................13

4 Hinweise zum Hochrüsten auf Openness V13 SP1...................................................................................15

5 Einführung..................................................................................................................................................17

6 Konfigurationen..........................................................................................................................................19

7 Grundlagen.................................................................................................................................................23

7.1 Voraussetzungen für TIA Portal Openness V13 SP1............................................................23

7.2 Installation..............................................................................................................................247.2.1 TIA Portal Openness V13 SP1 installieren............................................................................247.2.2 Benutzer der Benutzergruppe "Siemens TIA Openness" hinzufügen....................................287.2.3 Auf das TIA Portal zugreifen..................................................................................................337.2.4 Enabler-File und Usage-File..................................................................................................34

7.3 Aufgaben von Openness........................................................................................................357.3.1 Einsatzmöglichkeiten.............................................................................................................357.3.2 Export/Import..........................................................................................................................36

7.4 Objektliste..............................................................................................................................36

7.5 Standard-Bibliotheken............................................................................................................41

7.6 Hinweise zur Performance von TIA Portal Openness V13 SP1.............................................41

8 Public API...................................................................................................................................................43

8.1 Einleitung...............................................................................................................................43

8.2 Programmierschritte...............................................................................................................44

8.3 Openness-Objektmodell.........................................................................................................45

8.4 Hierarchie von Hardware-Objekten des Objektmodells.........................................................49

8.5 Beispielprogramm..................................................................................................................51

8.6 Einsatz der Codebeispiele.....................................................................................................56

8.7 Allgemeine Funktionen...........................................................................................................598.7.1 Verbindung zum TIA Portal aufbauen....................................................................................598.7.2 Event-Handler........................................................................................................................658.7.3 Gleichzeitiger Zugriff auf Projekte..........................................................................................678.7.4 Dialoge mit Systemmeldungen programmgesteuert bestätigen............................................688.7.5 Verbindung zum TIA Portal beenden.....................................................................................71

8.8 Funktionen auf Projekte/Projektdaten....................................................................................718.8.1 Projekt öffnen.........................................................................................................................718.8.2 Alle Geräte enumerieren........................................................................................................738.8.3 Alle Geräteelemente enumerieren.........................................................................................75

Projekte über Skripte automatisierenSystemhandbuch 3

8.8.4 Objektstruktur und -Attribute ermitteln...................................................................................778.8.5 Alle Subnetze enumerieren....................................................................................................798.8.6 Alle mit einem Subnetz verbundenen Geräte enumerieren...................................................808.8.7 Editor "Geräte & Netze" öffnen..............................................................................................808.8.8 PLC-Target und HMI-Target abfragen...................................................................................828.8.9 Systemordner für PLC-Variablen abfragen............................................................................838.8.10 Benutzerdefinierte Ordner für PLC-Variablen enumerieren...................................................848.8.11 PLC-Variablen enumerieren...................................................................................................868.8.12 PLC-Variablentabellen in einem Ordner enumerieren...........................................................878.8.13 Informationen einer PLC-Variablentabelle abfragen..............................................................888.8.14 Projekt übersetzen.................................................................................................................888.8.15 Funktionen auf Bibliotheken...................................................................................................918.8.15.1 Funktionen auf Objekte und Instanzen..................................................................................918.8.15.2 Auf Bibliotheken zugreifen.....................................................................................................928.8.15.3 Auf Ordner in einer Bibliothek zugreifen................................................................................938.8.15.4 Auf Typen zugreifen...............................................................................................................958.8.15.5 Auf Typ-Versionen zugreifen..................................................................................................968.8.15.6 Auf Instanzen zugreifen.......................................................................................................1018.8.15.7 Auf Kopiervorlagen zugreifen...............................................................................................1038.8.15.8 Kopiervorlage kopieren........................................................................................................1048.8.15.9 Inhalt einer Kopiervorlage ins Projekt kopieren....................................................................1068.8.15.10 Typ-Versionen von Instanzen ermitteln................................................................................1088.8.15.11 Projekt aktualisieren.............................................................................................................1118.8.15.12 Bibliothek aktualisieren........................................................................................................1148.8.15.13 Bibliotheksinhalte löschen....................................................................................................1168.8.16 Projektgrafik löschen............................................................................................................1198.8.17 Projekt speichern.................................................................................................................1208.8.18 Status einer PLC ermitteln...................................................................................................1218.8.19 Geräte vergleichen...............................................................................................................1228.8.20 Auf Parameter einer Online-Verbindung zugreifen..............................................................1258.8.21 Online-Verbindung zur PLC aufbauen oder trennen............................................................1288.8.22 Projekt schließen..................................................................................................................1298.8.23 Netzwerkinformationen abfragen.........................................................................................1308.8.24 Mastersystem-Parameter abfragen......................................................................................133

8.9 Funktionen auf Daten eines HMI-Gerätes............................................................................1348.9.1 Bilder....................................................................................................................................1348.9.1.1 Benutzerdefinierte Bildordner erzeugen...............................................................................1348.9.1.2 Bild aus einem Ordner löschen............................................................................................1348.9.1.3 Bildvorlage aus einem Ordner löschen................................................................................1358.9.1.4 Alle Bilder aus einem Ordner löschen..................................................................................1368.9.2 Zyklen...................................................................................................................................1378.9.2.1 Zyklus löschen.....................................................................................................................1378.9.3 Textlisten..............................................................................................................................1388.9.3.1 Textliste löschen..................................................................................................................1388.9.4 Grafiklisten...........................................................................................................................1398.9.4.1 Grafikliste löschen................................................................................................................1398.9.5 Verbindungen.......................................................................................................................1408.9.5.1 Verbindung löschen.............................................................................................................1408.9.6 Variablentabelle...................................................................................................................1418.9.6.1 Variablentabelle aus einem Ordner löschen........................................................................1418.9.6.2 Benutzerdefinierte Ordner für HMI-Variablen erzeugen.......................................................1418.9.6.3 Variablen einer HMI-Variablentabelle enumerieren.............................................................142

Inhaltsverzeichnis

Projekte über Skripte automatisieren4 Systemhandbuch

8.9.6.4 Einzelne Variable aus einer HMI-Variablentabelle löschen.................................................1438.9.7 VB-Skripte............................................................................................................................1438.9.7.1 Benutzerdefinierte Skriptunterordner erzeugen...................................................................1438.9.7.2 VB-Skript aus einem Ordner löschen...................................................................................144

8.10 Funktionen auf Daten eines PLC-Gerätes...........................................................................1458.10.1 Bausteine.............................................................................................................................1458.10.1.1 Ordner "Programmbausteine" abfragen...............................................................................1458.10.1.2 Benutzerdefinierte Bausteinordner enumerieren.................................................................1458.10.1.3 Alle Bausteine enumerieren.................................................................................................1478.10.1.4 Informationen eines Bausteins/Anwenderdatentyps abfragen.............................................1488.10.1.5 Baustein löschen..................................................................................................................1498.10.1.6 Anwenderdatentyp löschen..................................................................................................1508.10.1.7 Gruppe für Bausteine erzeugen...........................................................................................1518.10.1.8 Quelle aus Baustein generieren...........................................................................................1528.10.1.9 Gruppe für Bausteine löschen..............................................................................................1538.10.1.10 Systemordner für Systembausteine abfragen......................................................................1548.10.1.11 Systemunterordner enumerieren.........................................................................................1558.10.1.12 Externe Datei hinzufügen.....................................................................................................1568.10.1.13 Bausteine aus externer Datei generieren.............................................................................1578.10.1.14 Externe Datei löschen..........................................................................................................1588.10.1.15 Bausteineditor starten..........................................................................................................1588.10.2 Variablentabellen.................................................................................................................1598.10.2.1 Benutzerdefinierte Ordner für PLC-Variablen erzeugen......................................................1598.10.2.2 Benutzerdefinierte Ordner für PLC-Variablen löschen.........................................................1608.10.2.3 PLC-Variablentabelle aus einem Ordner löschen................................................................1618.10.2.4 Einzelne Variable aus einer PLC-Variablentabelle löschen.................................................1618.10.2.5 Editor "Variablen" starten.....................................................................................................1628.10.2.6 Zeit der letzen Änderungen einer PLC-Variablentabelle lesen............................................163

8.11 Grundkonzepte.....................................................................................................................1648.11.1 Umgang mit Exceptions.......................................................................................................1648.11.2 Arbeiten mit Assoziationen...................................................................................................1658.11.3 Arbeiten mit Aggregationen..................................................................................................1668.11.4 Objektgleichheit prüfen........................................................................................................1678.11.5 Lese-Operationen für Attribute.............................................................................................168

9 Export/Import............................................................................................................................................171

9.1 Überblick..............................................................................................................................1719.1.1 Grundlagen zum Import/Export............................................................................................1719.1.2 Einsatzgebiet von Import/Export..........................................................................................1739.1.3 Aufbau einer XML-Datei.......................................................................................................1749.1.4 Struktur der Daten für Import/Export....................................................................................1769.1.5 Bearbeiten der XML-Datei....................................................................................................1809.1.6 Export/Import von Grafiken..................................................................................................1819.1.7 Export von Projektierungsdaten...........................................................................................1829.1.8 Import von Projektierungsdaten...........................................................................................184

9.2 Import/Export von Projektdaten............................................................................................1859.2.1 Grafiken................................................................................................................................1859.2.1.1 Grafiken eines Projektes exportieren...................................................................................1859.2.1.2 Grafiken in ein Projekt importieren.......................................................................................186

9.3 Import/Export von Daten eines HMI-Geräts.........................................................................187

Inhaltsverzeichnis

Projekte über Skripte automatisierenSystemhandbuch 5

9.3.1 Zyklen...................................................................................................................................1879.3.1.1 Zyklen exportieren................................................................................................................1879.3.1.2 Zyklen importieren................................................................................................................1889.3.2 Variablentabellen.................................................................................................................1899.3.2.1 HMI-Variablentabellen exportieren.......................................................................................1899.3.2.2 HMI-Variablentabelle importieren.........................................................................................1929.3.2.3 Einzelne Variable einer HMI-Variablentabelle exportieren...................................................1929.3.2.4 Einzelne Variable in eine HMI-Variablentabelle importieren................................................1939.3.2.5 Besonderheiten beim Export/Import von HMI-Variablen......................................................1949.3.3 VB-Skripte............................................................................................................................1969.3.3.1 VB-Skripte exportieren.........................................................................................................1969.3.3.2 VB-Skripte aus einem Ordner exportieren...........................................................................1979.3.3.3 VB-Skripte importieren.........................................................................................................1989.3.4 Textlisten..............................................................................................................................1999.3.4.1 Textlisten aus einem HMI-Gerät exportieren.......................................................................1999.3.4.2 Textliste in ein HMI-Gerät importieren.................................................................................2009.3.4.3 Erweiterte XML-Formate für Export/Import von Textlisten...................................................2019.3.5 Grafiklisten...........................................................................................................................2029.3.5.1 Grafiklisten exportieren........................................................................................................2029.3.5.2 Grafikliste importieren..........................................................................................................2039.3.6 Verbindungen.......................................................................................................................2049.3.6.1 Verbindungen exportieren....................................................................................................2049.3.6.2 Verbindungen importieren....................................................................................................2059.3.7 Bilder....................................................................................................................................2069.3.7.1 Übersicht der exportierbaren Bild-Objekte...........................................................................2069.3.7.2 Alle Bilder eines HMI-Geräts exportieren.............................................................................2109.3.7.3 Bild aus einem Bildordner exportieren.................................................................................2119.3.7.4 Bilder in ein HMI-Gerät importieren......................................................................................2139.3.7.5 Permanentfenster exportieren..............................................................................................2169.3.7.6 Permanentfenster importieren..............................................................................................2179.3.7.7 Bildvorlagen aus einem Ordner exportieren.........................................................................2189.3.7.8 Alle Bildvorlagen eines HMI-Geräts exportieren..................................................................2209.3.7.9 Bildvorlagen importieren......................................................................................................221

9.4 Import/Export von Daten eines PLC-Geräts.........................................................................2239.4.1 Bausteine.............................................................................................................................2239.4.1.1 Bausteine und Anwenderdatentypen exportieren................................................................2239.4.1.2 Bausteine mit Know-how-Schutz exportieren......................................................................2269.4.1.3 F-Bausteine exportieren.......................................................................................................2279.4.1.4 System-Bausteine exportieren.............................................................................................2279.4.1.5 Baustein importieren............................................................................................................2289.4.1.6 Anwenderdatentyp importieren............................................................................................2309.4.2 Variablentabellen.................................................................................................................2319.4.2.1 PLC-Variablentabellen exportieren......................................................................................2319.4.2.2 PLC-Variablentabelle importieren........................................................................................2339.4.2.3 Einzelne Variable einer PLC-Variablentabelle exportieren..................................................2339.4.2.4 Einzelne Variable in eine PLC-Variablentabelle importieren................................................235

Index.........................................................................................................................................................237

Tabellen

Inhaltsverzeichnis

Projekte über Skripte automatisieren6 Systemhandbuch

Tabelle 7-1 Bilder...........................................................................................................................................36Tabelle 7-2 Bildobjekte...................................................................................................................................37Tabelle 7-3 Dynamik......................................................................................................................................39Tabelle 7-4 Weitere Objekte...........................................................................................................................39Tabelle 7-5 Variablen.....................................................................................................................................39Tabelle 7-6 Listen...........................................................................................................................................40Tabelle 7-7 Texte...........................................................................................................................................40Tabelle 9-1 Projekte.....................................................................................................................................171Tabelle 9-2 PLC...........................................................................................................................................171Tabelle 9-3 HMI............................................................................................................................................172Tabelle 9-4 Unterstützte Bilder.....................................................................................................................206Tabelle 9-5 Unterstützte Bild-Objekte..........................................................................................................207

Bilder

Bild 9-1 Zusammenhang zwischen der WinCC-Oberfläche und der XML-Struktur................................179Bild 9-2 Zusammenhang zwischen den Einstellungen in WinCC und der XML-Struktur.......................180

Inhaltsverzeichnis

Projekte über Skripte automatisierenSystemhandbuch 7

Inhaltsverzeichnis

Projekte über Skripte automatisieren8 Systemhandbuch

1

Projekte über Skripte automatisierenSystemhandbuch 9

Projekte über Skripte automatisieren10 Systemhandbuch

Liesmich 2Kopieren von Openness

Wenn Sie eine Openness-Anwendung kopieren, kann unter Umständen trotzdem noch der Verzeichnispfad ausgelesen werden, in dem die Openness-Anwendung ursprünglich erstellt wurde.

Abhilfe:

Wenn Sie die Openness-Anwendung in ein neues Verzeichnis kopiert haben, öffnen Sie z. B. den Eigenschaftsdialog und schließen den Eigenschaftsdialog gleich wieder.

Durch diese Aktion wird der Windows-Cache aktualisiert.

Weitere Hinweise finden Sie unter: http://support.microsoft.com/kb/2987926 (http://support.microsoft.com/kb/2987926)

Fehlerhafter Import von VariablenWenn Sie folgende Sonderzeichen im Namen von Variablen oder referenzierten Variablen verwenden, dann ist der Import von Variablen fehlerhaft:

● . (Punkt)

● \ (Backlslash)

Abhilfe 1:

Überprüfen Sie vor einem Export, dass im Namen der zu exportierenden Variablen oder referenzierten Variable kein Punkt oder Backslash enthalten ist.

Abhilfe 2:

Klammern Sie in der Import-Datei die Namen von Variablen oder referenzierte Variablen aus.

Beispiel

● Variablenname mit Sonderzeichen:

<name>Siemens.Simatic.Hmi.Utah.Tag.HmiTag:41000_Options_Time_Date\DB_SFX0908_HMI1.Actual_Date_Time.Hour</name>

● Ausgeklammerter Varablenname mit Sonderzeichen:<name>"Siemens.Simatic.Hmi.Utah.Tag.HmiTag:41000_Options_Time_Date\DB_SFX0908_HMI1.Actual_Date_Time.Hour"</name>

Projekte über Skripte automatisierenSystemhandbuch 11

Liesmich

Projekte über Skripte automatisieren12 Systemhandbuch

Was ist neu in Openness V13 SP1? 3Zugriff auf Bibliotheken

Mit Openness V13 SP1 können Sie auf die folgenden Inhalte der Projektbibliothek und globalen Bibliotheken zugreifen:

● Typen

● Typ-Versionen

● Kopiervorlagen

Insbesondere können Sie Verwendungen von Typ-Versionen in oder von anderen Typ-Versionen ermitteln. Sie können die Instanzen einer Typ-Version ermitteln und neue Instanzen von ausgewählten Typ-Versionen erzeugen.

Bibliotheken synchronisierenMit Openness V13 SP1 können Sie globale Bibliotheken mit der Projektbibliothek synchronisieren. Beim Synchronisieren werden veraltete Typ-Versionen in der Projektbibliothek durch die aktuellste Typ-Version aus einer globalen Bibliothek ersetzt. Sie können den gesamten Inhalt einer Bibliothek synchronisieren oder einzelne Typ-Versionen oder Typ-Ordner auswählen und synchronisieren.

Instanzen aktualisierenMit Openness V13 SP1 können Sie die Instanzen von Typ-Versionen im Projekt auf Basis der letzten freigegebenen Typ-Version aktualisieren. Wenn Sie die Aktualisierung der Instanzen von einer globalen Bibliothek aus starten, wird zuvor eine Synchronisation ausgeführt.

Zugriff auf Online-Verbindung zu einer PLCMit Openness V13 SP1 können Sie auf die Online-Verbindung zu einer PLC zugreifen:

● Status der Online-Verbindung ermitteln

● Verbindungsparameter setzen

● Online-Verbindung aufbauen

● Online-Verbindung trennen

Zusätzlich können Sie die in eine PLC geladenen Daten mit den Projektierungsdaten vergleichen.

Projekte über Skripte automatisierenSystemhandbuch 13

Änderungen beim Export und ImportDer Funktionsumfang beim Export und Import wurde erweitert:

● Die Bildobjekt-Eigenschaften, die das verbesserte Design der Benutzeroberfläche unterstützen, werden erfasst.

● Alle Kommunikationstreiber für HMI-Verbindungen, außer SINUMERIK und SIMOTION, werden erfasst.

Hinweis: Der Export und Import unterstützt ausschließlich absolute Pfadangaben, z. B. "C:\Export\Screens.xml".

Verbindungsanfrage einer Openness-AnwendungWenn eine Openness-Anwendung auf ein TIA-Portal zugreift, muss der Benutzer den Zugriff bestätigen. Der Benutzer kann jede Openness-Anwendung in eine Whitelist aufnehmen. Wenn eine Openness-Anwendung einmal in die Whitelist aufgenommen ist, werden keine Verbindungsanfragen mehr ausgeführt.

Detailliertere ExceptionsDamit Sie auf unterschiedliche Fehlertypen besser reagieren können, wurden die Exceptions wie folgt erweitert:

● Sicherheitsrelevante Exceptions (EngineeringSecurityException)

● Exceptions beim Zugriff auf Objekte (EngineeringObjectDisposedException)

● Exceptions beim Zugriff auf Attribute (EngineeringNotSupportedException)

● Allgemeine Exceptions beim Aufruf (EngineeringTargetInvocationException)

● Exceptions aus Runtime (EngineeringRuntimeException)

● Exceptions durch Anwender, z.B. durch Abbruch eines Imports (EngineeringUserAbortException)

Weiterführende Informationen finden Sie unter Umgang mit Exceptions (Seite 164).

Quelle aus Baustein generierenMit Openness V13 SP1 können Sie jetzt auch die Quelle aus Bausteinen mit der Programmiersprache "AWL" generieren.

Siehe auchHinweise zum Hochrüsten auf Openness V13 SP1 (Seite 15)

Was ist neu in Openness V13 SP1?

Projekte über Skripte automatisieren14 Systemhandbuch

Hinweise zum Hochrüsten auf Openness V13 SP1 4Einleitung

In Openness V13 SP1 wurden folgende Änderungen durchgeführt, die Auswirkungen auf ihre bestehenden Applikationen haben können:

Änderung Notwendige Programmcode-AnpassungDer Installationspfad der "Openness V13 SP 1" wurde ange‐passt. Die Datei "Siemens.Engineering.dll" wird in folgendem Verzeichnis abgelegt: ● <Installationsverzeichnis>\PublicAPI\V13 SP 1

Wenn Sie zum Starten des TIA-Portals eine Anwendungs‐konfigurationsdatei verwenden: ● Ändern Sie in der Anwendungskonfigurationsdatei unter

<codeBase [...] /> den Pfad zur Datei "Siemens.Engineering.dll" wie folgt: – href="FILE://<Installationspfad>\PublicAPI\V13 SP

1\Siemens.Engineering.dll"Weiterführende Informationen zu diesem Thema finden Sie unter Verbindung zum TIA Portal aufbauen (Seite 59).

Wenn Sie zum Starten des TIA-Portals die Technik "Assembl‐yResolve" verwenden:1. Aktualisieren Sie in Ihrer Entwicklungsumgebung den

Verweis auf die Datei "Siemens.Engineering.dll".2. Übersetzen Sie die Applikation.

Die Objekte ControllerTag und ControllerConstant sind nun im Namespace Siemens.Engineering.SW ent‐halten.

1. Fügen Sie den Namespace Siemens.Engineering.SW hinzu.

2. Übersetzen Sie die Applikation. Der Namespace für den Zugriff auf Bibliotheken wurde geän‐dert.

1. Ersetzen Sie den Namespace Siemens.Engineering.GlobalLibrary durch Siemens.Engineering.Library.

2. Übersetzen Sie die Applikation. Die Methode Close zum Schließen eines Projekts ist überla‐den.

Keine. Empfehlung: Verwenden Sie die Methode Close mit dem Parameter CloseMode. Weiterführende Informationen finden Sie unter Projekt schlie‐ßen (Seite 129).

Die engineering exceptions wurden erweitert. Keine.Empfehlung: Damit Sie auf unterschiedliche Fehlertypen bes‐ser reagieren können, verwenden Sie die neu implementier‐ten Erweiterungen. Weiterführende Informationen finden Sie unter Umgang mit Exceptions (Seite 164).

Siehe auchWas ist neu in Openness V13 SP1? (Seite 13)

Projekte über Skripte automatisierenSystemhandbuch 15

Hinweise zum Hochrüsten auf Openness V13 SP1

Projekte über Skripte automatisieren16 Systemhandbuch

Einführung 5Einleitung

TIA Portal Openness V13 SP1 beschreibt offen gelegte Schnittstellen zum Engineering mit dem TIA Portal V13 SP1.

Mit TIA Portal Openness V13 SP1 automatisieren Sie das Engineering, indem Sie aus einem von Ihnen erstellten Programm heraus das TIA Portal fremd steuern.

Mit TIA Portal Openness V13 SP1 können Sie folgende Aktionen durchführen:

● Projektdaten erzeugen

● Projekte und Projektdaten modifizieren

● Projektdaten löschen

● Projektdaten einlesen

● Projekte und Projektdaten für andere Anwendungen bereitstellen.

Hinweis

Siemens übernimmt keine Haftung oder Gewährleistung dafür, dass die über diese Schnittstellen transportierten Daten und Informationen kompatibel zu Software Dritter sind.

Wir weisen ausdrücklich darauf hin, dass es bei unsachgemäßer Nutzung der Schnittstellen zu Datenverlust oder Produktionsausfall kommen kann.

Hinweis

Die in dieser Dokumentation enthaltenen Programmcodes sind in der C#-Syntax formuliert.

Wegen der Kürze der verwendeten Codebeispiele wird zum größten Teil auf die Beschreibung der Fehlerbehandlung verzichtet.

AnwendungSie nutzen die Openness-Schnittstellen folgendermaßen:

● Sie stellen Projektdaten bereit.

● Sie greifen auf den TIA Portal-Prozess zu.

● Sie nutzen Projektdaten.

Nutzen von Vorgaben aus dem Vorfeld des Automatisierungs-Engineering● Über den Import von extern erzeugten Daten

● Über die Fernsteuerung des TIA Portals zur Erzeugung von Projekten

Bereitstellen von Projektdaten des TIA Portals für externe Anwendungen● Über den Export von Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 17

Sichern von Wettbewerbsvorteilen durch effizientes Engineering● Bereits vorhandene Engineering-Daten müssen Sie nicht im TIA Portal projektieren.

● Automatisierte Engineering-Abläufe ersetzen manuelles Engineering.

● Geringer Engineering-Aufwand stärkt die Angebotsposition gegenüber Wettbewerber.

Gemeinsam an Projektdaten arbeiten● Prüf-Routinen und Massendatenbearbeitung sind parallel zur laufenden Projektierung

möglich.

Siehe auchKonfigurationen (Seite 19)

Einführung

Projekte über Skripte automatisieren18 Systemhandbuch

Konfigurationen 6Mit TIA Portal Openness V13 SP1 können Sie mit zwei Varianten arbeiten:

Anwendung und TIA Portal sind auf verschiedenen PCs

● Die Daten werden über XML-Dateien ausgetauscht. Die XML-Dateien können von Ihren Programmen exportiert oder importiert werden.

● Vom TIA Portal-Projekt auf PC2 exportierte Daten können Sie auf PC1 verändern und wieder importieren.

Hinweis

Sie müssen für PC2 ein ausführbares Programm "Ihr Programm 2" entwickeln, z. B. "programm2.exe". Das TIA Portal läuft mit diesem Programm im Hintergrund.

Import und Export von XML-Dateien laufen ausschließlich über die Public API.

● Ausgetauschte Dateien können Sie zu Nachweiszwecken archivieren.

● Ausgetauschte Daten können Sie an unterschiedlichen Orten und zu unterschiedlicher Zeit bearbeiten.

Projekte über Skripte automatisierenSystemhandbuch 19

Anwendung und TIA Portal sind auf demselben PC

● Ihr Programm startet das TIA Portal entweder mit oder ohne Bedienoberfläche. Ihr Programm öffnet, speichert und/oder schließt ein Projekt. Alternativ kann sich das Programm auch mit einem laufenden TIA Portal verbinden.

● Um die Projektdaten zu erfragen, generieren, modifizieren oder Import- und Exportvorgänge anzustoßen, nutzen Sie die Funktionalität des TIA Portals.

● Die Daten werden unter Kontrolle der TIA Portal-Verarbeitung erzeugt und in den Projektdaten abgelegt.

Konfigurationen

Projekte über Skripte automatisieren20 Systemhandbuch

Typische Anwendung im Modularen Maschinenbau

● Ähnliche Maschinen sollen effizient automatisiert werden.

● Im TIA Portal ist ein Projekt vorhanden, das die Bestandteile aller Maschinenvariationen enthält.

● Das Generator-Tool steuert die Erstellung des Projekts zu einer konkreten Maschinenvariation.

● Das Generator-Tool erhält Vorgaben über Einlesen der Parameter zu der gewünschten Maschinenvariation.

● Das Generator-Tool leitet die relevanten Teile aus dem Gesamtprojekt des TIA Portals aus, modifiziert diese Teile bei Bedarf und erzeugt das gewünschte Maschinenprojekt.

Konfigurationen

Projekte über Skripte automatisierenSystemhandbuch 21

Konfigurationen

Projekte über Skripte automatisieren22 Systemhandbuch

Grundlagen 77.1 Voraussetzungen für TIA Portal Openness V13 SP1

Voraussetzungen für das Nutzen von Openness-Anwendungen● Ein auf dem TIA Portal basierendes Produkt ist auf dem PC installiert, z. B. "STEP 7

Professional" oder "WinCC Professional".

● Das Optionspaket "TIA Portal Openness V13 SP1" ist auf dem PC installiert. Siehe TIA Portal Openness V13 SP1 installieren (Seite 24)

Unterstützte Windows-BetriebssystemeDie folgende Tabelle zeigt, welche Kombinationen von Windows-Betriebssystem, TIA-Portal und Benutzeranwendung zueinander kompatibel sind:

Windows-Betriebssystem TIA Portal Benutzeranwendung32 Bit 32 Bit 32 Bit und "AnyCPU"64 Bit 32 WoW 32 Bit, 64 Bit und "AnyCPU"64 Bit 64 Bit 32 Bit, 64 Bit und "AnyCPU"

Voraussetzungen für das Programmieren von Openness-Anwendungen● Microsoft Visual Studio 2010 oder 2012 oder höher mit .Net 4.0, 32-bit Applikation ist auf

dem PC installiert.

Erforderliches Knowhow des Anwenders ● Kenntnisse als System Engineer

● Fortgeschrittene Kenntnisse von Microsoft Visual Studio 2010 oder 2012

● Fortgeschrittene Kenntnisse von C# / VB.net und .Net

● Anwenderwissen vom TIA Portal

Siehe auchBenutzer der Benutzergruppe "Siemens TIA Openness" hinzufügen (Seite 28)

Projekte über Skripte automatisierenSystemhandbuch 23

7.2 Installation

7.2.1 TIA Portal Openness V13 SP1 installieren

EinleitungDie Installation des Optionspakets "TIA Portal Openness V13 SP1" wird durch ein Setup-Programm automatisch durchgeführt.

Die Installationsdatei "Siemens_TIA_Openness_V13_SP1.exe" ist ein selbstextrahierendes Archiv und befindet sich auf der Produkt-DVD im Verzeichnis "Support".

Voraussetzungen● Hardware und Software des PG/PC entsprechen den Systemanforderungen.

● Sie haben Administratorrechte.

● Laufende Programme sind beendet.

● Autorun ist deaktiviert.

● WinCC V13 SP1 und/oder STEP 7 V13 SP1 sind installiert.

● Die Versionsnummer des Optionspakets "TIA Portal Openness" stimmt mit den Versionsnummern von WinCC und STEP 7 überein.

HinweisPublic API - Openness V13 und Openness V13 SP1

Wenn Sie Openness V13 SP1 installiert haben wird der Inhalt des Ordners "Public API" von Openness V13 mit "Public API" von Openness V13 SP1 überschrieben.

Vorgehen

Hinweis

Das Optionspaket "TIA Portal Openness V13 SP1" können Sie erst nach der Installation des TIA Portals installieren.

Um das Optionspaket zu installieren, gehen Sie folgendermaßen vor:

1. Legen Sie den Installationsdatenträger in das entsprechende Laufwerk ein und wechseln Sie in das Verzeichnis "Support" .

2. Doppelklicken Sie auf die Datei "Siemens_TIA_Openness_V13_SP1.exe".

3. Wählen Sie Installationssprache aus.

Grundlagen7.2 Installation

Projekte über Skripte automatisieren24 Systemhandbuch

4. Die Installationsdaten werden extrahiert. Nach dem Extrahieren wird das Setup von Openness gestartet. Folgender Setup-Dialog wird geöffnet:

Grundlagen7.2 Installation

Projekte über Skripte automatisierenSystemhandbuch 25

5. Klicken Sie auf "Next" und wählen Sie die gewünschte Option aus.Folgende Optionen stehen Ihnen zur Verfügung:

Grundlagen7.2 Installation

Projekte über Skripte automatisieren26 Systemhandbuch

6. Klicken Sie auf "Next" und wählen Sie das Produkt "TIA Portal Openness V13 SP1" aus.

Ändern Sie bei Bedarf das Zielverzeichnis für die Installation und klicken Sie auf "Next".Beachten Sie, dass die Länge des Installationspfades 89 Zeichen nicht überschreiten darf.

7. Akzeptieren Sie im nächsten Installationsschritt alle Lizenzvereinbarungen und klicken Sie auf "Next".Wenn die Installation des TIA Portals Sicherheits- und Rechteeinstellungen geändert werden müssen, wird der Dialog zu den Sicherheitseinstellungen geöffnet.

8. Um die Installation fortzusetzen, akzeptieren Sie die Änderungen der Sicherheits- und Rechteeinstellungen und klicken Sie auf die Schaltfläche "Next".Im nächsten Dialog wird eine Übersicht der Installationseinstellungen angezeigt.

Grundlagen7.2 Installation

Projekte über Skripte automatisierenSystemhandbuch 27

9. Überprüfen Sie die gewählten Installationseinstellungen und ändern Sie diese bei Bedarf.

10.Um die Installation zu starten, klicken Sie auf die Schaltfläche "Install".Wenn die Installation erfolgreich war, wird eine entsprechende Meldung auf dem Bildschirm angezeigt. Bei einer fehlerhaften Installation wird eine Fehlermeldung eingeblendet, die Sie über die Art der aufgetretenen Fehler informiert.

ErgebnisDas Optionspaket "TIA Portal Openness V13 SP1" wird auf dem PC installiert. Außerdem wird die lokale Benutzergruppe "Siemens TIA Openness" erzeugt.

Hinweis

Mit dem Optionspaket "TIA Portal Openness V13 SP1" haben Sie noch keinen Zugriff auf das TIA Portal. Abhängig von den Zugriffsrechten sind unterschiedliche Zugangsvoraussetzungen erforderlich (siehe Auto-Hotspot). Alternativ müssen Sie mindestens in der Benutzergruppe "Siemens TIA Openness" Mitglied sein (siehe Benutzer der Benutzergruppe "Siemens TIA Openness" hinzufügen (Seite 28)).

7.2.2 Benutzer der Benutzergruppe "Siemens TIA Openness" hinzufügen

EinleitungWenn Sie TIA Portal Openness V13 SP1 auf dem PC installieren, wird automatisch die Benutzergruppe "Siemens TIA Openness" angelegt.

Wenn Sie mit Ihrer Openness-Anwendung auf das TIA Portal zugreifen, prüft das TIA Portal, ob Sie entweder direkt oder indirekt über eine andere Gruppe Mitglied der Benutzergruppe "Siemens TIA Openness" sind. Wenn Sie Mitglied der Benutzergruppe "Siemens TIA Openness" sind, startet die Openness-Anwendung und baut eine Verbindung zum TIA Portal auf.

Vorgehen Sie fügen einen Benutzer der Benutzergruppe "Siemens TIA Openness" mit Anwendungen Ihres Betriebssystems hinzu. Das TIA Portal unterstützt diesen Vorgang nicht.

Hinweis

Je nach Konfiguration Ihrer Domain oder Ihres PCs werden für die Erweiterung einer Benutzergruppe die Administrator-Rechte benötigt.

Grundlagen7.2 Installation

Projekte über Skripte automatisieren28 Systemhandbuch

Bei dem Betriebssystem Windows 7 (englische Spracheinstellung) können Sie einen Benutzer zur Benutzergruppe folgendermaßen hinzufügen:

1. Rufen Sie den Menüpfad "Start" > "Control Panel" auf.

2. Doppelklicken Sie in der Systemsteuerung auf den Eintrag "Administrative Tools".

3. Klicken Sie auf den Eintrag "Computer Management", um den gleichnamigen Konfigurationsdialog zu öffnen.

Grundlagen7.2 Installation

Projekte über Skripte automatisierenSystemhandbuch 29

4. Markieren Sie "Local Users and Groups > Groups", um alle angelegten Benutzergruppen anzuzeigen.

5. Wählen Sie rechts in der Liste der Benutzergruppen den Eintrag "Siemens TIA Openness" aus.

Grundlagen7.2 Installation

Projekte über Skripte automatisieren30 Systemhandbuch

6. Wählen Sie den Menübefehl "Action > Add to Group...".

Daraufhin öffnet sich der Eigenschaftsdialog der Benutzergruppe:

Grundlagen7.2 Installation

Projekte über Skripte automatisierenSystemhandbuch 31

7. Klicken Sie auf die Schaltfläche "Add".Ein Auswahldialog mit den auswählbaren Benutzern wird geöffnet:

8. Geben Sie einen gültigen Benutzernamen in das Eingabefeld ein.

Hinweis

Über die Schaltfläche "Check Names" können Sie überprüfen, ob der erfasste Benutzer ein gültiges Benutzerkonto dieser Domain oder dieses Computers besitzt.

Das Feld "From this location" zeigt die Domain bzw. den Computernamen des erfassten Benutzernamens an. Weitere Informationen erhalten Sie von Ihrem Systemadministrator.

9. Bestätigen Sie die Auswahl mit "OK".Der neue Benutzer wird im Eigenschaftsdialog der Benutzergruppe angezeigt.

Weitere Benutzer erfassen Sie mithilfe der Schaltfläche "Add".

Grundlagen7.2 Installation

Projekte über Skripte automatisieren32 Systemhandbuch

10.Klicken Sie anschließend auf "OK", um den Vorgang zu beenden.

11.Damit die Änderungen wirksam werden, melden Sie sich am PC neu an.

7.2.3 Auf das TIA Portal zugreifen

Überblick

Vorgehen1. Um auf das TIA Portal zuzugreifen und zu starten, richten Sie die Entwicklungsumgebung

ein.

2. Um das Portal zu starten, Instanziieren Sie in Ihrem Programm das Objekt der Portalanwendung.

3. Suchen Sie das gewünschte Projekt und öffnen Sie es.

4. Greifen Sie auf die Projektdaten zu.

5. Schließen Sie das Projekt und beenden Sie das TIA Portal.

Siehe auchVerbindung zum TIA Portal aufbauen (Seite 59)

Verbindung zum TIA Portal beenden (Seite 71)

Grundlagen7.2 Installation

Projekte über Skripte automatisierenSystemhandbuch 33

7.2.4 Enabler-File und Usage-File

EinleitungDamit Sie Bausteine eines PLC-Geräts importieren können, benötigen Sie zwei Dateien:

● Enabler-File

● Usage-File

Die Beschreibung zum Erhalt der beiden Dateien erhalten Sie in der Lieferfreigabe STEP 7 V13 SP1 jeweils am Ende des Beitrags unter der Überschrift "Informationsmaterial"

Stichwort: TIA Portal Openness Anleitung EnablerFile/UsageFile: TIA Portal Openness Anleitung zu Enabler-File und Usage-File (http://support.automation.siemens.com/WW/view/de/103627307)

Funktion der Dateien Enable-Files und Usage-FileEin Import und die Verwendung von Bausteinen eines PLC-Geräts ist an zwei verschiedene Dateien gebunden.

Im Bausteine zu importieren benötigen Sie das "Enabler-File" und das "Usage-File". Damit sie auf dem selben PC den improtierten Baustein auch verwenden können, benötigen Sie das "Usage-File".

Wenn Sie den importierten Baustein auf einem anderen PC kopieren und verwenden wollen, müssen Sie das "Usage-File" des kopierten Bausteins ebenfalls auf den anderen PC mitkopieren.

Grundlagen7.2 Installation

Projekte über Skripte automatisieren34 Systemhandbuch

7.3 Aufgaben von Openness

7.3.1 Einsatzmöglichkeiten

EinleitungTIA Portal Openness V13 SP1 ermöglicht Ihnen verschiedene Zugriffe auf das TIA Portal und stellt Ihnen eine Auswahl von Funktionen für definierte Aufgaben zur Verfügung.

Auf folgende Bereiche des TIA Portals greifen Sie über die Public API-Schnittstelle zu:

● Projektdaten

● PLC-Daten

● HMI-Daten

Hinweis

Über die Public API-Schnittstelle dürfen Sie keine Prüfungen vornehmen oder Daten erzeugen, die zu einer Abnahme einer fehlersicheren Anlage verwendet werden. Für eine Abnahme ist ausschließlich ein Sicherheitsausdruck über das Optionspaket STEP 7 Safety bzw. der Funktionstest geeignet. Die Public API-Schnittstelle ist kein Ersatz dafür.

Zugriff auf das TIA PortalÜber TIA Portal Openness V13 SP1 stehen Ihnen verschieden Varianten zur Verfügung, auf das TIA Portal zuzugreifen. Sie erzeugen dabei eine externe TIA Portal-Instanz wahlweise mit oder ohne UI. Auch auf laufende TIA Portal-Prozesse können Sie parallel zugreifen.

Zugriff auf Projekte und ProjektdatenBeim Zugriff auf Projekte und Projektdaten verwenden Sie TIA Portal Openness V13 SP1 hauptsächlich für folgende Aufgaben:

● Projekt schließen, öffnen und speichern

● Objekte enumerieren und abfragen

● Objekte anlegen

● Objekte löschen

Grundlagen7.3 Aufgaben von Openness

Projekte über Skripte automatisierenSystemhandbuch 35

7.3.2 Export/Import

EinleitungTIA Portal Openness V13 SP1 unterstützt den Import und Export von Projektdaten über XML-Dateien. Die Import/Export-Funktion ermöglicht das externe Projektieren von vorhandenen Engineering-Daten. Sie verwenden diese Funktion, um Ihren Engineering-Ablauf effektiv und fehlersicher zu machen.

AnwendungSie nutzen die Import/Export-Funktion für folgende Zwecke:

● Datenaustausch

● Kopieren von Teilen eines Projekts

● Externe Bearbeitung von Projektierungsdaten, z. B. für Massendatenoperationen über Suchen und Ersetzen

● Externe Bearbeitung von Projektierungsdaten für neue Projekte auf Basis vorhandener Projektierungen

● Import von extern erzeugten Projektierungsdaten, z. B. Textlisten und Variablen

● Bereitstellung von Projektdaten für externe Anwendungen

7.4 Objektliste

EinleitungDie folgenden Tabellen zeigen die verfügbaren Objekte bis einschließlich Runtime Advanced und ob diese Objekte von Openness unterstützt werden.

Runtime Professional sowie Geräte-Proxy-Daten werden von Openness in WinCC V13 SP1 nicht unterstützt.

Objekte Abhängig vom Bediengerät können Sie folgende Projektdaten ansteuern:

Tabelle 7-1 Bilder

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedBild ja ja ja ja ja jaGlobales Bild ja ja ja ja ja jaVorlagen ja ja ja ja ja jaPermanentfens‐ter

nein ja ja ja ja ja

Grundlagen7.4 Objektliste

Projekte über Skripte automatisieren36 Systemhandbuch

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedPop-up-Bild nein nein nein nein nein neinSlide-in-Bild nein nein nein nein nein nein

Tabelle 7-2 Bildobjekte

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedLinie ja ja ja ja ja jaPolygonzug nein ja ja ja ja jaPolygon nein ja ja ja ja jaEllipse nein ja ja ja ja jaEllipsensegment nein nein nein nein nein neinKreissegment nein nein nein nein nein neinEllipsenbogen nein nein nein nein nein neinKamera-Anzeige nein nein nein nein nein neinKreisbogen nein nein nein nein nein neinKreis ja ja ja ja ja jaPDF-Anzeige nein nein nein nein nein neinRechteck ja ja ja ja ja jaVerbinder nein nein nein nein nein neinTextfeld ja ja ja ja ja jaGrafikanzeige ja ja ja ja ja jaRohr nein nein nein nein nein neinDoppel-T-Stück nein nein nein nein nein neinT-Stück nein nein nein nein nein neinRohrbogen nein nein nein nein nein neinE/A-Feld ja ja ja ja ja jaDatum/Uhrzeit-Feld

ja ja ja ja ja ja

Grafisches E/A-Feld

ja ja ja ja ja ja

Editierbares Textfeld

nein nein nein nein nein nein

Listenfeld nein nein nein nein nein neinKombinations‐feld

nein nein nein nein nein nein

Schaltfläche ja ja ja ja ja jaRundschaltflä‐che

nein nein nein nein nein nein

Leuchtdrucktas‐ter

nein nein nein nein ja nein

Schalter ja ja ja ja ja jaSymbolisches E/A-Feld

ja ja ja ja ja ja

Grundlagen7.4 Objektliste

Projekte über Skripte automatisierenSystemhandbuch 37

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedSchlüsselschal‐ter

nein nein nein nein ja nein

Balken ja ja ja ja ja jaSymbolbibliothek nein ja ja ja ja jaSchieberegler nein ja ja ja ja jaBildlaufleiste nein nein nein nein nein neinKontrollkästchen nein nein nein nein nein neinOptionsschaltflä‐chen

nein nein nein nein nein nein

Zeigerinstrument nein ja ja ja ja jaUhr nein ja ja ja ja jaSpeicherplatzan‐zeige

nein nein nein nein nein nein

Funktionstasten ja ja ja ja ja jaBildbaustein-In‐stanzen

nein nein nein nein nein nein

Bildfenster nein nein nein nein nein neinBenutzeranzeige ja ja ja ja ja jaHTML-Browser nein nein nein nein nein neinDruckauftrag / Skriptdiagnose

nein nein nein nein nein nein

Rezepturanzeige nein nein nein nein nein neinMeldeanzeige nein nein nein nein nein neinMeldeindikator nein nein nein nein nein neinMeldefenster nein nein nein nein nein neinf(x)-Kurvenan‐zeige

nein nein nein nein nein nein

f(t)-Kurvenanzei‐ge

nein nein nein nein nein nein

Tabellenanzeige nein nein nein nein nein neinWertetabelle nein nein nein nein nein neinMedia Player nein nein nein nein nein neinKanaldiagnose nein nein nein nein nein neinWLAN-Empfang nein nein nein nein nein neinZonen-Name nein nein nein nein nein neinZonen-Signal nein nein nein nein nein neinWirkbereichs-Name

nein nein nein nein nein nein

Wirkbereichs-Name (RFID)

nein nein nein nein nein nein

Wirkbereichs-Signal

nein nein nein nein nein nein

Ladezustand nein nein nein nein nein neinHandrad nein nein nein nein ja nein

Grundlagen7.4 Objektliste

Projekte über Skripte automatisieren38 Systemhandbuch

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedHilfeindikator nein nein nein nein nein neinSm@rtClient-An‐zeige

nein nein nein nein nein nein

Status/Steuern nein nein nein nein nein neinSystem-Diagno‐seanzeige

nein nein nein nein nein nein

System-Diagno‐sefenster

nein nein nein nein nein nein

Tabelle 7-3 Dynamik

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedAnzeige ja ja ja ja ja jaBedienbarkeit nein ja ja ja ja jaSichtbarkeit ja ja ja ja ja jaBewegungen ja ja ja ja ja ja

Tabelle 7-4 Weitere Objekte

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedGruppen ja ja ja ja ja jaSoftkeys ja ja ja ja ja jaZyklen ja ja ja ja ja jaVB Skripte nein ja ja ja ja jaFunktionslisten ja ja ja ja ja jaProjektgrafiken ja ja ja ja ja ja

Tabelle 7-5 Variablen

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedMultiplex Vari‐ablen

ja ja ja ja ja ja

Arrays ja ja ja ja ja jaAnwenderda‐tentypen

ja ja ja ja ja ja

Internal nein ja ja ja ja jaVerwendungs‐stellen von elemtaren Da‐tentypen

ja ja ja ja ja ja

Grundlagen7.4 Objektliste

Projekte über Skripte automatisierenSystemhandbuch 39

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedVerwendungs‐stellen von An‐wenderdatenty‐pen

ja ja ja ja ja ja

Verwendungs‐stellen von Ar‐rays

ja ja ja ja ja ja

Zusätzlich unterstützt Openness alle Wertebereiche, die von den Kommunikationstreibern unterstützt werden.

Verbindungen

Openness unterstützt alle Verbindungen, die auch von den jeweiligen Bediengeräten unterstützt werden. Detaillierte Informationen dazu finden Sie in der Online-Hilfe des TIA-Portals unter "Prozesse visualisieren > Mit Steuerungen kommunizieren > Geräteabhängigkeit".

Tabelle 7-6 Listen

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedTextlisten ja ja ja ja ja jaGrafiklisten ja ja ja ja ja ja

Tabelle 7-7 Texte

Objekt Basic Panels Panels Comfort Panels Multi Panels Mobile Panels RT AdvancedMehrsprachige Texte

ja ja ja ja ja ja

Formatierte Texte und de‐ren Verwen‐dungsstellen

nein ja ja ja ja ja

Grundlagen7.4 Objektliste

Projekte über Skripte automatisieren40 Systemhandbuch

7.5 Standard-BibliothekenDamit die Code-Beispiele funktionieren, fügen Sie am Anfang des entsprechenden Code-Beispiels folgende Namespace-Anweisungen ein:

using System;using Siemens.Engineering;using Siemens.Engineering.HW;using Siemens.Engineering.SW;using Siemens.Engineering.Hmi;using ControllerTarget = Siemens.Engineering.HW.ControllerTarget;using Siemens.Engineering.Hmi.Tag;using Siemens.Engineering.Hmi.Screen;using Siemens.Engineering.Hmi.Cycle;using Siemens.Engineering.Hmi.Communication;using Siemens.Engineering.Hmi.Globalization;using Siemens.Engineering.Hmi.TextGraphicList;using Siemens.Engineering.Hmi.RuntimeScripting;using System.Collections.Generic; using Siemens.Engineering.Online;using Siemens.Engineering.Compiler; //for Compiler related methodsusing Siemens.Engineering.Library;using Siemens.Engineering.Library.Types;using Siemens.Engineering.Library.MasterCopies;using Siemens.Engineering.Compare;using System.IO; //for certain export related methods

7.6 Hinweise zur Performance von TIA Portal Openness V13 SP1

Root-ObjekteIn Import-Dateien können Sie mehrere Root-Objekte angeben.

Beispiel: Sie können mehrere Textlisten in einer XML-Datei statt einer Textliste pro XML-Datei anlegen.

Openness-FunktionenWenn Sie eine Openness-Funktion zum ersten Mal aufrufen, kann der Aufruf länger dauern als die nachfolgenden Aufrufe der Openness-Funktion.

Beispiel: Wenn Sie mehrere Exporte von Projektierungsdaten nacheinander ausführen, kann der erste Export länger dauern als die nachfolgenden Exporte.

Grundlagen7.6 Hinweise zur Performance von TIA Portal Openness V13 SP1

Projekte über Skripte automatisierenSystemhandbuch 41

Grundlagen7.6 Hinweise zur Performance von TIA Portal Openness V13 SP1

Projekte über Skripte automatisieren42 Systemhandbuch

Public API 88.1 Einleitung

ÜbersichtTIA Portal Openness unterstützt eine Auswahl von Funktionen für definierte Aufgaben, die Sie außerhalb vom TIA Portal über die Public API aufrufen können.

HinweisPublic API - Openness V13 und Openness V13 SP1

Wenn Sie Openness V13 SP1 installiert haben wird der Inhalt des Ordners "Public API" von Openness V13 mit "Public API" von Openness V13 SP1 überschrieben.

Im Folgenden erhalten Sie eine Übersicht über die typischen Programmierschritte. Sie erfahren, wie die einzelnen Code-Abschnitte zusammenwirken und wie Sie die jeweiligen Funktionen in ein vollständiges Programm integrieren. Außerdem erhalten Sie einen Überblick, welche Code-Bestandteile für jede Aufgabe angepasst werden müssen.

BeispielprogrammAnhand der Beispielfunktion "API-Zugriff in einer Konsolenapplikation erstellen" werden die einzelnen Programmierschritte erläutert. In diesen Programm-Code integrieren Sie die bereitgestellten Funktionen und passen die entsprechenden Code-Bestandteile für diese Aufgabe an.

FunktionenIm folgenden Abschnitt sind die Funktionen für definierte Aufgaben gelistet, die Sie mit TIA Portal Openness außerhalb vom TIA Portal aufrufen können

Siehe auchEinsatzmöglichkeiten (Seite 35)

Objektliste (Seite 36)

Projekte über Skripte automatisierenSystemhandbuch 43

8.2 Programmierschritte

ÜbersichtTIA Portal Openness erfordert für den Zugriff über die Public API folgende Programmierschritte:

1. TIA Portal in Entwicklungsumgebung bekannt machen

2. Programmzugriff auf TIA Portal einstellen

3. Programmzugriff auf TIA Portal aktivieren

4. TIA Portal bekannt machen und starten

5. Projekt öffnen

6. Befehle ausführen

7. Projekt speichern und schließen

8. Verbindung zum TIA Portal beenden

HinweisZulässige Zeichenketten

Im TIA Portal sind in Zeichenketten nur bestimmte Zeichen zulässig. Alle per Openness-Anwendung an das TIA-Portal übergebenen Zeichenketten unterliegen diesen Regeln. Wenn Sie in einem Parameter ein nicht zulässiges Zeichen übergeben, wird eine Exception ausgelöst.

Siehe auchBeispielprogramm (Seite 51)

Einsatz der Codebeispiele (Seite 56)

Public API8.2 Programmierschritte

Projekte über Skripte automatisieren44 Systemhandbuch

8.3 Openness-Objektmodell

ÜbersichtDie folgende Abbildung des Openness-Objektmodells stellt nur die verfügbaren Objekttypen dar. Die Auflistungen können Sie über IntelliSense ermitteln.

ControllerTagUserFolder

ControllerTagTable

ControllerTag

ControllerConstant

ControllerTagSystemFolder

SystemblockSystemFolder

ScreenTemplateSystemFolder

ScreenTemplateUserFolder

ScreenTemplate

ScreenGlobalElements

ScreenOverview

ExternalSourceSystemFolder

ExternalSource

SystemblockComponentFolder

Project

DeviceItem

CodeBlock

DataBlock

Connection

Cycle

GraphicList

TextList Tag

Screen

ScreenUserFolder

ScreenSystemFolder

TagTable

TagSystemFolder

TagUserFolder

VBScriptSystemFolder

VBScriptUserFolder

VBScript

CodeBlock

DataBlock

HmiTarget

ControllerTarget

NonProgrammableTarget

ProgramblockSystemFolder

ProgramblockUserFolder

DeviceUserFolder

Device

MultiLingualGraphic

1

1

1

1

1

1

1

1

1

1

1

1

ControllerDatatype

ControllerDatatypeUserFolder

ControllerDatatypeFolder1

MasterCopy

MasterCopyUserFolder

ProjectLibrary

GlobalLibrary

2

3

2

MasterCopySystemFolder

ILibraryType

ILibraryTypeVersion

LibraryTypeUserFolder

LibraryTypeSystemFolder

TIAPortal

1 Nur eine Instanz erlaubt2 Import wird nur für die Programmiersprache AWL unterstützt. 3 Enthält dieselben Objekttypen wie "ProjectLibrary".

Public API8.3 Openness-Objektmodell

Projekte über Skripte automatisierenSystemhandbuch 45

Nur Export möglich

Export und Import möglich

Nur Import möglich

Zugriff auf Objekte in AuflistungenUm ein Objekt in einer Auflistung zu adressieren, haben Sie folgende Möglichkeiten:

● Über den Index adressieren. Die Zählung innerhalb der Auflistungen beginnt bei 0.

● Methode Find verwenden. Mit dieser Methode adressieren Sie ein Objekt über dessen Namen. Die Methode können Sie auf eine Aggregation oder Auflistung anwenden. Die Methode Find ist nicht rekursiv. Beispiel: ScreenAggregation screens = folder.ScreensScreen screen = screens.Find("myScreen")

● Symbolischen Namen verwenden. Nur möglich bei Bausteinen mit symbolischer Adressierung.

Public API8.3 Openness-Objektmodell

Projekte über Skripte automatisieren46 Systemhandbuch

Zusammenhang zwischen TIA Portal und Openness-ObjektmodellDie folgende Abbildung zeigt den Zusammenhang zwischen dem Objektmodell und einem Projekt im TIA Portal:

Project

DeviceItem

HmiTarget

ControllerTarget

NonProgrammableTarget

DeviceUserFolder

Device1

1

1

1

1

1

1

1

1

1

1

2 2

① Das Objekt "Project" entspricht einem geöffneten Projekt im TIA Portal. ② Das Objekt "ControllerTarget" ist vom Typ "DeviceItem" ④ und entspricht einer PLC. Die Inhalte des Objekts

entsprechen einer PLC in der Projektnavigation mit Zugriff auf Objekte wie Bausteine oder PLC-Variablen. ③ Das Objekt "HmiTarget" ist vom Typ "DeviceItem" ④ und entspricht einem Bediengerät. Die Inhalte des Objekts

entsprechen einem Bediengerät in der Projektnavigation mit Zugriff auf Objekte wie Bilder oder HMI-Variablen.

Public API8.3 Openness-Objektmodell

Projekte über Skripte automatisierenSystemhandbuch 47

④ Das Objekt "DeviceItem" entspricht einem Objekt im Editor "Geräte & Netze". Ein Objekt vom Typ "DeviceItem" kann sowohl ein Baugruppenträger als auch ein gestecktes Modul sein.

⑤ Das Objekt "NonProgrammableTarget" entspricht einem nicht programmierbaren Objekt im Editor "Geräte & Netze", z. B. einem Kommunikationsprozessor in einer dezentralen Peripherie.

Siehe auchHierarchie von Hardware-Objekten des Objektmodells (Seite 49)

Public API (Seite 43)

Export/Import (Seite 171)

Externe Datei hinzufügen (Seite 156)

Grafiken eines Projektes exportieren (Seite 185)

Bausteine und Anwenderdatentypen exportieren (Seite 223)

System-Bausteine exportieren (Seite 227)

PLC-Variablentabellen exportieren (Seite 231)

PLC-Variablentabelle importieren (Seite 233)

Einzelne Variable einer PLC-Variablentabelle exportieren (Seite 233)

Einzelne Variable in eine PLC-Variablentabelle importieren (Seite 235)

Verbindungen exportieren (Seite 204)

Verbindungen importieren (Seite 205)

Zyklen exportieren (Seite 187)

Zyklen importieren (Seite 188)

Grafiklisten exportieren (Seite 202)

Grafikliste importieren (Seite 203)

Textlisten aus einem HMI-Gerät exportieren (Seite 199)

Textliste in ein HMI-Gerät importieren (Seite 200)

VB-Skripte exportieren (Seite 196)

VB-Skripte importieren (Seite 198)

HMI-Variablentabellen exportieren (Seite 189)

HMI-Variablentabelle importieren (Seite 192)

Einzelne Variable einer HMI-Variablentabelle exportieren (Seite 192)

Einzelne Variable in eine HMI-Variablentabelle importieren (Seite 193)

Grafiken in ein Projekt importieren (Seite 186)

Alle Bilder eines HMI-Geräts exportieren (Seite 210)

Bilder in ein HMI-Gerät importieren (Seite 213)

Bildvorlagen importieren (Seite 221)

Public API8.3 Openness-Objektmodell

Projekte über Skripte automatisieren48 Systemhandbuch

Bildvorlagen aus einem Ordner exportieren (Seite 218)

Permanentfenster exportieren (Seite 216)

Permanentfenster importieren (Seite 217)

8.4 Hierarchie von Hardware-Objekten des Objektmodells

Beziehung zwischen den sichtbaren Elementen im TIA Portal und den modellierten Elementen im Objektmodell

Hardware-Objekt ErläuterungGerät (Device)

Container-Objekt für eine zentrale oder dezentrale Konfiguration

Geräteelement (IDeviceItem)

Jedes Geräteelement-Objekt hat ein Container-Objekt. Das umgekehrte Verhältnis ist "Elemente".

Internes Geräteelement (IInternalDeviceItem)

Internes Gerät, das für einen TIA Portal-Benutzer nicht sichtbar vorhanden istAnwendungsbeispiel: Das ProfiNet-IO-Controller-Objekt bei den Submodulen.

Bei den Geräteelement-Objekten ist das Container-Element-Verhältnis mit dem Verhältnis der Module vergleichbar.

Beispiel: Ein Gerät enthält ein oder mehrere Steckplätze. Ein Steckplatz enthält Module. Ein Modul enthält Submodule.

Dies ist das Verhältnis ähnlich der Darstellung in der Netzwerkanzeige und Geräteanzeige des TIA Portals. Das Attribut "PositionNumber" eines Geräteelement-Elements ist einzigartig im Bereich des Containers.

Im Objektmodell ist das Eltern-Kind-Verhältnis zwischen Geräteelement-Objekten eine rein logische Beziehung. Ein Kind kann nicht ohne seine Eltern existieren.

● Wenn ein Submodul als Bestandteil eines Moduls (Kind) modelliert ist, kann das Submodul ohne das Modul nicht entfernt werden.

● Wenn Sie dem Modul ein Submodul hinzufügen und wieder entfernen, hat dieses Kind die gleichen Eltern wie das Modul.

Die folgende Abbildung zeigt Folgendes:

● Links: Verhältnis zwischen Geräteelement-Objekten

● Rechts: Eltern-Kind-Verhältnis

Public API8.4 Hierarchie von Hardware-Objekten des Objektmodells

Projekte über Skripte automatisierenSystemhandbuch 49

Die folgende Abbildung zeigt ein HMI-Bediengerät mit einer "Runtime Advanced".

Public API8.4 Hierarchie von Hardware-Objekten des Objektmodells

Projekte über Skripte automatisieren50 Systemhandbuch

Über die Container-Elemente "ControllerTarget" und "HmiTarget" greifen Sie über das Openness-Objektmodell auf deren Objekte zu.

Siehe auchPublic API (Seite 43)

Export/Import (Seite 171)

8.5 Beispielprogramm

Anwendungsbeispiel: API-Zugriff in einer Applikation erstellen Im Folgenden ist der vollständige Programmcode des Anwendungsbeispiels dargestellt. Im Anschluss daran sind die typischen Programmierschritte anhand dieses Beispiels erklärt.

Public API8.5 Beispielprogramm

Projekte über Skripte automatisierenSystemhandbuch 51

Das Anwendungsbeispiel benötigt eine Anwendungskonfigurationsdatei (Seite 59).

Public API8.5 Beispielprogramm

Projekte über Skripte automatisieren52 Systemhandbuch

using System;using Siemens.Engineering;using Siemens.Engineering.HW;using Siemens.Engineering.SW;using Siemens.Engineering.Hmi;using HmiTarget = Siemens.Engineering.Hmi.HmiTarget;using ControllerTarget = Siemens.Engineering.HW.ControllerTarget;using Siemens.Engineering.Hmi.Tag;using Siemens.Engineering.Hmi.Screen;using Siemens.Engineering.Hmi.Cycle;using Siemens.Engineering.Hmi.Communication;using Siemens.Engineering.Hmi.Globalization;using Siemens.Engineering.Hmi.TextGraphicList;using Siemens.Engineering.Hmi.RuntimeScripting;using System.Collections.Generic; using Siemens.Engineering.Compiler; //for Compiler related methodsusing Siemens.Engineering.GlobalLibrary; //for global library and update check related methodsusing System.IO; //for certain export related methods namespace HelloTIA{ internal class Program { private static void Main(string[] args) { RunTiaPortal(); } private static void RunTiaPortal() { Console.WriteLine("Starting TIA Portal"); using (TiaPortal tiaPortal = new TiaPortal(TiaPortalMode.WithUserInterface)) { Console.WriteLine("TIA Portal has started"); ProjectAggregation projects = tiaPortal.Projects; Console.WriteLine("Opening Project..."); string projectPath = @"C:\Demo\AnyCompanyProject.ap13"; Project project = null; try { project = projects.Open(projectPath); } catch (Exception) { Console.WriteLine(String.Format("Could not open project {0}", projectPath)); Console.WriteLine("Demo complete hit enter to exit"); Console.ReadLine(); return; }

Public API8.5 Beispielprogramm

Projekte über Skripte automatisierenSystemhandbuch 53

Console.WriteLine(String.Format("Project {0} is open", project.Path)); IterateThroughDevices(project); project.Save(); project.Close(CloseMode.PromptIfModified); Console.WriteLine("Demo complete hit enter to exit"); Console.ReadLine(); } } private static void IterateThroughDevices(Project project) { if (project == null) { Console.WriteLine("Project cannot be null"); return; } Console.WriteLine(String.Format("Iterate through {0} device(s)", project.Devices.Count)); foreach (Device device in project.Devices) { Console.WriteLine(String.Format("Device: \"{0}\".", device.Name)); } Console.WriteLine(); } }}

Vorgehen in Schritten

1. TIA Portal in Entwicklungsumgebung bekannt machenErstellen Sie in Ihrer Entwicklungsumgebung eine Referenz auf alle "dll-Dateien" im Verzeichnis "C:\Program Files\Siemens\Automation\PortalV13\PublicAPI\V13 SP1".

Im Folgenden wird dieser Vorgang exemplarisch für die Datei "Siemens.Engineering.dll" gezeigt.

Die Datei "Siemens.Engineering.dll" finden Sie im Verzeichnis "C:\Program Files\Siemens\Automation\PortalV13\PublicAPI\V13 SP1". Erstellen Sie in Ihrer Entwicklungsumgebung eine Referenz auf die Datei "Siemens.Engineering.dll".

Hinweis

Achten Sie darauf, dass in den Eigenschaften der Referenz der Parameter "CopyLocal" mit dem Wert "False" belegt sein muss.

Public API8.5 Beispielprogramm

Projekte über Skripte automatisieren54 Systemhandbuch

2. Machen Sie den Namespace für das TIA Portal bekanntFügen Sie folgenden Code hinzu:

using Siemens.Engineering;

3. TIA Portal bekannt machen und startenUm das TIA Portal bekannt zu machen und zu starten, fügen Sie folgenden Code ein:

using (TiaPortal tiaPortal = new TiaPortal())

4. Projekt öffnenUm ein Projekt zu öffnen, verwenden Sie beispielsweise folgenden Code:

ProjectAggregation projects = tiaPortal.Projects; Console.WriteLine("Opening Project..."); string projectPath = @"C:\Demo\AnyCompanyProject.ap13";Project project = null;try{ project = projects.Open(projectPath);}catch (Exception){ Console.WriteLine(String.Format("Could not open project {0}", projectPath)); Console.WriteLine("Demo complete hit enter to exit"); Console.ReadLine(); return;} Console.WriteLine(String.Format("Project {0} is open", project.Path));

Public API8.5 Beispielprogramm

Projekte über Skripte automatisierenSystemhandbuch 55

5. Geräte eines Projektes enumerierenUm alle Geräte des Projektes zu enumerieren, fügen Sie folgenden Code ein:

static private void IterateThroughDevices(Project project) { if (project == null) { Console.WriteLine("Project cannot be null"); return; } Console.WriteLine(); Console.WriteLine(String.Format("Iterate through {0} device(s)", project.Devices.Count)); foreach (Device device in project.Devices) { Console.WriteLine(String.Format("Device: \"{0}\".", device.Name)); } Console.WriteLine(); }

6. Projekt speichern und schließenUm das Projekt abschließend zu speichern und zu schließen, fügen Sie folgenden Code ein:

project.Save();project.Close(CloseMode.PromptIfModified);

8.6 Einsatz der Codebeispiele

Aufbau der CodebeispieleJedes Codebeispiel in dieser Dokumentation ist als Funktion ohne Rückgabewert mit einer Objektreferenz als Übergabeparameter realisiert. Objekte des TIA Portals werden mithilfe der Methode Find über ihren Namen angesprochen.

Public API8.6 Einsatz der Codebeispiele

Projekte über Skripte automatisieren56 Systemhandbuch

Im folgenden Codebeispiel wird ein Bild "MyScreen" aus der Gruppe "myScreenFolder" gelöscht:

private static void DeleteScreenFromFolder(HmiTarget hmitarget)//Deletes a single screen from a user folder or a system folder{ //Change the names according to the names in your project string screenName = "MyScreen"; ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("myScreenFolder"); //or ScreenSystemFolder folder = hmitarget.ScreenFolder; ScreenAggregation screens = folder.Screens; Screen screen = screens.Find(screenName); if (screen != null) { screens.Delete(screen); }}

Um dieses Codebeispiel auszuführen, benötigten Sie Folgendes:

● Ein WinCC-Projekt mit einem Bediengerät, das eine Gruppe mit wenigstens einem Bild enthält

● Eine Funktion, die das Bediengerät instanziiert

Hinweis

Wenn Sie Verzeichnispfade angeben, verwenden Sie den absoluten Verzeichnispfad, z. B. "C:/path/file.txt".

Relative Verzeichnispfade sind nur in den XML-Dateien für den Import und Export erlaubt, z. B. "file.txt" oder "C:/path01/.../path02/file.txt".

Public API8.6 Einsatz der Codebeispiele

Projekte über Skripte automatisierenSystemhandbuch 57

Beispiel für die Ausführung des CodebeispielsUm das Codebeispiel "DeleteScreenFromFolder" im Rahmen des Beispielprogramms "Hello TIA" auszuführen, verwenden Sie folgendes Beispiel:

//In the sample program "Hello TIA" replace the function call //"IterateThroughDevices(project)" by the following functions calls: HmiTarget hmiTarget = GetTheFirstHmiTarget(project); DeleteScreenFromFolder(hmiTarget); //Put the following the function definitions before or after the //function definition of "private static void IterateThroughDevices(Project project)": private static HmiTarget GetTheFirstHmiTarget(Project project){ if (project == null) { Console.WriteLine("Project cannot be null"); throw new ArgumentNullException("project"); } foreach (Device device in project.Devices) { foreach (IDeviceItem deviceItem in device.DeviceItems) { if (deviceItem is HmiTarget) { return deviceItem as HmiTarget; } } } return null;} private static void DeleteScreenFromFolder(HmiTarget hmitarget)//Deletes a single screen from a user folder or a system folder{ string screenName = "MyScreen"; ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("myScreenFolder"); //or ScreenSystemFolder folder = hmitarget.ScreenFolder; ScreenAggregation screens = folder.Screens; Screen screen = screens.Find(screenName); if (screen != null) { screens.Delete(screen); }}

Public API8.6 Einsatz der Codebeispiele

Projekte über Skripte automatisieren58 Systemhandbuch

8.7 Allgemeine Funktionen

8.7.1 Verbindung zum TIA Portal aufbauen

EinleitungMit TIA Portal Openness starten Sie das TIA Portal oder Sie verbinden sich mit einem bereits laufenden TIA Portal. Beim Starten des TIA Portals über eine Openness-Anwendung legen Sie fest, ob das TIA Portal mit oder ohne grafische Benutzeroberfläche gestartet wird. Wenn Sie das TIA Portal ohne Benutzeroberfläche betreiben, wird das TIA Portal vom Betriebssystem nur als Prozess gestartet. Mit einer Openness-Anwendung erzeugen Sie bei Bedarf mehrere Instanzen des TIA Portals.

Hinweis

Wenn Sie Openness mit der TIA Portal Oberfläche nutzen, darf der aktive Editor kein HMI-Editor sein. Sie können z. B. die Editoren "Geräte & Netze" oder den Programmiereditor manuell oder über Public API aufrufen.

Um das TIA Portal über eine Openness-Anwendung zu starten, haben Sie folgende Möglichkeiten:

● Sie verwenden eine Anwendungskonfigurationsdatei.

● Sie verwenden die Technik "AssemblyResolve".

TIA Portal über eine Anwendungskonfigurationsdatei startenReferenzieren Sie in der Anwendungskonfigurationsdatei alle benötigten Programmbibliotheken. Die Anwendungskonfigurationsdatei verteilen Sie zusammen mit der Openness-Anwendung.

Legen Sie die Anwendungskonfigurationsdatei im gleichen Verzeichnis wie die Openness-Anwendung ab.

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisierenSystemhandbuch 59

Verwenden Sie für die Anwendungskonfigurationsdatei z. B. folgenden Inhalt:

<?xml version="1.0"?><configuration> <runtime> <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"> <dependentAssembly> <assemblyIdentity name="Siemens.Engineering" culture="neutral" publicKeyToken="d29ec89bac048f84"/> <!-- Edit the following path according to your installation --> <codeBase version="1.2.0.0" href="FILE://C:\Program Files (x86)\Siemens\Automation\PortalV13\PublicAPI\V13 SP1\Siemens.Engineering.dll"/> </dependentAssembly> <dependentAssembly> <assemblyIdentity name="Siemens.Engineering.Hmi" culture="neutral" publicKeyToken="37b6e3a80df0900f"/> <!-- Edit the following path according to your installation --> <codeBase version="1.2.0.0" href="FILE://C:\Program Files (x86)\Siemens\Automation\PortalV13\PublicAPI\V13 SP1\Siemens.Engineering.Hmi.dll"/> </dependentAssembly> </assemblyBinding> </runtime></configuration>

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisieren60 Systemhandbuch

Um eine Verbindung zum TIA Portal über die Anwendungskonfigurationsdatei aufzubauen, verwenden Sie folgenden Programmcode:

//Connect an openness application via API using using System;using System.IO;using Siemens.Engineering; namespace UserProgram{ internal class MyProgram { private static void Main(string[] args) { RunTiaPortal(); } } private static void RunTiaPortal() { // To start TIA Portal with user interface: // using (TiaPortal tiaPortal = new TiaPortal(TiaPortalMode.WithUserInterface) // // To start TIA Portal without user interface: // using (TiaPortal tiaPortal = new TiaPortal(TiaPortalMode.WithoutUserInterface) using (TiaPortal tiaPortal = new TiaPortal(TiaPortalMode.WithUserInterface)) { //begin of code for further implementation //... //end of code } } }}

TIA Portal über Technik "AssemblyResolve" startenGestalten Sie den Programmcode der Openness-Anwendung so, dass Sie sich so früh wie möglich auf das Ereignis "AssemblyResolve" registrieren. Kapseln Sie den Zugriff auf das TIA Portal in einem weiteren Objekt oder einer Methode.

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisierenSystemhandbuch 61

Um eine Verbindung zum TIA Portal aufzubauen, verwenden Sie folgenden Programmcode.

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisieren62 Systemhandbuch

//Connect an openness application via API with TIAP using System;using System.IO;using System.Reflection;using Siemens.Engineering; namespace UserProgram{ static class MyProgram { static int Main(string[] args) { AppDomain.CurrentDomain.AssemblyResolve += MyResolver; MyApplication myApplication = new MyApplication(); myApplication.Run(); return 0; } private static Assembly MyResolver(object sender, ResolveEventArgs args) { int index = args.Name.IndexOf(','); if (index == -1) { return null; } string name = args.Name.Substring(0, index) + ".dll"; string path = Path.Combine(@"..\PublicAPI\V13 SP1\", name); // User must provide the correct path string fullPath = Path.GetFullPath(path); if (File.Exists(fullPath)) { return Assembly.LoadFrom(fullPath); } return null; } } public class MyApplication { public void Run() { // To start TIA Portal with user interface: // using (TiaPortal tiaPortal = new TiaPortal(TiaPortalMode.WithUserInterface) // // To start TIA Portal without user interface: // using (TiaPortal tiaPortal = new TiaPortal(TiaPortalMode.WithoutUserInterface) using (TiaPortal tiaPortal = new TiaPortal()) { //begin of code for further implementation //... //end of code } }

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisierenSystemhandbuch 63

}}

Auf laufende Instanzen des TIA Portals zugreifenUm sich mithilfe einer Openness-Anwendung mit einer laufenden Instanz des TIA Portals zu verbinden, enumerieren Sie zunächst die Instanzen des TIA Portals. Sie können sich innerhalb einer Arbeitssitzung in Windows mit mehreren Instanzen verbinden. Die laufende Instanz kann ein TIA Portal mit oder ohne gestarteter Benutzeroberfläche sein:

foreach (TiaPortalProcess tiaPortalProcess in TiaPortal.GetProcesses() { ... }

Wenn Sie die Prozess-ID der Instanz des TIA Portals kennen, verwenden Sie diese Prozess-ID zum Zugriff auf das Objekt. Das TIA Portal benötigt zum Starten eine bestimmte Zeit, bevor Sie die Openness-Anwendung mit dem TIA Portal verbinden können.

Wenn Sie sich mit einer laufenden Instanz des TIA Portals verbinden, wird eine Verbindungsanfrage gestellt. Die Verbindungsanfrage bietet folgende Möglichkeiten:

● Verbindung einmalig zulassen

● Verbindung nicht zulassen

● Verbindungen von dieser Anwendung immer zulassenDie Openness-Anwendung wird nach einer separaten Bestätigung in der Registry eingetragen: HKEY_LOCAL_MACHINE\\SOFTWARE\Siemens\Automation\Openness\<TIA Portal-Version>\Whitelist.

Hinweis

Wenn die Registry-Anfrage dreimal ablehnt wird, löst das System eine Exception vom Typ EngineeringSecurityException aus.

Wenn Sie sich mit dem Prozess verbunden haben, können Sie über folgende Attribute Informationen über die Instanzen des TIA Portals abrufen:

Attribut InformationVersion as string Gibt die Produktversion des installierten TIA Portals zurückMode as TiaPortalMode Gibt den Modus zurück, in dem das TIA Portal gestartet wurde (WithoutUserInterface/Wi‐

thUserInterface)AttachedApplications as Process[]

Gibt ein Array der verbundenen Applikationen am TIA Portal zurück

ProjectPath as string Gibt den Dateinamen des im TIA Portal geöffneten Projekts inklusive Ablageordner zurück, z. B. "D:\WinCCProjects\ColorMixing\ColorMixing.ap13"Wenn kein Projekt geöffnet ist, wird eine leere Zeichenkette zurückgegeben.

Process as Process Gibt den TIA Portal-Prozess zurück

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisieren64 Systemhandbuch

Siehe auchStandard-Bibliotheken (Seite 41)

8.7.2 Event-Handler

Event-Handler in Openness-Anwendung Eine Instanz des TIA Portals stellt folgende Events bereit, auf die Sie in einer Openness-Anwendung mit einem Event-Handler reagieren können. Sie können auf die Eigenschaften von Meldungen zugreifen und dementsprechend Reaktionen definieren.

Event ReaktionDisposed Über dieses Event reagieren Sie mit einer Openness-Anwendung auf das Schließen des

TIA Portals. Notification Über dieses Event reagieren Sie mit einer Openness-Anwendung auf Meldungen des TIA

Portals. Meldungen erfordern ausschließlich eine Bestätigung, z. B. "OK".Confirmation Über dieses Event reagieren Sie mit einer Openness-Anwendung auf Systemmeldungen

des TIA Portals. Systemmeldungen erfordern immer eine Entscheidung, z. B. "Soll das Projekt gespeichert werden?".

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisierenSystemhandbuch 65

ProgrammcodeUm Event-Handler in einer Openness-Anwendung zu registrieren, verwenden Sie folgenden Programmcode:

//Register event handler for Disposed-Event .... TiaPortal.Disposed +=TiaPortal_Disposed;.... private static void TiaPortal_Disposed(object sender, EventArgs e){ ....} //Register event handler for Notification-Event .... TiaPortal.Notification += TiaPortal_Notification;.... private static void TiaPortal_Notification(object sender, NotificationEventArgs e) { ....} //Register event handler for Confirmation-Event .... TiaPortal.Confirmation += TiaPortal_Confirmation;.... private static void TiaPortal_Confirmation(object sender, ConfirmationEventArgs e){ ....}

Eigenschaften von Meldungen des TIA-PortalsMeldungen des TIA-Portals haben folgende Eigenschaften:

Eigenschaft BeschreibungCaption Gibt die Bezeichnung der Systemmeldung zurück.DetailText Gibt den Detailtext der Systemmeldung zurück.Icon Gibt das Symbol der Systemmeldung zurückIsHandled Gibt zurück oder legt fest, ob die Systemmeldung noch ansteht.MessageID Gibt die eindeutige ID innerhalb des Service zurückServiceID Gibt die ID des Service zurück, der die Systemmeldung ausgelöst hatText Gibt den Text der Systemmeldung zurück.

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisieren66 Systemhandbuch

Eigenschaften von SystemmeldungenSystemmeldungen haben folgende Eigenschaften:

Eigenschaft BeschreibungCaption Gibt die Bezeichnung der Systemmeldung zurück.Choices Gibt die Möglichkeiten zurück, die Systemmeldung zu bestätigen. DetailText Gibt den Detailtext der Systemmeldung zurück.Icon Gibt das Symbol der Systemmeldung zurückIsHandled Gibt zurück oder legt fest, ob die Systemmeldung noch ansteht.MessageID Gibt die eindeutige ID innerhalb des Service zurückResult Gibt das Ergebnis der Bestätigung zurück oder legt es fest.ServiceID Gibt die ID des Service zurück, der die Systemmeldung ausgelöst hatText Gibt den Text der Systemmeldung zurück.

Siehe auchDialoge mit Systemmeldungen programmgesteuert bestätigen (Seite 68)

8.7.3 Gleichzeitiger Zugriff auf Projekte

EinleitungMit einer Openness-Anwendung können Sie gleichzeitig mit einem Projekteur auf die Projektdaten einer TIA Portal-Instanz zugreifen. Dazu müssen Sie das TIA Portal mit grafischer Benutzeroberfläche gestartet haben.

Verhalten des TIA Portals bei gleichzeitigem ZugriffDie Bedienaktionen der Openness-Anwendung und des Projekteurs werden im Aktionsstapel des TIA Portals gespeichert. Die Aktionen einer Openness-Anwendung werden im Aktionsstapel mit "Änderung von externer Anwendung" gekennzeichnet. Ein Projekteur kann eine oder mehrere Aktionen einer Openness-Anwendung rückgängig machen oder wiederholen.

Wenn die Openness-Anwendung und der Projekteur dieselben Projektdaten gleichzeitig bearbeiten, kann das zum Abbruch der Openness-Anwendung führen.

Beispiel: Die Openness-Anwendung erstellt ein HMI-Bild und fügt Bildobjekte ein. Der Projekteur löscht das neu erstellte HMI-Bild. Die Openness-Anwendung soll die eingefügten Bildobjekte mit Variablen verbinden. Bild und Bildobjekte sind mehr vorhanden. Eine Exception wird ausgelöst, die Sie in der Openness-Anwendung z. B. mit einem Anwenderdialog behandeln können.

Wenn Sie mit einer Openness-Anwendung voneinander abhängige Aktionen ausführen, kapseln Sie diese Aktionen in einer "Transaktion".

Weiterführende Informationen zum Aktionsstapel finden im Informationssystem des TIA Portal unter "Grundlagen zum Rückgängig machen und Wiederholen von Aktionen".

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisierenSystemhandbuch 67

Definieren von TransaktionenEine Transaktion sichert den Aktionen der Openness-Anwendung einen exklusiven Zugriff im TIA Portal. Solange die Transaktion aktiv ist, kann ein Projekteur das TIA Portal nicht bedienen. Dieser Transaktionsmodus wird dem Projekteur durch einen Dialog angezeigt.

Während einer laufenden Transaktion werden Projektdaten zunächst nur temporär geändert. Erst wenn ein fehlerfreier Ablauf garantiert ist, wird die Transaktion abgeschlossen. Ansonsten werden alle temporären Änderungen rückgängig gemacht. Bei einem unvorgesehenen Programmabbruch wird die Transaktion ebenfalls nicht ausgeführt.

Hinweis

Vor jedem Start einer Transaktion müssen sich alle Geräte im Status "Offline" befinden.

Verwenden Sie zum Arbeiten mit Transaktionen folgenden Programmcode:

Project project = ...; //This call starts a transaction project.StartTransaction();//or//This call starts a transaction and specifies a transaction name that will appear in the undo box//Note that the transaction name is language independent. project.StartTransaction("Do something");... //This call exits a running transaction and commits all changes project.CommitTransaction();or//This call exits a running transaction and rolls back all changes project.RollbackTransaction();

8.7.4 Dialoge mit Systemmeldungen programmgesteuert bestätigen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Event-Handler sind registriert.Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisieren68 Systemhandbuch

VerwendungWenn Sie das TIA Portal über die Benutzeroberfläche bedienen, werden Sie bei einigen Programmabläufen Dialog mit Systemmeldungen angezeigt. Auf Basis dieser Systemmeldungen entscheiden Sie, wie Sie weiter verfahren.

Wenn Sie auf das TIA Portal über eine Openness-Anwendung zugreifen, müssen die Systemmeldungen über entsprechende ".NET"-Ereignisse bestätigt werden.

Die zugelassenen Bestätigungen sind in der Auflistung Choices enthalten:

● Abort● Cancel● Ignore● No● NoToAll● None● OK● Retry● Yes● YesToAllDer Wert von ConfirmationEventArgs.Result muss einer der oben genannten Einträge sein. Ansonsten wird eine Exception ausgelöst.

ProgrammcodeUm einen Dialog mit einer Systemmeldung programmgesteuert zu bestätigen, verwenden Sie folgenden Programmcode:

//Handles confirmation of message boxesusing (TiaPortal tiaPortal = new TiaPortal()){ tiaPortal.Confirmation += Confirmation;}

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisierenSystemhandbuch 69

private static void Confirmation (object sender, ConfirmationEventArgs e){ if (e.IsHandled == false) { if ((e.Choices & ConfirmationResult.Cancel) == ConfirmationResult.Cancel) { e.Result = ConfirmationResult.Cancel; e.IsHandled = true; } else if ((e.Choices & ConfirmationResult.No) == ConfirmationResult.No) { e.Result = ConfirmationResult.No; e.IsHandled = true; } }}

Um den Projekteur über ausgeführte Aktionen einer Openness-Anwendung zu informieren, verwenden Sie folgenden Programmcode:

//Handles notifications using (TiaPortal tiaPortal = new TiaPortal()){ tiaPortal.Notification += Notification; try { //perform actions that will result in a notification event } finally { tiaPortal.Notification -= Notification; }}

private void Notification(object sender, EventArgs e){ e.IsHandled = True}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.7 Allgemeine Funktionen

Projekte über Skripte automatisieren70 Systemhandbuch

8.7.5 Verbindung zum TIA Portal beenden

EinleitungWenn Sie die TIA Portal-Instanz ohne Benutzeroberfläche gestartet haben, können Sie diese TIA Portal-Instanz über die Openness-Anwendung beenden. In allen anderen Fällen trennen Sie die Openness-Anwendung von der TIA Portal-Instanz. Wenn ein Projekteur die TIA Portal-Instanz trotz laufender Zugriffe einer Openness-Anwendung schließt, wird in der Openness-Anwendung die Exception der Klasse "NonRecoverableException" ausgelöst.

Um die aktive Instanz des TIA Portals zu trennen oder zu beenden, verwenden Sie die Methode IDisposable.Dispose().

Sie können die Methode IDisposable.Dispose() folgendermaßen verwenden:

● Verwenden Sie ein using-Statement.

● Umgeben Sie die Objektbeschreibung mit einem try-finally-Block und rufen Sie die Methode IDispose.Dispose() innerhalb des finally-Blocks auf.

Wenn Sie die aktive Instanz des TIA Portals beenden, können Sie auf das TIA Portal nicht mehr zugreifen.

ProgrammcodeUm die Verbindung zum TIA Portal zu trennen oder zu beenden, verwenden Sie folgenden Programmcode:

// Add code to dispose the application if the application is still instantiatedif (tiaPortal != null){ tiaPortal.Dispose();}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8 Funktionen auf Projekte/Projektdaten

8.8.1 Projekt öffnen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 71

Hinweis

Das zu öffnende Projekt darf in keinem anderen TIA Portal geöffnet sein.

HinweisZugriff auf Projekte des TIA Portals V13 SP1

TIA Portal Openness V13 SP1 greift ausschließlich auf Projekte zu, die mit dem TIA Portal V13 SP1 angelegt oder auf die Version 13 hochgerüstet wurden.

Wenn Sie mit TIA Portal Openness V13 SP1 auf ein Projekt einer vorhergehenden Version zugreifen, wird "Null" zurückgegeben.

HinweisKein Zugriff auf schreibgeschützte Projekte

TIA Portal Openness V13 SP1 greift ausschließlich auf Projekte mit Lese- und Schreibrechten zu.

VerwendungUm ein Projekt zu öffnen, verwenden Sie die Methode Projects.Open.

Platzieren Sie den Öffnungs-Befehl für das Projekt in einem try-Block und den Schließen-Befehl in einem finally-Block.

Geben Sie in der Methode Projects.Open einen Pfad zu dem gewünschten Projekt ein.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren72 Systemhandbuch

ProgrammcodeUm ein Projekt zu öffnen, verwenden Sie folgenden Programmcode:

//Use the code in the try block to open a projectProject project = null; try { project = tiaPortal.Projects.Open(@"Some\Path\ProjectName.ap13"); //begin of code for further implementation //... // end of code } catch (TargetInvocationException) { //handle error here } catch{ //something is very wrong and the TIA Portal crashed tiaPortal = null; } finally { if(tiaPortal != null && project != null) { project.Close; }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.2 Alle Geräte enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Verwendung

Hinweis

Beachten Sie die Hierarchie von Hardware-Objekten des Objektmodells (Seite 49).

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 73

Um die Geräte eines Projekts zu enumerieren, verwenden Sie eine der folgenden Möglichkeiten:

● Alle Geräte auf erster Ebene enumerieren

● Alle Geräte in Gruppen und Untergruppen enumerieren

Beispiele für enumerierbare Geräte:

● Central station

● PB-Slave / PN-IO device

● HMI Device

Programmcode: Geräte auf erster Ebene enumerierenUm Geräte der ersten Ebene zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateDevicesInProject(Project project)//Enumerates all devices in project{ DeviceAggregation deviceAggregation = project.Devices; foreach (Device device in deviceAggregation) { // add code here }}

Um auf ein einzelnes Gerät zuzugreifen, verwenden Sie folgenden Programmcode. Die Methode Find können Sie nur auf Geräte anwenden, die ein Bediengerät repräsentieren:

private static void AccessSingleDeviceByName(Project project)//Access single device by its name{ DeviceAggregation deviceAggregation = project.Devices; // The parameter specifies the name of the device Device device = deviceAggregation.Find("ColorMixing_HMI");}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren74 Systemhandbuch

Programmcode: Geräte in Gruppen oder Untergruppen enumerierenUm Geräte in Gruppen oder Untergruppen zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateDevicesInFolders(Project project)//Enumerates devices in folders and subfolders{ foreach (DeviceUserFolder deviceUserFolder in project.DeviceFolders) { EnumerateDeviceUserFolder(deviceUserFolder); }} private static void EnumerateDeviceUserFolder(DeviceUserFolder deviceUserFolder) { EnumerateDeviceObjects(deviceUserFolder.Devices); foreach (DeviceUserFolder subDeviceUserFolder in deviceUserFolder.Folders) { EnumerateDeviceUserFolder(subDeviceUserFolder); // recursion } } private static void EnumerateDeviceObjects(DeviceAggregation deviceAggregation) { foreach (Device device in deviceAggregation) { // add code here } }

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.3 Alle Geräteelemente enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 75

VerwendungUm die Geräteelemente zu enumerieren, verwenden Sie eine der folgenden Möglichkeiten:

● Mit der Aggregationshierarchie enumerieren

● Mit der Element-Verknüpfung enumerieren

Hinweis

Bevor Sie auf einer untergeordneten Ebene auf interne Geräteelemente zugreifen können, müssen Sie möglicherweise durch mehrere Ebenen von Geräteelementen navigieren.

Weiterführende Informationen zu diesem Thema finden Sie im Kapitel Hierarchie von Hardware-Objekten des Objektmodells (Seite 49).

Interne Geräteelemente enumerieren Sie mit der Aggregationshierarchie. Beim Enumerieren über die Element-Verknüpfung führt das Enumerieren zu keinem Ergebnis.

Interne Geräteelemente sind Elemente, die nicht als reguläre Module angesehen werden. Beispiel: Die PROFINET IO Controller-Funktionalität ist als internes Geräteelement ausgebildet.

Programmcode: Mit Aggregationshierarchie enumerierenUm die Geräteelemente eines Geräts über die Aggregationshierarchie zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateWithAggregationHierarchy1(Device device)//Enumerates devices using an aggregation{ IDeviceItemAggregation deviceItemAggregation = device.DeviceItems; foreach (IDeviceItem deviceItem in deviceItemAggregation) { // add code here }}

Um auf ein einzelnes Geräteelement zuzugreifen, verwenden Sie folgenden Programmcode:

private static void AccessDeviceelementWithinAggregation(Device device)//Accesses a device element by its positioning number in a deviceitem like a rack{ int positionnumber = 1; IHardwareObject containerObject = device; IDeviceItemAggregation deviceItemAggregation = device.DeviceItems; IDeviceItem deviceItem = deviceItemAggregation.Find(positionnumber,containerObject);}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren76 Systemhandbuch

Programmcode: Mit Element-Verknüpfung enumerierenUm die Geräteelemente eines Geräts über die Element-Verknüpfung zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateDevicesWithAssociation(Device device)//Enumerates devices using an association{ IDeviceItemAssociation deviceItemAssociation = device.Elements; foreach (IDeviceItem deviceItem in deviceItemAssociation) { // add code here }}

Ein Geräteelement kann interne Geräteelemente besitzen.

Um auf die internen Geräteelemente zuzugreifen, verwenden Sie folgenden Programmcode:

private static void AccessInternalDevices(DeviceItem deviceItem)//Accesses an internal device{ IInternalDeviceItemAggregation internalDeviceItemAggregation = deviceItem.InternalDeviceItems; foreach (InternalDeviceItem InternalDeviceItem in internalDeviceItemAggregation) { // add code here }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.4 Objektstruktur und -Attribute ermitteln

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 77

VerwendungDie Navigationsstruktur durch die Objekthierarchie können Sie mit der IEngineeringObject-Schnittstelle ermitteln. Das Ergebnis wird als Liste zurückgegeben:

● Untergeordnete Objekte

● Untergeordnete Aggregationen

● Alle Attribute mit bestimmten Zugriffsrechten, z. B. Schreiben oder Lesen.

SignaturVerwenden Sie zum Ermitteln von Attributen mit bestimmten Zugriffsrechten die Methode GetAttributeNames.

IList<string> IEngineeringObject.GetAttributeNames(AttributeAccessMode attributeAccessMode);

Parameter FunktionAttributeAccessMode Legt das Zugriffsrecht fest, mit dem die Attribute

des angegebenen Objekts abgefragt werden. ● Read: Gibt alle Attribute mit Zugriff "Lesen"

zurück.● ReadOnly: Gibt alle Attribute mit Zugriff "Nur

Lesen" zurück.● Write: Gibt alle Attribute mit Zugriff

"Schreiben" zurück. ● WriteOnly: Gibt alle Attribute mit Zugriff "Nur

Schreiben" zurück.● ReadWrite: Gibt alle Attribute mit Zugriff

"Lesen und Schreiben" zurück.

Programmcode: Objekte oder Aggregationen ermittelnWenn Sie den Rückgabewert kennen, verwenden Sie folgenden Programmcode:

public static void DetermineObjectsorAggregations(Device device){ //Determines Navigators IList<string> aggregationNames = ((IEngineeringObject)device).GetAggregationNames(); IDeviceItemAggregation aggregation = ((IEngineeringObject)device).GetAggregation<IDeviceItemAggregation>("DeviceItems");}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren78 Systemhandbuch

Wenn Sie den Rückgabewert nicht kennen, verwenden Sie folgenden Programmcode:

public static void DetermineObjectsorAggregations(Device device){ IEngineeringAggregationOrObject deviceItem = ((IEngineeringObject) device).GetAggregation<IEngineeringAggregationOrObject>("DeviceItems"); }

Programmcode: Attribute ermittelnUm Attribute eines Objekts mit bestimmten Zugriffsrechten in einer Liste zurückzugeben, verwenden Sie folgenden Programmcode:

public static void DetermineAttributes(Device device){ IList<string> attributeNamesReadOnly = device.GetAttributeNames(AttributeAccessMode.Read);}

8.8.5 Alle Subnetze enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

ProgrammcodeUm alle Subnetze im Projekt zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateSubnets(Project project){ foreach (Subnet subnet in project.Subnets) { ... }}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 79

8.8.6 Alle mit einem Subnetz verbundenen Geräte enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

ProgrammcodeUm alle in Geräten enthaltenen Module mit Anschluss an einem bestimmten Subnetz zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateDevicesConnectedToASubnet(Project project)//Enumerates devices connected to a subnet{ Subnet subnet = project.Subnets.Find("MySubnet"); foreach (Node node in subnet.Nodes) { IEngineeringObject currentItem = node; do { currentItem = currentItem.Parent; } while (!(currentItem is Device)); Device device = currentItem as Device; }}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.8.7 Editor "Geräte & Netze" öffnen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren80 Systemhandbuch

VerwendungSie können über die API-Schnittstelle den Editor "Geräte & Netze" über eine der beiden Methoden öffnen:

● ShowHwEditor(View.Topology|Network|Device): Öffnet den Editor "Geräte & Netze" aus dem Projekt.

● ShowInEditor(View.Topology|Network|Device) : Zeigt das angegebene Gerät im Editor "Geräte & Netze" an.

Über den Parameter View definieren Sie die Sicht, die beim Öffnen des Editors angezeigt wird:

● View.Topology: Topologiesicht

● View.Network: Netzsicht

● View.Device: Gerätesicht

ProgrammcodeUm den Editor "Geräte & Netze" zu öffnen, verwenden Sie folgenden Programmcode:

private static void OpenEditorDevicesAndNetworksFromProject(Project project)// Open topology view from project{ project.ShowHwEditor(Siemens.Engineering.HW.View.Topology);}

Um den Editor "Geräte & Netze" für ein Gerät zu öffnen, verwenden Sie folgenden Programmcode:

private static void OpenEditorDevicesAndNetworksFromDevice(Device device)// Open topology view for given device{ device.ShowInEditor(Siemens.Engineering.HW.View.Topology);}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 81

8.8.8 PLC-Target und HMI-Target abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

VerwendungSie können ermitteln, ob ein Gerätelement als PLC-Target oder als HMI-Target in der Public API verwendet werden kann.

Programmcode: PLC-TargetUm festzustellen, ob ein Gerätelement als PLC-Target verwendet werden kann, verwenden Sie folgenden Programmcode:

private static void GetControllerTarget(Device device)//Checks whether a device is of type controllertarget{ IDeviceItemAggregation deviceItemAggregation = device.DeviceItems; foreach (IDeviceItem deviceItem in deviceItemAggregation) { ControllerTarget controllerTarget = deviceItem as ControllerTarget; if (controllerTarget != null) { // add code here } }}

Um den Typ zu bestimmen, können Sie die Eigenschaft "DeviceItemType" verwenden:

long type = deviceItem.DeviceItemType;

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren82 Systemhandbuch

Programmcode: HMI-TargetUm festzustellen, ob ein Geräteelement als HMI-Target verwendet werden kann, verwenden Sie folgenden Programmcode:

private static void GetHMITarget(Device device)//Checks whether a device is of type hmitarget{ IDeviceItemAggregation deviceItemAggregation = device.DeviceItems; foreach (IDeviceItem deviceItem in deviceItemAggregation) { HmiTarget hmitarget = deviceItem as HmiTarget; if (hmitarget != null) { // add code here } }}

Siehe auchStandard-Bibliotheken (Seite 41)

Alle Geräte enumerieren (Seite 73)

8.8.9 Systemordner für PLC-Variablen abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Alle Geräte sind enumeriert.Siehe Alle Geräte enumerieren (Seite 73)

● Alle Geräteelemente eines ausgewählten PLC-Geräts sind enumeriert.Siehe Alle Geräteelemente enumerieren (Seite 75)

● Alle Geräteelemente sind ermittelt, die Variablentabellen enthalten.Siehe PLC-Target und HMI-Target feststellen (Seite 82)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 83

ProgrammcodeUm den Systemordner der PLC-Variablen einer PLC abzufragen, verwenden Sie folgenden Programmcode:

private static void GetControllerTagfolder(ControllerTarget controllertarget)//Retrieves the controller tag folder from a controller target{ ControllerTagSystemFolder controllerTagSystemFolder = controllertarget.ControllerTagFolder;}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.10 Benutzerdefinierte Ordner für PLC-Variablen enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59) n

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Alle Geräte sind enumeriert.Siehe Alle Geräte enumerieren (Seite 73)

● Alle Geräteelemente eines ausgewählten PLC-Geräts sind enumeriert.Siehe Alle Geräteelemente enumerieren (Seite 75)

● Alle Geräteelemente sind ermittelt, die Variablentabellen enthalten.Siehe PLC-Target und HMI-Target feststellen (Seite 82)

VerwendungEnthaltene Unterordner werden beim Enumerieren rekursiv berücksichtigt.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren84 Systemhandbuch

Programmcode: Benutzerdefinierte Ordner für PLC-Variablen enumerierenUm benutzerdefinierte Ordner für PLC-Variablen zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateControllertagUserFolders(ControllerTarget controllertarget)//Enumerates all controller tag user folders including subfolders{ foreach (ControllerTagUserFolder tagUserFolder in controllertarget.ControllerTagFolder.Folders) { EnumerateTagUserFolders(tagUserFolder); }} private static void EnumerateTagUserFolders(ControllerTagUserFolder tagUserFolder) { foreach (ControllerTagUserFolder subTagUserFolder in tagUserFolder.Folders) { EnumerateTagUserFolders(subTagUserFolder); // recursion } }

Programmcode: Auf einen benutzerdefinierten Ordner zugreifenUm auf einen benutzerdefinierten Ordner für PLC-Variablen zuzugreifen, verwenden Sie folgenden Programmcode:

private static void GiveIndidualAccdessToControllerTagUserFolder(ControllerTarget controllertarget)//Gives individual access to a specific controller tag user folder{ ControllerTagUserFolderAggregation controllerTagUserFolderAggregation = controllertarget.ControllerTagFolder.Folders; ControllerTagUserFolder controllerTagUserFolder = controllerTagUserFolderAggregation.Find("User folder XYZ"); // The parameter specifies the name of the user folder}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 85

8.8.11 PLC-Variablen enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Programmcode: PLC-Variablen in Variablentabellen enumerierenUm alle PLC-Variablen in einer Variablentabelle zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateAllControllerTagsInTagTable(ControllerTarget controllertarget)//Enumerates all controller tags in a specific tag table { ControllerTagTable tagTable = controllertarget.ControllerTagFolder.TagTables.Find("Tag table XYZ"); foreach (ControllerTag tag in tagTable.Tags) { // add code here }}

Programmcode: Auf PLC-Variable zugreifenUm auf die gewünschte PLC-Variable zuzugreifen, verwenden Sie folgenden Programmcode. Auf folgende Eigenschaften haben Sie Zugriff:

● Name

● Datentyp

● Symbolische Adresse

● Kommentar

private static void AccessControllerTag(ControllerTagTable tagTable)//Gives individual access to a specific controller tag { ControllerTag tag = tagTable.Tags.Find("Tag XYZ"); // The parameter specifies the name of the tag}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren86 Systemhandbuch

8.8.12 PLC-Variablentabellen in einem Ordner enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Programmcode: PLC-Variablentabellen enumerierenUm alle PLC-Variablentabellen in Systemordnern oder in benutzerdefinierten Ordnern zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateAllControllerTagTablesInFolder(ControllerTarget controllertarget)//Enumerates all controller tag tables in a specific system folder or and user folders{ ControllerTagTableAggregation tagTables = controllertarget.ControllerTagFolder.TagTables; // alternatively, ControllerTagTableAggregaion tagTables = tagUserFolder.TagTables; foreach (ControllerTagTable tagTable in tagTables) { // add code here }}

Programmcode: Auf PLC-Variablentabelle zugreifenUm auf die PLC-Variablentabelle zuzugreifen, verwenden Sie folgenden Programmcode:

private static void AccessToControllerTagTable(ControllerTarget controllertarget)//Gives individual access to a specific controller tag table{ ControllerTagTableAggregation tagTables = controllertarget.ControllerTagFolder.TagTables; // alternatively, ControllerTagTableAggregation tagTables = tagUserFolder.TagTables; ControllerTagTable controllerTagTable = tagTables.Find("Tag table XYZ"); // The parameter specifies the name of the tag table}

Siehe auchStandard-Bibliotheken (Seite 41)

Alle Geräte enumerieren (Seite 73)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 87

8.8.13 Informationen einer PLC-Variablentabelle abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie Anzahl der Variablen in der PLC-Variablentabelle entnehmen Sie der Nummer der Variablen-Aggregation.

ProgrammcodeUm die Informationen zu einer PLC-Variablentabelle abzufragen, verwenden Sie folgenden Programmcode:

private static void ReadControllerTagTableInformation(ControllerTarget controllertarget)//Reads controller tag table information { ControllerTagTable tagTable = controllertarget.ControllerTagFolder.TagTables.Find("Tag table XYZ"); String tagTableName = tagTable.Name; bool isDefaultTagTable = tagTable.IsDefault;}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.14 Projekt übersetzen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Projekt öffnen (Seite 71)

● Alle Geräte sind im Status "Offline".

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren88 Systemhandbuch

VerwendungDie API-Schnittstelle unterstützt das Übersetzen von Geräten und Programmbausteinen. Das Übersetzungsergebnis wird als Objekt zurückgegeben. Folgende Objekttypen werden unterstützt:

● Device● ControllerTarget● HmiTarget● CodeBlock● DataBlock● ControllerDatatype● ProgramblockSystemFolder● ProgramblockUserFolder● ControllerDatatypeSystemFolder● ControllerDatatypeUserFolder

SignaturZum Übersetzen verwenden Sie die Methode Compile mit den Parametern CompilerOptions und BuildOptions.CompilerResult result <EOM Object>.Compile (CompilerOptions compilerOptions, BuildOptions buildOptions)CompilerResult result <EOM Object>.Compile(BuildOptions buildOptions)

Parameter FunktionCompilerOptions compilerOptions Legt fest, ob die Hardware oder Software eines

Geräts übersetzt wird: ● Hardware: Hardwarekonfiguration wird

übersetzt. ● Software: Software wird übersetzt.

BuildOptions buildOptions Legt den Übersetzungsumfang fest:● Build: Entspricht dem Befehl "Übersetzen

(nur Änderungen)"● Rebuild: Entspricht dem Befehl "Übersetzen

(komplett)"

Hinweis

Um die Hardware eines Geräts zu übersetzen, verwenden Sie den Objekttyp Device.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 89

ProgrammcodeUm von einem Objekt vom Typ ControllerTarget die Softwareänderungen zu übersetzen, verwenden Sie folgenden Programmcode:

public static void CompileControllerTarget(ControllerTarget controllertarget){ CompilerResult result = ControllerTarget.Compile (CompilerOptions.Software, BuildOptions.Build)}

Um von einem Objekt vom Typ CodeBlock die Softwareänderungen zu übersetzen, verwenden Sie folgenden Programmcode:

public static void CompileCodeBlockControllerTarget(ControllerTarget controllertarget){ CodeBlock block = controllertarget.ProgramblockFolder.Blocks.Find("MyCodeBlock") as CodeBlock; if (block != null) { CompilerResult result = block.Compile (BuildOptions.Build); //or BuildOptions.Rebuild }}

Um das Übersetzungsergebnis auszuwerten, verwenden Sie folgenden Programmcode:

private void WriteCompilerResults(CompilerResult result){ Console.WriteLine("State:" + result.State); Console.WriteLine("Warning Count:" + result.WarningCount); Console.WriteLine("Error Count:" + result.ErrorCount); RecursivelyWriteMessages(result.Messages);} private void RecursivelyWriteMessages (CompilerResultMessageAggregation messages, string indent =""){ indent += "\t"; foreach (CompilerResultMessage message in messages) { Console.WriteLine(indent + "Path: " + message.Path); Console.WriteLine(indent + "DateTime: " + message.DateTime); Console.WriteLine(indent + "State: " + message.State); Console.WriteLine(indent + "Description: " + message.Description); Console.WriteLine(indent + "Warning Count: " + message.WarningCount); Console.WriteLine(indent + "Error Count: " + message.ErrorCount); RecursivelyWriteMessages(message.Messages, indent); }}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren90 Systemhandbuch

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.8.15 Funktionen auf Bibliotheken

8.8.15.1 Funktionen auf Objekte und Instanzen

Zugriff auf Typen und InstanzenMit der Public API-Schnittstelle können Sie auf Typen, Typ-Versionen und Kopiervorlagen in der Projektbibliothek oder globalen Bibliotheken zugreifen. Sie können Verbindungen zwischen Typ-Versionen und Instanzen ermitteln. Außerdem können Sie Instanzen im Projekt aktualisieren und Änderungen in einer globalen Bibliothek mit der Projektbibliothek abgleichen. Zusätzlich unterstützt die Public API-Schnittstelle den Vergleich zwischen Typ-Versionen und Instanzen.

Funktionen für Objekte und InstanzenFolgende Funktionen für Typen, Typenversionen, Kopiervorlagen und Instanzen stehen Ihnen über die Public API-Schnittstelle zur Verfügung:

① Eigenschaften von Typen, Typ-Versionen, Kopiervorlagen und Instanzen anzeigen② Innerhalb der Projektbibliothek stehen Ihnen folgende Funktionen zur Verfügung:

● Instanzen der Typen aktualisieren ● Typ-Versionen im Projekt instanziieren● Innerhalb der Bibliotheksordner navigieren● Ordner, Typen, Typ-Versionen und Kopiervorlagen löschen

③ Innerhalb der globalen Bibliothek stehen Ihnen folgende Funktionen zur Verfügung:● Instanzen der Typen aktualisieren● Typ-Version im Projekt instanziieren● Innerhalb der Bibliotheksordner navigieren

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 91

8.8.15.2 Auf Bibliotheken zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungSie können mit der Public API-Schnittstelle auf die Inhalte der globalen Bibliothek und der Projektbibliothek zugreifen.

Programmcode

Hinweis

Sie können mit Openness nur auf globale Bibliotheken ab TIA-Portal V13 SP1 zugreifen. Wenn Sie globale Bibliotheken einer vorhergehenden Version öffnen, wird eine Exception ausgelöst.

Hinweis

GlobalLibraries.Open öffnet die globale Bibliothek nicht in der Benutzeroberfläche des TIA Portals.

GlobalLibraries gibt keine Liste der geöffneten Bibliotheken zurück.

Um auf eine globale Bibliothek zuzugreifen, verwenden Sie folgenden Programmcode:

public static void AccessGlobalLibrary(TiaPortal tiaPortal){ String strPathToGlobalLib = @"C:\OpennessSamples\MyGlobalLib\MyGlobalLib.al13"; GlobalLibrary globalLibrary = tiaPortal.GlobalLibraries.Open(strPathToGlobalLib); }

Um auf die Projektbibliothek zuzugreifen, verwenden Sie folgenden Programmcode:

public static void AccessProjectLibrary(Project project){ ProjectLibrary projectLibrary = project.ProjectLibrary;}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren92 Systemhandbuch

Siehe auchAuf Ordner in einer Bibliothek zugreifen (Seite 93)

8.8.15.3 Auf Ordner in einer Bibliothek zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

VerwendungÜber die Public API-Schnittstelle können Sie in einer Bibliothek auf die Systemordner für Typen und Kopiervorlagen zugreifen. Innerhalb der Systemordner können Sie auf Typen, Typ-Versionen, Kopiervorlagen und benutzerdefinierte Ordner zugreifen.

Der Zugriff auf einen benutzerdefinierten Ordner ist jederzeit über die Methode Find möglich, z. B. libTypeUserFolder.Folders.Find("SomeUserFolder");.

ProgrammcodeUm auf den Systemordner für Typen in einer Bibliothek zuzugreifen, verwenden Sie folgenden Programmcode:

public static void AccessTypeSystemFolder(ILibrary library){ LibraryTypeSystemFolder libTypeSystemFolder = library.TypeFolder;}

Um auf den Systemordner für Kopiervorlagen in einer Bibliothek zuzugreifen, verwenden Sie folgenden Programmcode:

public static void AccessMasterCopySystemFolder(ILibrary library){ MasterCopySystemFolder libMasterCopySystemFolder = library.MasterCopyFolder;}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 93

Um benutzerdefinierte Ordner in einem Systemordner enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateUserFoldersInTypeSystemFolder(ILibrary library){ // Enumerating user folders in type system folder: LibraryTypeSystemFolder libTypeSystemFolder = library.TypeFolder; foreach (LibraryTypeUserFolder libTypeUserFolder in libTypeSystemFolder.Folders) { //... } }

public static void EnumerateUserFoldersInMasterCopySystemFolder(ILibrary library){ // Enumerating user folders in master copy system folder: MasterCopySystemFolder libMasterCopySystemFolder = library.MasterCopyFolder; foreach (MasterCopyUserFolder libMasterCopyUserFolder in libMasterCopySystemFolder.Folders) { //.. }}

Um benutzerdefinierte Unterordner in einem benutzerdefinierten Ordner für Typen zu enumerieren, verwenden Sie folgenden Programmcode

public static void EnumerateAllUserFolders(LibraryTypeUserFolder libUserFolder){ foreach (LibraryTypeUserFolder libSubUserFolder in libUserFolder.Folders) { EnumerateAllUserFolders(libSubUserFolder); }}

Um benutzerdefinierte Unterordner in einem benutzerdefinierten Ordner für Kopiervorlagen zu enumerieren, verwenden Sie folgenden Programmcode

public static void EnumerateAllUserFolders(MasterCopyUserFolder libUserFolder){ foreach (MasterCopyUserFolder libSubUserFolder in libUserFolder.Folders) { EnumerateAllUserFolders(libSubUserFolder); }}

Siehe auchAuf Kopiervorlagen zugreifen (Seite 103)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren94 Systemhandbuch

8.8.15.4 Auf Typen zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für TypenSiehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

VerwendungSie können mit der Public API-Schnittstelle auf die in einer Bibliothek enthaltenen Typen zugreifen:

● Sie können die Typen enumerieren

● Sie können bei jedem Typen auf folgende Eigenschaften zugreifen:

Eigenschaft Datentyp BeschreibungAuthor String Gibt den Namen des Erstellers zurück. Comment MultilingualText Gibt den Kommentar zurück. Guid Guid Gibt die Guid des Typen zurück.1

Name String Gibt den Namen des Typs zurück.2

1 In einer Bibliothek können Sie über diese Eigenschaft einen einzelnen Typen finden. Die Suche ist rekursiv.

2 In einem Ordner können Sie über diese Eigenschaft einen einzelnen Typen finden. Unterordner bleiben bei der Suche unberücksichtigt.

ProgrammcodeUm alle Typen im Systemordner einer Bibliothek zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateTypesInTypesSystemFolder (LibraryTypeSystemFolder libraryTypeSystemFolder){ foreach (ILibraryType libraryType in libraryTypeSystemFolder.Types) { //... }}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 95

Um alle Typen in einem benutzerdefinierten Ordner einer Bibliothek zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateTypesInTypesUserFolder (LibraryTypeUserFolder libraryTypeUserFolder){ foreach (ILibraryType libraryType in libraryTypeUserFolder.Types) { //... }}

Um auf die Eigenschaften eines Typen zuzugreifen, verwenden Sie folgenden Programmcode:

public static void InspectPropertiesOfType (ILibraryType libTypeObject){ string typeAuthor = libTypeObject.Author; MultilingualText typeComment = libTypeObject.Comment; string typeName = libTypeObject.Name; Guid typeGUID = libTypeObject.Guid;}

Um einen einzelnen Typen über dessen Namen oder GUID zu finden, verwenden Sie folgenden Programmcode:

public static void FindTypeObjectInLibrary(ILibrary library){ // Find type object by its GUID in a given library: System.Guid targetGuid = ...; ILibraryType libTypeByGUID = library.FindType(targetGuid); // Find type object by its name in a given folder: ILibraryTypeFolder libTypeSystemFolder = library.TypeFolder; ILibraryType libTypeByName = libTypeSystemFolder.Types.Find("myTypeObject");}

8.8.15.5 Auf Typ-Versionen zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für Typen.Siehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren96 Systemhandbuch

VerwendungSie können mit der Public API-Schnittstelle auf Typ-Versionen zugreifen:

● Sie können die Typ-Versionen eines Typen enumerieren

● Sie können den Typen ermitteln, zu dem eine Typ-Version gehört.

● Sie können die Instanzen einer Typ-Version ermitteln

● Sie können Kopiervorlagen ermitteln, die Instanzen enthalten.

● Sie können die Instanzen einer Typ-Version ermitteln

● Sie können eine neue Instanz einer Typ-Version erzeugen

● Sie können bei jeder Typ-Version auf folgende Eigenschaften zugreifen:

Eigenschaft Datentyp BeschreibungAuthor String Gibt den Namen des Erstellers zurück. Comment MultilingualText Gibt den Kommentar zurück. Guid Guid Gibt die Guid der Typ-Version zurück.1

ModifiedDate DateTime Gibt Datum und Uhrzeit zurück, an dem die Typ-Version in den Status "Committed" gesetzt wurde.

State LibraryTypeVersionS‐tate

Gibt den Status zurück, in dem sich die Version befindet:● InWork: Entspricht je nach zugehörigem Typen dem

Status "in Bearbeitung" oder "im Test". ● Committed: Entspricht dem Status "Freigegeben".

TypeObject ILibraryType Gibt den Typen zurück, zu dem diese Typ-Version gehört. VersionNumber Version Gibt die Versionsnummer als dreistellige Versionsbezeich‐

nung zurück, z. B. "1.0.0".2 1 In einer Bibliothek können Sie über diese Eigenschaft eine einzelne Typ-Version finden.2 In einer "ILibraryTypeVersion"-Aggregation können Sie über diese Eigenschaft eine einzelne Typ-

Version finden.

Verwendungen einer Typ-Version ermittelnBei Typ-Versionen wird zwischen folgenden Verwendungen unterschieden:

● Die Typ-Version verwendet andere Typ-Versionen aus der Bibliothek.Beispiel: In einem Programmbaustein wird ein Anwenderdatentyp verwendet. Der Programmbaustein muss Zugriff auf den Anwenderdatentypen haben. Daher ist der Programmbaustein abhängig vom Anwenderdatentyp.Wenn Sie die Methode GetDependencies() am Programmbaustein aufrufen, wird der Anwenderdatentyp zurückgegeben.

● Die Typ-Version wird von einer anderen Typ-Version innerhalb der Bibliothek verwendet Beispiel: Ein Anwenderdatentyp wird in einem Programmbaustein verwendet. Der Programmbaustein muss Zugriff auf den Anwenderdatentyp haben. Der Anwenderdatentyp hat den angehörigen Programmbaustein. Der Programmbaustein ist abhängig vom Anwenderdatentyp.Wenn Sie die Methode GetDependents() am Anwenderdatentyp aufrufen, wird der Programmbaustein zurückgegeben.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 97

Beide Methoden geben eine Liste zurück, die Objekte vom Typ ILibraryTypeVersion enthält. Wenn keine Verwendungen existieren, wird eine leere Liste zurückgegeben.

Hinweis

Wenn Sie diese Methoden auf Typ-Versionen mit dem Status "InWork" anwenden, kann eine Exception ausgelöst werden.

Ermitteln Sie stattdessen die Testinstanz vom Objekttyp ILibraryTypeInstance dieser Typ-Version und wenden Sie die Methoden auf dieses Objekt an.

Instanzen einer Typ-Version ermittelnUm die Instanzen einer Typ-Version zu ermitteln, verwenden Sie die Methode FindInstancesInProject(IInstanceSearchScope searchScope).

Über den Parameter searchScope geben Sie an, welcher Bereich des Projekts durchsucht wird. Die folgenden Klassen implementieren die Schnittstelle IInstanceSearchScope und können nach Instanzen durchsucht werden:

● ControllerTarget● HmiTargetDie Methode gibt eine Liste zurück, die Objekte vom Typ ILibraryTypeInstance enthält. Wenn keine Instanzen existieren, wird eine leere Liste zurückgegeben.

Instanz einer Typ-Version erzeugenSie können von einer Typ-Version eine neue Instanz im Projekt erzeugen. Folgende Objekte werden unterstützt:

● Bausteine (FB/FC)

● PLC-Anwenderdatentypen

● Bilder

● VB-Skripte

Eine Instanz können Sie sowohl von einer Typ-Version aus einer globalen Bibliothek und der Projektbibliothek erzeugen. Wenn Sie die Instanz von einer Typ-Version aus einer globalen Bibliothek erzeugen, wird die Typ-Version zuerst mit der Projektbibliothek synchronisiert.

SignaturVerwenden Sie zum Erzeugen einer Instanz die Methode Instantiate:

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren98 Systemhandbuch

ILibraryTypeInstance Instantiate(ILibraryTypeInstantiationTarget instantiationTarget, UpdatePathsMode updatePathsMode)

Parameter FunktionILibraryTypeInstantiationTarget instantiationTarget

Legt den Ordner fest, in dem Instanz erzeugt wird. Unterstützt werden die Systemordner und darin enthaltenen benutzerdefninierten Ordner für die oben angegebenen Objekte.

UpdatePathsMode updatePathsMode Definiert das Verhalten, wenn im Zielordner be‐reits eine Instanz dieser Typ-Version existiert:● UpdatePathsInTarget: Die vorhandene

Instanz wird in den angegebenen Ordner verschoben.

● KeepExistingPathsInTarget: Die vorhandene Instanz wird im ursprünglichen Ordner belassen.

● ThrowIfPathsConfict: Eine Exception wird ausgelöst. Die Ausführung wird abgebrochen. Keine Instanz wird angelegt.

ProgrammcodeUm alle Typ-Versionen eines Typen zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateVersionsInType(ILibraryType libraryType){ foreach (ILibraryTypeVersion libraryTypeVersion in libraryType.Versions) { //... }}

Um den Typen zu ermitteln, zu dem eine Typ-Version gehört, verwenden Sie folgenden Programmcode:

public static void GetParentTypeOfVersion(ILibraryTypeVersion libTypeVersion){ ILibraryType parentType = libTypeVersion.TypeObject;}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 99

Um die Verwendungen einer Typ-Version in einer Bibliothek zu ermitteln, verwenden Sie folgenden Programmcode:

public static void GetDependenciesAndDependentsOfAVersion (ILibraryTypeVersion libTypeVersion){ IList<ILibraryTypeVersion> versionDependents = libTypeVersion.GetDependents(); IList<ILibraryTypeVersion> versionDependencies = libTypeVersion.GetDependencies();}

Um die Instanzen einer Typ-Version im Projekt zu ermitteln, verwenden Sie folgenden Programmcode:

Public static void GetInstancesOfVersionInProject(ILibraryTypeVersion libTypeVersion){ ControllerTarget controllerTarget = ...; // or HmiTarget IInstanceSearchScope searchScope = controllerTarget as IInstanceSearchScope; if(searchScope != null) { IList<ILibraryTypeInstance> instances = libTypeVersion.FindInstancesInProject(searchScope); }}

Um Kopiervorlagen zu ermitteln, die Instanzen einer Typ-Version enthalten, verwenden Sie folgenden Programmcode:

public static void GetMasterCopiesContainingInstances(ILibraryTypeVersion libTypeVersion){ IList<MasterCopy> masterCopiesContainingInstances = libTypeVersion.MasterCopiesContainingInstances;}

Um eine Instanz einer Typ-Version zu erzeugen, verwenden Sie folgenden Programmcode:

public static void InstantiateTypeVersion(ILibraryTypeVersion libTypeVersion, ILibraryTypeInstantiationTarget instantiationTarget){ ILibraryTypeVersion Version = libTypeVersion as ILibraryTypeVersion; ILibraryTypeInstance instance = Version.Instantiate(instantiationTarget, UpdatePathsMode.UpdatePathsInTarget);}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren100 Systemhandbuch

Um auf die Eigenschaften einer Typ-Version zuzugreifen, verwenden Sie folgenden Programmcode:

public static void InspectPropertiesOfVersion (ILibraryTypeVersion libTypeVersion){ string versionAuthor = libTypeVersion.Author; MultilingualText versionComment = libTypeVersion.Comment; Guid versionGUID = libTypeVersion.Guid; DateTime versionModifiedDate = libTypeVersion.ModifiedDate; LibraryTypeVersionState versionStateLibrary = libTypeVersion.State; ILibraryType versionParentObject = libTypeVersion.TypeObject; Version versionNumber = libTypeVersion.VersionNumber;}

Um eine einzelne Typ-Version über deren Versionsnummer zu finden, verwenden Sie folgenden Programmcode:

public static void FindVersionInLibrary(ILibrary library){ // Find version by its version number in a given library: Guid versionGUID = ...; ILibraryTypeVersion libTypeVersionByVersionNumber = library.FindVersion(versionGUID);}

8.8.15.6 Auf Instanzen zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für Typen.Siehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 101

VerwendungSie können mit der Public API-Schnittstelle auf Instanzen von Typ-Versionen zugreifen.

Hinweis

Instanzen von Bildbausteinen und HMI-Anwenderdatentypen sind immer an die zugehörige Typ-Version gebunden.

Instanzen von allen anderen Objekten wie Programmbausteinen oder Bildern können an eine Typ-Version gebunden sein.

ProgrammcodeUm auf eine Instanz zuzugreifen, verwenden Sie folgenden Programmcode:

public static void GetInstance(){ var codeBlock = ...; // Or screen, datatype, etc. Browsed from the projectILibraryTypeInstance libTypeInstance = codeBlock as ILibraryTypeInstance; }

Wenn z. B. eine Instanz eines PLC-Anwenderdatentyps an der Instanz einer Bausteinschnittstelle verwendet wird, sind beide Instanzen voneinander abhängig.

Um die von einer Instanz abhängigen Instanzen zu ermitteln, verwenden Sie folgenden Programmcode:

public static void GetDependents(ILibraryTypeInstance libTypeInstance){ ILibraryTypeInstanceAssociation dependentInstances = libTypeInstance.Dependents;}

Um die Instanz zu ermitteln, von der eine Instanz abhängig ist, verwenden Sie folgenden Programmcode:

public static void GetDependencies(ILibraryTypeInstance libTypeInstance){ ILibraryTypeInstanceAssociation dependencyInstances = libTypeInstance.Dependencies;}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren102 Systemhandbuch

Um die an eine Instanz gebundene Typ-Version zu ermitteln, verwenden Sie folgenden Programmcode. Prüfen Sie vor weiteren Schritten, ob die Instanz an eine Typ-Version gebunden ist.

public static void NavigateFromInstanceToObjectVersion(ILibraryTypeInstance libTypeInstance){ ILibraryTypeVersion connectedVersion = libTypeInstance.ConnectedVersion; if(connectedVersion != null) { //instance object is connected to a library type-version //... } else { //instance object is not connected to a library type-version //... }}

8.8.15.7 Auf Kopiervorlagen zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für KopiervorlagenAuf Ordner in einer Bibliothek zugreifen (Seite 93)

VerwendungDie Public-API-Schnittstelle unterstützt den Zugriff auf Kopiervorlagen in einer globalen Bibliothek und der Projektbibliothek:

● Kopiervorlagen in Systemordnern und benutzerdefinierten Ordnern enumerieren

● Informationen von Kopiervorlagen abfragen

Eigenschaft Datentyp BeschreibungAuthor String Gibt den Namen des Erstellers zurück. CreationDate DateTime Gibt das Erstellungsdatum zurück. Name String Gibt den Namen der Kopiervorlage zurück.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 103

ProgrammcodeUm alle Kopiervorlagen im Systemordner einer Bibliothek zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateMasterCopiesInSystemFolder (MasterCopySystemFolder masterCopySystemFolder){ foreach (MasterCopy masterCopy in masterCopySystemFolder.MasterCopies) { //... }}

Um Informationen zu einer Kopiervorlage auszulesen, verwenden Sie folgenden Programmcode:

public static void GetMasterCopyInformation(MasterCopy masterCopy){ string author = masterCopy.Author; DateTime creationDate = masterCopy.CreationDate; string name = masterCopy.Name;}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

Kopiervorlage kopieren (Seite 104)

Bibliotheksinhalte löschen (Seite 116)

Inhalt einer Kopiervorlage ins Projekt kopieren (Seite 106)

8.8.15.8 Kopiervorlage kopieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren104 Systemhandbuch

VerwendungDie Public API-Schnittstelle unterstützt das Kopieren von Kopiervorlagen:

● Sie können eine Kopiervorlage aus einer globalen Bibliothek in die Projektbibliothek kopieren.

● Sie können eine Kopiervorlage innerhalb der Projektbibliothek kopieren.

Wenn Sie eine Kopiervorlage kopieren, wird als Ergebnis die kopierte Kopiervorlage zurückgegeben.

SignaturVerwenden Sie zum Kopieren einer Kopiervorlage aus einer globalen Bibliothek in die Projektbibiothek die Methode CopyTo.

MasterCopy CopyTo(IMasterCopyFolder targetFolder)

Parameter FunktionIMasterCopyFolder targetFolder

Legt den Ordner fest, in den die Kopiervorlage kopiert wird. Als Ord‐ner sind der Systemordner oder ein darin enthaltener benutzerdefi‐nierter Ordner zulässig. Wenn bereits eine Kopiervorlage gleichen Namens existiert, wird eine Kopie der Kopiervorlage eingefügt.

ProgrammcodeUm eine Kopiervorlage aus einer globalen Bibliothek in den Systemordner für Kopiervorlagen in der Projektbibliothek zu kopieren, verwenden Sie folgenden Programmcode:

public static void CopyMasterCopyToFolder(MasterCopy masterCopyFromGlobalLib, ProjectLibrary projectLibrary){ MasterCopy copyInProjectLib = masterCopyFromGlobalLib.CopyTo(projectLibrary.MasterCopyFolder);}

Um eine Kopiervorlage innerhalb der Projektbibliothek zu kopieren, verwenden Sie folgenden Programmcode:

public static void CopyMasterCopyToUserFolder(MasterCopy masterCopyFromProjectLib, MasterCopyUserFolder userFolder){ MasterCopy copyInProjectLibFolder = masterCopyFromProjectLib.CopyTo(userFolder);}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

Auf Kopiervorlagen zugreifen (Seite 103)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 105

8.8.15.9 Inhalt einer Kopiervorlage ins Projekt kopieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

VerwendungDie Public API-Schnittstelle unterstützt die Verwendung von Kopiervorlagen im Projekt. Sie können den Inhalt einer Kopiervorlage in einen Ordner im geöffneten Projekt kopieren.

Wenn Sie den Inhalt einer Kopiervorlage kopieren, wird als Ergebnis wird eine Liste der kopierten Stammobjekte zurückgeben. Folgende Stammobjekte werden unterstützt:

● Bilder

● Vorlagen

● Skripte

● HMI-Variablentabellen

● PLC-Variablentabellen

● PLC-Datentypen

● Programmbausteine

– Organisationsbausteine (OB)

– Funktionen (FC)

– Funktionsbausteine (FB)

– Datenbausteine (DB)

Beispiel: Sie kopieren eine Kopiervorlage, die eine Variablentabelle mit Variablen enthält. Variablentabelle und Variablen werden kopiert. Die zurückgegebene Liste enthält nur die Variablentabelle.

SignaturVerwenden Sie zum Kopieren des Inhalts einer Kopiervorlage die Methode CopyTo:

IList<IEngineeringObject> copiedItems CopyTo(IMasterCopyTarget target, MasterCopyMode copyMode)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren106 Systemhandbuch

Parameter FunktionIMasterCopyTarget target Zielordner-Objekt in der Projektnavigation, in den der Inhalt der Kopiervorlage ko‐

piert wird. Wenn Inhalt und Zielordner nicht übereinstimmen, wird eine Exception ausgelöst. Beispiel: Die Kopiervorlage enthält Programmbausteine. Als Zielordner geben Sie ScreenUserFolder an.

MasterCopyMode copyMode Der Kopiermodus definiert die Verfahrensweise, wenn das an der Zielstelle bereits ein Objekt gleichen Namens vorhanden ist. ● ThrowIfExists

Der Kopiervorgang wird abgebrochen und eine Exception ausgelöst. Die Exception enthält Informationen über das Objekt, das die Exception ausgelöst hat.

● RenameDas zu kopierende Objekt wird nach den Namensregeln des TIA Portals umbenannt und an der Zielstelle eingefügt.

● ReplaceDie Objekte gleichen Namens an der Zielstelle werden durch die kopierten Objekte ersetzt.

ProgrammcodeUm den Inhalt einer Kopiervorlage von einer Bibliothek in die Projektnavigation zu kopieren, verwenden Sie folgenden Programmcode:

public static void CopyMasterCopyToFolder(MasterCopy masterCopy, ProgramblockUserFolder programblockFolder){ IList<IEngineeringObject> copiedObjects = masterCopy.CopyTo(programblockFolder, MasterCopyMode.ThrowIfExists);}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

Auf Kopiervorlagen zugreifen (Seite 103)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 107

8.8.15.10 Typ-Versionen von Instanzen ermitteln

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek. Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für Typen.Siehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

VerwendungDie Public API-Schnittstelle unterstützt das Ermitteln der Typ-Versionen, die zu den Instanzen im geöffneten Projekt gehören. Dabei liefert die Public API- pro Instanz einen der beiden folgenden Zustände:

● Die Instanz bezieht sich auf eine veraltete Typ-Version.

● Die Instanz bezieht sich auf die neueste Typ-Version.

Für die Versionsermittlung gelten folgenden Regeln:

● Basis für die Versionsermittlung sind eine Bibliothek und das Projekt, die Sie über die Public API-Schnittstelle öffnen.

● Im Zuge der Versionsermittlung werden keine Instanzen aktualisiert.

SignaturUm Typ-Versionen von Instanzen zu ermitteln, verwenden Sie die Methode UpdateCheck:UpdateCheck(Project project, UpdateCheckMode updateCheckMode)

Parameter FunktionProject Legt das Projekt fest, in dem die Typ-Versionen von Instanzen ermittelt

werden.Nur notwendig, wenn Sie Typ-Versionen einer globalen Bibliothek ermitteln.

UpdateCheckMode Legt fest, welche Versionen ermittelt werden:● ReportOutOfDateOnly: Gibt ausschließlich Status vom Typ

"veraltet" zurück.● ReportOutOfDateAndUpToDate:

Gibt Status vom Typ "veraltet" und "auf dem neuesten Stand" zurück.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren108 Systemhandbuch

ErgebnisBei der Versionsermittlung werden die Geräte des Projekts von oben nach unten durchlaufen. Pro Gerät wird geprüft, ob in dessen Projektierungsdaten eine Instanz einer Typ-Version aus der angegebenen Bibliothek enthalten ist. Die Methode UpdateCheck gibt das Ergebnis der Versionsermittlung hierarchisch gegliedert zurück.

Die folgende Tabelle zeigt ein Ergebnis einer Versionsermittlung mit dem Parameter UpdateCheck.ReportOutOfDateAndUpToDate:

Update check for: HMI_1 Update check for library element Screen_1 0.0.3

Out-of-date \HMI_1\Screens Screen_4 0.0.1

\HMI_1\Screens Screen_2 0.0.2Up-to-date \HMI_1\Screens Screen_1 0.0.3

\HMI_1\Screens Screen_10 0.0.3Update check for: HMI_2 Update check of library element Screen_4 0.0.3

Out-of-date \Screens folder1 Screen_02 0.0.1

\Screens folder1 Screen_07 0.0.2Up-to-date \Screens folder1 Screen_05 0.0.3

\Screens folder1 Screen_08 0.0.3

ProgrammcodeUm Typ-Versionen aus einer globalen Bibliothek für Instanzen im Projekt zu ermitteln, verwenden Sie folgenden Programmcode:

public static void UpdateCheckOfGlobalLibrary(Project project, TiaPortal tiaPortal){ GlobalLibrary globalLibrary = tiaPortal.GlobalLibraries.Open(@"SomePathHere"); // check for out of date instances and report only out of date instances // in the returned feedback UpdateCheckResult result = globalLibrary.UpdateCheck(project, UpdateCheckMode.ReportOutOfDateOnly); //Alternatively, check for out of date instances and report both out of date //and up to date instances in the returned feedback UpdateCheckResult alternateResult = globalLibrary.UpdateCheck(project, UpdateCheckMode.ReportOutOfDateAndUpToDate); //Show result RecursivelyWriteMessages(result.Messages); // Alternatively, show result and access single message parts RecursivelyWriteMessageParts(result.Messages);}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 109

Um Typ-Versionen aus der Projektbibliothek für Instanzen im Projekt zu ermitteln, verwenden Sie folgenden Programmcode:

public static void UpdateCheckOfProjectLibrary(Project project){ // check for out of date instances and report only out of date instances // in the returned feedback UpdateCheckResult result = project.ProjectLibrary.UpdateCheck(UpdateCheckMode.ReportOutOfDateOnly); //Alternatively, check for out of date instances and report both out of date //and up to date instances in the returned feedback UpdateCheckResult alternateResult = project.ProjectLibrary.UpdateCheck(UpdateCheckMode.ReportOutOfDateAndUpToDate); //Show result RecursivelyWriteMessages(result.Messages); // Alternatively, show result und access single message parts RecursivelyWriteMessageParts(result.Messages);}

Um das Ergebnis der Versionsermittlung auszugeben und die Meldungen einzeln zu durchlaufen, verwenden Sie folgenden Programmcode:

private void RecursivelyWriteMessages (UpdateCheckResultMessageAggregation messages, string indent = ""){ indent += "\t"; foreach (UpdateCheckResultMessage message in messages) { Console.WriteLine(indent + message.Description); RecursivelyWriteMessages(message.Messages, indent); }}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren110 Systemhandbuch

Um im Ergebnis der Versionsermittlung auf einzelne Meldungsteile zuzugreifen, verwenden Sie folgenden Programmcode:

private void RecursivelyWriteMessageParts (UpdateCheckResultMessageAggregation messages, string indent= ""){ indent += "\t"; foreach (UpdateCheckResultMessage message in messages) { Console.WriteLine(indent + "Full description: " + message.Description); foreach (KeyValuePair<string, string> messagePart in message.MessageParts) { // first level // part 1: device name // second level: // part 1: Name of the type in the global library // part 2: version of the type in the global library // third level: // part 1: title (either "Out-of-date" or "Up-to-date"); // fourth level: // part 1: Path hierarchy to instance // part 2: Instance name in project // part 3: Version of the instance in the project Console.WriteLine(indent + "*Key: {0} Value:{1}", messagePart.Key, messagePart.Value); } RecursivelyWriteMessageParts(message.Messages,indent); }}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.8.15.11 Projekt aktualisieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für Typen.Siehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 111

VerwendungDie Public API-Schnittstelle unterstützt die Aktualisierung von Instanzen ausgewählter Typen innerhalb eines Typ-Ordners in einem Projekt.

Beim Aktualisieren werden die im Projekt verwendeten Instanzen auf Basis der letzten freigegebenen Typ-Version aktualisiert. Wenn Sie die Aktualisierung der Instanzen von einer globalen Bibliothek aus starten, wird zuvor eine Synchronisation ausgeführt.

SignaturVerwenden Sie zum Aktualisieren von Instanzen die Methode UpdateProject.

Für Klassen, die die Schnittstelle ILibraryType implementieren, verwenden Sie folgenden Aufruf:

void UpdateProject(IUpdateProjectScope updateProjectScope, UpdatePathsMode updatePathsMode, DeleteUnusedVersionsMode deleteUnusedVersionsMode)Für Klassen, die die Schnittstelle ILibrary implementieren, verwenden Sie folgenden Aufruf:

void UpdateProject(IEnumerable<ILibraryTypeOrFolderSelection> selectedTypesOrFolders, IEnumerable <IUpdateProjectScope> updateProjectScope, UpdatePathsMode updatePathsMode, DeleteUnusedVersionsMode deleteUnusedVersionsMode)Jeder Aufruf wird in der Log-Datei im Projektverzeichnis eingetragen.

Parameter FunktionIEnumerable<ILibraryTypeOrFolderSelection> selectedTypesOrFolders

Legt die Ordner oder Typen fest, die synchronisiert oder deren Instanzen im Projekt aktualisiert wer‐den sollen.

IUpdateProjectScope updateProjectScopeIEnumerable <IUpdateProjectScope> updateProjectScope

Legt das oder die Objekte im Projekt fest, in denen die Verwendungen von Instanzen aktualisiert wer‐den. Folgende Objekte werden unterstützt:● ControllerTarget● HmiTarget

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren112 Systemhandbuch

Parameter FunktionUpdatePathsMode updatePathsMode Legt das Verhalten fest, wenn sich die Ordner‐

strukturen zwischen der globalen Bibliothek und der Projektbibliothek unterscheiden. Der Parame‐ter wird nur ausgewertet, wenn Sie die Aktualisie‐rung des Projekts von einer globalen Bibliothek aus starten: ● UpdatePathsInTarget: Die Ordnerstruktur

in der Zielbibliothek wird aktualisiert und die Inhalte entsprechend verschoben.

● KeepExistingPathsInTarget: Die Ordnerstruktur in der Zielbibliothek wird beibehalten. Der Inhalt wird aktualisiert.

● ThrowIfPathsConflict: Die Aktualisierung wird abgebrochen. Keine Änderungen werden durchgeführt. Eine Exception wird ausgelöst.

DeleteUnusedVersionsMode deleteUnusedVersionsMode

Legt das Verhalten fest, wie mit nicht mehr ver‐wendeten Typ-Versionen umgegangen wird:● AutomaticallyDelete: Typ-Version wird

gelöscht. Gelöscht werden nur veraltete Typ-Versionen, die bei der Aktualisierung erfasst wurden.

● DoNotDelete: Typ-Version wird nicht gelöscht.

ProgrammcodeUm Instanzen von ausgewählten Typen innerhalb eines Typ-Ordners zu aktualisieren, verwenden Sie folgenden Programmcode:

private static void UpdateInstances(ILibrary myLibrary, ILibraryTypeFolder singleFolderContainingTypes, ILibraryType singleType, ControllerTarget controllerTarget, HmiTarget hmiTarget){ //Update Instances of multiple types (subset of types and folders) IUpdateProjectScope[] updateProjectScopes = {controllerTarget as IUpdateProjectScope, hmiTarget as IUpdateProjectScope}; myLibrary.UpdateProject(new ILibraryTypeOrFolderSelection[]{singleType,singleFolderContainingTypes}, updateProjectScopes, UpdatePathsMode.KeepExistingPathsInTarget, DeleteUnusedVersionsMode.AutomaticallyDelete); //Update Instances of multiple types (all types in library) myLibrary.UpdateProject(new[]{myLibrary.TypeFolder}, updateProjectScopes, UpdatePathsMode.UpdatePathsInTarget, DeleteUnusedVersionsMode.AutomaticallyDelete);}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 113

8.8.15.12 Bibliothek aktualisieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für Typen.Siehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

VerwendungDie Public API-Schnittstelle unterstützt folgende Aktualisierungen der Projektbibliothek:

● Alle Typen zwischen globaler Bibliothek und Projektbibliothek synchronisieren

● Ausgewählte Typen zwischen globaler Bibliothek und Projektbibliothek synchronisieren

Beim Synchronisieren von Typen wird nur die Synchronisationsrichtung von einer globalen Bibliothek in die Projektbibliothek unterstützt. Beim Synchronisieren wird optional auch die Ordnerstruktur angepasst. Die zu aktualisierenden Typen werden anhand ihrer Guid identifiziert und aktualisiert:

● Wenn ein Typ in einer Bibliothek eine Typ-Version enthält, die in der zu aktualisierenden Bibliothek fehlt, wird die Typ-Version kopiert.

● Wenn ein Typ in einer Bibliothek eine Typ-Version mit folgenden Eigenschaften enthält, wird der Vorgang abgebrochen und eine Exception ausgegeben:

– Die Typ-Version ist in der zu aktualisierenden Bibliothek vorhanden.

– Die Typ-Version hat die gleiche Versionsnummer

– Die Typ-Version hat eine andere Guid.

SignaturVerwenden Sie zum Synchronisieren von Typ-Versionen die Methode UpdateLibrary.

Für Klassen, die die Schnittstelle ILibraryType implementieren, verwenden Sie folgenden Aufruf:

void UpdateLibrary(ILibrary targetLibrary, UpdatePathsMode updatePathsMode, DeleteUnusedVersionsMode deleteUnusedVersionsMode)Für Klassen, die die Schnittstelle ILibrary implementieren, verwenden Sie folgenden Aufruf:

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren114 Systemhandbuch

void UpdateLibrary(IEnumerable<ILibraryTypeOrFolderSelection> selectedTypesOrFolders, ILibrary targetLibrary, UpdatePathsMode updatePathsMode, DeleteUnusedVersionsMode deleteUnusedVersionsMode)

Parameter FunktionIEnumerable<ILibraryTypeOrFolderSelection> selectedTypesOrFolders

Legt die Ordner oder Typen fest, die synchronisiert oder deren Instanzen im Projekt aktualisiert wer‐den sollen.

ILibrary targetLibrary Legt die Bibliothek fest, deren Inhalte mit einer globalen Bibliothek synchronisiert werden.Wenn Quellbibliothek und Zielbibliothek identisch sind, wird eine Exception ausgelöst. Wenn die Zielbibliothek eine globale Bibliothek ist, wird eine Exception ausgelöst.

UpdatePathsMode updatePathsMode Legt das Verhalten fest, wenn sich die Ordner‐strukturen zwischen der globalen Bibliothek und der Projektbibliothek unterscheiden. Der Parame‐ter wird nur ausgewertet, wenn Sie die Aktualisie‐rung des Projekts von einer globalen Bibliothek aus starten: ● UpdatePathsInTarget: Die Ordnerstruktur

in der Zielbibliothek wird aktualisiert und die Inhalte entsprechend verschoben.

● KeepExistingPathsInTarget: Die Ordnerstruktur in der Zielbibliothek wird beibehalten. Der Inhalt wird aktualisiert.

● ThrowIfPathsConflict: Die Aktualisierung wird abgebrochen. Keine Änderungen werden durchgeführt. Eine Exception wird ausgelöst.

DeleteUnusedVersionsMode deleteUnusedVersionsMode

Legt das Verhalten fest, wie mit nicht mehr ver‐wendeten Typ-Versionen umgegangen wird:● AutomaticallyDelete: Typ-Version wird

gelöscht. Gelöscht werden nur veraltete Typ-Versionen, die bei der Aktualisierung erfasst wurden.

● DoNotDelete: Typ-Version wird nicht gelöscht.

ProgrammcodeUm einen Typ aus der Projektbibliothek mit einer globalen Bibliothek zu synchronisieren, verwenden Sie folgenden Programmcode:

sourceType.UpdateLibrary(projectLibrary, UpdatePathsMode.KeepExistingPathsInTarget, DeleteUnusedVersionsMode.DoNotDelete);

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 115

Um ausgewählte Typen innerhalb eines Typ-Ordners zwischen einer globalen Bibliothek und der Projektbibliothek zu synchronisieren, verwenden Sie folgenden Programmcode:

globalLibrary.UpdateLibrary(new[]{globalLibrary.TypeFolder}, projectLibrary, UpdatePathsMode.KeepExistingPathsInTarget, DeleteUnusedVersionsMode.DoNotDelete);

8.8.15.13 Bibliotheksinhalte löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

● Sie haben Zugriff auf die benötigte Bibliothek.Siehe Auf Bibliotheken zugreifen (Seite 92)

● Sie haben Zugriff auf einen Ordner für TypenSiehe Auf Ordner in einer Bibliothek zugreifen (Seite 93)

VerwendungSie können über die Public API-Schnittstelle folgende Inhalte aus der Projektbibliothek löschen:

● Typen

● Typ-Versionen

● Benutzerdefinierte Ordner für Typen

● Kopiervorlagen

● Benutzerdefinierte Ordner für Kopiervorlagen

SignaturVerwenden Sie zum Löschen die Methode Delete. Die Parameter sind abhängig vom Objekt, auf das die Methode angewendet wird. Wenn das Löschen erfolgreich war, wird TRUE zurückgegeben. Wenn der Parameter leer ist, wird FALSE zurückgegeben. Bei allen anderen Fehlern wird eine Exception ausgelöst.Bool Delete(IEnumerable<ILibraryTypeOrFolderSelection> typesAndFoldersToDelete, DeleteInstancesMode deleteInstancesMode)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren116 Systemhandbuch

Parameter1 FunktionIEnumerable<ILibraryTypeOrFolderSelection> typesAndFoldersToDelete

Legt die Typen und/oder benutzerdefinierten Typordner fest, die gelöscht wer‐den sollen.

DeleteInstancesMode deleteInstancesMode

Legt das Vorgehen fest, wenn beim Löschen auch Instanzen oder Kopiervorla‐gen gelöscht werden müssen: ● ThrowIfExists: Das Löschen wird mit einer Exception abgebrochen. ● DeleteIfExists: Instanzen oder Kopiervorlagen werden ohne Nachfrage

gelöscht. ● PromptIfExists: Der Benutzer muss die Löschvorgänge bestätigen oder

ablehnen. Sobald der Benutzer einen Löschvorgang ablehnt, wird der ganze Löschvorgang abgebrochen.

1 Bei Anwendung der Methode auf ein Library-Objekt. Bool Delete(ILibraryTypeVersion version, DeleteInstancesMode deleteInstancesMode)

Parameter1 FunktionILibraryTypeVersion version Legt die Version fest, die gelöscht werden soll. Die Version muss in der Aggre‐

gation enthalten sein. DeleteInstancesMode deleteInstancesMode

Legt das Vorgehen fest, wenn beim Löschen auch Instanzen oder Kopiervorla‐gen gelöscht werden müssen: ● ThrowIfExists: Das Löschen wird mit einer Exception abgebrochen. ● DeleteIfExists: Instanzen oder Kopiervorlagen werden ohne Nachfrage

gelöscht. ● PromptIfExists: Der Benutzer muss die Löschvorgänge bestätigen oder

ablehnen. Sobald der Benutzer einen Löschvorgang ablehnt, wird der ganze Löschvorgang abgebrochen.

1 Bei Anwendung der Methode auf ein ILibraryTypeVersion-Objekt. Bool Delete(MasterCopyUserFolder item)

Parameter1 FunktionMasterCopyUserFolder item Legt den benutzerdefinierten Kopiervorlagenordner fest, der gelöscht werden

soll.1 Bei Anwendung der Methode auf eine MasterCopyUserFolder-Aggregation.

Bool Delete(MasterCopy item)

Parameter1 FunktionMasterCopy item Legt die Kopiervorlage fest, die gelöscht werden soll.

1 Bei Anwendung der Methode auf eine MasterCopies-Aggregation.

HinweisLöschen von Typen und benutzerdefinierten Typordnern

Wenn Sie einen Typ oder benutzerdefinierten Typordner löschen wollen, müssen die "Regeln zum Löschen von Versionen" erfüllt sein. Einen leeren Typordner können Sie immer löschen.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 117

HinweisRegeln beim Löschen von Versionen

Sie können nur Versionen mit Status "Committed" löschen. Zusätzlich gelten für das Löschen von Versionen folgende Regeln:● Wenn von einer Version mit Status "Committed" gerade eine neue Version mit dem Status

"InWork" erzeugt wurde, können Sie die Version mit Status "Committed" erst löschen, wenn die neue Version verworfen wird oder den Status "Committed" erhält.

● Wenn ein Typ nur eine Version besitzt, wird zusätzlich der Typ gelöscht. ● Wenn Version A von Version B eines anderen Typen abhängig ist, löschen Sie zuerst

Version A und dann Version B.● Wenn von Version A Instanzen existieren, können Sie Version A nur löschen, wenn

zusätzlich die Instanzen gelöscht werden. Wenn eine Instanz zusätzlich in einer Kopiervorlage enthalten ist, wird auch die Kopiervorlage gelöscht. Dieses Verhalten erreichen Sie mit den Werten DeleteIfExists oder PromptIfExists des Parameters "deleteInstancesMode".

ProgrammcodeUm Typen oder benutzerdefinierten Typordner zu löschen, verwenden Sie folgenden Programmcode:

public static void DeleteMultipleTypesOrTypeUserFolders(ILibrary library){ ILibraryType t1 = library.TypeFolder.Types.Find("type1"); ILibraryType t2 = library.TypeFolder.Types.Find("type2"); ILibraryTypeFolder f1 = library.TypeFolder.Folders.Find("folder1"); bool result = library.Delete(new ILibraryTypeOrFolderSelection[]{t1,t2,f1}, DeleteInstancesMode.DeleteIfExist);}

Um einen einzelnen Typen oder benutzerdefinierten Typordner zu löschen, verwenden Sie folgenden Programmcode:

public static void DeleteSingleTypeOrTypeUserFolder(ILibrary library){ bool result; //Delete a single type ILibraryType t1 = library.TypeFolder.Types.Find("type1"); bool Delete(t1, DeleteInstancesMode.DeleteIfExist); //Delete a single folder ILibraryTypeFolder parentFolder = library.TypeUserFolder; ILibraryTypeFolder f1 = parentFolder.Folders.Find("folder1"); bool Delete(f1, DeleteInstancesMode.DeleteIfExist);}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren118 Systemhandbuch

Um eine Version zu löschen, verwenden Sie folgenden Programmcode:

public static void DeleteVersion(ILibrary library){ ILibraryType singleType = library.TypeFolder.Types.Find("type1"); ILibraryTypeVersion version1 = singleType.Versions.Find(new System.Version(1,0,0)); bool result = singleType.Versions.Delete(version1, DeleteInstancesMode.DeleteIfExist);}

Um eine Kopiervorlage oder einen benutzerdefinierten Kopiervorlagenordner zu löschen, verwenden Sie folgenden Programmcode:

public static void DeleteMasterCopies(ILibrary library){ bool result; //Delete a master copy MasterCopy masterCopy = library.MasterCopyFolder.MasterCopies.Find("myMasterCopy"); result = library.MasterCopyFolder.MasterCopies.Delete(masterCopy); //Delete a master copy user folder MasterCopyUserFolder masterUserFolder = library.MasterCopyFolder.Folders.Find("myFolder"); result = library.MasterCopyFolder.Folders.Delete(masterUserFolder);}

Siehe auchAuf Kopiervorlagen zugreifen (Seite 103)

8.8.16 Projektgrafik löschen

Voraussetzung ● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 119

ProgrammcodeUm eine Projektgrafik zu löschen, verwenden Sie folgenden Programmcode:

public static void DeletesSingleProjectGraphicEntry(Project project)//Deletes a single project graphic entry{ MultiLingualGraphicAggregation graphicsAggregation = project.Graphics; MultiLingualGraphic graphic = graphicsAggregation.Find("Graphic XYZ"); graphicsAggregation.Delete(graphic);}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.17 Projekt speichern

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungUm ein Projekt zu speichern, verwenden Sie die Methode project.Save().

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren120 Systemhandbuch

ProgrammcodeUm ein geöffnetes Projekt zu speichern, verwenden Sie folgenden Programmcode:

public static void SaveProject(Project project){ //Use the code in the try block to open and save a project try { project = tiaPortal.Projects.Open(@"Some\Path\ProjectName.ap13"); //begin of code for further implementation //... //end of code project.Save(); } //Use the code in the finally block to close a project finally { project.Close(); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.18 Status einer PLC ermitteln

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungSie können den Status einer PLC oder aller PLCs innerhalb eines Projekts ermitteln.

Openness unterscheidet folgende Status:

● Offline

● PLC wird verbunden ("Connecting")

● Online

● PLC wird getrennt ("Disconnecting")

● Inkompatibel

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 121

● Nicht erreichbar

● Geschützt

ProgrammcodeUm den Status einer PLC oder aller PLCs zu ermitteln, verwenden Sie folgenden Programmcode:

private static void IdentifyOnlineStateOfPLC(ControllerTarget controllerTarget, Project project){ //Identify online state of single PLC OnlineState singleState = ((IOnline)controllerTarget).State; //Identify online state of PLCs in root device aggregation foreach (Device device in project.Devices) { foreach (IDeviceItem deviceItem in device.DeviceItems) { if (deviceItem is ControllerTarget) { OnlineState state = ((IOnline)deviceItem).State; } } }}

8.8.19 Geräte vergleichen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungUm die Abweichung zwischen zwei Geräten zu ermitteln, stehen Ihnen folgende Möglichkeiten zur Verfügung:

● Abgleich zwischen zwei projektierten PLCs

● Abgleich zwischen einer PLC und der Projektbibliothek

● Abgleich zwischen einer PLC und der globalen Bibliothek

● Abgleich zwischen einer PLC und der Kopiervorlage einer PLC

● Abgleich einer projektierten PLC mit der verbundenen PLC im Zustand "Online"

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren122 Systemhandbuch

SignaturVerwenden Sie zum Vergleichen die Methode CompareTo oder CompareToOnline.

CompareResult compareResult = CompareTo(IControllerTargetComparable compareTarget)CompareResult compareResult = CompareToOnline

Rückgabewert/Parameter FunktionCompareResult compareResult Gibt das Vergleichsergebnis zurück:

● FolderContentsDifferent: Inhalt der verglichenen Ordner unterscheidet sich.

● FolderContentsIdentical: Inhalt der verglichenen Ordner ist identisch.

● ObjectsDifferent: Die verglichenen Objekte unterscheiden sich.

● ObjectsIdentical: Die verglichenen Objekte sind identisch.

● LeftMissing: Das Objekt ist nicht in dem Objekt enthalten, von dem Vergleich gestartet wurde.

● RightMissing: Das Objekt ist nicht in dem Objekt enthalten, mit dem verglichen wird.

IControllerTargetComparable compareTarget

Legt das Vergleichsobjekt fest.

ProgrammcodeUm das Vergleichsergebnis auszugeben, verwenden Sie folgenden Programmcode:

private static void WriteResult(CompareResultElement compareResultElement, string indent){ Console.WriteLine("{0}<{1}> <{2}> <{3}> <{4}> <{5}> ", indent, compareResultElement.LeftName, compareResultElement.ComparisonResult, compareResultElement.RightName, compareResultElement.PathInformation, compareResultElement.DetailedInformation); WriteResult(compareResultElement.Elements, indent);}private static void WriteResult (IEnumerable<CompareResultElement> compareResultElements, string indent){ indent += " "; foreach (CompareResultElement compareResultElement in compareResultElements) { WriteResult(compareResultElement, indent); }}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 123

Um Geräte zu vergleichen, verwenden Sie folgenden Programmcode:

private static void CompareTwoOfflinePlcs(ControllerTarget controllerTarget0, ControllerTarget controllerTarget1){ if (controllerTarget0 != null && controllerTarget1 != null) { CompareResult compareResult = controllerTarget0.CompareTo(controllerTarget1); WriteResult(compareResult.RootElement, String.Empty); }}

Um eine PLC mit der Projektbibliothek zu vergleichen, verwenden Sie folgenden Programmcode:

private static void ComparePlcToProjectLibrary(Project project, ControllerTarget controllerTarget){ if (project != null && controllerTarget != null) { CompareResult compareResult = controllerTarget.CompareTo(project.ProjectLibrary); WriteResult(compareResult.RootElement, String.Empty); }}

Um eine PLC mit der globalen Bibliothek zu vergleichen, verwenden Sie folgenden Programmcode:

private static void ComparePlcToGlobalLibrary(ControllerTarget controllerTarget, GlobalLibrary globalLibrary){ if (controllerTarget != null && globalLibrary != null) { CompareResult compareResult = controllerTarget.CompareTo(globalLibrary); WriteResult(compareResult.RootElement, String.Empty); }}

Um eine PLC mit einer Kopiervorlage zu vergleichen, verwenden Sie folgenden Programmcode:

private static void ComparePlcToMasterCopy(Project project, ControllerTarget controllerTarget){ if (project != null && controllerTarget != null) { CompareResult compareResult = controllerTarget.CompareTo(project.ProjectLibrary.MasterCopyFolder.MasterCopies[0]); WriteResult(compareResult.RootElement, String.Empty); }}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren124 Systemhandbuch

Um eine PLC mit der verbundenen PLC zu vergleichen, verwenden Sie folgenden Programmcode:

private static void ComparePlcToGlobalLibrary(ControllerTarget controllerTarget, GlobalLibrary globalLibrary){ if (controllerTarget != null && globalLibrary != null) { CompareResult compareResult = controllerTarget.CompareTo(globalLibrary); WriteResult(compareResult.RootElement, String.Empty); }}

8.8.20 Auf Parameter einer Online-Verbindung zugreifen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

VerwendungSie können mit der Public API-Schnittstelle die Parameter für eine Online-Verbindung ermitteln oder festlegen:

● Die an einer PLC verfügbaren Verbindungsmodi enumerieren

● Die an einem PC verfügbaren Schnittstellen enumerieren

● Die belegten Steckplätze enumerieren

● Die verfügbaren Adressen der Subnetze und Gateways enumerieren

● Die Verbindungsparameter setzen.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 125

Programmcode: Verbindungsparameter ermittelnUm die verfügbaren Verbindungsmodi, PC-Schnittstellen und Steckplätze zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumerateConnectionModesOfPLC(IOnline onlineTarget){ foreach(OnlineMode mode in onlineTarget.Modes) { Console.WriteLine("Mode name:{0}", mode.Name); foreach(OnlinePcInterface pcInterface in mode.PcInterfaces) { Console.WriteLine("PcInterface name:{0}", pcInterface.Name); Console.WriteLine("PcInterface number:{0}", pcInterface.Number); foreach(OnlineTargetInterface targetInterface in pcInterface.TargetInterfaces) { Console.WriteLine("TargetInterface:{0}", targetInterface.Name); } } }}

Alternativ können Sie auf einen Verbindungsmodus und eine PC-Schnittstelle auch über deren Namen zugreifen:

public static void GetTargetInterfaceForOnlineConnection(IOnline onlineTarget){ OnlineMode mode = onlineTarget.Modes.Find("PN/IE"); OnlinePcInterface pcInterface = mode.PcInterfaces.Find("PLCSIM", 1); OnlineTargetInterface slot = pcInterface.TargetInterfaces.Find("2 X3");}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren126 Systemhandbuch

Um die an einer PC-Schnittstelle verfügbaren Adressen der Subnetze und Gateways zu enumerieren, verwenden Sie folgenden Programmcode:

public static void EnumeratingPCInterfaceSubnetsAndGateways(OnlinePcInterface pcInterface){ foreach(OnlineSubnet subnet in pcInterface.Subnets) { Console.WriteLine("Subnet name:{0}", subnet.Name); foreach(OnlineGateway gateway in subnet.Gateways) { //Get the name of the gateway: Console.WriteLine("Gateway name:{0}", gateway.Name); //Get the IP address of each gateway: foreach(OnlineAddress gatewayAddress in gateway.Addresses) { Console.WriteLine("Gateway Address:{0}", gatewayAddress.Name); } } }}

Alternativ können Sie auf ein Subnetz und Gateway auch über deren Namen oder IP-Adressen zugreifen:

public static void GetSubnetAndGatewayOfPCInterface(OnlinePcInterface pcInterface){ OnlineSubnet subnet = pcInterface.Subnets.Find("PN/IE_1"); OnlineAddress subnetAddress = subnet.Addresses.Find("192.168.0.1"); OnlineGateway gateway = subnet.Gateways.Find("Gateway 1"); OnlineAddress gatewayAddress = gateway.Addresses.Find("192.168.0.2");}

Programmcode: Verbindungsparameter setzen

Hinweis

Beim Setzen der Verbindungsparameter werden alle zuvor gesetzten Verbindungsparameter überschrieben. Wenn Sie die Verbindungsparameter bereits direkt im TIA-Portal gesetzt haben, ist der Aufruf von ApplyConfiguration nicht notwendig. Ob die Verbindungsparameter bereits gesetzt sind, können Sie mit der Eigenschaft IsConfigured prüfen.

Wenn zu einer PLC bereits eine Online-Verbindung besteht während ApplyConfiguration aufgerufen wird, wird eine Exception ausgelöst.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 127

Um Verbindungsparameter zu setzen, verwenden Sie folgenden Programmcode:

bool isConfigured = onlineTarget.IsConfigured;if (isConfigured == false){ bool result; // "ApplyConfiguration" returns true if configuration is successfully applied result = onlineTarget.ApplyConfiguration(slot); //or result = onlineTarget.ApplyConfiguration(gatewayAddress); //or result = onlineTarget.ApplyConfiguration(subnetAddress);}

8.8.21 Online-Verbindung zur PLC aufbauen oder trennen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Alle Geräte sind enumeriert.Siehe Alle Geräteelemente enumerieren (Seite 75)

VerwendungSie können die Online-Verbindung zu einer PLC aufbauen oder eine bestehende Online-Verbindung trennen.

ProgrammcodeUm die Online-Verbindung zu einer PLC aufzubauen oder zu trennen, verwenden Sie folgenden Programmcode:

public static void SetOnlineConnection(ControllerTarget controllerTarget){ ((IOnline)controllerTarget).GoOnline(); //or ((IOnline)controllerTarget).GoOffline();}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren128 Systemhandbuch

Alternativ können Sie die Online-Verbindungen zu allen im Projekt verfügbaren PLCs aufbauen oder trennen.

public static void SetOnlineConnectionForAllPLCs(Project project){ foreach (Device device in project.Devices) { foreach (IDeviceItem deviceItem in device.DeviceItems) { if (deviceItem is ControllerTarget) { // Establish online connection to PLC: ((IOnline)deviceItem).GoOnline(); // Disconnect online connection to PLC: ((IOnline)deviceItem).GoOffline(); } } }}

8.8.22 Projekt schließen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungUm ein Projekt zu schließen, verwenden Sie die Methode Close. Die Methode hat folgende Parameter:

● CloseMode.PromptIfModified: Wenn das Projekt verändert wurde, wird der Dialog "Projekt speichern" geöffnet.

● CloseMode.IgnoreChanges: Schließt das Projekt und verwirft alle Änderungen seit dem letzten Speichern.

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 129

ProgrammcodeUm ein Projekt zu schließen, verwenden Sie folgenden Programmcode:

public static void CloseProject(Project project){ //Use the code in the try block to open a project try { //project = tiaPortal.Projects.Open(@"Some\Path\ProjectName.ap13"); //begin of code for further implementation //... //end of code } //Use the code in the finally block to close a project finally { CloseMode closeMode = CloseMode.IgnoreChanges; //or, closeMode = CloseMode.PromptIfModified if (project != null) { bool isClosed = project.Close(closeMode); if (isClosed) { Console.WriteLine("Project was successfully closed."); } } }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.8.23 Netzwerkinformationen abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● Im Editor "Geräte & Netze" sind Geräte miteinander verbunden

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren130 Systemhandbuch

VerwendungDie Public API-Schnittstelle unterstützt das Abfragen von Netzwerkinformationen der Gerätekonfiguration im Editor "Geräte & Netze":

● Netzwerkzuordnung abfragen

● Netzwerkinformationen eines Geräts abfragenUnterstützt werden Netzwerke vom Typ "Ethernet". In einem Ethernet-Netzwerk werden nur IP4-Adressen unterstützt.

● Stationsadressen eines Moduls abfragen

ProgrammcodeUm Informationen über das mit einer Schnittstelle verbundene Subnetz abzufragen, verwenden Sie folgenden Programmcode:

public static void GetSubnetInformation(Device device){ //use with an appropriate device item, e.g. "PLC_1" IDeviceItem deviceItem = device.DeviceItems[0]; IDeviceItem subDeviceItem = deviceItem.DeviceItems[0]; //use with an appropriate device item, e.g. "S71500 \Submodules\CPU\IE\Interface\MDD_IEthernetInterface_Basic_1P_Submodule_V1.5" // Accessing a subnet connected to a node of a device Node node = subDeviceItem.Nodes[0]; Subnet subnet = node.Subnet; //...and read the name of subnet string name = subnet.Name;}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 131

Um die Netzwerkinformationen eines Geräts oder einer Schnittstelle abzufragen, verwenden Sie folgenden Programmcode:

public static void GetNetworkInformation(Device device){ //replace with an appropriate device item, e.g. "PLC_1" IDeviceItem deviceItem = device.DeviceItems[0]; IDeviceItem subDeviceItem = deviceItem.DeviceItems[0]; //replace with an appropriate device item, e.g. "S71500\Submodules\CPU\IE\Interface\MDD_IEthernetInterface_IRT_2P_Submodule_V1.5" // Accessing a subnet connected to a node of a device Node node = subDeviceItem.Nodes[0]; object sourceAddress = device.GetAttribute("Failsafe_F_Source_Add"); // Accessing the firmware version String fwVersion = deviceItem.FirmwareVersion; // Accessing the device name String deviceName = device.Name; //Accessing the F-Addresses object destinationAddress = device.GetAttribute("Failsafe_F_Dest_Add"); //Get address of a PROFINET network int pnStationNumber = (int)node.GetAttribute("_PUBLIC_DeviceNumber"); String pnDeviceName = node.GetAttribute("_PUBLIC_ProfinetDeviceName") as String; String ipAddress = node.GetAttribute("_PUBLIC_NetworkAddress") as String; String ipSubnetMask = node.GetAttribute("_PUBLIC_SubnetMask") as String; String ipRouterAddress = node.GetAttribute("_PUBLIC_RouterAddress") as String; String dhcpClientId = node.GetAttribute("_PUBLIC_DhcpClientId") as String; }

Um Stationsadressen eines Moduls abzufragen, verwenden Sie folgenden Programmcode:

public static void GetStationAddressInformation(Device device){ //replace with an appropriate device item, e.g. "DI 8x24VDC ST_1" IDeviceItem deviceItem = device.DeviceItems[0]; IDeviceItem subDeviceItem = deviceItem.DeviceItems[0]; //replace with an appropriate device item, e.g. "DI8_1" //Get start address of module foreach (AddressObject addressObject in subDeviceItem.Addresses) { Int IOTypeAddress = addressObject.IoType; Int startAddress = addressObject.StartAddress; Int length = addressObject.Length; Int bitAddress = addressObject.BitAddress; }}

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisieren132 Systemhandbuch

8.8.24 Mastersystem-Parameter abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

VerwendungSie können folgende Parameter eines Mastersystems abfragen:

● Name des PPROFIBUS-Mastersystems oder des PROFINET IO-Systems

● Nummer des PROFIBUS-Mastersystems oder des PROFINET IO-Systems

ProgrammcodeUm die Parameter "Name" und "Nummer" eine PROFIBUS-Mastersystems oder PROFINET IO-Systems abzufragen, verwenden Sie folgenden Programmcode:

Mastersystem mastersystem = ...;String name = mastersystem.GetAttribute("Name");Int number = mastersystem.GetAttribute("Number");

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

Public API8.8 Funktionen auf Projekte/Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 133

8.9 Funktionen auf Daten eines HMI-Gerätes

8.9.1 Bilder

8.9.1.1 Benutzerdefinierte Bildordner erzeugen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

ProgrammcodeUm einen benutzerdefinierten Bildordner zu erzeugen, verwenden Sie folgenden Programmcode:

private static void CreateScreenFolder(HmiTarget hmitarget)//Creates a screen folder{ ScreenUserFolder myCreatedFolder = hmitarget.ScreenFolder.Folders.Create("myScreenFolder");}}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.1.2 Bild aus einem Ordner löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisieren134 Systemhandbuch

Verwendung

Hinweis

Sie können ein Permanentfenster nicht löschen. Ein Permanentfenster ist ein Systembild, das immer vorhanden ist.

ProgrammcodeUm ein Bild aus einem vorgegebenen Ordner zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteScreenFromFolder(HmiTarget hmitarget)//Deletes a single screen from a user folder or a system folder{ string screenName = "MyScreen"; ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("myScreenFolder"); //or ScreenSystemFolder folder = hmitarget.ScreenFolder; ScreenAggregation screens = folder.Screens; Screen screen = screens.Find(screenName); if (screen != null) { screens.Delete(screen); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.1.3 Bildvorlage aus einem Ordner löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 135

ProgrammcodeUm eine Bildvorlage aus einem vorgegebenen Ordner zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteScreenTemplateFromFolder(HmiTarget hmitarget)//Deletes a single screen template from a user folder or a system folder{ string templateName = "MyScreenTemplate"; ScreenTemplateUserFolder folder = hmitarget.ScreenTemplateFolder.Folders.Find("myScreenTemplateFolder"); //or ScreenTemplateSystemFolder folder = hmitarget.ScreenTemplateFolder; ScreenTemplateAggregation templates = folder.ScreenTemplates; ScreenTemplate template = templates.Find(templateName); if(template != null) { templates.Delete(template); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.1.4 Alle Bilder aus einem Ordner löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Verwendung

Hinweis

Sie können ein Permanentfenster nicht löschen. Ein Permanentfenster ist ein Systembild, das immer vorhanden ist.

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisieren136 Systemhandbuch

ProgrammcodeUm alle Bilder aus einem vorgegebenen Ordner zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteAllScreensFromFolder(HmiTarget hmitarget)//Deletes all screens from a user folder or a system folder{ ScreenUserFolder folder = hmitarget.Screenfolder.Folders.Find("myScreenFolder"); //or ScreenSystemFolder folder = hmitarget.ScreenFolder; ScreenAggregation screens = folder.Screens; List<Screen> list = new List<Screen>(); foreach(Screen screen in screens) { list.Add(screen); } foreach (Screen screen in list) { screens.Delete(screen); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.2 Zyklen

8.9.2.1 Zyklus löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

VerwendungSie können Standard-Zyklen nicht löschen.

Dass tatsächlich Zyklen gelöscht worden sind, erkennen Sie an der Nummer der Aggregation (Aggregation count) des jeweiligen Zyklus. Auf diesen Zyklus haben Sie keinen Zugriff mehr.

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 137

ProgrammcodeUm einen Zyklus aus einem HMI-Gerät zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteCycleFromHMI(HmiTarget hmitarget)//Deletes a cycle from an HMI device{ CycleAggregation Cycles = hmitarget.Cycles; Cycle cycle = Cycles.Find("myCycle"); Cycles.Delete(cycle);}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.3 Textlisten

8.9.3.1 Textliste löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

ProgrammcodeUm eine ausgewählte Textliste und alle dazugehörigen Listeneinträge aus einem HMI-Gerät zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteTextlistFromHMI(HmiTarget hmitarget)//Deletes a textlist from an HMI device{ TextListAggregation textListAggregation = hmitarget.TextLists; TextList textListToDelete = textListAggregation.Find("myTextlist"); if (textListToDelete != null) { textListAggregation.Delete(textListToDelete); }}

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisieren138 Systemhandbuch

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.4 Grafiklisten

8.9.4.1 Grafikliste löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

ProgrammcodeUm eine ausgewählte Grafikliste und alle dazugehörigen Listeneinträge aus einem HMI-Gerät zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteGraphiclistFromHMI(HmiTarget hmitarget)// Deletes a graphiclist from an HMI device{ GraphicListAggregation graphicListAggregation = hmitarget.GraphicLists; GraphicList graphicListToDelete = graphicListAggregation.Find("myGraphiclist"); if (graphicListToDelete != null) {graphicListAggregation.Delete(graphicListToDelete); }}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 139

8.9.5 Verbindungen

8.9.5.1 Verbindung löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

ProgrammcodeUm eine ausgewählte Kommunikationsverbindung aus einem HMI-Gerät zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteConnectionFromHMI(HmiTarget hmitarget)//Deletes a communication connection of a given HMI device{ ConnectionAggregation connections = hmitarget.Connections; string connName = "HMI_connection_1"; Connection conn = connections.Find(connName); if (conn != null) { connections.Delete(conn); }}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisieren140 Systemhandbuch

8.9.6 Variablentabelle

8.9.6.1 Variablentabelle aus einem Ordner löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

ProgrammcodeUm eine Variablentabelle aus einem vorgegebenen Ordner zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteTagtableInsideTagfolder(HmiTarget hmitarget){ //Deletes a tag table inside a given tag folder string tableName = "myTagtable"; TagSystemFolder folder = hmitarget.TagFolder; TagTableAggregation tables = folder.TagTables; TagTable table = tables.Find(tableName); if (table != null) { tables.Delete(table); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.6.2 Benutzerdefinierte Ordner für HMI-Variablen erzeugen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 141

ProgrammcodeUm einen benutzerdefinierten Ordner für HMI-Variablen zu erzeugen, verwenden Sie folgenden Programmcode:

private static void CreateUserfolderForHMITags(HmiTarget hmitarget)// Creates an HMI tag user folder{ TagSystemFolder folder = hmitarget.TagFolder; TagUserFolder myCreatedFolder = folder.Folders.Create("MySubFolder");}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.6.3 Variablen einer HMI-Variablentabelle enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

ProgrammcodeUm alle Variablen einer HMI-Variablentabelle zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateTagsInTagtable(HmiTarget hmitarget)// //Enumerates all tags of a tag table{ TagTable table = hmitarget.TagFolder.TagTables.Find("MyTagtable"); // Alternatively, you can access the default tag table: // TagTable defaulttable = hmitarget.TagFolder.DefaultTagTable; TagAggregation tagAggregation = table.Tags; foreach (Tag tag in tagAggregation) { // Do something... }}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisieren142 Systemhandbuch

8.9.6.4 Einzelne Variable aus einer HMI-Variablentabelle löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

ProgrammcodeUm eine bestimmte Variable aus einer HMI-Variablentabelle zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteTagFromHMITagtable(HmiTarget hmitarget)// Deletes a single tag of a tag table{ string tagName = "MyTag"; TagTable table = hmitarget.TagFolder.DefaultTagTable; TagAggregation tagAggregation = table.Tags; Tag tag = tagAggregation.Find(tagName); if (tag != null) { tagAggregation.Delete(tag); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.7 VB-Skripte

8.9.7.1 Benutzerdefinierte Skriptunterordner erzeugen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 143

ProgrammcodeUm einen benutzerdefinierten Skriptunterordner unterhalb eines Systemordners oder eines anderen benutzerdefinierten Ordners anzulegen, verwenden Sie folgenden Programmcode:

private static void CreateFolderInScriptfolder(HmiTarget hmitarget)//Creates a script user subfolderVBScriptSystemFolder { VBScriptSystemFolder vbScriptFolder = hmitarget.VBScriptFolder; VBScriptUserFolderAggregation vbScriptFolders = vbScriptFolder.Folders; VBScriptUserFolder vbScriptSubFolder = vbScriptFolder.Folders.Create("mySubfolder");}

Siehe auchStandard-Bibliotheken (Seite 41)

8.9.7.2 VB-Skript aus einem Ordner löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Im Projekt ist ein HMI-Gerät vorhanden.

ProgrammcodeUm ein VB-Skript aus einem vorgegebenen Ordner zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteVBScriptFromScriptFolder(HmiTarget hmitarget)//Deletes a vbscript from a script folderVBScriptSystemFolder { VBScriptUserFolder vbscriptfolder = hmitarget.VBScriptFolder.Folders.Find("MyScriptFolder"); var vbScripts = vbscriptfolder.VBScripts; if (null != vbScripts) { var vbScript = vbScripts.Find("MyScript"); vbScripts.Delete(vbScript); }}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.9 Funktionen auf Daten eines HMI-Gerätes

Projekte über Skripte automatisieren144 Systemhandbuch

8.10 Funktionen auf Daten eines PLC-Gerätes

8.10.1 Bausteine

8.10.1.1 Ordner "Programmbausteine" abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Eine PLC ist im Projekt ermittelt.

ProgrammcodeUm den Ordner "Programmbausteine" abzufragen, verwenden Sie folgenden Programmcode:

private static void GetProgramblockFolderOfPLC(ControllerTarget controllertarget)//Retrieves the system folder of a block{ ProgramblockSystemFolder programBlockFolder = controllertarget.ProgramblockFolder;}

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.1.2 Benutzerdefinierte Bausteinordner enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Eine PLC ist im Projekt ermittelt.

VerwendungEnthaltene Unterordner werden beim Enumerieren rekursiv berücksichtigt.

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 145

Programmcode: Alle Ordner enumerierenUm die benutzerdefinierten Ordner für Bausteine zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateAllBlockFoldersAndSubfolders(ControllerTarget controllertarget)//Enumerates all block user folder including sub folders{ foreach (ProgramblockUserFolder blockUserFolder in controllertarget.ProgramblockFolder.Folders) { EnumerateBlockUserFolders(blockUserFolder); }} private static void EnumerateBlockUserFolders(ProgramblockUserFolder blockUserFolder) { foreach (ProgramblockUserFolder subBlockUserFolder in blockUserFolder.Folders) { EnumerateBlockUserFolders(subBlockUserFolder); // recursion } }

Programmcode: Auf einen Ordner zugreifenUm auf einen ausgewählten benutzerdefinierten Ordner für Bausteine zuzugreifen, verwenden Sie folgenden Programmcode:

private static void AccessBlockuserfolder(ControllerTarget controllertarget)//Gives individual access to a specific block user folder{ ProgramblockUserFolderAggregation programBlockUserFolderAggregation = controllertarget.ProgramblockFolder.Folders; ProgramblockUserFolder programBlockUserFolder = programBlockUserFolderAggregation.Find("MyUserfolder");}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren146 Systemhandbuch

8.10.1.3 Alle Bausteine enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● Eine PLC ist im Projekt ermittelt.

VerwendungWenn der Name eines Programm-Bausteins bekannt ist, können Sie gezielt auf diesen Baustein zugreifen.

Programmcode: Alle Bausteine enumerierenUm die Bausteine aller Bausteinordner zu enumerieren, verwenden Sie folgenden Programmcode:

private static void EnumerateAllBlocks(ControllerTarget controllertarget)//Enumerates all blocks{ foreach (IBlock block in controllertarget.ProgramblockFolder.Blocks) { // Do something... }}

Programmcode: Auf einen bestimmten Baustein zugreifenUm auf einen bestimmten Baustein zuzugreifen, verwenden Sie folgenden Programmcode:

private static void AccessASingleProgramblock(ControllerTarget controllertarget)//Gives individual access to a program block{ // The parameter specifies the name of the block IBlock block = controllertarget.ProgramblockFolder.Blocks.Find("MyBlock");}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 147

8.10.1.4 Informationen eines Bausteins/Anwenderdatentyps abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

VerwendungDie Public API-Schnittstelle unterstützt Abfragen folgender Informationen für Programm- und Datenbausteine sowie Anwenderdatentypen:

● Zeitstempel im Zeitformat UTC.Mit dem Zeitstempel überprüfen Sie Folgendes:

– Wann der Baustein zuletzt übersetzt wurde.

– Wann der Baustein zuletzt geändert wurde.

● Attribut "Konsistenz" Das Attribut "Konsistenz" wird in folgenden Fällen auf "True" gesetzt:

– Der Baustein wurde erfolgreich übersetzt.

– Der Baustein wurde nach dem Übersetzen nicht mehr verändert.

– Keine Änderungen wurden bei externen Objekten ausgeführt, die eine erneute Übersetzung erforderlich machen.

● TypDie Bausteintypen sind in folgender Auflistung definiert:public enum BlockType{ OB = 1, FB = 2, FC = 3, DB = 4}

● Verwendete Programmiersprache (nur Programm- und Datenbausteinen)

● Bausteinnummer

● Bausteinname

● Bausteinautor

● Bausteinfamilie

● Bausteintitel

● Bausteinversion

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren148 Systemhandbuch

ProgrammcodeUm die oben genannten Informationen abzufragen, verwenden Sie folgenden Programmcode:

private static void GetProgramblockInformation(ControllerTarget controllertarget)//Reads infomation from a block{ //Gives individual access to a program block // The parameter specifies the name of the block IBlock iBlock = controllertarget.ProgramblockFolder.Blocks.Find("MyBlock"); //Read information DateTime compileDate = iBlock.CompileDate; DateTime modifiedDate = iBlock.ModifiedDate; bool isConsistent = iBlock.IsConsistent; BlockType blockType = iBlock.Type; int blockNumber = iBlock.Number; string blockName = iBlock.Name; ProgrammingLanguage programmingLanguage = iBlock.ProgrammingLanguage; string blockAuthor = iBlock.HeaderAuthor; string blockFamilie = iBlock.HeaderFamily; string blockTitle = iBlock.HeaderName; string blockVersion = iBlock.HeaderVersion;}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.1.5 Baustein löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 149

ProgrammcodeUm einen Programmbaustein zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteBlocks(ControllerTarget controllertarget)//Runs through program block folder and deletes blocks{ ProgramblockSystemFolder folder = controllertarget.ProgramblockFolder; // or ProgramblockUserFolder folder = ...; for (int i = folder.Blocks.Count - 1; i > 0; i--) { IBlock block = folder.Blocks[i]; if (block != null) { folder.Blocks.Delete(block); } }}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.1.6 Anwenderdatentyp löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren150 Systemhandbuch

ProgrammcodeUm einen Anwenderdatentyp zu löschen, verwenden Sie folgenden Programmcode:

public static void DeleteUserdatatype(Controllertarget controllertarget)// You can delete userdatatypes from ControllerdatatypeUserFolder and ControllerdatatypeUserFolder{ ControllerDatatypeSystemFolder folder = controllertarget.ControllerDatatypeFolder; // or ControllerDatatypeSystemFolder = ...; ControllerDatatypeAggregation datatypes = folder.Datatypes; ControllerDatatype datatype = datatypes.Find("DataTypeName"); if (datatype != null) { datatypes.Delete(datatype); }}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.1.7 Gruppe für Bausteine erzeugen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

ProgrammcodeUm eine Gruppe für Bausteine zu erzeugen, verwenden Sie folgenden Programmcode:

private static void CreateProgramblockFolder(ControllerTarget controllertarget)//Creates a programblock folder{ ProgramblockSystemFolder systemFolder = controllertarget.ProgramblockFolder; ProgramblockUserFolderAggregation folderAggregation = systemFolder.Folders; ProgramblockUserFolder myCreatedFolder = folderAggregation.Create("MySubFolderName");}

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 151

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.1.8 Quelle aus Baustein generieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

VerwendungDie API-Schnittstelle unterstützt das Erzeugen von Quellen aus Bausteinen und Anwenderdatentypen.

Bei Bausteinen werden nur die Programmiersprachen AWL und SCL unterstützt. Exceptions werden in folgenden Fällen ausgelöst:

● Programmiersprache ist nicht AWL oder SCL

● An Zielstelle ist bereits eine Datei gleichen Namens vorhanden

Bei Anwenderdatentypen wird nur die Dateiendung "*.sd" unterstützt. Exceptions werden in folgenden Fällen ausgelöst:

● Die Dateiendung ist "*.udt".

● Die Dateiendung ist "*.awl".

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren152 Systemhandbuch

ProgrammcodeUm aus einem Baustein oder Anwenderdatentyp die Quelle im Dateisystem zu speichern, verwenden Sie folgenden Programmcode:

private static void GenerateASCIISourceFromBlock(ControllerTarget controllerTarget){ IBlock FC1 = controllerTarget.ProgramblockFolder.Blocks.Find("FC 1"); IBlock FC2 = controllerTarget.ProgramblockFolder.Blocks.Find("FC 2"); IEnumerable<IBlock> blocks = controllerTarget.ProgramblockFolder.Blocks; IBlockAggregation blockAggregation = controllerTarget.ProgramblockFolder.Blocks; ProgramblockSystemFolder programblockFolder = controllerTarget.ProgramblockFolder; String FileExtension = ".awl"; //or ".scl" String PathAndFileName = "@C:/Temp/ASCIISource/myBlock"+FileExtension; programblockFolder.GenerateSourceFromBlocks(new IBlock[] { FC1 }, PathAndFileName); //or programblockFolder.GenerateSourceFromBlocks(new IBlock[]{ FC1, FC2 }, PathAndFileName); //or programblockFolder.GenerateSourceFromBlocks(new List<IBlock> { FC1, FC2 }, PathAndFileName); //or programblockFolder.GenerateSourceFromBlocks(blocks, PathAndFileName); //or programblockFolder.GenerateSourceFromBlocks(blockAggregation, PathAndFileName);}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.1.9 Gruppe für Bausteine löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 153

ProgrammcodeUm eine Gruppe für Bausteine zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteBlockFolder(ControllerTarget controllertarget)// Deletes user folders from ProgramblockSystemFolder and ProgramblockUserFolder{ ProgramblockUserFolder folder = controllertarget.ProgramblockFolder.Folders.Find("myFolder"); //ProgramblockSystemFolder folder = ... ProgramblockUserFolderAggregation subfolders = folder.Folders; ProgramblockUserFolder subfolder = subfolders.Find ("myUserFolder"); if (subfolder != null) { subfolders.Delete(subfolder); }}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.1.10 Systemordner für Systembausteine abfragen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Programmcode: Um den vom System erstellten Ordner für Systembausteine zu ermitteln, verwenden Sie folgenden Programmcode:

private static void GetSystemfolderForSystemblocks(ControllerTarget controllertarget)//Retrieves the system generated folder for system blocks{ SystemblockSystemFolder sbSystemFolder = controllertarget.ProgramblockFolder.SystemFolder; foreach (var folder in sbSystemFolder.Folders) { // add code here }}

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren154 Systemhandbuch

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.1.11 Systemunterordner enumerieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Programmcode: Alle Systemunterordner enumerierenUm alle Systemunterordner aller Systembausteine zu enumerieren, verwenden Sie folgenden Programmcode:

private static void GetSystemfolderForSystemblocks(ControllerTarget controllertarget)//Retrieves the system generated folder for system blocks{ SystemblockSystemFolder sbSystemFolder = controllertarget.ProgramblockFolder.SystemFolder; foreach (var folder in sbSystemFolder.Folders) { EnumerateSystemBlockFolders(folder); }}private static void EnumerateSystemBlockFolders(SystemblockComponentFolder systemBlockFolder){ foreach (var folder in systemBlockFolder.Folders) { EnumerateSystemBlockFolders(folder); // recursion }}

Programmcode: Auf einen bestimmten Unterordner zugreifenUm auf einen bestimmten Systemunterordner zuzugreifen, verwenden Sie folgenden Programmcode:

private static void AccessSbFolder(SystemblockComponentFolder systemBlockFolder){ SystemblockComponentFolder folder1 = systemBlockFolder.Folders.Find("User folder XYZ"); SystemblockComponentFolder folder2 = folder1.Folders.Find("User folder ZYX"); }

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 155

Siehe auchStandard-Bibliotheken (Seite 41)

Externe Datei hinzufügen (Seite 156)

8.10.1.12 Externe Datei hinzufügen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet: Siehe Projekt öffnen (Seite 71)

VerwendungSie können aus einem Baustein eine externe Datei erzeugen. Diese externe Datei wird im Dateisystem unter dem definierten Pfad abgelegt.

Folgende Formate werden unterstützt:

● AWL

● SCL

Hinweis

Der Zugriff auf Gruppen im Ordner "Externe Quellen" wird nicht unterstützt.

Wenn Sie eine andere Dateiendung als *.AWL oder *.SCL angeben, wird eine Exception ausgelöst.

ProgrammcodeUm aus einem Baustein eine externe Datei im Ordner "Externe Quellen" zu erzeugen, verwenden Sie folgenden Programmcode.

private static void CreateBlockFromFile(ControllerTarget controllertarget)// Creates a block from a AWL, SCL, DB or UDT file{ ExternalSource externalSource = controllertarget.ExternalSourceFolder.ExternalSources.CreateFromFile("SomeBlockNameHere", "SomePathHere");}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren156 Systemhandbuch

8.10.1.13 Bausteine aus externer Datei generieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

VerwendungSie können aus allen externen Dateien im Ordner "Externe Quellen" die Bausteine generieren und übersetzen. Unterstützt werden nur externe Dateien im Format ASCII.

Hinweis

Der Zugriff auf Gruppen im Ordner "Externe Quellen" wird nicht unterstützt.

Bereits existierende Bausteine werden überschrieben.

Wenn beim dabei enthaltenen Übersetzen ein Fehler auftritt, wird eine Exception ausgelöst. In der Meldung der Exception sind die ersten 256 Zeichen jeder Fehlermeldung enthalten. Das Projekt wird auf den Bearbeitungsstand vor dem Ausführen der Methode GenerateBlocksFromSourceAndCompile zurückgesetzt.

ProgrammcodeUm aus allen externen Dateien im Ordner "Externe Quellen" die Bausteine zu generieren und zu übersetzen, verwenden Sie folgenden Programmcode.

private static void CreateBlockFromFileAndCompile(ControllerTarget controllertarget)// Creates a block from an AWL or SCL file and compiles the block{ foreach (var externalSource in controllertarget.ExternalSourceFolder.ExternalSources) { externalSource.GenerateBlocksFromSourceAndCompile(); }}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 157

8.10.1.14 Externe Datei löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden

siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist über eine Openness-Anwendung geöffnet: siehe Projekt öffnen (Seite 71)

ProgrammcodeUm eine externe Datei im Ordner "Externe Quellen" zu löschen, verwenden Sie folgenden Programmcode.

Hinweis

Der Zugriff auf Gruppen im Ordner "Externe Quellen" wird nicht unterstützt.

private static void DeleteExternalSource(ControllerTarget controllertarget)// Deletes an external file{ ExternalSource externalSource = controllertarget.ExternalSourceFolder.ExternalSources.Find("myExternalsource"); controllertarget.ExternalSourceFolder.ExternalSources.Delete(externalSource);}

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.1.15 Bausteineditor starten

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● Instanz des TIA-Portals ist mit Benutzeroberfläche geöffnet.

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren158 Systemhandbuch

ProgrammcodeUm für eine Objektreferenz vom Typ IBlock in der TIA-Portal-Instanz den zugehörigen Editor zu starten, verwenden Sie folgenden Programmcode:

private static void StartBlockEditor(ControllerTarget controllertarget)//Reads programming language and last modification date from a block{ IBlock iBlock = controllertarget.ProgramblockFolder.Blocks.Find("MyBlock"); iBlock.ShowInEditor();}

Um für eine Objektreferenz vom Typ ControllerDatatyp in der TIA-Portal-Instanz den zugehörigen Editor zu starten, verwenden Sie folgenden Programmcode

private static void StartControllerDatatypEditor(ControllerTarget controllertarget)//Opens an udt in udt editor{ ControllerDatatypeAggregation datatypes = controllertarget.ControllerDatatypeFolder.Datatypes; ControllerDatatype udt = datatypes.Find("my_udt"); udt.ShowInEditor();}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.2 Variablentabellen

8.10.2.1 Benutzerdefinierte Ordner für PLC-Variablen erzeugen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt das Erstellen eines benutzerdefinierten Ordners für PLC-Variablen.

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 159

ProgrammcodeUm einen benutzerdefinierten Ordner für PLC-Variablen zu erstellen, verwenden Sie folgenden Programmcode:

private static void CreateControllertagUserFolder(ControllerTarget controllertarget)//Creates a controller tags user folder{ ControllerTagSystemFolder systemFolder = controllertarget.ControllerTagFolder; ControllerTagUserFolderAggregation folderAggregation = systemFolder.Folders; ControllerTagUserFolder myCreatedFolder = folderAggregation.Create("MySubFolderName"); // Optional; create a subfolder ControllerTagUserFolder mySubCreatedFolder = myCreatedFolder.Folders.Create("MySubSubFolderName");}

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.2.2 Benutzerdefinierte Ordner für PLC-Variablen löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt das Löschen eines bestimmten benutzerdefinierten Ordners für PLC-Variablentabellen.

ProgrammcodeUm einen bestimmten benutzerdefinierten Ordner für PLC-Variablentabellen zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteControllertagUserFolder(ControllerTarget controllertarget){ ControllerTagUserFolder folder = controllertarget.ControllerTagFolder.Folders.Find("MySubFolderName"); if (folder != null) { controllertarget.ControllerTagFolder.Folders.Delete(folder); }}

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren160 Systemhandbuch

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.2.3 PLC-Variablentabelle aus einem Ordner löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

ProgrammcodeUm eine bestimmte Variablentabelle aus einem Ordner zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteControllertagtableInAFolder(ControllerTarget controllertarget)//Deletes a ControllerTagTable of a folder{ ControllerTagSystemFolder folder = controllertarget.ControllerTagFolder; ControllerTagUserFolderAggregation folderAggregation = folder.Folders; ControllerTagUserFolder myCreatedFolder = folderAggregation.Create("MySubFolderName"); ControllerTagTable tagtable = folder.TagTables.Find("MyTagTable"); if (tagtable!= null) { folder.TagTables.Delete(tagtable); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.2.4 Einzelne Variable aus einer PLC-Variablentabelle löschen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 161

ProgrammcodeUm eine bestimmte Variable aus einer PLC-Variablentabelle zu löschen, verwenden Sie folgenden Programmcode:

private static void DeleteTagFromPLCTagtable(ControllerTarget controllertarget)// Deletes a single tag of a tag table{ string tagName = "MyTag"; ControllerTagTable table = controllertarget.ControllerTagFolder.TagTables.Find("myTagTable"); ControllerTagAggregation tagAggregation = table.Tags; ControllerTag tag = tagAggregation.Find(tagName); if (tag != null) { tagAggregation.Delete(tag); }}

Siehe auchStandard-Bibliotheken (Seite 41)

8.10.2.5 Editor "Variablen" starten

Voraussetzung● Die Openness-Anwendung ist mit dem TIA-Portal verbunden.

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Projekt öffnen (Seite 71)

● Instanz des TIA-Portals ist mit Benutzeroberfläche geöffnet.

ProgrammcodeUm für eine Objektreferenz vom Typ ControllerTagTable in der TIA-Portal-Instanz den zugehörigen Editor zu starten, verwenden Sie folgenden Programmcode:

private static void OpenTagtableInEditor(ControllerTarget controllertarget)//Opens tagtable in editor "Tags"{ ControllerTagTable controllertagtable = controllertarget.ControllerTagFolder.TagTables.Find("MyTagTable"); controllertagtable.ShowInEditor();}

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisieren162 Systemhandbuch

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

8.10.2.6 Zeit der letzen Änderungen einer PLC-Variablentabelle lesen

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDas Format des Zeitstempels ist UTC.

ProgrammcodeUm den Zeitstempel einer bestimmten PLC-Variablentabelle zu lesen, verwenden Sie folgenden Programmcode:

private static void GetLastModificationDateOfTagtable(ControllerTarget controllertarget)//Reads Time-Stamp of a controller Tag Table{ ControllerTagTable controllertagtable = controllertarget.ControllerTagFolder.TagTables.Find("MyTagTable"); DateTime modifiedTagTableTimeStamp = controllertagtable.ModifiedTimeStamp;}

Siehe auchStandard-Bibliotheken (Seite 41)

Public API8.10 Funktionen auf Daten eines PLC-Gerätes

Projekte über Skripte automatisierenSystemhandbuch 163

8.11 Grundkonzepte

8.11.1 Umgang mit Exceptions

Exceptions beim Zugriff über Public APIs auf das TIA PortalBei der Ausführung einer Openness-Anwendung über das Public API werden alle auftretenden Fehler als Exceptions gemeldet. Diese Exceptions enthalten Informationen, die Ihnen beim Korrigieren der aufgetretenen Fehler helfen.

Zwei Arten von Exceptions werden unterschieden:

● Recoverable (Siemens.Engineering.EngineeringException)Bei dieser Exception können Sie weiterhin ohne Unterbrechung auf das TIA Portal zugreifen. Alternativ können Sie die Verbindung zum TIA Portal abbrechen.Zu den EngineeringExceptions gehören folgende Typen:

– Sicherheitsrelevante Exceptions (EngineeringSecurityException), z B. bei fehlenden Zugriffsrechten.

– Exceptions beim Zugriff auf Objekte (EngineeringObjectDisposedException), z. B. beim Zugriff auf nicht mehr vorhandene Objekte.

– Exceptions beim Zugriff auf Attribute (EngineeringNotSupportedException), z. B. beim Zugriff auf nicht existierende Attribute.

– Allgemeine Exceptions beim Aufruf (EngineeringTargetInvocationException), z. B. Fehler trotz gültigem Aufruf der Public API.

Die EngineeringExceptions besitzen folgende Attribute:

– ExceptionMessageData messageData: Enthält die Ursache, welche die Exeception ausgelöst hat.

– ExceptionMessageData detailMessageData: Enthält zusätzliche Informationen zur Ursache. Das Ergebnis wird als <IList> zurückgegeben.

– String message: Gibt das Ergebnis aus MessageData und DetailMessageData zurück.

ExceptionMessageData liefert folgende Informationen:

– String Text: Enthält die Ursache, welche die Exception ausgelöst hat.

– Int ServiceId: Gibt die ID des Service zurück, der die Exception ausgelöst hat

– Int MessageId: Eindeutige ID innerhalb des Service.

● NonRecoverable (Siemens.Engineering.NonRecoverableException)Bei dieser Exception wird das TIA Portal beendet und die Verbindung zum TIA Portal getrennt. .Sie müssen das TIA Portal durch die Openness-Anwendung neu starten.

Public API8.11 Grundkonzepte

Projekte über Skripte automatisieren164 Systemhandbuch

ProgrammcodeDas folgende Beispiel zeigt die Möglichkeiten, wie Sie auf Exceptions reagieren können:

try{ ...} catch(EngineeringSecurityException engineeringSecurityException){ Console.WriteLine(engineeringSecurityException);} catch(EngineeringObjectDisposedException engineeringObjectDisposedException){ Console.WriteLine(engineeringObjectDisposedException.Message);} catch(EngineeringNotSupportedException engineeringNotSupportedException){ Console.WriteLine(engineeringNotSupportedException.MessageData.Text); Console.WriteLine(); Foreach(ExceptionMessageData detailMessageData in engineeringNotSupportedException.DetailMessageData) { Console.WriteLine(detailMessageData.Text) }} catch (TargetInvocationException){ throw;} catch (EngineeringException){ //Do not catch general exceptions throw;} catch(NonRecoverableException nonRecoverableException){ Console.WriteLine(nonRecoverableException.Message);}

8.11.2 Arbeiten mit Assoziationen

Zugriff auf AssoziationenEine Assoziation beschreibt die Beziehung zwischen zwei oder mehr Objekten auf Typebene.

Public API8.11 Grundkonzepte

Projekte über Skripte automatisierenSystemhandbuch 165

TIA Portal Openness V13 SP1 unterstützt den Zugriff auf Assoziationen über Index und über "foreach"-Schleifen. Ein direkter Zugriff, z. B. über string name, wird nicht unterstützt.

EigenschaftenFolgende Eigenschaften stehen zur Verfügung:

● int Count● bool IsReadonly● IEngineeringObject Parent● retType this [ int index ] { get; }

MethodenTIA Portal Openness V13 SP1 unterstützt folgende Methoden:

● int IndexOf ( type ): Liefert zu einer übergebenen Instanz den Index in der Assoziation.

● bool Contains ( type ): Ermittelt, ob die übergebene Instanz in der Assoziation enthalten ist.

● IEnumerator GetEnumerator <retType>(): Wird innerhalb von "foreach"-Schleifen eingesetzt, um auf ein Objekt zuzugreifen.

● void Add ( type )1: Fügt die übergebene Instanz zur Assoziation hinzu.

● void Remove ( type )1: Entfernt die übergebene Instanz aus der Assoziation.1: Wird nicht von allen Assoziationen unterstützt.

8.11.3 Arbeiten mit Aggregationen

Zugriff auf AggregationenEine Aggregation ist der Sonderfall einer Assoziation. Eine Aggregation drückt ein semantisches Verhältnis von zwei Objekten aus, von denen eines Teil des anderen ist.

EigenschaftenFolgenden Eigenschaften stehen zur Verfügung:

● int Count● bool IsReadonly● IEngineeringObject Parent● retType this [int index] {get;}: Greift indiziert auf ein Objekt der Aggregation

zu. Diese Art des Zugriffs setzen Sie nur gezielt ein, da jeder einzelne indizierte Zugriff über Prozessgrenzen geht.

Public API8.11 Grundkonzepte

Projekte über Skripte automatisieren166 Systemhandbuch

MethodenTIA Portal Openness V13 SP1 unterstützt folgende Methoden:

● retType Create (id, …): Legt eine neue Instanz an und fügt diese Instanz der Aggregation hinzu. Die Signatur der Methode ist abhängig von der Art, wie die Instanz angelegt wird. Diese Methode wird nicht von allen Aggregationen unterstützt.

● type Find (id, …): Sucht in einer Aggregation die Instanz mit der übergebenen ID. Die Suche ist nicht rekursiv. Die Signatur der Methode ist abhängig von der Art, wie die Instanz gesucht wird. Diese Methode wird nicht von allen Aggregationen unterstützt.

● IEnumerator GetEnumerator<retType> (): Wird innerhalb von "foreach"-Schleifen eingesetzt, um auf ein Objekt zuzugreifen.

● Delete (type)1: Löscht die Instanz, die über die aktuelle Objektreferenz festgelegt ist.

● int IndexOf (type): Liefert zu einer übergebenen Instanz den Index in der Aggregation.

● bool Contains (type): Ermittelt, ob die übergebene Instanz in der Aggregation enthalten ist.

● void Import(string path, ImportOptions importOptions)1: Wird auf jede Aggregation angewendet, die importierbare Typen enthält. In jeder Import-Signatur ist ein Konfigurationsparameter vom Typ "ImportOptions (Seite 184)" ("None", "Overwrite") enthalten, über den der Anwender das Importverhalten steuert.

1: Wird nicht von allen Aggregationen unterstützt.

8.11.4 Objektgleichheit prüfen

VerwendungAls Benutzer einer Public API können Sie mit Programmcode die Objektgleichheit prüfen:

● Mit dem Operator "==" überprüfen zwei Objektreferenzen auf Gleichheit.

● Mit der Methode System.Object.Equals() prüfen Sie, ob beide Objekte in Bezug auf das TIA Portal gleich sind.

Public API8.11 Grundkonzepte

Projekte über Skripte automatisierenSystemhandbuch 167

ProgrammcodeUm auf Objektreferenz-Typen zu prüfen, verwenden Sie folgenden Programmcode:

...//AggregationDeviceAggregation sameAggrA = project.Devices;DeviceAggregation sameAggrB = project.Devices;if (sameAggrA.Equals(sameAggrB)){ Console.WriteLine("sameAggrA is equal to sameAggrB");}if (!(sameAggrA == sameAggrB)){ Console.WriteLine("sameAggrA is not reference equal to sameAggrB");} DeviceAggregation sameAggrAsA = sameAggrA;if (sameAggrAsA.Equals(sameAggrA)){ Console.WriteLine("sameAggrAsA is equal to sameAggrA");}if (sameAggrAsA == sameAggrA){ Console.WriteLine("sameAggrAsA is reference equal to sameAggrA");} MultiLingualGraphicAggregation notSameAggr = project.Graphics;if (!sameAggrA.Equals(notSameAggr)){ Console.WriteLine("sameAggrA is not equal to notSameAggr");}

Siehe auchStandard-Bibliotheken (Seite 41)

8.11.5 Lese-Operationen für Attribute

Mengenoperationen und Standard-Lese-Operationen für AttributeTIA Portal Openness V13 SP1 unterstützt den Zugriff auf Attribute über folgende Methoden, die auf Objektebene verfügbar sind:

● Mengenoperation für lesenden Zugriff

● Standard-Lese-Operationen

Public API8.11 Grundkonzepte

Projekte über Skripte automatisieren168 Systemhandbuch

Programmcode für Mengenoperationen

//Exercise GetAttributes and GetAttributeNames//get all available attributes for a device,//then get the names for those attributes, then display the results. private static void dynamictest(Project project) { System.Collections.Generic.IList<string> attributes = project.Devices[0].GetAttributeNames(); System.Collections.Generic.IList<object> values = project.Devices[0].GetAttributes(attributes); for (int i = 0; i < attributes.Count; i++) { Console.WriteLine("attribute name: " + attributes[i] + " value: " + values[i]); } }

Mengenoperation für lesenden ZugriffDiese Methode ist für jedes Objekt verfügbar:

public abstract IList<object> GetAttributes(IList<string> names);

Standard-Lese-OperationenStandard-Lese-Operationen sind optionale Methoden. Diese Methoden wenden Sie auf Objekte an, die dynamische Attribute unterstützen.

Folgende Optionen sind verfügbar:

● Standardmethode für alle aktuell verfügbaren Attributnamen, abhängig vom aktuellen Status des Objektspublic abstract IList<string> GetAttributeNames();

● Standardmethode zum Lesen eines Attributspublic abstract object GetAttribute(string name);

Hinweis

Dynamische Attribute werden in der IntelliSense nicht angezeigt, da ihre Verfügbarkeit vom Zustand der Objektinstanz abhängt.

Public API8.11 Grundkonzepte

Projekte über Skripte automatisierenSystemhandbuch 169

Public API8.11 Grundkonzepte

Projekte über Skripte automatisieren170 Systemhandbuch

Export/Import 99.1 Überblick

9.1.1 Grundlagen zum Import/Export

EinleitungSie können bestimmte Projektierungsdaten exportieren und die Daten nach der Bearbeitung wieder in das gleiche Projekt oder in ein anderes Projekt zu importieren.

Hinweis

Die Benutzung dieser Beschreibung zur manuellen Änderung und Auswertung der Quelldatei ist mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Siemens übernimmt daher keine Haftung aufgrund der Benutzung dieser Beschreibung oder Teile daraus.

Exportierbare und importierbare ObjekteFolgende Projektierungsdaten können Sie auch über Public APIs importieren oder exportieren:

Tabelle 9-1 Projekte

Objekte Export ImportProjektgrafiken X X

Tabelle 9-2 PLC

Objekte Export ImportBausteine X –Know-how-geschützte Bausteine X –F-Bausteine X –Systembausteine X –PLC-Variablentabellen X XPLC-Variablen X XAnwenderdatentypen X X

Projekte über Skripte automatisierenSystemhandbuch 171

Tabelle 9-3 HMI

Objekte Export ImportBilder X XBildvorlagen X XGlobale Bilder X XSkripte X XTextlisten X XGrafiklisten X XZyklen X XVerbindungen X XVariablentabelle X XVariablen X X

Vollständiger Export oder Export offener ReferenzenDie oben aufgelisteten Objekttypen werden komplett mit allen Objekten exportiert oder importiert, wenn Sie zum gleichen Teilbaum gehören. Dies gilt auch für referenzierte Objekte des gleichen Teilbaums.

Referenzierte Objekte in anderen Teilbäumen können dagegen nicht vollständig exportiert oder importiert werden. Stattdessen werden "offene Referenzen" zu diesen Objekten exportiert oder importiert.

Referenzierte Objekte des gleichen Teilbaums werden nur dann exportiert, wenn diese zur Gruppe der exportierbaren Objekte gehören. An Objekten bestehende Dynamisierungen werden beim Import/Export als Objekte behandelt und werden ebenfalls exportiert und importiert.

Beim Export werden alle Objekteigenschaften exportiert, die bei der Projektierung verändert wurden. Dies gilt unabhängig davon, ob eine geänderte Eigenschaft verwendet wird oder nicht.

Beispiel: Sie haben ein grafisches EA-Feld mit dem Modus "Eingabe/Ausgabe" projektiert und für die Eigenschaft "Typ Bildlaufleiste" die Einstellung "Sichtbar nach Klicken" gewählt. Im weiteren Verlauf der Projektierung haben Sie den Modus geändert in "Zwei Zustände". In diesem Modus ist die Eigenschaft "Typ Bildlaufleiste" nicht verfügbar. Da die Eigenschaft "Typ Bildlaufleiste" geändert wurde, wird diese beim Export mitexportiert, obwohl die Eigenschaft nicht verwendet wird.

Import von offenen ReferenzenSie können auch Objekte mit offenen Referenzen importieren (siehe Import von Projektierungsdaten (Seite 184)).

Wenn die referenzierten Objekte im Zielprojekt enthalten sind, werden die offenen Referenzen automatisch wieder mit den Objekttypen verbunden. Diese Objekte müssen am selben Ort liegen und den gleichen Namen tragen wie beim Export.

Import und Export von SchriftartenAn Objekten definierte Schriftarten werden ebenfalls exportiert und importiert.

Export/Import9.1 Überblick

Projekte über Skripte automatisieren172 Systemhandbuch

Wenn Sie Schriftarten importieren, die nicht im Projekt enthalten sind, wird nach dem Import die Standard-Schriftart am Objekt angezeigt. In der Datenhaltung wird jedoch die importierte Schriftart gespeichert.

Wenn in einer Importdatei die Attribute für die Schriftart nicht vergeben sind, werden die Attribute nach dem Import mit Standard-Werten versehen.

EinschränkungenDas Exportformat ist intern und gilt ausschließlich für die V13 SP1. Das Exportformat kann sich bei zukünftigen Versionen ändern.

Alle beim Import und Export auftretende Fehler werden als Exceptions gemeldet. Weitergehende Informationen zu Exceptions erhalten Sie im Kapitel Umgang mit Exceptions (Seite 164).

Siehe auchEinsatzgebiet von Import/Export (Seite 173)

Export von Projektierungsdaten (Seite 182)

Aufbau einer XML-Datei (Seite 174)

Export/Import von Grafiken (Seite 181)

Übersicht der exportierbaren Bild-Objekte (Seite 206)

9.1.2 Einsatzgebiet von Import/Export

EinleitungMit dem Import/Export exportieren Sie gezielt einzelne Objekte oder Objektgruppen.

Die exportierten Daten können Sie mit einem externen Programm bearbeiten oder unverändert in anderen Projekten des TIA Portals wieder verwenden.

Wenn Sie die Importdatei korrekt aufbauen, können Sie auch extern erstellte Projektierungsdaten importieren, ohne vorher einen Export durchzuführen.

EinsatzgebietDer Export und Import von Daten ist hilfreich für folgende Arbeiten:

● Zur externen Bearbeitung von Projektierungsdaten.

● Zum Import von extern erzeugten Projektierungsdaten, z. B. Textlisten und Variablen.

● Zur Verteilung vorgegebener Projektierungsdaten an verschiedene Projekte, z. B. ein geändertes Prozessbild, das in mehreren Projekten verwendet werden soll.

Export/Import9.1 Überblick

Projekte über Skripte automatisierenSystemhandbuch 173

Siehe auchGrundlagen zum Import/Export (Seite 171)

9.1.3 Aufbau einer XML-Datei

EinleitungDie Daten der Exportdatei aus Import/Export sind anhand einer Basisstruktur aufgebaut.

Basisstruktur einer ExportdateiDie Exportdatei wird als eine XML-Datei abgelegt.

Die XML-Datei beginnt mit einer Dokumentinformation. Darin enthalten sind die Daten der rechnerspezifischen Installation, mit der das Projekt exportiert wurde.

Die Exportdatei ist in folgende beide Bereiche aufgeteilt:

● Informationen zum DokumentIn diesem Bereich können Sie eigene Informationen zum Export in valider XML-Syntax angeben. Der Inhalt wird vom Import übersprungen. Sie können z. B. einen Block <IntegrityInformation>...</IntegrityInformation> einfügen, in dem Sie zusätzliche Informationen zur Validierung platzieren. Nach einer Weitergabe der XML-Datei kann der Empfänger vor dem Import anhand dieses Blocks prüfen, ob die XML-Datei verändert wurde.

● BildobjektIn diesem Bereich sind die zu exportierenden Elemente enthalten.

Export/Import9.1 Überblick

Projekte über Skripte automatisieren174 Systemhandbuch

Export/Import9.1 Überblick

Projekte über Skripte automatisierenSystemhandbuch 175

Bildobjekte einer ExportdateiDie exportierten Elemente sind in weiteren Elementen der XML-Datei enthalten.

Siehe auchGrundlagen zum Import/Export (Seite 171)

9.1.4 Struktur der Daten für Import/Export

ObjekteDer grundsätzliche Aufbau ist für alle Objekte gleich.

Jedes Objekt in der XML-Datei beginnt mit seinem Typ, z. B. "Hmi.Screen.Button" und einer ID. Die ID wird beim Export automatisch erzeugt.

Jedes Objekt außer dem Startobjekt enthält auch ein XML-Attribut "AggregationName". Der Wert für dieses Attribut ist vorgegeben. In einigen Fällen müssen Sie dieses Attribut spezifizieren, z. B. um die Beschriftung zu wechseln, wenn eine Schaltfläche gedrückt oder losgelassen wird.

Export/Import9.1 Überblick

Projekte über Skripte automatisieren176 Systemhandbuch

AttributeJedes Objekt enthält Attribute, die in einem Abschnitt "AttributeList" enthalten sind. Jedes Attribut ist als XML-Element modelliert, z. B. "BackColor". Der Wert eines Attributs ist modelliert als XML-Inhalt, z. B. "204, 204, 204".

Um Objekte zu referenzieren, enthält jedes Objekt bei Bedarf einen Abschnitt "LinkList". Dieser Abschnitt enthält Links zu anderen Objekten in oder außerhalb der XML-Datei. Jeder Link ist als XML-Element modelliert. Die Bezeichnung eines Links wird durch das Zielobjekt in der Schema-Datei vorgegeben. Jeder Link enthält auch das Attribut "TargetID". Wenn das Zielobjekt in der XML-Datei enthalten ist, ist der Wert des Attributs "TargetID" ist die ID des referenzierten Objekts mit einem vorangestellten "#". Wenn das Zielobjekt nicht in der XML-Datei enthalten ist, ist der Wert des Attributs "TargetID" gleich "@OpenLink". Die eigentliche Referenz auf das Objekt ist als unterlagertes XML-Element modelliert.

Export/Import9.1 Überblick

Projekte über Skripte automatisierenSystemhandbuch 177

Export/Import9.1 Überblick

Projekte über Skripte automatisieren178 Systemhandbuch

Bezug zwischen Objekten und XML-StrukturIn den folgenden Abbildungen sehen Sie den Zusammenhang zwischen der exportierten XML-Struktur und den zugehörigen Objekten in WinCC. Zur besseren Übersicht ist die XML-Struktur nicht vollständig abgebildet, z. B. wurden einige Attribute weggelassen.

Bild 9-1 Zusammenhang zwischen der WinCC-Oberfläche und der XML-Struktur.

Export/Import9.1 Überblick

Projekte über Skripte automatisierenSystemhandbuch 179

Bild 9-2 Zusammenhang zwischen den Einstellungen in WinCC und der XML-Struktur.

9.1.5 Bearbeiten der XML-Datei

EinleitungZur Bearbeitung einer XML-Datei für den Import von Projektierungsdaten verwenden Sie einen XML-Editor oder einen Texteditor.

Wenn Sie umfangreiche Änderungen durchführen oder selbst Objektstrukturen aufbauen, empfehlen wir die Verwendung eines XML-Editors mit Auto-Vervollständigungsfunktion.

Hinweis

Ändern des XML-Inhalts setzt umfangreiche Kenntnisse der Struktur und der Validierungsregeln in XML voraus. Vermeiden Sie Validierungsfehler und arbeiten Sie nur in Ausnahmefällen manuell in der XML-Struktur.

Export/Import9.1 Überblick

Projekte über Skripte automatisieren180 Systemhandbuch

9.1.6 Export/Import von Grafiken

EinleitungBeim Export von Projektierungsdaten aus dem TIA Portal werden ausgewählte oder von einem Objekt referenzierte Grafiken nicht in der XML-Datei gespeichert. Die Grafiken werden beim Export separat gespeichert. In der XML-Datei werden die Grafiken über eine relative Pfadangabe und ihren Dateinamen referenziert. Eine Grafikreferenz wird in der XML-Datei als Objekt modelliert und enthält wie die übrigen Objekte eine Attributliste und bei Bedarf eine Linkliste.

Export von GrafikenBeim Export von Projektierungsdaten werden nur Grafiken exportiert, die direkt für den Export ausgewählt wurden. Die exportierbaren Grafiken sind im TIA Portal sprachabhängig abgelegt. Wenn ein Projekt mehrsprachig projektiert ist, werden beim Export alle verwendeten Sprachausprägungen exportiert.

Beim Export von Grafiken wird im Ordner der Exportdatei ein neuer Ordner angelegt. In diesem Ordner werden die exportierten Grafiken gespeichert. Wenn dieser Ordner bereits besteht, wird ein neuer Ordner angelegt und mit einer fortlaufenden Nummer ergänzt.

Die Grafiken werden im gleichen Dateiformat gespeichert, wie sie im Projekt enthalten sind. Das Datenformat wird nicht verändert oder konvertiert, auch die Auflösung und die Farbtiefe bleiben unverändert.

Export/Import9.1 Überblick

Projekte über Skripte automatisierenSystemhandbuch 181

Bei der Sprache, die als Standardsprache gewählt ist, wird als Dateinamenserweiterung die Kennung "default" verwendet.

Wenn in dem Ordner bereits eine gleichnamige Datei besteht, wird im Dateinamen der exportierten Grafik eine fortlaufende Nummer ergänzt.

Import von GrafikenFür den Import von Grafiken bestehen folgende Anforderungen:

● Die Grafiken müssen ein Dateiformat haben, das vom TIA Portal unterstützt wird.

● Die Grafiken müssen in der XML-Datei durch eine relative Pfadangabe referenziert werden.

Wenn Sie eine Grafik exportieren, können Sie diese Grafik außerhalb des TIA Portals mit einem Grafikprogramm bearbeiten und danach wieder importieren.

Siehe auchGrundlagen zum Import/Export (Seite 171)

9.1.7 Export von Projektierungsdaten

EinleitungDie Projektierungsdaten werden jeweils pro Startobjekt (Root) in eine XML-Datei exportiert.

Für die Bearbeitung der Exportdatei werden entsprechende Kenntnisse in XML vorausgesetzt. Zur einfacheren Bearbeitung verwenden Sie einen XML-Editor.

BeispielSie haben ein Prozessbild, in dem ein EA-Feld enthalten ist. An das EA-Feld ist eine externe Variable projektiert. Wenn Sie das Prozessbild exportieren, werden das Bild und das EA-Feld exportiert. Die Variable und die von der Variablen benutzte Verbindung werden nicht exportiert. Stattdessen wird jeweils nur eine offene Referenz dazu exportiert.

Export/Import9.1 Überblick

Projekte über Skripte automatisieren182 Systemhandbuch

Inhalt der ExportdateiIn der Exportdatei werden ab dem Startobjekt alle Objekte eines Teilbaums komplett mit ihren Eigenschaften hinterlegt. Alle Referenzen zu Objekten anderer Teilbäume werden dagegen nur als offene Referenzen exportiert. Die entsprechenden Eigenschaften der referenzierten Objekte in anderen Teilbäumen werden nicht in die Exportdatei geschrieben.

HinweisExport von Objekttypen aus der Bibliothek wird nicht unterstützt

Sie können Objekte als Typ in der Bibliothek anlegen. Im Projekt verwendete Instanzen des Objekttyps können Sie mit der Openness-Anwendung wie andere Objekte bearbeiten. Wenn Sie Objekte exportieren, werden die Instanzen ohne die Typinformation exportiert.

Wenn Sie diese Objekte wieder in das Projekt importieren, werden die Instanzen der Objekttypen überschrieben und die Instanz vom Objekttyp gelöst.

Die Exportdatei enthält nicht grundsätzlich alle Attribute eines Objekts. Beim Export definieren Sie, welche Daten exportiert werden:

● ExportOptions.NoneDiese Einstellung exportiert nur die modifizierten oder die vom Standard abweichenden Daten. Zusätzlich enthält die Exportdatei alle Werte, die für den späteren Import der Daten obligatorisch sind.

● ExportOptions.WithDefaults1

Wie "None". Zusätzlich werden die Standardwerte exportiert.

● ExportOptions.WithReadOnly1

Wie "None". Zusätzlich werden die schreibgeschützten Werte exportiert.1: Diese beiden Optionen können Sie mit folgender Syntax kombinieren: Export(<Path>; ExportOptions.WithDefaults | ExportOptions.WithReadOnly);

Der gesamte Inhalt der Exportdatei ist in englischer Sprache. Unabhängig davon werden enthaltene Projekttexte in allen vorhandenen Sprachen exportiert und importiert.

In der Exportdatei werden alle Projektierungsdaten als XML-Objekte modelliert.

Wenn in einem Export eine Grafik enthalten ist, wird diese Grafik in Ihrem Ursprungsformat exportiert und in einem separaten Ordner gespeichert. In die Exportdatei wird lediglich ein Verweis auf die Grafikdatei geschrieben.

Siehe auchGrundlagen zum Import/Export (Seite 171)

Standard-Bibliotheken (Seite 41)

Bausteine und Anwenderdatentypen exportieren (Seite 223)

Export/Import9.1 Überblick

Projekte über Skripte automatisierenSystemhandbuch 183

9.1.8 Import von Projektierungsdaten

EinleitungDie Projektierungsdaten werden aus einer zuvor exportierten und bearbeiteten oder einer selbst erstellten XML-Datei importiert. Beim Importvorgang werden die enthaltenen Daten geprüft. Damit wird sichergestellt, dass die Projektierungsdaten im TIA Portal durch den Import nicht inkonsistent werden.

Einschränkungen● Beim Import von Texten müssen im Zielprojekt die entsprechenden Projektsprachen

angelegt sein, damit der Import nicht fehlschlägt.

● Nur die Bereichszeiger unter "Für jede Verbindung getrennt" sind importierbar oder exportierbar.

● Wenn in einer Importdatei mehrere Root-Objekte angegeben sind und ein dieser Objekte ist nicht valide, wird der gesamte Inhalt der Importdatei nicht importiert.

● Wenn Sie ungültige Eigenschaften eines Objekts in der Importdatei angeben, die in der grafischen Oberfläche vom TIA Portal nicht editierbar sind, wird der Import abgebrochen.

HinweisGeräteabhängige Wertebereiche für grafische Eigenschaften

Wenn Werte grafischer Eigenschaften den gültigen Wertebereich überschreiten, werden diese Werte beim Import auf die am Bediengerät möglichen Maximalwerte zurückgesetzt.

HinweisImport von Objekttypen aus der Bibliothek wird nicht unterstützt

Sie können Objekte als Typ in der Bibliothek anlegen. Im Projekt verwendete Instanzen des Objekttyps können Sie mit der Openness-Anwendung wie andere Objekte bearbeiten. Wenn Sie Objekte exportieren, werden die Instanzen ohne die Typinformation exportiert.

Wenn Sie diese Objekte wieder in das Projekt importieren, werden die Instanzen der Objekttypen überschrieben und die Instanz vom Objekttyp gelöst.

Unterschiedliches ImportverhaltenWenn zu importierende Objekte bereits im Projekt existieren, steuern Sie das Importverhalten über verschiedene Programmcodes. Ansonsten werden die Objekte im Projekt beim Import neu angelegt.

Folgende Einstellungen für das Importverhalten sind möglich:

Export/Import9.1 Überblick

Projekte über Skripte automatisieren184 Systemhandbuch

● Import ohne Überschreiben mit Fehleranzeige (Exception)Wenn ein Objekt beim Import aus einer XML-Datei bereits im Projekt vorhanden ist, wird mit einer Fehlermeldung (Exception) abgebrochen.Dieses Verhalten erreichen Sie mit ImportOptions.None.

● Import mit automatischem ÜberschreibenBeim Import über eine Public API können Sie festlegen, dass mit dem Import bestehende Objekte innerhalb des Projekts überschrieben werden. Entsprechende Objekte werden vor dem Import im Projekt gelöscht und mit Defaultwerten neu angelegt. Beim Import werden diese Standardwerte mit den Werten aus dem Import überschrieben.Dieses Verhalten erreichen Sie mit ImportOptions.Override.

Ablauf beim Import Für den Import einer XML-Datei müssen die enthaltenen Daten bestimmten Regeln genügen. Der Inhalt der Importdatei muss wohl geformt sein. Keine Syntaxfehler und keine Fehler in der Datenstruktur dürfen enthalten sein. Verwenden Sie bei umfangreichen Änderungen einen XML-Editor, der diese Kriterien bereits vor dem Import prüft.

Beim Import der XML-Datei in das TIA Portal werden die enthaltenen Daten zuerst auf formale Fehler im XML-Code geprüft. Wenn bei der Prüfung Fehler auftreten, wird der Importvorgang abgebrochen und die Fehler werden in einer Exception angezeigt (siehe Umgang mit Exceptions (Seite 164)).

Siehe auchGrundlagen zum Import/Export (Seite 171)

Standard-Bibliotheken (Seite 41)

Anwenderdatentyp importieren (Seite 230)

9.2 Import/Export von Projektdaten

9.2.1 Grafiken

9.2.1.1 Grafiken eines Projektes exportieren

Voraussetzungen● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Export/Import9.2 Import/Export von Projektdaten

Projekte über Skripte automatisierenSystemhandbuch 185

VerwendungSie können entweder eine einzelne Grafik oder alle Grafiken der Grafiksammlung eines Projekts in allen Sprachen exportieren. Beim Export wird eine XML-Datei mit allen betroffenen Projektgrafik-Einträgen erstellt und mit den ebenfalls exportierten Grafiken referenziert. Die betroffenen Grafiken werden zusammen mit der XML-Datei im gleichen Verzeichnis des Dateisystems abgelegt.

Damit Sie die exportierten Grafiken ("*.jpg", "*.bmp", "*.png", "*.ico" etc.) ändern können, sind diese Grafiken nicht schreibgeschützt abgelegt.

Programmcode: Eine Grafik exportierenUm die gewünschte Grafik zu exportieren, verwenden Sie folgenden Programmcode:

//Exports all language variants of a single graficProject project = …;MultiLingualGraphicAggregation graphicsAggregation = project.Graphics;MultiLingualGraphic graphic = graphicsAggregation.Find("graphicName");graphic.Export(@"D:\ExportFolder\graphicName.xml", ExportOptions.WithDefaults);

Programmcode: Alle Grafiken exportierenUm alle Grafiken der Grafiksammlung zu exportieren, verwenden Sie folgenden Programmcode:

//Exports all graphics of a graphic libraryProject project = …;MultiLingualGraphicAggregation graphicsAggregation = project.Graphics;foreach(MultiLingualGraphic graphic in graphicsAggregation){ graphic.Export(String.Format(@"D:\Graphics\{0}.xml", graphic.Name), ExportOptions.WithDefaults);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.2.1.2 Grafiken in ein Projekt importieren

Voraussetzungen● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Export/Import9.2 Import/Export von Projektdaten

Projekte über Skripte automatisieren186 Systemhandbuch

VerwendungIn einem Verzeichnis Ihres Dateisystems ist eine XML-Datei zusammen mit den Sprachvarianten einer Grafik abgelegt.

In der XML-Datei können Sie alle Grafiken in einen relativen Pfad referenzieren.

Sie können nun aus der XML-Datei alle dort enthaltenen Sprachvarianten einer Grafik in die Grafiksammlung importieren.

Beachten Sie dabei auch den Import von Projektierungsdaten (Seite 184).

ProgrammcodeUm eine oder mehrere Grafiken zu importieren, verwenden Sie folgenden Programmcode:

//Import all language variants of a single graficProject project = …;MultiLingualGraphicAggregation graphicsAggregation = project.Graphics;string graphicExportFileName = "graphicExport.xml";ImportOptions importOptions = ImportOptions.Override;graphicListAggregation.Import(fullFilePath, importOptions);

Siehe auchStandard-Bibliotheken (Seite 41)

9.3 Import/Export von Daten eines HMI-Geräts

9.3.1 Zyklen

9.3.1.1 Zyklen exportieren

Voraussetzungen● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt den Export aller Zyklen eines bekannten HMI-Geräts in eine XML-Datei. Die Erstellung der entsprechenden Exportdatei zeigt den durchgeführten Export an.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 187

ProgrammcodeUm Zyklen aus einem HMI-Gerät in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportCyclesFromHMITarget(HmiTarget hmitarget)//Exports cycles from an HMI device{ CycleAggregation cycles = hmitarget.Cycles; foreach(Cycle cycle in cycles) { cycle.Export(String.Format(@"C:\OpennessSamples\ExportFiles\" + cycle.Name + ".xml"), ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.1.2 Zyklen importieren

Voraussetzungen● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

VerwendungWenn Sie ImportOptions.None verwenden, erkennen Sie an der Nummer der Aggregation (Aggregation count) die tatsächlich importierten Zyklen. Auf diesen importierten Zyklus haben Sie Zugriff.

Hinweis

Standard-Zyklen verfügen über Eigenschaften, die nicht über die Benutzeroberfläche editierbar sind. Wenn Sie in der Importdatei angeben, dass diese Eigenschaften verändert werden sollen, verursacht der Import eine NonRecoverableException ab und beendet das TIA Portal.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren188 Systemhandbuch

ProgrammcodeUm einen Zyklus oder mehrere Zyklen aus einer XML-Datei in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportCyclesToHMITarget(HmiTarget hmitarget)//Imports cycles to an HMI device{ CycleAggregation cycles = hmitarget.Cycles; string dirPathImport = @"C:\OpennessSamples\Import"; string cycleImportFileName = "CycleImport.xml"; string fullFilePath = dirPathImport + cycleImportFileName; cycles.Import(fullFilePath, ImportOptions.None);}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

9.3.2 Variablentabellen

9.3.2.1 HMI-Variablentabellen exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungPro HMI-Variablentabelle wird jeweils eine XML-Datei exportiert. Die API-Schnittstelle unterstützt diesen Exportvorgang. Der Export von Variablentabellen wird auch in Unterordnern angeboten.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 189

Programmcode: Alle HMI-Variablentabellem aus einem vorgegebenen Ordner exportierenUm alle HMI-Variablentabellen aus einem definierten Ordner zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportAllTagTablesFromTagFolder(HmiTarget hmitarget)//Exports all tag tables from a tag folder{ TagSystemFolder folder = hmitarget.TagFolder; TagTableAggregation tables = folder.TagTables; foreach (TagTable table in tables) { string fullFilePath = string.Format(@"C:\OpennessSamples\TagTables\{0}.xml", table.Name); table.Export(fullFilePath, ExportOptions.WithDefaults); }}

Programmcode: Eine HMI-Variablentabelle exportierenUm eine einzelne HMI-Variablentabelle zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportTagTableFromHMITarget(HmiTarget hmitarget)//Exports a tag table from an HMI device{ string tableName = "Tag table XYZ"; TagSystemFolder folder = hmitarget.TagFolder; TagTableAggregation tables = folder.TagTables; TagTable table = tables.Find(tableName); if (table != null) { string fullFilePath = string.Format(@"C:\OpennessSamples\TagTables\{0}.xml", table.Name); table.Export(fullFilePath, ExportOptions.WithDefaults); }}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren190 Systemhandbuch

Programmcode: Alle HMI-Variablentabellen exportierenUm alle HMI-Variablentabellen zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportAllTagTablesFromHMITarget(HmiTarget hmitarget)//Exports all tag tables from an HMI device{ TagSystemFolder sysFolder = hmitarget.TagFolder; //First export the tables in underlying user folder foreach (TagUserFolder userFolder in sysFolder.Folders) { ExportUserFolderDeep(userFolder); } //then, export all tables in the system folder ExportTablesInSystemFolder(sysFolder);} private static void ExportUserFolderDeep(TagUserFolder rootUserFolder){ foreach (TagUserFolder userFolder in rootUserFolder.Folders) { ExportUserFolderDeep(userFolder); } ExportTablesInUserFolder(rootUserFolder);} private static void ExportTablesInUserFolder(TagUserFolder folderToExport){ TagTableAggregation tables = folderToExport.TagTables; foreach (TagTable table in tables) { string fullFilePath = string.Format(@"C:\OpennessSamples\TagTables\{0}.xml", table.Name); table.Export(fullFilePath, ExportOptions.WithDefaults); } } private static void ExportTablesInSystemFolder(TagSystemFolder folderToExport){ TagTableAggregation tables = folderToExport.TagTables; foreach (TagTable table in tables) { string fullFilePath = string.Format(@"C:\OpennessSamples\TagTables\{0}.xml", table.Name); table.Export(fullFilePath, ExportOptions.WithDefaults); } }

Siehe auchStandard-Bibliotheken (Seite 41)

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 191

9.3.2.2 HMI-Variablentabelle importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

ProgrammcodeUm die HMI-Variablentabelle einer XML-Datei in einen benutzerdefinierten Ordner oder einen Systemordner zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportSingleHMITagTable(HmiTarget hmitarget)//Imports a single HMI tag table from a XML file{ TagSystemFolder folder = hmitarget.TagFolder; TagTableAggregation tables = folder.TagTables; string fullFilePath = @"C:\OpennessSamples\TagTables\myExportedTagTable.xml"; tables.Import(fullFilePath, ImportOptions.Override);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.2.3 Einzelne Variable einer HMI-Variablentabelle exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

VerwendungDie folgenden Objektmodell-Objekttypen können als untergeordnete Elemente einer HMI-Variablen vorhanden sein und werden beim Export berücksichtigt:

MultilingualText Für Kommentar, TagValue, DisplayNameTagArrayMemberTag Für HMI-Array-ElementeTagStructureMember Für HMI-Strukturelemente

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren192 Systemhandbuch

Ereignis Für konfigurierte EreignisseMultiplexEntry Für konfigurierte Variablen-Multiplexing-Einträge

ProgrammcodeUm eine einzelne Variable einer HMI-Variablentabelle in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportSelectedTagFromTagTable(HmiTarget hmitarget)//Exports a selected tag from a tag table{ TagSystemFolder tagFolder = hmitarget.TagFolder; TagTable mytable = tagFolder.TagTables.Find("MyTagTable"); TagAggregation containingTags = mytable.Tags; Tag myTag = containingTags.Find("MyTag"); if (myTag != null) { string fullFilePath = string.Format(@"C:\OpennessSamples\Tags\{0}.xml", myTag.Name); myTag.Export(fullFilePath, ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.2.4 Einzelne Variable in eine HMI-Variablentabelle importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie folgenden Objektmodell-Objekttypen können als untergeordnete Elemente einer HMI-Variablen vorhanden sein und werden beim Import berücksichtigt:

MultilingualText Für Kommentar, TagValue, DisplayNameTagArrayMemberTag Für HMI-Array-ElementeTagStructureMember Für HMI-StrukturelementeEreignis Für konfigurierte EreignisseMultiplexEntry Für konfigurierte Variablen-Multiplexing-Einträge

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 193

ProgrammcodeUm eine HMI-Variable aus einer XML-Datei in eine HMI-Variablentabelle zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportTagIntoTagTable(HmiTarget hmitarget)//Imports a tag into a tag table{ TagSystemFolder tagFolder = hmitarget.TagFolder; TagTable myTable = tagFolder.DefaultTagTable; TagAggregation tagAggregation = myTable.Tags; string fullFilePath = @"C:\OpennessSamples\Tags\myExportedTag.xml"; tagAggregation.Import(fullFilePath, ImportOptions.Override);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.2.5 Besonderheiten beim Export/Import von HMI-Variablen

EinleitungFür den Export und Import von folgenden HMI-Variablen gelten Besonderheiten:

● Externe HMI-Variablen mit integrierter Verbindung

● HMI-Variablen mit Datentyp "UDT"

Ähnliche Programmcodes Der Programmcode für die oben genannten HMI-Variablen ist nahezu identisch mit den folgenden Programmcodes:

● Programmcode: Export von HMI-Variablen (Seite 192)

● Programmcode: Import von HMI-Variablen (Seite 193)

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Besonderheiten beim Export/Import einer externen HMI-Variablen mit integrierter VerbindungBeim Export einer externen HMI-Variablen mit integrierter HMI-Verbindung wird anstelle der PLC-Variablen-Daten nur der Link der HMI-Variablen auf die PLC-Variable in der Exportdatei gespeichert.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren194 Systemhandbuch

Stellen Sie vor dem Import sicher, dass die PLC, die entsprechenden PLC-Variablen und die integrierte Verbindung zur entsprechenden PLC im Projekt vorhanden sind. Wenn dies nicht der Fall ist, müssen Sie diese Elemente vor dem Import anlegen. Beim anschließenden Import der externen HMI-Variable wird die Verknüpfung zur PLC-Variable wieder aktiv.

Namen von externen HMI-Variablen müssen über alle Variablen-Tabellen verteilt eines Projekts eindeutig sein. Wenn Sie beim Import nicht die passende Variablen-Tabelle zur HMI-Variable angeben, wird der Import abgebrochen.

Um eine externe HMI-Variable mit integrierter Verbindung zu importieren, verwenden Sie folgende XML-Struktur:

<Hmi.Tag.Tag ID="1" AggregationName="Tags"> <AttributeList> <Name>MyIntegratedHmiTag_1</Name> </AttributeList> <LinkList> <AcquisitionCycle TargetID="@OpenLink"> <Name>1 s</Name> </AcquisitionCycle> <Connection TargetID="@OpenLink"> <Name>HMI_Connection_MP277_300400</Name> <- Must exist in the project </Connection> <ControllerTag TargetID="@OpenLink"> <Name>Datablock_1.DBElement1</Name> <- Must exist in the project </ControllerTag> </LinkList> </Hmi.Tag.Tag>

Besonderheiten beim Export/Import einer HMI-Variablen vom Datentyp "UDT"Beim Export einer HMI-Variablen vom Datentyp "UDT" wird der Link auf den Datentyp exportiert. Beim Import werden ausschließlich versionierte Datentypen unterstützt.

Die Datentypen müssen in der Projektbibliothek gespeichert sein. Datentypen in der globalen Bibliothek werden nicht unterstützt.

Beim Import gelten folgende Regeln:

● Der referenzierte Datentyp muss in der Projektbibliothek enthalten sein. Wenn der Datentyp nicht in der Projektbibliothek enthalten ist, wird der Import abgebrochen.

● Der referenzierte Datentyp muss versioniert sein. Die Versionierung wird ab TIA Portal V13 SP1 unterstützt. Wenn der Datentyp nicht versioniert ist, wird eine Exception ausgelöst.

HinweisBeim Import wird der erste gefundene Datentyp zum Auflösen der Referenz verwendet.

Dabei gilt: Zuerst wird das Stammverzeichnis der Projektbibliothek durchsucht, danach die Unterordner.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 195

Um eine HMI-Variable vom Datentyp "UDT" zu importieren, verwenden Sie folgende XML-Struktur:

<Hmi.Tag.Tag ID="1" AggregationName="Tags"> ... <LinkList> <DataType TargetID="@OpenLink"> <Name>HmiUdt_1 V 1.0.0</Name> <- Must exist in the project library </DataType> ... </LinkList> ...</Hmi.Tag.Tag>

9.3.3 VB-Skripte

9.3.3.1 VB-Skripte exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungBeim Export werden alle untergeordneten benutzerdefinierten Ordner berücksichtigt. Für jedes exportierte VB-Skript wird jeweils eine XML-Datei erzeugt.

Programmcode: Ein VB-Skript exportierenUm ein ausgewähltes VB-Skript eines HMI-Geräts in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportSingleVBScriptOfHMITarget(HmiTarget hmitarget)//Exports one single vbscript of an HMI device{ VBScriptSystemFolder vbScriptFolder = hmitarget.VBScriptFolder; VBScriptAggregation vbScripts = vbScriptFolder.VBScripts; VBScript vbScript = vbScripts.Find("MyVBScript"); string fullFilePath = String.Format(@"C:\OpennessSamples\Export\Scripts\{0}.xml", vbScript.Name); vbScript.Export(fullFilePath, ExportOptions.None);}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren196 Systemhandbuch

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.3.2 VB-Skripte aus einem Ordner exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

VerwendungFür jedes exportierte VB-Skript wird jeweils eine XML-Datei erzeugt.

Programmcode: VB-Skript aus einem benutzerdefinierten Ordner exportierenUm ein VB-Skript aus einem benutzerdefinierten Ordner in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportVBScriptOfSelectedVBScriptSystemFolder(HmiTarget hmitarget)//Exports vbscripts of a selected vbscript system folder{ string dirPathExport = "C:\Export"; VBScriptSystemFolder vbScriptFolder = hmitarget.VBScriptFolder; VBScriptUserFolderAggregation vbUserFolders = vbScriptFolder.Folders; VBScriptUserFolder vbUserFolder = vbUserFolders.Find("MyVBUserFolder"); VBScriptAggregation vbScripts = vbUserFolder.VBScripts; foreach (VBScript script in vbScripts) { string fullPathExport1 = String.Format(@"C:\OpennessSamples\Export\Scripts\{0}.xml", script.Name); script.Export(fullPathExport1, ExportOptions.None); }}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 197

Programmcode: Alle VB-Skripte aus einem Systemordner exportierenUm alle VB-Scripte aus dem Systemordner zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportAllVBScripts(HmiTarget hmitarget)//Exports all vbscripts; using a foreach loop{ VBScriptSystemFolder vbScriptFolder = hmitarget.VBScriptFolder; VBScriptAggregation vbScripts = vbScriptFolder.VBScripts; if (null != vbScripts) { foreach (VBScript script in vbScripts) { String fullFilePath = String.Format(@"C:\OpennessSamples\Scripts\{0}.xml", script.Name); script.Export(fullFilePath, ExportOptions.None); } }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.3.3 VB-Skripte importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungEin Massenimport ist möglich. Alternativ können Sie für den Multi-Import einen Programmcode mit einer Foreach-Schleife verwenden (siehe VB-Skripte exportieren (Seite 196)).

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren198 Systemhandbuch

ProgrammcodeUm ein VB-Skript aus einer XML-Datei in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportSingleVBScriptToHMITarget(HmiTarget hmitarget)//Imports a single vbscript to an HMI device{ string dirPathImport = @"C:\OpennessSamples\Import"; VBScriptSystemFolder vbScriptFolder = hmitarget.VBScriptFolder; VBScriptAggregation vbScripts = vbScriptFolder.VBScripts; if (null != vbScripts) { string fullPath = dirPathImport + "ImportTest_VBScript.xml"; vbScripts.Import(fullPath, ImportOptions.None); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.4 Textlisten

9.3.4.1 Textlisten aus einem HMI-Gerät exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungBeim Export von Text- und Grafiklisten werden alle Einträge dieser Listen ebenfalls exportiert. Text- und Grafiklisten können Sie separat exportieren.

Die Textlisten eines HMI-Geräts werden exportiert. Für jede exportierte Textliste wird jeweils eine XML-Datei erzeugt.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 199

ProgrammcodeUm Textlisten aus einem HMI-Gerät zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportTextLists(HmiTarget hmitarget)//Export TextLists{ TextListAggregation text = hmitarget.TextLists; foreach (TextList textList in text) { String fullFilePath = String.Format(@"C:\OpennessSamples\TextGraphic\TextLists\{0}.xml", textList.Name); textList.Export(fullFilePath, ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.4.2 Textliste in ein HMI-Gerät importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt den Import einer Textliste aus einer XML-Datei in ein HMI-Gerät.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren200 Systemhandbuch

ProgrammcodeUm eine Textliste aus einer XML-Datei in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportSingleTextList(HmiTarget hmitarget)//Imports a single TextList{ TextListAggregation textListAggregation = hmitarget.TextLists; string dirPathImport = @"C:\OpennessSamples\Import"; string textListImportFileName = "textListImport.xml"; string fullFilePath = dirPathImport + textListImportFileName ; ImportOptions importOptions = ImportOptions.Override; textListAggregation.Import(fullFilePath , importOptions);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.4.3 Erweiterte XML-Formate für Export/Import von Textlisten

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Standardexport von TextlistenSiehe Textlisten aus einem HMI-Gerät exportieren (Seite 199)

● Standardimport von TextlistenSiehe Textlisten in ein HMI-Gerät importieren (Seite 200)

VerwendungEine Textliste kann auch formatierte Texte enthalten. Im Wesentlichen betrifft das folgende Formatierungen:

● Text-Formatierung

● Verweise auf andere Objekte innerhalb des Textes

Reine Textformatierungen innerhalb einer zu exportierenden Textliste führen zu einem erweiterten XML-Export-Format. Objektverweise werden als Open Links ausgeprägt. Das gleiche gilt auch für zu importierende Textlisten mit formatierten Texten.

Erweiterte XML-Exportformate können auch deutlich komplexer werden. Beispielsweise ist manchmal in der Textliste mehr als nur der Name des Objektes verknüpft, z. B. über einen

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 201

Open Link zu einer PLC-Variablen eines anderen Geräts. In diesem Fall müssen alle Informationen in eine Zeichenfolge codiert werden, um den Open Link zu beheben.

<?xml version="1.0" encoding="utf-8"?><Document> <!-- ... --> <MultilingualText ID="4" AggregationName="Text"> <AttributeList> <TextItems> <Value lang="en-US"> <body> <p> Mary<field ref="0" /> </p> </body> <fieldinfos> <fieldinfo name="0" domaintype="HMICommonTagDisplayFormat"> <reference TargetID="@OpenLink"> <name>Siemens.Simatic.Hmi.Utah.Tag.HmiTag:Tag_1</name> </reference> <domaindata> <format displaytype="Decimal" length="1" formatpattern="9" /> </domaindata> </fieldinfo> </fieldinfos> </Value> </TextItems> </AttributeList> </MultilingualText> <!-- ... --></Document>

9.3.5 Grafiklisten

9.3.5.1 Grafiklisten exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungBeim Export von Text- und Grafiklisten werden alle Einträge dieser Listen ebenfalls exportiert. Text- und Grafiklisten können Sie separat exportieren.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren202 Systemhandbuch

Pro Grafikliste wird jeweils eine XML-Datei angelegt. In den Grafiklisten enthaltene globale Grafiken werden als Open Links exportiert.

ProgrammcodeUm Grafiklisten eines HMI-Gerätes zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportGraphicLists(HmiTarget hmitarget)//Exports GraphicLists{ GraphicListAggregation graphic = hmitarget.GraphicLists; foreach (GraphicList graphicList in graphic) { string fullFilePath = String.Format(@"C:\OpennessSamples\TextGraphic\GraphicLists\{0}.xml", graphicList.Name); graphicList.Export(fullFilePath, ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.5.2 Grafikliste importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt den Import einer Grafikliste aus einer XML-Datei in ein HMI-Gerät.

Beim Import werden alle referenzierten Grafiken der Grafikliste importiert. Ausgenommen sind Verweise auf globale Grafiken. Wenn die referenzierten globalen Grafiken im Zielprojekt existieren, werden die Verweise auf die globalen Grafiken beim Import wiederhergestellt.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 203

ProgrammcodeUm eine Grafikliste aus einer XML-Datei in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportSingleGraphicList(HmiTarget hmitarget)//Imports a single GraphicList{ Siemens.Engineering.Hmi.TextGraphicList.GraphicListAggregation graphicListAggregation = hmitarget.GraphicLists; string dirPathImport = @"C:\OpennessSamples\Import"; string graphicListExportFileName = "graphicListImport.xml"; string fullFilePath = dirPathImport + graphicListExportFileName ; ImportOptions importOptions = ImportOptions.Override; graphicListAggregation.Import(fullFilePath, importOptions);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.6 Verbindungen

9.3.6.1 Verbindungen exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt den Export aller Verbindungen eines HMI-Geräts in eine XML-Datei.

HinweisExport von integrierten Verbindungen

Der Export von integrierten Verbindungen wird nicht unterstützt.

Für jede exportierte Verbindung wird jeweils eine XML-Datei erzeugt.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren204 Systemhandbuch

ProgrammcodeUm alle Verbindungen eines HMI-Gerätes in eine XML-Dateizu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportCommunicationConnectionsFromHMITarget(HmiTarget hmitarget)//Exports communication connections from an HMI device{ ConnectionAggregation connections = hmitarget.Connections; foreach(Connection conn in connections) { String fullFilePath = String.Format(String.Format(@"C:\OpennessSamples\Export\{0}.xml", conn.Name)); conn.Export(fullFilePath, ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.6.2 Verbindungen importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie API-Schnittstelle unterstützt den Import aller Verbindungen eines HMI-Geräts aus einer XML-Datei in ein HMI-Gerät. Wenn Sie mehrere Kommunikationsverbindungen importieren wollen, importieren Sie jeweils die entsprechende XML-Datei.

Hinweis

Wenn Sie eine Verbindung in ein Projekt importieren, in dem schon eine integrierte Verbindung projektiert ist, wird diese Verbindung nicht überschrieben. Der Import wird abgebrochen und eine Exception ausgelöst.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 205

ProgrammcodeUm eine einzelne Verbindung eines HMI-Geräts aus einer XML-Datei in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportCommunicationConnectionsToHMITarget(HmiTarget hmitarget)//Imports Communication connections to an HMI device{ ConnectionAggregation connections = hmitarget.Connections; string fileName = "ConnectionImport.xml"; string dirPathImport = @"C:\OpennessSamples\Import"; string fullFilePath = dirPathImport + fileName; ImportOptions importOptions = ImportOptions.Override; connections.Import(fullFilePath, importOptions);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7 Bilder

9.3.7.1 Übersicht der exportierbaren Bild-Objekte

VerwendungFolgende Bilder können Sie über Public APIs exportieren oder importieren:

Tabelle 9-4 Unterstützte Bilder

Objekt WinCC V13SP1Bild xGlobales Bild xBildvorlage xPermantentfenster xPop-up-Bild –Slide-in-Bild –

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren206 Systemhandbuch

Folgende Bild-Objekte können Sie über Public APIs exportieren oder importieren:

Tabelle 9-5 Unterstützte Bild-Objekte

Bereich Objekttyp WinCC V13SP1Basisobjekte Linie x

Polylinie xPolygon xEllipse xEllipsensegment –Kreissegment –Ellipsenbogen –Kreisbogen –Kreis xRechteck xVerbinder –Textfeld xGrafikanzeige xRohr –Doppel-T-Stück –T-Stück –Rohrbogenn –

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 207

Bereich Objekttyp WinCC V13SP1Elemente E/A-Feld x

Grafisches E/A-Feld xEditierbares Textfeld –Listenfeld –Kombinationsfeld –Schaltfläche xRundschaltfläche –Leuchtdrucktaster xSchalter xSymbolisches E/A-Feld xDatum/Uhrzeit-Feld xBalken xSymbolbibliothek xSchieberegler xBildlaufleiste –Kontrollkästchen –Optionsschaltflächen –Zeigerinstrument xUhr xSpeicherplatzanzeige –Funktionstasten (Softkeys) xGruppen xBildbaustein-Instanzen –

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren208 Systemhandbuch

Bereich Objekttyp WinCC V13SP1Controls Bildfenster –

Benutzeranzeige xDruckauftrag / Skriptdiagnose –Kamera-Anzeige –PDF-Anzeige –Rezepturanzeige –Meldeanzeige –Meldeindikator –Meldefenster –f(x)-Kurvenanzeige –f(t)-Kurvenanzeige –Tabellenanzeige –Wertetabelle –HTML Browser –Media Player –Kanaldiagnose –WLAN-Empfang –Zonen-Name –Zonen-Signal –Wirkbereichs-Name –Wirkbereichs-Name (RFID) –Wirkbereichs-Signal –Ladezustand –Handrad –Hilfeindikator –Sm@rtClient-Anzeige –Status/Steuern –Speicherplatzanzeige –NC-Teilprogramm-Anzeige –System-Diagnoseanzeige –System-Diagnosefenster –

Siehe auchGrundlagen zum Import/Export (Seite 171)

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 209

9.3.7.2 Alle Bilder eines HMI-Geräts exportieren

Voraussetzungen● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungEin anderer Programmcode ist erforderlich, um alle aggregierten Bilder aller benutzerdefinierten Bildordner eines HMI-Geräts zu exportieren.

Programmcode: Alle Bilder eines benutzerdefinierten Ordners exportierenUm die Bilder eines benutzerdefinierten Bildordners eines HMI-Geräts und des Bild-Systemordners zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportScreensFromFolder(HmiTarget hmitarget)//Exports all screens of an HMI device{ ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("MyScreenFolder"); //or ScreenSystemFolder folder = …; ScreenAggregation screens = folder.Screens; foreach(Screen screen in screens) { screen.Export(String.Format(@"D:\Screens\{0}.xml", screen.Name), ExportOptions.WithDefaults); }}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren210 Systemhandbuch

Programmcode: Benutzerunabhängig alle Bilder eines HMI-Geräts exportierenUm alle Bilder zu exportieren, verwenden Sie folgenden Programmcode:

public static void ExportScreens (string screenPath , HmiTarget target){ string exportFilePath = @"C:\OpennessSamples\Screens"; foreach (Screen screen in target.ScreenFolder.Screens) { screen.Export(System.IO.Path.Combine(exportFilePath, screen.Name + ".xml"), ExportOptions.WithDefaults); } foreach (ScreenUserFolder folder in target.ScreenFolder.Folders) { ExportScreenUserFolder(System.IO.Path.Combine(exportFilePath, folder.Name), folder); }} private static void ExportScreenUserFolder(string exportFilePath,ScreenUserFolder folder ){ DirectoryInfo info = new DirectoryInfo(rootPath); info.Create(); foreach (Screen screen in folder.Screens) { screen.Export(System.IO.Path.Combine(exportFilePath, screen.Name + ".xml"), ExportOptions.WithDefaults); } foreach (ScreenUserFolder subFolder in folder.Folders) { ExportScreenUserFolder(System.IO.Path.Combine(exportFilePath, subFolder.Name), subFolder); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.3 Bild aus einem Bildordner exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 211

VerwendungFolgende Daten eines Bildes werden exportiert:

Bild DatenEigenschaften ActiveLayer, BackColor, Height, Width, Name, Number, HelpTextOffene Links TemplateAggregationen ● Layers

● Animationsalle konfigurierten Runtime Advanced basierten Animationen werden exportiert.

● Eventsalle konfigurierten Runtime Advanced basierten Events werden exportiert.

● SoftkeysAlle konfigurierten Softkeys werden exportiert.

Für jeden Layer werden folgende Daten exportiert:

Hinweis

Standardmäßig ist der Layer-Name im TIA Portal ein leerer Text.

Wenn Sie den Layer-Namen im TIA Portal nicht ändern, dann wird der exportierte Layer-Name ein leerer Text sein. In diesem Fall wird der angezeigte Layer-Name im TIA Portal abhängig von der Oberflächensprache angezeigt.

Wenn Sie den Layer-Namen im TIA Portal ändern, dann wird der abgeänderte Layer-Name in allen relevanten Sprachen angezeigt.

Layer DatenEigenschaften Name, Index, VisibleESAggregationen ScreenItems (inkl. ScreenItems)

Nicht exportiert werden:

● SCADA-spezifische Eigenschaften.

● Layer, die keine Bildelemente (Screen items) enthalten und deren Eigenschaften sich nicht von den Defaultwerten unterscheiden.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren212 Systemhandbuch

ProgrammcodeUm ein einzelnes Bild aus dem Benutzerordner oder dem Systemordner eines HMI-Geräts zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportSingleScreenFromScreenFolder(HmiTarget hmitarget)//Exports a single screen from a screen folder{ string screenName = "Screen_1.xml"; ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("MyScreenFolder"); //or ScreenSystemFolder folder = hmitarget.ScreenFolder; ScreenAggregation screens = folder.Screens; Screen screen = screens.Find(screenName); if (screen != null) { screen.Export(String.Format(@"C:\OpennessSamples\Screens\{0}.xml", screen.Name), ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.4 Bilder in ein HMI-Gerät importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungDie Bilder können Sie nur in HMI-Geräte eines bestimmten Gerätetyps importieren. Das HMI-Gerät muss den gleichen Gerätetyp besitzen wie das Gerät aus dem die Bilder vorher exportiert wurden.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 213

Folgende Daten eines Bildes werden importiert:

Bild DatenEigenschaften ActiveLayer, BackColor, Height, Width, Name, Number, HelpTextOffene Links TemplatesAggregationen ● Layers

● AnimationsAlle auf Bilder konfigurierbaren Animationen werden importiert.

● EventsAlle auf Bilder konfigurierbaren Events werden importiert.

● SoftkeysAlle auf Bilder konfigurierbaren Softkeys werden importiert.

Für jeden Layer werden folgende Daten importiert:

Hinweis

Wenn Sie vor dem Import für den Layer-Namen einen leeren Text vergeben haben, dann wird nach dem Import der angezeigte Layer-Name im TIA Portal abhängig von der Oberflächensprache angezeigt.

Wenn Sie einen Layer-Namen vergeben haben, dann wird nach dem Import der angegebene Layer-Name in allen relevanten Sprachen angezeigt.

Layer DatenEigenschaften Name, IndexAggregationen ScreenItems

Einschränkungen:● Wenn Breite und Höhe eines Bildes nicht mit der Größe des Geräts übereinstimmen, wird

der Import abgebrochen und eine Exception ausgelöst. Eine Anpassung der enthaltenen Bildelemente wird nicht unterstützt. Deshalb können sich einige Bildelemente außerhalb des Bildes befinden. In diesem Fall kommt es zu einer Compilerwarnung.

● Die Bildnummer muss für alle Bilder eines Geräts eindeutig sein. Beim Import eines Bildes mit einer schon im Gerät angelegten Bildnummer wird der Import abgebrochen. Wenn Sie noch keine Bildnummer vergeben haben, wird beim Import eine eindeutige Nummer für das Bild vergeben.

● Die Anordnung der Bildelemente innerhalb der Z-Reihenfolge muss im Bild für jede Ebene eindeutig und lückenlos sein. Deshalb wird nach dem Import des Bildes eine Konsistenzprüfung durchgeführt, welche die Anordnung bei Bedarf repariert. Dies kann bei einigen Bildelementen zu veränderten "Tabindexes" führen.Sie können die Z-Reihenfolge der Bildelemente in der XML-Datei manuell anpassen. Das an erster Stelle stehende Bildelement liegt in der Z-Reihenfolge ganz hinten.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren214 Systemhandbuch

Hinweis

In der XML-Datei können Sie Werte für Breite und Höhe bei Bildelementen auch dann ändern, wenn für das Bildelement die Eigenschaft "Größe an Inhalt anpassen" aktiviert ist.

HinweisImport von Bildtypen aus der Bibliothek wird nicht unterstützt

Ab WinCC V12 SP1 können Sie ein Bild als Typ in der Bibliothek anlegen. Im Projekt verwendete Instanzen des Bildtyps können Sie mit der Openness-Anwendung wie andere Bilder bearbeiten. Wenn Sie Bilder exportieren, werden die Instanzen von Bildtypen ohne die Typinformation und exportiert.

Wenn Sie diese Bilder wieder in das Projekt importieren, werden die Instanzen der Bildtypen überschrieben und die Instanz vom Bildtyp gelöst.

Programmcode: Bilder in ein HMI-Gerät importierenUm Bilder über eine For each-Schleife in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportScreensToHMITarget(HmiTarget hmitarget)//Imports all screens to an HMI device{ string[] exportedScreens = new string[] { "Screen_1.xml", "Screen_n.xml" }; ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("MyScreenFolder"); string dirPathImport = @"C:\OpennessSamples\Import"; ImportOptions importoptions = ImportOptions.Override; foreach (string screenFileName in exportedScreens) { string fullFilePath = dirPathImport+screenFileName; folder.Screens.Import(fullFilePath,importoptions); }}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 215

Programmcode: In einen neu erstellten Benutzerordner importierenUm ein Bild in einen neu erstellten Benutzerordner eines HMI-Geräts zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportSingleScreenToNewFolderOfHMITarget(HmiTarget hmitarget)//Imports a single screen to a new created user folder of an HMI device{ String exportFileName = "ExportedScreens.xml"; String dirPathImport = @"C:\OpennessSamples\Import"; String fullFilePath = dirPathImport + exportFileName; ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Create("MyFolder"); ImportOptions importoptions = ImportOptions.Override; folder.Screens.Import(fullFilePath, importoptions);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.5 Permanentfenster exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungFolgende Daten des Permanentfensters werden exportiert:

Permanentfenster DatenEigenschaften ActiveLayer, BackColor, Height, Width, NameAggregationen Layers

Für jeden Layer werden folgende Daten exportiert:

Layer DatenEigenschaften Name, IndexAggregationen ScreenItems (inkl. ScreenItems)

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren216 Systemhandbuch

ProgrammcodeUm ein Permanentfenster eines HMI-Geräts in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportScreenoverview(HmiTarget hmitarget)//Exports a screenoverview{ ScreenOverview overview = hmitarget.ScreenOverview; String fullFilePath = @"C:\OpennessSamples\Export"; if (overview != null) { overview.Export(fullFilePath, ExportOptions.WithDefaults); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.6 Permanentfenster importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungFolgende Daten des Permanentfensters werden importiert:

Permanentfenster DatenEigenschaften ActiveLayer, BackColor, Height, Width, Name, Visible, NumberAggregationen Layers

Für jeden Layer werden folgende Daten importiert:

Layer DatenEigenschaften Name, IndexAggregationen ScreenItems (inkl. ScreenItems)

Wenn Breite und Höhe eines Bildes nicht mit der Größe des Geräts übereinstimmen, wird der Import abgebrochen und eine Exception ausgelöst. Eine Anpassung der enthaltenen Geräteelemente (Screenitems) wird nicht unterstützt. Deshalb können sich einige Geräteelemente außerhalb des Bildes befinden. In diesem Fall kommt es zu einer Compilerwarnung.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 217

Die Anordnung der Geräteelemente muss im Permanentfenster eindeutig und lückenlos sein. Deshalb wird nach dem Import des Permanentfensters eine Konsistenzprüfung durchgeführt, welche die Anordnung bei Bedarf repariert. Dies kann bei einigen Geräteelementen zu veränderten "Tabindexes" führen.

ProgrammcodeUm ein Permanentfenster aus einer XML-Datei in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode

private static void ImportScreenoverview(HmiTarget hmitarget)//Imports a screenoverview{ string fullFilePath = @"C:\OpennessSamples\Export"; hmitarget.ImportScreenOverview(fullFilePath, ImportOptions.Override);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.7 Bildvorlagen aus einem Ordner exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungFolgende Daten einer Bildvorlage werden exportiert:

Bildvorlagen DatenEigenschaften ActiveLayer, BackColor, Height, Width, NameAggregationen ● Layers

● AnimationsAlle konfigurierten Animationen werden exportiert. SCADA-Animationen werden nicht exportiert.

● SoftkeysAlle konfigurierten Softkeys werden exportiert.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren218 Systemhandbuch

Für jeden Layer werden folgende Daten exportiert:

Layer DatenEigenschaften Name, IndexAggregationen ScreenItems (inkl. ScreenItems)

Programmcode: Eine Bildvorlage exportierenUm eine einzelne Bildvorlage aus dem Systemordner oder einem benutzerdefinierten Ordner zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportSingleScreenTemplate(HmiTarget hmitarget)//Exports a single screen template{ string templateName = "Template name XYZ"; string fullFilePath = String.Format(@"C:\OpennessSamples\Templates\{0}.xml", templateName); ScreenTemplateUserFolder folder = hmitarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder"); //or ScreenTemplateSystemFolder folder = hmitarget.ScreenTemplateFolder; ScreenTemplateAggregation templates = folder.ScreenTemplates; ScreenTemplate template = templates.Find(templateName); if(template != null) { template.Export(fullFilePath, ExportOptions.WithDefaults); }}

Programmcode: Alle Bildvorlagen exportierenUm alle Bildvorlagen aus einem festgelegten Ordner zu exportieren, verwenden Sie folgenden Programmcode.

private static void ExportAllScreenTamplates(HmiTarget hmitarget)//Exports all screen templates of a selected folder{ ScreenTemplateUserFolder folder = hmitarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder"); //or ScreenTemplateSystemFolder folder = hmitarget.ScreenTemplateFolder; ScreenTemplateAggregation templates = folder.ScreenTemplates; foreach(ScreenTemplate template in templates) { string fullFilePath = String.Format(@"C:\OpennessSamples\Templates\{0}.xml", template.Name); template.Export(fullFilePath, ExportOptions.WithDefaults); }}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 219

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.8 Alle Bildvorlagen eines HMI-Geräts exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungPro Bildvorlage wird jeweils eine XML-Datei angelegt.

Da kein Massenexport möglich ist, müssen Sie für den Export alle Bildvorlagen enumerieren und einzeln exportieren. Stellen Sie dabei sicher, dass die verwendeten Namen der Bildvorlagen den Regeln Ihres Dateisystems zur Bezeichnung von Dateien entsprechen.

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren220 Systemhandbuch

ProgrammcodeUm eine Bildvorlage aus einem HMI-Gerät zu exportieren, verwenden Sie folgenden Programmcode:

public static void ExportScreenTemplates(string templatePath, HmiTarget target){ string templatePath = @"C:\OpennessSamples\Templates"; foreach (ScreenTemplate screen in target.ScreenTemplateFolder.ScreenTemplates) { screen.Export(Path.Combine(templatePath, screen.Name + ".xml"), ExportOptions.WithDefaults); } foreach (ScreenTemplateUserFolder folder in target.ScreenTemplateFolder.Folders) { ExportTemplateUserFolder(Path.Combine(templatePath, folder.Name), folder); }} private static void ExportTemplateUserFolder(string exportFilePath, ScreenTemplateUserFolder folder){ DirectoryInfo info = new DirectoryInfo(rootPath); info.Create(); foreach (ScreenTemplate screen in folder.ScreenTemplates) { screen.Export(Path.Combine(exportFilePath, screen.Name + ".xml"), ExportOptions.WithDefaults); } foreach (ScreenTemplateUserFolder subFolder in folder.Folders) { ExportTemplateUserFolder(Path.Combine(exportFilePath, subFolder.Name + ".xml"), subFolder); }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.3.7.9 Bildvorlagen importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisierenSystemhandbuch 221

VerwendungFolgende Daten einer Bildvorlage werden importiert:

Bildvorlage DatenEigenschaften ActiveLayer, BackColor, Height, Width, Name, SetTabOrderInFrontAggregationen ● Layers

● AnimationsAlle auf Bilder konfigurierbaren Animationen werden importiert.

● SoftkeysAlle auf Bilder konfigurierbaren Softkeys werden importiert.

Für jeden Layer werden folgende Daten importiert:

Layer DatenEigenschaften Name, IndexAggregationen ScreenItems (inkl. ScreenItems)

Wenn Breite und Höhe einer Bildvorlage nicht mit der Größe des Geräts übereinstimmen, wird der Import abgebrochen und eine Exception ausgelöst. Eine Anpassung der enthaltenen Bildelemente (Screenitems) wird nicht unterstützt. Deshalb können sich einige Bildelemente außerhalb des Bildes befinden. In diesem Fall kommt es zu einer Compilerwarnung.

Die Anordnung der Bildelemente muss in der Bildvorlage eindeutig und lückenlos sein. Deshalb wird nach dem Import der Bildvorlage eine Konsistenzprüfung durchgeführt, welche die Anordnung bei Bedarf repariert. Dies kann bei einigen Bildelementen zu veränderten "Tabindexes" führen.

Programmcode: Allgemeiner ImportUm alle Bildvorlagen über eine For each-Schleife in ein HMI-Gerät zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportScreenTemplatesToHMITarget(HmiTarget hmitarget)//Imports screen templates to an HMI device{ ScreenTemplateUserFolder folder = hmitarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder"); // or ScreenTemplateSystemFolder folder = hmitarget.ScreenTemplateFolder; string[] exportedTemplates = {"Template_1.xml", "Template_2.xml", "Template_3.xml"}; foreach (string templateFileName in exportedTemplates) { folder.ScreenTemplates.Import(templateFileName, ImportOptions.Override); }}

Export/Import9.3 Import/Export von Daten eines HMI-Geräts

Projekte über Skripte automatisieren222 Systemhandbuch

Programmcode: Import in einen neu erstellten BenutzerordnerUm eine Bildvorlage in einen neu erstellten Benutzerordner eines HMI-Geräts zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportScreenTemplatesToFolderOfHMITarget(HmiTarget hmitarget)//Imports screen templates to a user folder of an HMI device{ ImportOptions importoptions = ImportOptions.Override;; String exportFileName = "ExportedScreenTemplate.xml"; String dirPathImport = @"C:\OpennessSamples\Import"; String fullFilePath = dirPathImport + exportFileName; ScreenTemplateUserFolder screenTemplateFolder = hmitarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder"); ScreenTemplateUserFolder folder = screenTemplateFolder.Folders.Create("MyNewFolder"); folder.ScreenTemplates.Import(fullFilePath, ImportOptions.Override);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.4 Import/Export von Daten eines PLC-Geräts

9.4.1 Bausteine

9.4.1.1 Bausteine und Anwenderdatentypen exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

VerwendungDie API-Schnittstelle unterstützt das Exportieren von konsistenten Bausteinen und Anwenderdatentypen in eine XML-Datei.

Die XML-Datei erhält den Namen des Bausteins. Folgende Bausteintypen werden unterstützt:

● Funktionsbausteine (FB)

● Funktionen (FC)

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 223

● Organisationsbausteine (OB)

● Globale Datenbausteine (DB)

Folgende Programmiersprachen werden unterstützt:

● AWL

● FUP

● KOP

● GRAPH

● SCLDie aus dem Export eines SCL-Bausteins resultierende xml-Datei enthält nur die Bausteinschnittstelle.

Exportierte DatenFolgende Eigenschaften werden abhängig vom Baustein- oder Anwenderdatentyp und den gewählten ExportOptions exportiert (siehe Export von Projektierungsdaten (Seite 182)). Fett ausgezeichnete Eigenschaften werden immer exportiert.

Eigenschaft Typ Standardwert ReadOnly GültigkeitName String "" false Alle BausteineType BlockType - false Alle BausteineNumber Int32 - false Alle BausteineAutoNumber Bool true false Alle BausteineHeaderAuthor String "" false Alle BausteineHeaderFamily String "" false Alle BausteineHeaderName String "" false Alle BausteineHeaderVersion String "0.1" false Alle BausteineMemoryLayout enum MemoryLayout - false Alle BausteineIsWriteProtectedInAS Bool false false Nur DBIsOnlyStoredInLoadMemory Bool false false Nur DBIsIECCheckEnabled Bool false false Nur DB und FBIsRetainMemResEnabled1 Bool false false Nur DB und FBIsRetainStandardArea Bool false false Nur Instanz-DB ei‐

nes FBMemoryReserve Unsigned 0 false Nur DB und FBRetainMemoryReserve1 Unsigned 0 false Nur DB und FBSecondaryType2 String - false Nur OB ProgrammingLanguage enum ProgrammingLanguage - false Alle BausteineIsKnowHowProtected Bool false true Alle BausteineDatablockType enum DatablockType - false Nur DBInstanceOfName String "" false Nur DBInstanceOfNumber Unsigned Short - true Nur DBInstanceOfType enum BlockType - true Nur DBOfSystemLibElement String "" false Alle Bausteine

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren224 Systemhandbuch

Eigenschaft Typ Standardwert ReadOnly GültigkeitOfSystemLibVersion String "" false Alle BausteineParameterPassing Bool false false Nur FB und FC (STL)CreationDate DateTime - true Alle BausteineModifiedDate DateTime - true Alle BausteineInterface String - false Alle BausteineInterfaceModifiedDate DateTime - true Alle BausteineParameterModified DateTime - true Alle BausteineStructureModified DateTime - true Alle BausteineCodeModifiedDate DateTime - true Alle BausteineCompileDate DateTime - true Alle BausteineIsConsistent Bool - true Alle BausteineEnableTagReadback Bool false false Nur FB, FC und In‐

stanz-DB eines FBEnableTagReadbackBlockPro‐perties

String "" false Nur FB, FC und In‐stanz-DB eines FB

HandleErrorsWithinBlock Bool false true Nur FB und OBCanBeKHPLibElement Bool true true Nur FB und OBIsPLCDB Bool false false Nur DBSkipSteps Bool false false Nur GRAPH-Bau‐

steineAcknowledgeErrorsRequired Bool true false Nur GRAPH-Bau‐

steinePermanentILProcessingInMAN‐Mode

Bool false false Nur GRAPH-Bau‐steine

LockOperatingMode Bool false false Nur GRAPH-Bau‐steine

SetENOAutomatically Bool - false Nur GRAPH-Bau‐steine

CreateMinimizedDB Bool false false Nur GRAPH-Bau‐steine

LanguageInNetworks String - false Nur GRAPH-Bau‐steine

ISMultiInstanceCapable Bool - true Nur FBArrayDataType String - true Nur DBArrayLimitUpperBound Int32 - true Nur DBGraphVersion String - - DownloadWithoutReinit Bool - false kein GRAPH, wenn

nicht failsafe1 Wenn die Eigenschaft "IsRetainMemResEnabled" den Wert "false" und die Eigenschaft "RetainMemoryReserve" ungleich

"0" ist, wird eine Exception ausgelöst.2 Beim Export eines OB wird auf Basis der OB-Nummer zusätzlich die Eigenschaft "SecondaryType" gesetzt. Beim Import

wird die Zuordnung geprüft. Wenn die Zuordnung nicht korrekt ist, wird eine Exception vom Typ "Recoverable" ausgelöst.

Weiterführende Informationen finden Sie im Informationssystem des TIA Portals unter "Übersicht über die Bausteineigenschaften".

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 225

ProgrammcodeUm einen Baustein ohne Know-how-Schutz in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportRegularBlock(ControllerTarget controllertarget)//Exports a regular block{ IBlock iBlock = controllertarget.ProgramblockFolder.Blocks.Find("MyBlock"); iBlock.Export(String.Format(@"C:\OpennessSamples\Blocks\{0}.xml", iBlock.Name),ExportOptions.WithDefaults);}

Um einen Anwenderdatentyp in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportUserDefinedDataType(ControllerTarget controllertarget)//Exports a user defined data type{ string udtname = "udt name XYZ"; Siemens.Engineering.SW.ControllerDatatypeAggregation datatypes = controllerTarget.ControllerDatatypeFolder.Datatypes; Siemens.Engineering.SW.ControllerDatatype udt = datatypes.Find(udtname); udt.Export(String.Format(@"C:\OpennessSamples\udts\{0}.xml", udt.Name),ExportOptions.WithDefaults);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.4.1.2 Bausteine mit Know-how-Schutz exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

VerwendungDie resultierende XML-Datei ähnelt der Exportdatei eines Bausteins ohne Know-how-Schutz. Allerdings werden nur die Daten der Benutzeroberfläche exportiert, die sichtbar sind, wenn der Baustein ohne Kennwort geöffnet wird.

In der Attribut-Liste des Blocks wird angezeigt, dass der betreffende Baustein know-how-geschützt ist.

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren226 Systemhandbuch

ProgrammcodeUm die sichtbaren Daten eines Bausteins mit Know-how-Schutz in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportBlock(ControllerTarget controllertarget){ IBlock iBlock = controllertarget.ProgramblockFolder.Blocks.Find("MyBlock"); iBlock.Export(String.Format(@"C:\OpennessSamples\Blocks\{0}.xml", iBlock.Name),ExportOptions.WithDefaults);}

Siehe auchStandard-Bibliotheken (Seite 41)

9.4.1.3 F-Bausteine exportieren

Hinweis

F-Bausteine werden wie andere Bausteine exportiert.

Siehe auchVerbindung zum TIA Portal aufbauen (Seite 59)

Projekt öffnen (Seite 71)

Standard-Bibliotheken (Seite 41)

Bausteine und Anwenderdatentypen exportieren (Seite 223)

Bausteine mit Know-how-Schutz exportieren (Seite 226)

9.4.1.4 System-Bausteine exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

● Ein System-Baustein ist im Projekt vorhanden.

● PLC ist nicht online verbunden.

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 227

VerwendungIn der Attribut-Liste des Blocks wird angezeigt, dass der betreffende Baustein know-how-geschützt ist.

ProgrammcodeUm die sichtbaren Daten eines Bausteins in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportSystemBlocks(ControllerTarget controllertarget)//Exports system blocks{ SystemblockSystemFolder sbSystemFolder = controllertarget.ProgramblockFolder.SystemFolder; foreach (SystemblockComponentFolder folder in sbSystemFolder.Folders) { foreach (IBlock block in folder.Blocks) { String fullFilePath = String.Format(@"C:\OpennessSamples\Blocks\{0}.xml", block.Name); block.Export(fullFilePath, ExportOptions.WithDefaults); } }}

Siehe auchStandard-Bibliotheken (Seite 41)

9.4.1.5 Baustein importieren

Voraussetzung● Um Bausteine importieren zu können benötigen Sie folgende Dateien:

– XML-Enabler-File

– XML-Usage-File

Nähere Hinweise, wie Sie die Dateien bekommen und einsetzen finden SIe hier: Enabler-File und Usage-File (Seite 34)

● Die Openness-Anwendung ist mit dem TIA Portal verbunden.Siehe Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren228 Systemhandbuch

VerwendungDie Public API-Schnittstelle unterstützt das Importieren von Bausteinen mit der Programmiersprache "AWL", "FUP" oder "GRAPH" aus einer XML-Datei. Folgende Bausteintypen werden unterstützt:

● Funktionsbausteine (FB)

● Funktionen (FC)

● Organisationsbausteine (OB)

● Globale Datenbausteine (DB)

Hinweis

Wenn "BlockNumber" fehlt, wird die Bausteinnummer automatisch vergeben.

Wenn "Version" fehlt, wird aktuelle Versionsnummer verwendet.

HinweisImportieren von optimierten Datenbausteinen

Optimierte Datenbausteine werden nur von CPUs ab S7-1200 unterstützt. Wenn Sie optimierte Datenbausteine in eine S7-300 oder S7-400 importieren, werden diese Datenbausteine als "inkonsistent" gekennzeichnet.

Verhalten beim ImportierenBeim Importieren eines Bausteins gelten folgende Regeln:

● Die XML-Datei kann weniger Daten als der Baustein im Projekt haben, z. B. weniger Parameter.

● Redundante Informationen wie Aufrufinformationen müssen sowohl im Projekt als auch in der XML-Datei exakt gleich sein. Sonst wird eine Exception ausgelöst.

● Die Daten in der XML-Datei dürfen "inkonsistent" im Hinblick auf ihre Übersetzungsfähigkeit im TIA Portal sein.

● Attribute mit der Eigenschaften "ReadOnly=True" und "Informative=True" werden nicht importiert.

● Fehlende Instanz-DBs werden nicht automatisch angelegt.

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 229

ProgrammcodeUm einen Baustein aus einer XML-Datei zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportSystemBlocks(ControllerTarget controllertarget)//Imports system blocks{ String exportFileName = "ExportedSystemBlock.xml"; String dirPathImport = @"C:\OpennessSamples\Import"; String fullFilePath = dirPathImport + exportFileName; ProgramblockSystemFolder programBlockFolder = controllertarget.ProgramblockFolder; IList<IBlock> blocks = programBlockFolder.Blocks.Import(fullFilePath, ImportOptions.Override);}

9.4.1.6 Anwenderdatentyp importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Verbindung zum TIA Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Projekt öffnen (Seite 71)

● PLC ist nicht online verbunden.

VerwendungDie API-Schnittstelle unterstützt das Importieren von Anwenderdatentypen aus einer XML-Datei.

Syntax ImportdateiDas folgende Codebeispiel zeigt einen Auszug aus einer Importdatei eines benutzerdefinierten Datentyps:

<Section Name="Input"> <Member Name="Input1" Datatype=quot;myudt1&quot;> <Sections> <Section Name="None"> <Member Name="MyUDT1Member1" Datatype="bool"/> <Member Name="MyUDT1Member2" Datatype=&quot;myudt1&quot;> <Sections...

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren230 Systemhandbuch

HinweisSyntax für benutzerdefinierte Datentypen von Elementen

Wenn in der Importdatei für Anwenderdatentypen der benutzerdefinierte Datentyp eines Elements in der falschen Syntax steht, wird eine Exception ausgelöst.

Stellen Sie sicher, dass benutzerdefinierte Datentypen mit &quot; notiert sind.

ProgrammcodeUm einen Anwenderdatentyp zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportUserDataType(ControllerTarget controllertarget)//Imports user data type{ String exportFileName = "ExportedScreenTemplate.xml"; String dirPathImport = @"C:\OpennessSamples\Import"; String fullFilePath = dirPathImport + exportFileName; Siemens.Engineering.SW.ControllerDatatypeAggregation datatypes = controllertarget.ControllerDatatypeFolder.Datatypes; datatypes.Import(fullFilePath, ImportOptions.Override);}

Siehe auchImport von Projektierungsdaten (Seite 184)

Standard-Bibliotheken (Seite 41)

9.4.2 Variablentabellen

9.4.2.1 PLC-Variablentabellen exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 231

VerwendungPro PLC-Variablentabelle wird jeweils eine XML-Datei exportiert.

Die Public API-Schnittstelle unterstützt den Export aller PLC-Variablentabelle aus dem Systemordner und seinen Unterordnern.

ProgrammcodeUm alle PLC-Variablentabelle aus dem Systemordner und seinen Unterordnern zu exportieren, verwenden Sie folgenden Programmcode:

private static void ExportAllTagTables(ControllerTarget controllerTarget){ ControllerTagSystemFolder controllerTagSystemFolder = controllerTarget.ControllerTagFolder; // Export all tables in the system folder ExportTagTables(controllerTagSystemFolder.TagTables); // Export the tables in underlying user folders foreach(ControllerTagUserFolder userFolder in controllerTagSystemFolder.Folders) { ExportUserFolderDeep(userFolder); }} private static void ExportTagTables(ControllerTagTableAggregation tagTables){ foreach(ControllerTagTable table in tagTables) { String fullFilePath = String.Format(@"C:\OpennessSamples\TagTables\{0}.xml", table.Name); table.Export(fullFilePath, ExportOptions.WithDefaults); }} private static void ExportUserFolderDeep(ControllerTagUserFolder folder){ ExportTagTables(folder.TagTables); foreach(ControllerTagUserFolder userFolder in folder.Folders) { ExportUserFolderDeep(userFolder); }}

Siehe auchStandard-Bibliotheken (Seite 41)

Export von Projektierungsdaten (Seite 182)

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren232 Systemhandbuch

9.4.2.2 PLC-Variablentabelle importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

ProgrammcodeUm PLC-Variablentabellen oder eine Ordnerstruktur mit PLC-Variablentabellen aus einer XML-Datei in den Systemordner oder einen benutzerdefinierten Ordner zu importieren, verwenden Sie folgenden Programmcode:

private static void ImportTagTable(ControllerTarget controllerTarget,string tagTableFile)//Imports tag tables to the tag system folder{ String exportFileName = "ExportedTagTable.xml"; String dirPathImport = @"C:\OpennessSamples\Import"; String fullFilePath = dirPathImport + exportFileName; ControllerTagSystemFolder controllerTagSystemFolder = controllerTarget.ControllerTagFolder; ControllerTagTableAggregation tagTables = controllerTagSystemFolder.TagTables; tagTables.Import(fullFilePath, ImportOptions.Override); // Or, to import into a subfolder: // controllerTagSystemFolder.Folders.Find("SubFolder").TagTables.Import(fullFilePath, ImportOptions.Override);}

Siehe auchHinweise zur Performance von TIA Portal Openness V13 SP1 (Seite 41)

Standard-Bibliotheken (Seite 41)

9.4.2.3 Einzelne Variable einer PLC-Variablentabelle exportieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet.Siehe Projekt öffnen (Seite 71)

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 233

VerwendungDie API-Schnittstelle unterstützt den Export einer Variable oder eine Konstante aus einer PLC-Variablentabelle in eine XML-Datei. Stellen Sie sicher, dass die verwendeten Namen der Variablentabellen den Regeln Ihres Dateisystems zur Bezeichnung von Dateien entsprechen.

Der Kommentar einer Variablen oder Konstanten wird nur dann exportiert, wenn für den Kommentar mindestens eine Sprache gesetzt ist. Wenn der Kommentar nicht für alle Projektsprachen gesetzt ist, wird dieser Kommentar nur für die gesetzten Projektsprachen exportiert.

ProgrammcodeUm eine bestimmte Variable oder Konstante aus einer PLC-Variablentabelle in eine XML-Datei zu exportieren, verwenden Sie folgenden Programmcode:

//Exports a single tag or constant of a controller tag tableprivate static void ExportTag(ControllerTarget controllerTarget,string tagName){ ControllerTagSystemFolder controllerTagSystemFolder = controllerTarget.ControllerTagFolder; ControllerTag tag = controllerTagSystemFolder.TagTables[0].Tags.Find(tagName); if(tag != null) { tag.Export(String.Format(@"C:\OpennessSamples\SingleTags\{0}.xml",tag.Name),ExportOptions.WithDefaults); }}private static void ExportUserConstant(ControllerTarget controllerTarget, string userConstantName){ ControllerTagSystemFolder controllerTagSystemFolder = controllerTarget.ControllerTagFolder; ControllerConstant controllerConstant = controllerTagSystemFolder.TagTables[0].Constants.Find (userConstantName); if(controllerConstant!= null) { controllerConstant.Export(String.Format(@"C:\OpennessSamples\SingleUserConstants\{0}.xml",controllerConstant.Name),ExportOptions.WithDefaults); } }

Siehe auchExport von Projektierungsdaten (Seite 182)

Hinweise zur Performance von TIA Portal Openness V13 SP1 (Seite 41)

Standard-Bibliotheken (Seite 41)

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren234 Systemhandbuch

9.4.2.4 Einzelne Variable in eine PLC-Variablentabelle importieren

Voraussetzung● Die Openness-Anwendung ist mit dem TIA Portal verbunden.

Siehe Verbindung zum TIA-Portal aufbauen (Seite 59)

● Ein Projekt ist geöffnet. Siehe Projekt öffnen (Seite 71)

VerwendungIn einem Importaufruf können Sie entweder Variablen oder Konstanten importieren.

ProgrammcodeUm Variablen-Ordner oder einzelne Variablen und Konstanten aus einer XML-Datei zu importieren, verwenden Sie folgenden Programmcode:

//Imports tags or constants or folders intor controller tag table or tag system folder private static void ImportTag(ControllerTarget controllerTarget,string tagtableName, string tagFile){ ControllerTagSystemFolder controllerTagSystemFolder = controllerTarget.ControllerTagFolder; ControllerTagTable tagTable = controllerTagSystemFolder.TagTables.Find(tagtableName); if(tagTable != null) { tagTable.Tags.Import(tagFile, ImportOptions.Override); }}

Siehe auchExport von Projektierungsdaten (Seite 182)

Hinweise zur Performance von TIA Portal Openness V13 SP1 (Seite 41)

Standard-Bibliotheken (Seite 41)

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisierenSystemhandbuch 235

Export/Import9.4 Import/Export von Daten eines PLC-Geräts

Projekte über Skripte automatisieren236 Systemhandbuch

Index

AAbfragen

Bausteinautor, 149Bausteinfamilie, 149Bausteinname, 149Bausteinnummer, 149Bausteintitel, 149Bausteintyp, 149Bausteinversion, 149Informationen einer PLC-Variablentabelle, 88Informationen von Anwenderdatentyp, 149Informationen von Baustein, 149Konsistenz-Attribut eines Bausteins, 149Ordner Programmbausteine, 145Schnittstellenadresse, 131Stationsadresse, 131Subnetzname, 131Systemordner, 154Systemordner für PLC-Variablen, 83Zeitstempel eines Bausteins, 149

AnlegenBenutzerdefinierte Bildordner, 134Benutzerdefinierte Ordner für HMI-Variablen, 141Benutzerdefinierte Skriptordner, 143

Anwenderdatentypexportieren, 223importieren, 230Informationen abfragen, 149löschen, 151Quelle erzeugen, 152

Anwendungsbeispiel Public API, 51Aufbau einer Verbindung zum TIA Portal, 59

BBasisstruktur einer Exportdatei, 176Baustein

exportieren, 223Gruppe erzeugen, 151Gruppe löschen, 154importieren, 229Informationen abfragen, 149löschen, 150Quelle erzeugen, 152

Bausteineditorstarten, 159

BearbeitungssituationOpenness-Anwendung und TIA-Portal sind auf demselben Rechner, 20

Beenden der Verbindung zum TIA-Portal, 71Beispielprogramm, 43Besonderheiten bei HMI-Variablen vom Datentyp "UDT", 195Bibliothek

Funktionen, 91Typ-Versionen von Instanzen ermitteln, 108zugreifen auf Ordner, 93

EEditor "Geräte & Netze"

öffnen, 81Editor "Variablen"

starten, 162Enumerieren

Alle Variablen einer Variablentabelle, 142Bausteine, 147Benutzerdefinierte Bausteinordner, 145Benutzerdefinierter Ordner für PLC-Variablen, 84Geräte, 73Geräteelemente, 75PLC-Variablen, 86PLC-Variablentabellen, 87Subnetze, 79Systemunterordner, 155Unterstationen, 80

erzeugenBenutzerdefinierten Ordner für PLC-Variablentabellen, 159

ErzeugenGruppe für Baustein, 151Quelle aus Anwenderdatentyp, 152Quelle aus Baustein, 152

ExceptionsBeim Zugriff über Public APIs auf das TIA-Portal, 164

Export/ImportAnwendung, 36

ExportdateiBasisstruktur, 176Inhalt, 183Struktur der XML-Datei, 176

Exportierbare Bild-Objekte, 206Exportieren

Anwenderdatentyp, 223

Projekte über Skripte automatisierenSystemhandbuch 237

Baustein, 223Einzelne Variable oder Konstante einer PLC-Variablentabelle, 233

FFunktionen, 43

Alle Bilder löschen, 136Allgemein, 59, 68, 71Anwendungsbeispiel Public API, 51Bausteinautor abfragen, 149Bausteine enumerieren, 147Bausteinfamilie abfragen, 149Bausteinname abfragen, 149Bausteinnummer abfragen, 149Bausteintitel abfragen, 149Bausteintyp abfragen, 149Bausteinversion abfragen, 149Benutzerdefinierte Bausteinordner enumerieren, 145Benutzerdefinierte Bildordner anlegen, 134Benutzerdefinierte Ordner für HMI-Variablen anlegen, 141Benutzerdefinierte Skriptordner anlegen, 143Benutzerdefinierter Ordner für PLC-Variablen enumerieren, 84Bild löschen, 134Bildvorlage löschen, 135Eine PLC-Variablentabelle löschen, 161Eine Variable aus einer PLC-Variablentabelle löschen, 161Eine Variable aus einer Variablentabelle löschen, 143Eine Variable in eine PLC-Variablentabelle importieren, 235Eine Variable oder Konstante aus einer PLC-Variablentabelle exportieren, 233Einen benutzerdefinierten Ordner für PLC-Variablentabellen erzeugen, 159Einen benutzerdefinierten Ordner für PLC-Variablentabellen löschen, 160Geräte enumerieren, 73Geräteelemente enumerieren, 75Grafikliste löschen, 139HMI, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144Informationen einer PLC-Variablentabelle abfragen, 88Konsistenz-Attribut eines Bausteins abfragen, 149Limitierung auf Projekte des TIA-Portals V13, 71Ordner Programmbausteine abfragen, 145

PLC, 145, 147, 149, 154, 155, 159, 160, 161, 163, 233, 235PLC-Target und HMI-Target abfragen, 82PLC-Variablen enumerieren, 86PLC-Variablentabellen importieren, 233PLC-Variablentabellen in Ordnern enumerieren, 87Projekt öffnen, 71Projekt schließen, 129Projekt speichern, 120Projekte, 71, 73, 75, 82, 83, 84, 86, 87, 88, 119, 120, 129Projektgrafik löschen, 119Systemordner ermitteln, 154Systemordner für PLC-Variablen abfragen, 83Systemunterordner enumerieren, 155Textliste löschen, 138Variablen einer Variablentabelle enumerieren, 142Variablentabelle löschen, 141VB-Skript aus einem Ordner löschen, 144Verbindung löschen, 140Zeit der letzten Änderungen einer PLC-Variablentabelle lesen, 163Zeitstempel eines Bausteins abrufen, 149Zyklus löschen, 137

GGeräte enumerieren, 73Geräteelemente enumerieren, 75Globale Bibliothek

zugreifen, 92

HHardware

übersetzen, 89Hierarchie von Hardware-Objekten des Objektmodells, 49HMI-Variablen vom Datentyp "UDT", 195

IImport/Export

Ablauf beim Import, 185Alle Bildvorlagen exportieren, 220Auch Standardwerte exportieren, 183Bausteine mit Know-how-Schutz exportieren, 226Bausteine ohne Know-how-Schutz exportieren, 223

Index

Projekte über Skripte automatisieren238 Systemhandbuch

Besonderheiten bei integrierten HMI-Variablen, 194Bild aus einem Bildordner exportieren, 211Bilder eines HMI-Geräts exportieren, 210Bilder in ein HMI-Gerät importieren, 213Bildvorlagen exportieren, 218Bildvorlagen importieren, 221Datenstruktur, 176Einsatzgebiet, 173Einschränkung des Exports auf geänderte Werte, 183Einschränkungen, 173Erweiterte XML-Formate beim Import/Export von Textlisten, 201Export einer ausgewählten Variable, 192Export von Projektierungsdaten, 182Exporteinstellungen, 182Exportformat, 173Exportierbare Bild-Objekte, 206Exportierbare Objekte, 171Exportumfang, 182F-Bausteine exportieren, 227Grafiken, 181Grafiken eines Projektes exportieren, 185Grafiken in ein Projekt importieren, 186Grafikliste importieren, 203Grafiklisten exportieren, 202Grundlagen, 171HMI, 187, 188, 189, 192, 193, 194, 196, 197, 198, 199, 200, 201, 202, 203, 205, 206, 210, 211, 213, 216, 217, 218, 220, 221, 231HMI-Variable in eine Variablentabelle importieren, 193HMI-Variablentabelle exportieren, 189Import von Projektierungsdaten, 184Importierbare Objekte, 171Importverhalten über Programmcodes einstellen, 184Nur geänderte Werte exportieren, 183Offene Referenzen, 172Permanentfenster exportieren, 216Permanentfenster importieren, 217PLC, 223, 226, 227PLC-Variablentabelle exportieren, 231Projektdaten, 185, 186System-Bausteine exportieren, 227Textliste importieren, 200Textlisten exportieren, 199Variable aus Variablentabelle exportieren, 192Variablentabelle in einen Variablen-Ordner importieren, 192VB-Skripte exportieren, 196, 197

VB-Skripte importieren, 198Verbindungen exportieren, 204Verbindungen importieren, 205XML-Datei bearbeiten, 180Zyklen exportieren, 187Zyklen importieren, 188

ImportierenAnwenderdatentyp, 230Baustein, 229Einzelne Variable in eine eine PLC-Variablentabelle, 235PLC-Variablentabellen, 233

InstallationBenutzer zu Benutzergruppe hinzufügen, 28Optionspaket TIA Openness V13, 24, 34Prüfung der Zugangsberechtigung, 28Standardschritte für den Zugriff auf das TIA Portal, 33

InstanzenTyp-Versionen ermittlen, 108

Integrierte HMI-Variablen, 194

KKonfiguration

Openness-Anwendung und TIA-Portal laufen auf verschiedenen Rechnern, 19

KopierenInhalt einer Kopiervorlage in Projektordner, 106Kopiervorlage, 105

KopiervorlageInhalt in Projektordner kopieren, 106kopieren, 105

Kopiervorlagenlöschen, 116

LLesen

Zeit der letzten Änerung einer Variablentabelle, 163

LöschenAlle Bilder, 136Anwenderdatentyp, 151Baustein, 150Benutzerdefinierten Ordner für PLC-Variablentabellen, 160Bild, 134Bildvorlage, 135Eine PLC-Variablentabelle aus einem Ordner, 161

Index

Projekte über Skripte automatisierenSystemhandbuch 239

Einzelne Variable einer PLC-Variablentabelle, 161Einzelne Variable einer Variablentabelle, 143Grafikliste, 139Gruppe für Baustein, 154Programmbaustein, 150Projektgrafik, 119Textliste, 138Variablentabelle, 141VB-Skript aus einem Ordner, 144Verbindung, 140Zyklus, 137

OObjekte

Exportierbare Objekte, 171Importierbare Objekte, 171

Objektmodell, 45Öffnen

Editor "Geräte & Netze", 81Öffnen eines Projektes, 71Optionspaket installieren, 24, 34Ordner

löschen, 116

PPLC

Abgleich mit Ist-Zustand, 122Online-Verbindung aufbauen, 128Online-Verbindung trennen, 128Status ermitteln, 121vergleichen, 122

Programmbausteinlöschen, 150

Programmierübersicht, 43Projekt

Gerätetyp abfragen, 82HMI-Target abfragen, 82Öffnen, 71PLC-Target abfragen, 82Schließen, 129Speichern, 120

Projektbibliothekauf Kopiervorlagen zugreifen, 104zugreifen, 92

SSchnittstellenadresse, (abfragen)

Siemens.Engineering, 41Siemens.Engineering.Hmi, 41Siemens.Engineering.Hmi.Communication, 41Siemens.Engineering.Hmi.Cycle, 41Siemens.Engineering.Hmi.Globalization, 41Siemens.Engineering.Hmi.RuntimeScripting, 41Siemens.Engineering.Hmi.Screen, 41Siemens.Engineering.Hmi.Tag, 41Siemens.Engineering.Hmi.TextGraphicList, 41Siemens.Engineering.HW, 41Siemens.Engineering.SW, 41Software

übersetzen, 89Speichern eines Projektes, 120Starten

Bausteineditor, 159Editor "Variablen", 162

Stationsadresseabfragen, 131

Status (PLC)ermitteln, 121

Struktur der Exportdaten, 176Subnetze

enumerieren, 79Subnetzname

abfragen, 131Systemmeldungen programmgesteuert bestätigen, 68

TTIA Portal Openness

Funktionen, 43Programmierübersicht, 43Public API, 43Standardschritte für den Zugriff auf das TIA Portal, 33

TIA-Portal Openness, 17Benutzer zu Benutzergruppe hinzufügen, 28Einführung, 17Erforderliches Know how des Anwenders, 23Export/Import, 36Funktionsumfang, 17Grundkonzepte Aggregationen, 166Grundkonzepte Assoziationen, 165Grundkonzepte Prüfung der Objektgleichheit, 167Grundkonzepte Umgang mit Exceptions, 164Konfiguration, 19Typische Aufgaben, 35Voraussetzungen, 23Zugriff, 35Zugriffsrechte, 28

Index

Projekte über Skripte automatisieren240 Systemhandbuch

Typenlöschen, 116

UÜbersetzen

Hardware, 89Software, 89

Unterstationenenumerieren, 80

VVerbindung zum TIA Portal

Aufbauen, 59Verbindung zum TIA-Portal

Beenden, 71

XXML-Datei

Bearbeiten, 180Export, 183

ZZugreifen

auf Kopiervorlage in Projektbibliothek, 104

Index

Projekte über Skripte automatisierenSystemhandbuch 241

Index

Projekte über Skripte automatisieren242 Systemhandbuch


Recommended