TIAPortalOpenness FR FR

Consignes de sécurité 1
Lisezmoi
TIA Portal Openness 2
Nouveautés de TIA Portal
SIMATC Openness 3
notions de base 4
TIA Portal
Openness : Automatisation de la
création de projet Introduction 5
Configurations 6
Manuel système
TIA Portal Openness API 7
Exportation/importation 8
Principales modifications 9
Impression de l'aide en ligne
11/2019
Online help printout
Mentions légales
Signalétique d'avertissement
Ce manuel donne des consignes que vous devez respecter pour votre propre sécurité et pour éviter des dommages
matériels. Les avertissements servant à votre sécurité personnelle sont accompagnés d'un triangle de danger, les
avertissements concernant uniquement des dommages matériels sont dépourvus de ce triangle. Les
avertissements sont représentés ci-après par ordre décroissant de niveau de risque.
DANGER
signifie que la non-application des mesures de sécurité appropriées entraîne la mort ou des blessures graves.
ATTENTION
signifie que la non-application des mesures de sécurité appropriées peut entraîner la mort ou des blessures graves.
PRUDENCE
signifie que la non-application des mesures de sécurité appropriées peut entraîner des blessures légères.
IMPORTANT
signifie que la non-application des mesures de sécurité appropriées peut entraîner un dommage matériel.
En présence de plusieurs niveaux de risque, c'est toujours l'avertissement correspondant au niveau le plus élevé qui
est reproduit. Si un avertissement avec triangle de danger prévient des risques de dommages corporels, le même
avertissement peut aussi contenir un avis de mise en garde contre des dommages matériels.
Personnes qualifiées
L’appareil/le système décrit dans cette documentation ne doit être manipulé que par du personnel qualifié pour
chaque tâche spécifique. La documentation relative à cette tâche doit être observée, en particulier les consignes de
sécurité et avertissements. Les personnes qualifiées sont, en raison de leur formation et de leur expérience, en
mesure de reconnaître les risques liés au maniement de ce produit / système et de les éviter.
Utilisation des produits Siemens conforme à leur destination
Tenez compte des points suivants:
ATTENTION
Les produits Siemens ne doivent être utilisés que pour les cas d'application prévus dans le catalogue et dans la
documentation technique correspondante. S'ils sont utilisés en liaison avec des produits et composants d'autres
marques, ceux-ci doivent être recommandés ou agréés par Siemens. Le fonctionnement correct et sûr des produits
suppose un transport, un entreposage, une mise en place, un montage, une mise en service, une utilisation et une
maintenance dans les règles de l'art. Il faut respecter les conditions d'environnement admissibles ainsi que les
indications dans les documentations afférentes.
Marques de fabrique
Toutes les désignations repérées par ® sont des marques déposées de Siemens AG. Les autres désignations dans
ce document peuvent être des marques dont l'utilisation par des tiers à leurs propres fins peut enfreindre les droits
de leurs propriétaires respectifs.
Exclusion de responsabilité
Nous avons vérifié la conformité du contenu du présent document avec le matériel et le logiciel qui y sont décrits. Ne
pouvant toutefois exclure toute divergence, nous ne pouvons pas nous porter garants de la conformité intégrale. Si
l'usage de ce manuel devait révéler des erreurs, nous en tiendrons compte et apporterons les corrections
nécessaires dès la prochaine édition.
Siemens AG Numéro de référence du document: Online help printout Copyright © Siemens AG 2019.
Digital Industries Ⓟ 01/2020 Sous réserve de modifications Tous droits réservés
Postfach 48 48
90026 NÜRNBERG
ALLEMAGNE
Sommaire
1 Consignes de sécurité ................................................................................................................................17

2 Lisezmoi TIA Portal Openness ...................................................................................................................19
2.1 Lisezmoi .................................................................................................................................19
2.2 Modifications majeures dans TIA Portal Openness V16........................................................22
2.3 Notification des modifications majeures dans les prochaines versions .................................24
2.4 Remarques sur l'écriture d'un code stable à long terme ........................................................25
3 Nouveautés de TIA Portal Openness .........................................................................................................27
4 notions de base ..........................................................................................................................................29
4.1 Conditions requises pour TIA Portal Openness .....................................................................29
4.2 Installation ..............................................................................................................................30
4.2.1 Installation de TIA Portal Openness.......................................................................................30
4.2.2 Ajouter un utilisateur au groupe d'utilisateurs "Siemens TIA Openness"...............................31
4.2.3 Accéder au portail TIA............................................................................................................37
4.3 Tâches d'Openness ...............................................................................................................38
4.3.1 Possibilités d'utilisation...........................................................................................................38
4.3.2 Exportation/importation ..........................................................................................................39
4.4 Liste d'objets ..........................................................................................................................39
4.5 Définir les attributs de blocs, de DB et d'UDT. ......................................................................43
4.6 Bibliothèques standard...........................................................................................................45
4.7 Remarques sur la performance de TIA Portal Openness ......................................................45
5 Introduction.................................................................................................................................................47
6 Configurations ............................................................................................................................................49
7 TIA Portal Openness API ...........................................................................................................................53
7.1 Introduction ............................................................................................................................53
7.2 Etapes de programmation......................................................................................................53
7.3 Modèle d'objet TIA Portal Openness......................................................................................54
7.4 Blocs et types de modèle d'objet TIA Portal Openness .........................................................61
7.5 Hiérarchie des objets matériels du modèle d'objet.................................................................69
7.6 Informations sur les versions de TIA Portal Openness installées ..........................................71
7.7 Exemple d'application : Créer l'accès de l'API dans une application Windows Forms ..........72
7.8 Utilisation des exemples de code...........................................................................................77
7.9 Fonctions générales...............................................................................................................79
7.9.1 Prise en charge d'IntelliSense par TIA Portal Openness .......................................................79
Openness : Automatisation de la création de projet

Manuel système, 11/2019, Online help printout 3
Sommaire
7.9.2 Etablissement d'une connexion au portail TIA .......................................................................79

7.9.3 Pare-feu TIA Portal Openness ...............................................................................................84
7.9.4 Gestionnaire d'événements....................................................................................................85
7.9.5 Confirmer les boîtes de dialogue comportant des alarmes système par commande du
programme.............................................................................................................................87
7.9.6 Mettre fin à la connexion au portail TIA..................................................................................88
7.9.7 Interfaces de diagnostic dans TIA Portal ...............................................................................89
7.9.8 Accès en exclusivité...............................................................................................................94
7.9.9 Comportement dynamique.....................................................................................................96
7.9.10 Utilisation d'associations ........................................................................................................99
7.9.11 Utilisation de compositions.....................................................................................................99
7.9.12 Vérifier l'égalité des objets ...................................................................................................100
7.9.13 Opérations de lecture pour attributs.....................................................................................101
7.9.14 Traitement des transactions.................................................................................................103
7.9.15 Créer un objet DirectoryInfo/FileInfo ....................................................................................105
7.9.16 Prise en charge de l'autodescription pour attributs, navigateurs, actions et services ..........106
7.10 Fonctions des projets et données de projet .........................................................................109
7.10.1 Ouvrir un projet ....................................................................................................................109
7.10.2 Créer un projet .....................................................................................................................113
7.10.3 Accéder à des paramètres généraux de TIA Portal .............................................................114
7.10.4 Archiver et appeler un projet ................................................................................................118
7.10.5 Ouvrir le projet TIA Portal protégé en écriture .....................................................................122
7.10.6 Accéder à des langues.........................................................................................................123
7.10.7 Déterminer la structure et les attributs de l'objet ..................................................................125
7.10.8 Accéder au logiciel cible ......................................................................................................127
7.10.9 Accéder à des textes multilingues et les énumérer..............................................................128
7.10.10 Actualisation de la propriété de projet "Prise en charge de la simulation" ...........................129
7.10.11 Lire des attributs liés au projet .............................................................................................130
7.10.12 Suppression d'un graphique du projet..................................................................................133
7.10.13 Compiler le projet .................................................................................................................133
7.10.14 Enregistrer le projet..............................................................................................................136
7.10.15 Fermer un projet...................................................................................................................137
7.11 Fonctions pour connexions ..................................................................................................138
7.11.1 Attributs configurables d'une liaison port à port ...................................................................138
7.12 Fonctions dans les bibliothèques .........................................................................................141
7.12.1 Fonctions pour objets et instances.......................................................................................141
7.12.2 Accès aux bibliothèques globales ........................................................................................142
7.12.3 Accès à des langues de la bibliothèque globale ..................................................................144
7.12.4 Ouvrir des bibliothèques ......................................................................................................146
7.12.5 Énumérer des bibliothèques ouvertes..................................................................................148
7.12.6 Enregistrer et fermer les bibliothèques ................................................................................148
7.12.7 Archiver et appeler une bibliothèque....................................................................................150
7.12.8 Créer des bibliothèques globales.........................................................................................153
7.12.9 Accéder aux dossiers dans une bibliothèque.......................................................................154
7.12.10 Accéder aux types................................................................................................................157
7.12.11 Accéder aux types de versions ............................................................................................159
7.12.12 Accès aux blocs dans les bibliothèques...............................................................................164
7.12.13 Accéder aux instances .........................................................................................................166
7.12.14 Accéder à des modèles de copie .........................................................................................168
7.12.15 Créer la copie maîtresse d'un projet dans la bibliothèque ...................................................170
7.12.16 Créer un objet à partir d'une copie maîtresse ......................................................................172

4 Manuel système, 11/2019, Online help printout
Sommaire
7.12.17 Copier des copies maîtresse................................................................................................174

7.12.18 Déterminer les instances de type obsolètes ........................................................................175
7.12.19 Actualiser un projet ..............................................................................................................178
7.12.20 Actualiser une bibliothèque ..................................................................................................180
7.12.21 Supprimer les contenus de bibliothèque ..............................................................................181
7.13 Fonctions pour l'appel d'appareils, de réseaux et de liaisons ..............................................183
7.13.1 Ouvrir l'éditeur "Appareils & réseaux" ..................................................................................183
7.13.2 Interroger PLC Target et HMI Target ...................................................................................185
7.13.3 Accéder à des attributs d'un objet adresse ..........................................................................186
7.13.4 Appeler une voie de module ................................................................................................189
7.14 Fonctions dans les réseaux .................................................................................................191
7.14.1 Créer un sous-réseau ..........................................................................................................191
7.14.2 Accéder aux sous-réseaux...................................................................................................192
7.14.3 Accéder à des sous-réseaux internes..................................................................................193
7.14.4 Appeler l'identifiant de type de sous-réseaux.......................................................................194
7.14.5 Appeler les attributs d'un sous-réseau .................................................................................195
7.14.6 Supprimer un sous-réseau global ........................................................................................201
7.14.7 Énumérer tous les abonnés d'un sous-réseau.....................................................................201
7.14.8 Énumérer les réseaux IO d'un sous-réseau.........................................................................202
7.14.9 Accéder aux abonnés ..........................................................................................................203
7.14.10 Appeler les attributs d'un abonné.........................................................................................204
7.14.11 Relier l'abonné à un sous-réseau.........................................................................................208
7.14.12 Déconnecter un abonné d'un sous-réseau ..........................................................................208
7.14.13 Créer un réseau IO ..............................................................................................................209
7.14.14 Appeler les attributs d'un réseau IO .....................................................................................210
7.14.15 Relier IO-Connector à un réseau IO ....................................................................................210
7.14.16 Appeler le système maître ou le réseau IO d'une interface .................................................211
7.14.17 Appeler un contrôleur IO ......................................................................................................212
7.14.18 Appeler un connecteur IO ....................................................................................................213
7.14.19 Déconnecter IO-Connector d'un réseau IO ou d'un réseau maître DP................................214
7.14.20 Appeler un réseau maître DP...............................................................................................214
7.14.21 Appeler les attributs d'un réseau PROFINET IO..................................................................215
7.14.22 Supprimer un réseau maître DP ..........................................................................................217
7.14.23 Supprimer un réseau Profinet IO .........................................................................................217
7.14.24 Créer un réseau maître DP ..................................................................................................218
7.14.25 Appeler les informations de lien des ports de l'élément d'appareil du port ..........................219
7.14.26 Attributs de la connexion de port..........................................................................................220
7.14.27 Appeler les attributs d'un port...............................................................................................223
7.14.28 Énumérer les systèmes maître DP d'un sous-réseau ..........................................................224
7.14.29 Énumérer les connecteurs IO affectés.................................................................................224
7.14.30 Relier IO-Connector DP à un réseau maître DP ..................................................................225
7.14.31 Accès au profil AS-i et aux attributs de paramètre des esclaves virtuels.............................226
7.15 Fonctions sur les appareils ..................................................................................................228
7.15.1 Attributs obligatoires d'appareils ..........................................................................................228
7.15.2 Appeler l'identifiant de type des appareils et des éléments d'appareil.................................229
7.15.3 Paramétrer l'ID d'application dans l'appareil et les éléments d'appareils.............................232
7.15.4 Appeler l'ID d'application dans l'appareil et les éléments d'appareil ....................................233
7.15.5 Supprimer l'ID d'application dans l'appareil et les éléments d'appareil ................................234
7.15.6 Créer un appareil .................................................................................................................235
7.15.7 Énumérer des appareils .......................................................................................................236
7.15.8 Accéder à des appareils.......................................................................................................239

Sommaire
7.15.9 Supprimer un appareil..........................................................................................................241

7.16 Fonctions d'éléments d'appareils .........................................................................................242
7.16.1 Attributs obligatoires des éléments d'appareil......................................................................242
7.16.2 Créer et enficher un élément d'appareil ...............................................................................244
7.16.3 Déplacer un élément d'appareil dans un autre emplacement d'enfichage...........................248
7.16.4 Copier l'élément d'appareil...................................................................................................249
7.16.5 Supprimer un élément d'appareil .........................................................................................250
7.16.6 Énumérer des éléments d'appareil ......................................................................................250
7.16.7 Appeler des éléments d'appareil ..........................................................................................252
7.16.8 Accès à l'élément d'appareil en tant qu'interface .................................................................256
7.16.9 Accéder aux attributs d'une interface d'appareil I/O.............................................................257
7.16.10 Accès aux attributs de l'IoController.....................................................................................259
7.16.11 Accès aux attributs de l'IoConnector....................................................................................260
7.16.12 Accéder à un contrôleur d'adresse.......................................................................................263
7.16.13 Accéder à des adresses.......................................................................................................264
7.16.14 Accéder à l'"identifiant de matériel"......................................................................................266
7.16.15 Accéder au contrôleur d'identifiant de matériel ....................................................................266
7.16.16 Accéder aux voies d'éléments d'appareil .............................................................................267
7.16.17 Importation et exportation d'un fichier PSC..........................................................................269
7.16.18 Gestion de connexions pour les châssis d'extension...........................................................270
7.17 Fonctions sur les données d'un appareil HMI ......................................................................270
7.17.1 Vues .....................................................................................................................................270
7.17.1.1 Créer des dossiers de vues personnalisés ..........................................................................270
7.17.1.2 Supprimer la vue d'un dossier..............................................................................................271
7.17.1.3 Supprimer un modèle de vue d'un dossier...........................................................................272
7.17.1.4 Supprimer toutes les vues d'un dossier ...............................................................................272
7.17.2 Cycles ..................................................................................................................................273
7.17.2.1 Suppression de cycle ...........................................................................................................273
7.17.3 Listes de textes ....................................................................................................................274
7.17.3.1 Suppression de la liste de textes .........................................................................................274
7.17.4 Listes de graphiques ............................................................................................................275
7.17.4.1 Suppression d'une liste de graphiques ................................................................................275
7.17.5 Connexions ..........................................................................................................................275
7.17.5.1 Suppression de la liaison .....................................................................................................275
7.17.6 Table des variables ..............................................................................................................276
7.17.6.1 Générer des dossiers personnalisés pour variables IHM ....................................................276
7.17.6.2 Enumérer les variables d'une table de variables IHM ..........................................................276
7.17.6.3 Suppression de variables individuelles d'une table de variables IHM..................................277
7.17.6.4 Supprimer une table de variables d'un dossier ....................................................................278
7.17.7 Scripts VB ............................................................................................................................278
7.17.7.1 Créer des dossiers personnalisés pour les scripts...............................................................278
7.17.7.2 Supprimer les scripts VB d'un dossier..................................................................................279
7.17.8 Supprimer le dossier personnalisé d'un pupitre opérateur ..................................................280
7.18 Fonctions permettant l'accès à un appareil HMI (Unified)....................................................280
7.18.1 Liste d'objets ........................................................................................................................280
7.18.2 Objet logiciel HMI-Unified.....................................................................................................281
7.18.3 Interroger les erreurs............................................................................................................283
7.18.4 Alarmes ................................................................................................................................286
7.18.4.1 Utilisation des alarmes analogiques.....................................................................................286
7.18.4.2 Utilisation des alarmes de bit individuels .............................................................................290
7.18.4.3 Utilisation des classes d'alarmes .........................................................................................293

Sommaire
7.18.5 Logs .....................................................................................................................................296

7.18.5.1 Utilisation d'archives de données.........................................................................................296
7.18.5.2 Utilisation d'archives d'alarmes ............................................................................................299
7.18.5.3 Utilisation de variables d'archive ..........................................................................................302
7.18.6 Variables et tables de variables ...........................................................................................306
7.18.6.1 Utilisation des tables des variables ......................................................................................306
7.18.6.2 Utilisation de variables IHM..................................................................................................308
7.18.6.3 Utilisation de variables système...........................................................................................317
7.18.7 Connexions ..........................................................................................................................318
7.18.7.1 Utilisation de compositions...................................................................................................318
7.18.8 Paramètres d'exécution........................................................................................................322
7.18.8.1 Utilisation de paramètres d'exécution ..................................................................................322
7.18.9 Vues et dynamisations .........................................................................................................323
7.18.9.1 Utilisation de vues ................................................................................................................323
7.18.9.2 Objets graphiques de base ..................................................................................................328
7.18.9.3 Objets graphiques élément ..................................................................................................351
7.18.9.4 Objets graphiques de commande ........................................................................................380
7.18.9.5 Objets graphiques Instance de bloc d'affichage...................................................................402
7.18.9.6 Utilisation d'événements pour des vues/objets graphiques et des propriétés......................409
7.18.9.7 Utilisation de la dynamisation et des événements pour les vues/objets graphiques via
script.....................................................................................................................................412
7.18.9.8 Utilisation d'une dynamisation pour des vues/objets graphiques.........................................415
7.18.9.9 Vérifier la présence de la licence d'accès sur un appareil Unified .......................................419
7.18.10 Accès aux hiérarchies dans le Common Plant Model..........................................................422
7.18.10.1 Utiliser la vue de l'installation ...............................................................................................422
7.18.10.2 Utilisation de nœuds de vue de l'installation ........................................................................423
7.18.10.3 Énumérer une vue de l'installation .......................................................................................424
7.18.10.4 Utiliser la vue de l'installation et les appareils ......................................................................426
7.18.11 Accès aux instances dans le Common Plant Model ............................................................428
7.18.11.1 Utilisation d'instances d'objet CPM ......................................................................................428
7.18.11.2 Utilisation de nœuds de la vue de l'installation d'instances d'objet CPM .............................429
7.18.11.3 Énumérer les variables de l'interface d'instances d'objet CPM ...........................................431
7.18.12 Accéder aux propriétés des interfaces/variables d'archive des instances d'objets de
l'installation...........................................................................................................................432
7.18.12.1 Accès et actualisation des propriétés des variables de l'interface des instances d'objets
de l'installation CPM.............................................................................................................432
7.18.12.2 Accès et actualisation des propriétés de variables membre d'une variable d'interface .......434
7.18.12.3 Accès et actualisation des propriétés des variables de journalisation d'une variable
membre ................................................................................................................................437
7.19 Fonctions pour l'accès aux données d'un appareil API........................................................439
7.19.1 Déterminer le statut d'un API ...............................................................................................439
7.19.2 Accéder aux paramètres d'une liaison en ligne....................................................................440
7.19.3 Accès à l'empreinte pour une comparaison rapide des stations ..........................................444
7.19.4 Accès à CM DP comme esclave DP et zone de transfert....................................................452
7.19.5 Commuter l'API du système R/H en ligne ............................................................................453
7.19.6 Accéder à des conteneurs de logiciels via l'API principal d'un système R/H ......................455
7.19.7 Charger l'API d'un système R/H...........................................................................................456
7.19.8 Fonctions de chargement de données dans l'API................................................................463
7.19.8.1 Chargement du système PC ................................................................................................463
7.19.8.2 Charger des composants matériels et logiciels dans l'API...................................................466
7.19.8.3 Démarrage et arrêt d'un API ................................................................................................476
7.19.8.4 Prise en charge de rappels ..................................................................................................477

Sommaire
7.19.8.5 Protection de l'API par mot de passe ...................................................................................479

7.19.8.6 Manipulation des mots de passe d'API liée aux blocs .........................................................480
7.19.9 Fonctions permettant l'accès au service API .......................................................................481
7.19.9.1 Paramétrage des niveaux d'accès .......................................................................................481
7.19.9.2 Accès à l'interface serveur OPC UA ....................................................................................483
7.19.9.3 Accéder au total de contrôle logiciel ....................................................................................486
7.19.9.4 Affecter une interface PC .....................................................................................................486
7.19.10 Charger le matériel, le logiciel et des fichiers dans l'appareil API........................................488
7.19.11 Comparer le logiciel de l'API ................................................................................................494
7.19.12 Comparer le matériel API.....................................................................................................497
7.19.13 Etablir ou interrompre une liaison en ligne à l'API................................................................498
7.19.14 Affecter la langue du projet à l'API .......................................................................................499
7.19.15 Affecter des tables de visualisation et de forçage pour écran de serveur Web et d'API......500
7.19.16 Accès au serveur Web et à la gestion des utilisateurs OPC UA..........................................503
7.19.17 Accès aux paramètres de domaine......................................................................................506
7.19.18 Définir un mot de passe d'écran...........................................................................................508
7.19.19 Accessibilité .........................................................................................................................509
7.19.20 Actualisation de la description du module............................................................................510
7.19.21 Gérer le certificat..................................................................................................................511
7.19.22 Blocs ....................................................................................................................................514
7.19.22.1 Interroger le groupe "Blocs de programme" .........................................................................514
7.19.22.2 Interroger un groupe système pour blocs système ..............................................................515
7.19.22.3 Enumérer les sous-groupes système...................................................................................515
7.19.22.4 Enumérer les groupes Blocs personnalisés.........................................................................517
7.19.22.5 Enumérer tous les blocs.......................................................................................................518
7.19.22.6 Interroger les informations d'un bloc/type de données utilisateur ........................................519
7.19.22.7 Protéger un bloc et annuler la protection .............................................................................520
7.19.22.8 Supprimer un bloc ................................................................................................................523
7.19.22.9 Créer un groupe pour blocs .................................................................................................524
7.19.22.10 Supprimer un groupe pour blocs..........................................................................................524
7.19.22.11 Accéder aux attributs de tous les blocs................................................................................525
7.19.22.12 Créer un FB ProDiag............................................................................................................527
7.19.22.13 Accéder aux surveillances et aux propriétés du FB ProDiag ...............................................528
7.19.22.14 Lire des blocs fonctionnels ProDiag et des attributs ............................................................529
7.19.22.15 Ajouter un fichier externe .....................................................................................................530
7.19.22.16 Générer une source à partir d'un bloc..................................................................................531
7.19.22.17 Générer les blocs à partir de la source ................................................................................532
7.19.22.18 Génération à partir d'une source avec un format de source connu ....................................533
7.19.22.19 Supprimer un type de données utilisateur............................................................................536
7.19.22.20 Supprimer un fichier externe ................................................................................................536
7.19.22.21 Démarrer un éditeur de bloc ................................................................................................537
7.19.22.22 Modifier des blocs à l'aide des empreintes ..........................................................................538
7.19.22.23 Générer/supprimer des blocs pour des pages personnalisées............................................540
7.19.23 Objets technologiques..........................................................................................................542
7.19.23.1 Vue d'ensemble des objets technologiques .........................................................................542
7.19.23.2 Vue d'ensemble des objets technologiques et des versions................................................543
7.19.23.3 Vue d'ensemble des types de données ...............................................................................544
7.19.23.4 Interroger la composition des objets technologiques ...........................................................545
7.19.23.5 Créer un objet technologique ...............................................................................................546
7.19.23.6 Supprimer des objets technologiques ..................................................................................547
7.19.23.7 Compiler un objet technologique..........................................................................................548
7.19.23.8 Enumérer des objets technologiques...................................................................................549

Sommaire
7.19.23.9 Rechercher un objet technologique .....................................................................................550

7.19.23.10 Enumérer les paramètres d'un objet technologique.............................................................551
7.19.23.11 Rechercher les paramètres d'un objet technologique ..........................................................551
7.19.23.12 Lire les paramètres d'un objet technologique.......................................................................552
7.19.23.13 Ecrire les paramètre d'un objet technologique .....................................................................553
7.19.23.14 S7-1200 Motion Control .......................................................................................................555
7.19.23.15 S7-1500 Motion Control .......................................................................................................563
7.19.23.16 Régulation PID .....................................................................................................................585
7.19.23.17 Comptage.............................................................................................................................586
7.19.23.18 Easy Motion Control.............................................................................................................587
7.19.24 Variables et tables de variables ...........................................................................................587
7.19.24.1 Démarrage de l'éditeur de variables API..............................................................................587
7.19.24.2 Interroger un groupe système pour variables API................................................................588
7.19.24.3 Créer une table des variables API .......................................................................................589
7.19.24.4 Enumérer les groupes personnalisés pour variables API ....................................................589
7.19.24.5 Créer les groupes personnalisés pour variables API ...........................................................590
7.19.24.6 Supprimer les groupes personnalisés pour variables API ...................................................591
7.19.24.7 Enumérer des tables de variables API dans un dossier ......................................................592
7.19.24.8 Interroger les informations d'une table de variables API......................................................593
7.19.24.9 Lire la date et l'heure de la dernière modification d'une table de variables API...................594
7.19.24.10 Supprimer la table des variables API dans un groupe .........................................................595
7.19.24.11 Enumérer des variables API ................................................................................................595
7.19.24.12 Accéder à des variables API ................................................................................................596
7.19.24.13 Accéder à des constantes API .............................................................................................598
7.19.25 Fonctions pour unités logicielles ..........................................................................................600
7.19.25.1 Utilisation d'unités logicielles................................................................................................600
7.19.25.2 Accéder à des unités logicielles ...........................................................................................602
7.19.25.3 Accéder à des objets sur lesquels sont basés des unités logicielles ...................................604
7.19.25.4 Accéder relations aux relations existantes d'une unité ........................................................606
7.19.25.5 Actualiser les propriétés d'unités logicielles .........................................................................608
7.19.25.6 Publier un objet d'une unité logicielle ...................................................................................610
7.19.25.7 Ajouter des sources externes dans des unités ....................................................................612
7.19.25.8 Unités comme copies maîtres..............................................................................................615
7.19.25.9 Actualiser les relations existantes et créer/supprimer des relations ....................................617
7.20 Fonctions de l'interface de gestion des versions (VCI) ........................................................622
7.20.1 Accès au groupe système VCI dans le projet ......................................................................622
7.20.2 Énumérer des groupes d'utilisateurs dans un groupe VCI...................................................623
7.20.3 Créer un groupe d'utilisateurs dans un groupe VCI .............................................................624
7.20.4 Actualiser les propriétés d'un groupe VCI ............................................................................625
7.20.5 Supprimer un groupe d'utilisateurs VCI................................................................................625
7.20.6 Énumérer des Workspaces VCI dans un groupe VCI..........................................................626
7.20.7 Créer un espace de travail VCI dans un groupe VCI ...........................................................627
7.20.8 Actualiser les propriétés d'un espace de travail VCI ............................................................628
7.20.9 Supprimer un espace de travail VCI ....................................................................................629
7.20.10 Énumérer les mappages d'un espace de travail VCI dans un VCI ......................................629
7.20.11 Créer un mappage entre l'espace de travail et un espace de travail VCI ............................630
7.20.12 Actualiser les mappages dans l'espace de travail VCI.........................................................631
7.20.13 Supprimer le mappage entre espace de travail et VCI ........................................................632
7.20.14 Synchroniser le mappage d'espace de travail......................................................................633
7.21 Fonctions sur OPC...............................................................................................................636
7.21.1 Configuration du protocole de communication sécurisé pour le serveur OPC-UA ..............636

Sommaire
7.21.2 Définir la stratégie de sécurité pour OPC UA.......................................................................638

7.22 SiVArc Openness.................................................................................................................639
7.22.1 Introduction ..........................................................................................................................639
7.22.2 Propriétés de service SiVArc ..............................................................................................640
7.22.3 Copie de règles ou de groupes de règles de la bibliothèque ...............................................642
7.22.4 Recherche de règles de vue ou de groupes de règles de vue.............................................643
7.22.5 Suppression de règles et de groupes de règles...................................................................644
7.22.6 Configuration UMAC pour Openness...................................................................................645
7.22.7 Génération SiVArc ...............................................................................................................645
7.23 Openness pour CP 1604/CP 1616/CP 1626........................................................................647
7.24 Zones de transfert Openness pour coupleur PN/PN............................................................651
7.25 Modules/sous-modules Openness virtuels pour ET 200SP PN HF .....................................654
7.26 Fonctions pour SINUMERIK ................................................................................................656
7.26.1 Introduction ..........................................................................................................................656
7.26.2 Identifiant - Identification des composants ...........................................................................657
7.26.3 Notions de base ...................................................................................................................657
7.26.4 Modèle d'objet ......................................................................................................................661
7.26.5 Référence.............................................................................................................................663
7.26.5.1 DriveObject ..........................................................................................................................663
7.26.5.2 DriveObjectContainer...........................................................................................................663
7.26.5.3 DriveObjectComposition ......................................................................................................664
7.26.5.4 AddressComposition ............................................................................................................664
7.26.5.5 AddressContext....................................................................................................................666
7.26.5.6 AddressIoType .....................................................................................................................666
7.26.6 Exemple de code .................................................................................................................667
7.26.6.1 Généralités...........................................................................................................................667
7.26.6.2 Réalisation de la mise en route dans SINUMERIK ..............................................................667
7.26.6.3 Créer une NCU ....................................................................................................................667
7.26.6.4 Création d'un module NX .....................................................................................................668
7.26.6.5 Connexion du module NX avec une NCU............................................................................668
7.26.6.6 Création d'archives...............................................................................................................669
7.26.6.7 Activation de Safety Integrated ............................................................................................671
7.27 Fonctions pour SINUMERIK ONE........................................................................................672
7.27.1 Introduction ..........................................................................................................................672
7.27.2 Identification de l'identifiant des composants .......................................................................673
7.27.3 Notions de base ...................................................................................................................673
7.27.4 Modèle d'objet ......................................................................................................................677
7.27.5 Référence.............................................................................................................................679
7.27.5.1 Namespace Siemens.Engineering.MC.DriveConfiguration .................................................679
7.27.5.2 Namespace Siemens.Engineering.MC.Drives .....................................................................685
7.27.5.3 ArchiveProvider....................................................................................................................694
7.27.6 Exemple de code .................................................................................................................694
7.27.6.1 Généralités...........................................................................................................................694
7.27.6.2 Réalisation de la mise en route dans SINUMERIK ..............................................................694
7.27.6.3 Créer une NCU ....................................................................................................................695
7.27.6.4 Création d'un module NX .....................................................................................................695
7.27.6.5 Connexion du module NX avec une NCU............................................................................696
7.27.6.6 Accès aux événements du NCK ..........................................................................................696
7.27.6.7 Création d'archives...............................................................................................................698

Sommaire
7.27.6.8 Activation de Safety Integrated ............................................................................................699

7.27.6.9 Exemples de Namespace Siemens.Engineering.MC.DriveConfiguration............................700
7.27.6.10 Exemples de Namespace Siemens.Engineering.MC.Drives ...............................................704
7.28 Fonctions pour Startdrive .....................................................................................................708
7.28.1 Introduction ..........................................................................................................................708
7.28.2 TypeIdentifier - Identifiant des composants .........................................................................709
7.28.3 Références...........................................................................................................................710
7.28.3.1 AddressComposition ............................................................................................................710
7.28.3.2 AddressContext....................................................................................................................711
7.28.3.3 AddressIoType .....................................................................................................................711
7.28.3.4 ConfigurationEntry ...............................................................................................................712
7.28.3.5 DriveDomainFunctions.........................................................................................................712
7.28.3.6 DriveObject ..........................................................................................................................713
7.28.3.7 DriveObjectActivation...........................................................................................................713
7.28.3.8 DriveObjectContainer...........................................................................................................714
7.28.3.9 DriveObjectTypeHandler......................................................................................................714
7.28.3.10 DriveParameter ....................................................................................................................715
7.28.3.11 DriveParameterComposition ................................................................................................716
7.28.3.12 EncoderConfiguration ..........................................................................................................717
7.28.3.13 HardwareProjection..............................................................................................................718
7.28.3.14 MotorConfiguration...............................................................................................................719
7.28.3.15 OnlineDriveObject ................................................................................................................720
7.28.3.16 OnlineDriveObjectContainer ................................................................................................721
7.28.3.17 StartDriveDownloadCheckConfiguration..............................................................................721
7.28.3.18 SafetyTelegram....................................................................................................................721
7.28.3.19 Telegram ..............................................................................................................................722
7.28.3.20 TelegramComposition ..........................................................................................................723
7.28.3.21 TelegramType ......................................................................................................................724
7.28.3.22 TorqueTelegram...................................................................................................................725
7.28.4 Exemples de code................................................................................................................725
7.28.4.1 Déterminer l'état d'activation ................................................................................................725
7.28.4.2 Exécuter des fonctions d'entraînement ................................................................................726
7.28.4.3 Créer un groupe d'entraînement ..........................................................................................727
7.28.4.4 Créer un composant d'entraînement....................................................................................728
7.28.4.5 Déterminer un objet entraînement .......................................................................................728
7.28.4.6 Déterminer le type d'objet entraînement ..............................................................................729
7.28.4.7 Lire et écrire des paramètres FCOM....................................................................................729
7.28.4.8 Téléchargement ...................................................................................................................730
7.28.4.9 Éditer les connexions DRIVE-CLiQ......................................................................................732
7.28.4.10 Exécuter la mise en route dans Startdrive ...........................................................................733
7.28.4.11 Définir le type de capteur .....................................................................................................734
7.28.4.12 Effectuer une configuration de l'appareil ..............................................................................741
7.28.4.13 Créer un composant pour un composant d'entraînement (uniquement S120) ....................742
7.28.4.14 Définir le type de moteur et la configuration de moteur .......................................................743
7.28.4.15 Lire et écrire des paramètres ...............................................................................................745
7.28.4.16 Lire et écrire des paramètres en ligne..................................................................................747
7.28.4.17 Enregistrer le paramétrage ..................................................................................................747
7.28.4.18 Utiliser les télégrammes Safety Integrated ..........................................................................748
7.28.4.19 Insérer et étendre des télégrammes ....................................................................................749
7.28.4.20 Utiliser les télégrammes Torque ..........................................................................................750
7.28.4.21 Restaurer les réglages d'usine.............................................................................................751

Sommaire
7.29 Fonctions pour DCC.............................................................................................................751

7.29.1 Introduction ..........................................................................................................................751
7.29.2 DCC Openness ....................................................................................................................752
7.29.3 Modèle d'objet DCC Openness............................................................................................753
7.29.4 Références...........................................................................................................................753
7.29.4.1 DriveControlChartContainer.................................................................................................753
7.29.4.2 DriveControlChartComposition ............................................................................................754
7.29.4.3 DccImportOptions ................................................................................................................755
7.29.4.4 DccImportResultData ...........................................................................................................755
7.29.4.5 DriveControlChart ................................................................................................................755
7.29.4.6 Importation de la bibliothèque DCB Extension.....................................................................756
7.29.5 Exemples de codes..............................................................................................................757
7.29.5.1 Généralités...........................................................................................................................757
7.29.5.2 Accès à DriveControlChartContainer avec DriveObject.......................................................757
7.29.5.3 Appeler les diagrammes ......................................................................................................757
7.29.5.4 Accéder à des diagrammes .................................................................................................757
7.29.5.5 Importer des diagrammes ....................................................................................................758
7.29.5.6 Exporter des diagrammes ....................................................................................................758
7.29.5.7 Exporter tous les diagrammes .............................................................................................758
7.29.5.8 Appeler des diagrammes dans l'ordre chronologique d'exécution.......................................759
7.29.5.9 Trouver des diagrammes avec le nom.................................................................................759
7.29.5.10 Afficher le rapport d'importation ...........................................................................................759
7.29.5.11 Supprimer des diagrammes .................................................................................................760
7.29.5.12 Optimiser la séquence d'exécution ......................................................................................760
7.29.5.13 Importer une bibliothèque DCB Extension ...........................................................................761
7.29.6 Exceptions DCC Openness .................................................................................................762
7.29.6.1 Traitement des exceptions ...................................................................................................762
7.29.6.2 Exceptions DriveControlChart..............................................................................................764
7.29.6.3 Exceptions DriveControlChartComposition..........................................................................764
7.29.6.4 Exceptions ImportDcbLibrary ...............................................................................................765
7.30 Exceptions............................................................................................................................765
7.30.1 Traitement des exceptions ...................................................................................................765
7.30.2 Exception personnalisée ......................................................................................................768
8 Exportation/importation.............................................................................................................................773
8.1 Vue d'ensemble....................................................................................................................773
8.1.1 Notions élémentaires sur l'importation/exportation ..............................................................773
8.1.2 Domaine d'utilisation de l'importation/exportation ................................................................776
8.1.3 Importation SimaticML spécifique à la version.....................................................................777
8.1.4 Edition du fichier XML ..........................................................................................................778
8.1.5 Exportation de données de configuration.............................................................................778
8.1.6 Importation de données de configuration.............................................................................780
8.2 Importation/exportation de données du projet......................................................................782
8.2.1 Bibliothèque de graphiques..................................................................................................782
8.2.1.1 Exportation/importation de graphiques ................................................................................782
8.2.1.2 Exporter les graphiques d'un projet......................................................................................783
8.2.1.3 Importer des graphiques dans un projet ..............................................................................784
8.2.2 Textes du projet ...................................................................................................................785
8.2.2.1 Exportation de textes de projet ............................................................................................785
8.2.2.2 Importation de textes de projet.............................................................................................786

Sommaire
8.3 Importation/exportation de données d'un appareil IHM........................................................788

8.3.1 Structure d'un fichier XML ....................................................................................................788
8.3.2 Structure des données pour l'importation/exportation..........................................................790
8.3.3 Cycles ..................................................................................................................................793
8.3.3.1 Exportation de cycles ...........................................................................................................793
8.3.3.2 Importer des cycles ..............................................................................................................794
8.3.4 Table des variables ..............................................................................................................795
8.3.4.1 Exporter des tables de variables IHM ..................................................................................795
8.3.4.2 Importer une table de variables IHM ....................................................................................798
8.3.4.3 Exporter des variables individuelles d'une table de variables IHM ......................................799
8.3.4.4 Importer des variables individuelles d'une table de variables IHM.......................................800
8.3.4.5 Particularités de l'importation/exportation de variables IHM ................................................800
8.3.5 Scripts VB ............................................................................................................................802
8.3.5.1 Exporter des scripts VB........................................................................................................802
8.3.5.2 Exporter des scripts VB à partir d'un dossier .......................................................................803
8.3.5.3 Importer des scripts VB........................................................................................................804
8.3.6 Listes de textes ....................................................................................................................805
8.3.6.1 Exporter des listes de textes à partir d'un appareil IHM.......................................................805
8.3.6.2 Importer une liste de texte dans un appareil IHM ................................................................806
8.3.6.3 Formats XML avancés pour l'exportation/importation de listes de textes ............................807
8.3.7 Listes de graphiques ............................................................................................................809
8.3.7.1 Exporter les listes de graphiques .........................................................................................809
8.3.7.2 Importer les listes de graphiques .........................................................................................809
8.3.8 Connexions ..........................................................................................................................810
8.3.8.1 Exporter des connexions......................................................................................................810
8.3.8.2 Importation de connexions ...................................................................................................811
8.3.9 Vues .....................................................................................................................................812
8.3.9.1 Vue d'ensemble des objets graphiques pouvant être exportés............................................812
8.3.9.2 Exporter toutes les vues d'un appareil IHM..........................................................................816
8.3.9.3 Exporter une vue à partir d'un dossier de vues....................................................................817
8.3.9.4 Importer des vues dans un appareil IHM .............................................................................819
8.3.9.5 Exporter une fenêtre permanente ........................................................................................821
8.3.9.6 Importer une fenêtre permanente ........................................................................................822
8.3.9.7 Exporter tous les modèles de vue d'un appareil IHM...........................................................823
8.3.9.8 Exporter des modèles de vue à partir d'un dossier ..............................................................824
8.3.9.9 Importer des modèles de vue...............................................................................................826
8.3.9.10 Exportation d'une vue contextuelle ......................................................................................828
8.3.9.11 Importation d'une vue contextuelle.......................................................................................829
8.3.9.12 Exportation d'une vue encastrable .......................................................................................830
8.3.9.13 Importation d'une vue encastrable .......................................................................................832
8.3.9.14 Exportation d'une vue avec masque de saisie .....................................................................833
8.3.9.15 Importation d'une vue avec masque de saisie .....................................................................835
8.4 Exporter/importer des tables de visualisation et de forçage permanent ..............................838
8.5 Importer/exporter les données d'un appareil API .................................................................840
8.5.1 Blocs ....................................................................................................................................840
8.5.1.1 Structure XML de la section interface du bloc .....................................................................840
8.5.1.2 Modifications du modèle d'objet et format de fichier XML....................................................850
8.5.1.3 Exporter des blocs de données avec des instantanés.........................................................852
8.5.1.4 Exporter des blocs avec protection know-how.....................................................................854
8.5.1.5 Exportation/importation de blocs SCL..................................................................................854
8.5.1.6 Exportation/importation de types structurés de blocs SCL ..................................................868

Sommaire
8.5.1.7 Exportation/importation de blocs d'appel SCL .....................................................................874

8.5.1.8 Exporter/importer des commentaires multilingues dans SCL .............................................891
8.5.1.9 Exporter des blocs F ............................................................................................................892
8.5.1.10 Exporter des blocs système .................................................................................................892
8.5.1.11 Exporter des blocs GRAPH avec texte multilingue ..............................................................893
8.5.1.12 Importer un bloc ...................................................................................................................894
8.5.1.13 Exporter des blocs ..............................................................................................................896
8.5.1.14 Importer des blocs/UDT avec référence ouverte .................................................................903
8.5.1.15 Importer des blocs/UDT pour des objets de modification de structure ................................904
8.5.1.16 Exportation/importation de l'attribut de publication spécifique à l'unité des blocs et types....906
8.5.2 Tables des variables ............................................................................................................910
8.5.2.1 Exporter des tables de variables API ...................................................................................910
8.5.2.2 Importer une table de variables API.....................................................................................911
8.5.2.3 Exporter des variables ou constantes individuelles d'une table de variables API................912
8.5.2.4 Importer une seule variable ou constante dans une table de variables API ........................913
8.5.3 Objets technologiques..........................................................................................................915
8.5.3.1 Vue d'ensemble des objets technologiques et des versions................................................915
8.5.3.2 Structure XML de la section d'interface de bloc ...................................................................916
8.5.3.3 Exporter des objets technologiques .....................................................................................918
8.5.3.4 Importer des objets technologiques .....................................................................................920
8.5.3.5 S7-1200 Motion Control .......................................................................................................922
8.5.3.6 S7-1500 Motion Control .......................................................................................................925
8.5.3.7 Régulation PID .....................................................................................................................935
8.5.3.8 Comptage.............................................................................................................................936
8.5.3.9 Easy Motion Control.............................................................................................................936
8.5.4 Exporter un type de données utilisateur...............................................................................937
8.5.5 Importer un type de données utilisateur...............................................................................937
8.5.6 Exportation de données au format OPC UA XML................................................................938
8.6 Importation/exportation de données matérielles ..................................................................939
8.6.1 Format de fichier AML..........................................................................................................939
8.6.2 Pruned AML .........................................................................................................................940
8.6.3 Vue d'ensemble des objets et paramètres de l'importation/exportation CAx .......................941
8.6.4 Structure des données CAx pour l'importation/exportation ..................................................943
8.6.5 Identifiants de type AML.......................................................................................................948
8.6.6 Exportation/importation d'informations sur la BaseUnit via AML..........................................951
8.6.7 Exportation/importation d'un fichier AML en connexion avec le châssis d'extension...........954
8.6.8 Gestion de connexions pour les châssis d'extension...........................................................960
8.6.9 Exportation de données CAx ...............................................................................................961
8.6.10 Importation de données CAx................................................................................................964
8.6.11 Exporter/importer des sous-modules ...................................................................................966
8.6.12 Importer des données CAx sans adresse logique ...............................................................975
8.6.13 Exception pour l'importation et exportation de données CAx...............................................982
8.6.14 Appareils et modules Round-Trip.........................................................................................983
8.6.15 Importer AML et ignorer les artefacts inconnus ...................................................................986
8.6.16 Topologie de l'exportation/importation .................................................................................991
8.6.17 Importation d'un appareil avec des références de bibliothèque ...........................................992
8.6.18 Exportation d'un élément d'appareil .....................................................................................994
8.6.19 Importation d'un objet d'appareil ..........................................................................................998
8.6.20 Exportation/importation d'un appareil avec une adresse définie........................................1002
8.6.21 Exportation/importation d'un appareil avec des voies ........................................................1005
8.6.22 Exportation d'objets d'élément d'appareil...........................................................................1007
8.6.23 Importation d'objets d'élément d'appareil ...........................................................................1012

Sommaire
8.6.24 Exportation/importation d'appareils et éléments d'appareils basés sur GSD/GSDML.......1015

8.6.25 Exporter/importer la configuration de l'appareil avec une interface virtuelle ......................1021
8.6.26 Exportation/importation de sous-réseaux...........................................................................1024
8.6.27 Exportation/importation de réseaux IO...............................................................................1032
8.6.28 Exportation/importation de commentaires multilingues......................................................1033
8.6.29 Prise en charge des attributs avec AML AR APC 1.1 ........................................................1035
8.6.29.1 Exportation/importation de variables API ...........................................................................1035
8.6.29.2 Exportation/importation de RH/API ....................................................................................1038
8.6.29.3 Exportation/importation de AML avec des variables et éléments d'appareils
personnalisés .....................................................................................................................1040
8.6.29.4 Importation/exportation d'API de sécurité ..........................................................................1043
8.6.29.5 Importation/exportation d'E/S de sécurité ..........................................................................1049
8.6.29.6 Exporter/importer un attribut spécifique au fabricant ........................................................1050
8.6.30 Attributs AML comparés aux attributs TIA Portal Openness..............................................1051
9 Principales modifications ........................................................................................................................1055
9.1 Modifications majeures dans TIA Portal Openness V15.1.................................................1055
9.2 Modifications majeures dans TIA Portal Openness V15....................................................1057
9.3 Modifications importantes dans V14 SP1 ..........................................................................1060
9.3.1 Modifications importantes dans V14 SP1 ..........................................................................1060
9.3.2 Principales modifications dans le modèle d'objet...............................................................1063
9.3.3 Modifications apportées à la fonction du pilote ..................................................................1067
9.3.4 Modifications de l'importation et de l'exportation................................................................1072
9.3.4.1 Modifications de l'importation et de l'exportation................................................................1072
9.3.4.2 Modifications dans l'API .....................................................................................................1072
9.3.4.3 Extension des schémas .....................................................................................................1073
9.3.4.4 Modifications apportées au schéma...................................................................................1076
9.3.4.5 Modifications du comportement .........................................................................................1079
9.3.4.6 Modifications apportées aux attributs de bloc ....................................................................1090
9.4 Modifications importantes dans V14 ..................................................................................1092
9.4.1 Principales modifications du modèle d'objet ......................................................................1092
9.4.2 Avant la mise à niveau d'une application vers TIA Portal Openness V14..........................1094
9.4.3 Principales modifications de chaîne de caractères ............................................................1095
9.4.4 Importation de fichiers créés avec TIA Portal Openness V13 SP1 et des versions
antérieures .........................................................................................................................1098
Index.......................................................................................................................................................1101

Sommaire

Consignes de sécurité 1
Informations de sécurité
Siemens commercialise des produits et solutions comprenant des fonctions de sécurité
industrielle qui contribuent à une exploitation sûre des installations, systèmes, machines,
équipements et/ou réseaux.
Pour protéger les installations, les systèmes, les machines et les réseaux des cybermenaces,
il est nécessaire d'intégrer un concept de sécurité industrielle moderne complet et d'en assurer
la maintenance. Les produits et solutions de Siemens ne constituent qu’une partie d’un tel
concept.
Il incombe au client d'empêcher tout accès non autorisé à ses installations, systèmes,
machines et réseaux. Les systèmes, machines et composants doivent uniquement être
connectés au réseau d’entreprise ou à Internet dans la mesure où c’est nécessaire et en
appliquant des mesures de protection correspondantes (p. ex. utilisation de pare-feux et
segmentation du réseau).
En outre, il convient de respecter les directives de Siemens relatives aux mesures de sécurité
correspondantes. Pour plus d’informations sur la sécurité industrielle, rendez-vous sur
http://www.siemens.com/industrialsecurity
Les produits et solutions Siemens font l’objet de développements continus pour être plus sûrs.
Siemens recommande d'utiliser impérativement les mises à jour des produits dès qu'elles sont
disponibles ainsi que les versions de produits les plus récentes. L'utilisation de versions de
produits qui ne sont plus supportées et le non-respect des mises à jour les plus récentes peut
augmenter le risque d'exposition du client à des cybermenaces.
Afin d’être informé des mises à jour des produits, veuillez souscrire au flux RSS Siemens
Industrial Security à l'adresse
http://www.siemens.com/industrialsecurity

Consignes de sécurité

Lisezmoi TIA Portal Openness 2
2.1 Lisezmoi
Mesures de sécurité pour applications TIA Portal Openness

Il est recommandé
● d'installer une application TIA Portal Openness avec des droits d'administrateur dans le
dossier "Programmes".
● d'éviter le chargement dynamique d'éléments de programme tels que des Assemblies ou
DLL.
● D'exécuter l'application TIA Portal Openness avec des droits d'utilisateur.
Paramètres du matériel
Une description des paramètres du matériel est disponible dans le dossier d'installation de
TIA Portal sous Siemens\Automation\Portal V*\PublicAPI\V*\HW Parameter Description
\Openness_hardware_parameter_description.pdf .
Remarque
V* est la référence au chemin modifié en fonction de la version installée de TIA Portal.
Copie d'une application TIA Portal Openness

Lorsque vous copiez une application TIA Portal Openness exécutable, il est possible dans
certaines circonstances que le chemin de répertoire dans lequel l'application TIA Portal
Openness a été créée à l'origine soit lu par cette même application.
Solution :
Lorsque vous avez copié l'application TIA Portal Openness dans un nouveau répertoire,
ouvrez par exemple la boîte de dialogue "Propriétés", puis refermez-la pour mettre à jour le
cache de Windows.
Prise en charge de certaines fonctions dans un projet TIA Portal
Mode multi-utilisateurs
TIA Portal Openness ne prend en charge aucune opération administrative multi-utilisateurs. La
raison est que l'utilisation de TIA Portal Openness n'est pas recommandée dans des projets
multi-utilisateurs. Notez que certaines actions dans TIA Portal Openness peuvent même
perturber le bon déroulement des opérations multi-utilisateurs définies par l'interface utilisateur
de TIA Portal. Toutefois, si vous souhaitez effectuer des modifications avec TIA Portal
Openness, exportez d'abord le projet multi-utilisateurs dans un projet à utilisateur unique.

Lisezmoi TIA Portal Openness
2.1 Lisezmoi
Sécurité en cas de défaut

Si vous utilisez TIA Portal Openness, vous devez tenir compte de certaines restrictions
concernant la sécurité en cas de défaut. Pour plus d'informations, voir la documentation
"Systèmes de sécurité SIMATIC - Configuration et programmation".
Amélioration des performances de TIA Portal Openness

Pour atteindre le niveau de performance maximal de TIA Portal Openness, vous pouvez
désactiver la fonction de recherche globale de TIA Portal. Pour désactiver la recherche globale,
utilisez l'interface utilisateur ou l'appel de TIA Portal Openness API. À la fin de l'exécution de
l'application TIA Portal Openness, vous pouvez de nouveau activer la recherche globale. La
désactivation de la recherche globale permet certes d'améliorer le niveau de performance,
mais toutes les fonctions TIA Portal Openness sont opérationnelles normalement même
lorsque la recherche globale est activée.
Code du programme à thread sécurisé

Assurez-vous que votre code est à thread sécurisé : un événement apparaît dans différents
threads.
Comportement d'exportation d'éléments d'écran avec style activé

Lors de l'exportation d'un élément d'écran avec style activé, les attributs de l'élément de style
ne sont pas exportés, mais uniquement les attributs de l'élément d'écran avant l'activation du
style. Lorsqu'un style est sélectionné et que "UseDesignColorSchema" est activé pour
l'élément d'écran, ce dernier prend les valeurs des attributs du style sur l'interface utilisateur.
Toutefois, dans la base de données, les attributs définis avant la sélection du style restent
enregistrés pour cet élément d'écran. TIA Portal Openness exporte les valeurs réellement
enregistrées dans la base de données.
Lorsque le style est désactivé puis réactivé et que l'élément d'écran est à nouveau exporté, ce
sont les valeurs des attributs applicables dans l'élément de style qui sont exportées pour cet
élément d'écran. Les valeurs d'attributs de l'élément de style sélectionné pour cet élément
d'écran sont enregistrées dans la base de données lorsque "UseDesignColorSchema" n'est
pas activé.
Ce problème peut être résolu de la manière suivante :
1. Affectez l'élément d'écran à l'élément de style :
– La base de données contient les valeurs d'attributs valables avant l'activation du style.
– L'interface utilisateur reprend les attributs directement de l'élément de style.
2. Exportez l'élément d'écran affecté à l'élément de style :
– Le fichier XML contient les valeurs des attributs issues de la base de données, qui
correspondent aux valeurs antérieures à l'activation du style.
3. Désactivez "UseDesignColorSchema" :
– Les valeurs des attributs de l'élément de style sont ajoutées aux attributs de l'élément
d'écran dans la base de données.

2.1 Lisezmoi
4. Activez "UseDesignColorSchema" :
– Les valeurs des attributs de l'élément d'écran ne sont pas modifiées dans la base de
données et correspondent toujours à celles de l'étape 3.
– L'interface utilisateur reprend les attributs directement de l'élément de style.
5. Exportez l'élément d'écran affecté à l'élément de style :
– Le fichier XML contient les valeurs des attributs issues de la base de données, qui ont
été définies à l'étape 3 et qui correspondent aux valeurs de l'élément de style.
Copie des objets technologiques de S7-1500 pour la commande des mouvements

La copie de TO_CamTrack, TO_OutputCam ou TO_MeasuringInput à partir de la bibliothèque
de projet ou de la bibliothèque globale dans le projet n'est pas possible.
Importation des esclaves ASi via AML

Si l'un des esclaves ASI suivants est importé par le biais d'un fichier AML alors la version du
firmware de l'élément de l'appareil doit être placée dans tous les cas sur V13.0 :
● ASIsafe FS400 RCV-B: 3SF7 844-*B***-***1
● ASIsafe FS400 RCV-M: 3SF7 844-*M***-***1
● ASIsafe FS400 TRX-M: 3SF7 844-*M***-**T0
● ASIsafe FS400 RCV-C: 3SF7 844-*T***-***1
Importation et exportation de touches de fonction

Les touches de fonction sont synchronisées lors de l'importation. Si une touche de fonction est
créée dans un écran global et si la touche dans l'écran est vide, la touche de fonction
correspondante utilise la définition globale dans tous les écrans.
Si vous voulez désactiver l'utilisation globale de touches de fonction après l'importation,
définissez des touches vides dans les écrans et importez les types d'écrans dans l'ordre
suivant : écran global, modèles, écrans.
Si, lors de l'exportation d'écrans, vous voulez vous assurer que la définition globale d'une
touche de fonction n'est pas utilisée par le modèle ou par l'écran global, créez une touche de
fonction vide dans l'écran. Sélectionnez les touches de fonction requises dans l'écran. Puis
activez la propriété "Utiliser affectation globale" et désactivez-la de nouveau.
Accès à un appareil en ligne

L'écriture d'attributs dans un appareil en ligne n'est pas prise en charge. La lecture d'attributs
est prise en charge.
La coupure d'un sous-réseau pendant que l'appareil est en ligne n'est pas prise en charge.

2.2 Modifications majeures dans TIA Portal Openness V16
Attributs spécifiques aux instances lors de l'importation de blocs avec TIA Portal Openness
Dans certaines situations, les règles d'importation peuvent entraîner la perte des attributs
spécifiques aux instances comme p. ex. les valeurs de démarrage.
Informations sur des fonctions spécifiques

Référez-vous aux rubriques de FAQ dans le Siemens Industry Online Support pour plus
d'informations sur les fonctions Openness suivantes :
● Archiver/Restaurer un projet
● Exporter/importer une table de visualisation
Modifications
Si vous avez tenu compte des remarques concernant la programmation dans plusieurs
versions et n'avez pas mis à jour votre projet à la version V16, vos applications fonctionnent
sans aucune restriction sur tout ordinateur, même lorsque seul TIA Portal V16 est installé.
Si vous mettez à jour votre projet à la version V16, il est nécessaire de recompiler votre
application avec la SiemensEngineering.dll de version V16. Dans certains cas, il peut être
nécessaire d'adapter le code de votre application.
Exportation de blocs de données avec l'option "Aucun"

À partir de TIA Portal Openness V16, les parties protégées en écriture d'un bloc de données
sont exportées sous forme d'éléments d'information. Il est désormais impossible de modifier
les attributs correspondants dans le fichier XML exporté.
Attributs d'adresse de I&M et PROFIsafe pour panneaux de touches et boutons-poussoirs

À partir de TIA Portal Openness V16, les attributs d'adresse de I&M et PROFIsafe pour les
panneaux de touches et boutons-poussoirs se trouvent au niveau du module.
Exportation d'attributs de bloc de données de la propriété "Structure de la mémoire"

À partir de TIA Portal Openness V16, les blocs de données d'instance de FB, les attributs de
DB ARRAY et les blocs GRAPH sont exportés avec ReadOnly="True".
Attributs non pris en charge dans les unités

À partir de TIA Portal Openness V16, l'importation incohérente de blocs d'unité et de types de
données utilisateur (UDT) avec l'attribut "Access" est prise en charge, avec une exception pour
les tables de variables.

Définition du schéma du fichier XML de SimaticML

À partir de TIA Portal Openness V16, la valeur par défaut de l'attribut SystemDefined pour
l'abonné de l'attribut booléen dans la définition du schéma du fichier XML est modifiée de
SimaticML à "False". Cette modification n'a toutefois aucune répercussion sur les fonctions
d'exportation/importation de fichiers XML. Elle est pertinente uniquement pour les utilisateurs
qui essaient de générer des fichiers XML à l'aide du fichier modèle.
Amélioration de la méthode d'importation XML pour les blocs et les types

À partir de TIA Portal Openness V16, la nouvelle méthode d'importation dispose de paramètres
supplémentaires (path, importOptions et swImportOptions) ainsi que de la nouvelle valeur
d'énumération IgnoreUnitAttribute. Avec swImportOptions.IgnoreUnitAttributes, vous pouvez
importer un bloc à partir d'une unité dans un ensemble de non-unités.
Des GUID AML sont enregistrés dans des ID d'application

À partir de TIA Portal Openness V16, des GUID AML sont enregistrés dans l'attribut
CustomIdentity (ID d'application) et non plus dans le Comment, afin de prendre en charge le
remplacement direct de l'appareil et du module.
Nom de classes d'objets IHM

À partir de TIA Portal Openness V16, le tableau suivant contient une liste des modifications de
nom requises pour les classes d'objets IHM :
Nom de la classe Nouveau nom de la classe

AnalogAlarmComposition HmiAnalogAlarmComposition
DiscreteAlarmComposition HmiDiscreteAlarmComposition
AlarmClassComposition HmiAlarmClassComposition
DataLogComposition HmiDataLogComposition
AlarmLogComposition HmiAlarmLogComposition
LoggingTagComposition HmiLoggingTagComposition
LogConfiguration DataLog
Nom de propriété pour l'archive de données/archive d'alarmes ajouté/supprimé

À partir de TIA Portal Openness V16, les nouvelles propriétés suivantes "StorageDevice" et
"StorageFolder" sont ajoutées au DataLog/AlarmLog (archive de données/archive d'alarmes)
et les propriétés comme "StoragePath" et "RequireExplicitRelease" sont supprimées dans
DataLog/AlarmLog et ScreenItems.
Vous trouverez ici l'exemple de code actualisé pour les propriétés StorageDevice et
StorageFolder :
HmiDataLog dataLog = hmiSoftware.DataLogs.Find("DataLog1");

dataLog.Settings.StorageDevice = DeviceNode.Local;
dataLog.Settings.StorageFolder = @"D:\workdir\DataLogs";

2.3 Notification des modifications majeures dans les prochaines versions
Nom de propriété supprimé de HMI Tag

La propriété 'DisplayName' est supprimée de l'objet HMI Tag à partir de TIA Portal Openness
V16.
2.3 Notification des modifications majeures dans les prochaines versions
Notification des modifications

La TIA Portal Openness API sera modifié dans une version ultérieure. Il n'y a pas besoin de
changer immédiatement le code de votre application car les applications fonctionnent sans
aucune restriction sur la base de versions antérieures. Mais, pour les nouvelles applications,
il est recommandé d'utiliser les nouvelles fonctionnalités et de planifier le recodage votre
application car, à partir de V17, les méthodes suivantes ne sont plus prises en charge.
● Type de compositions et d'affectations
Type de compositions et d'affectations

Les types suivants sont modifiés afin d'afficher le comportement d'image de couple :
● AddressAssociation
● AddressComposition
● AddressControllerAssociation
● ChannelComposition
● DeviceItemAssociation
● DeviceItemComposition
● HwIdentifierAssociation
● HwIdentifierComposition
● HwIdentifierControllerAssociation
● IoConnectorComposition
● IoControllerComposition
Simocode Openness
Notez que tous les paramètres de la table de vérité peuvent certes être utilisés dans
Openness V15.1, mais que leur mise en œuvre sera modifiée dans la version V16.
Au lieu de définir chaque bit individuellement, il sera possible de paramétrer tous les bits de
sortie d'une table de vérité avec une opération Array rapide.
Si vous voulez continuer à utiliser votre application Openness existante dans la version V16,
vous devez adapter le cas échéant votre code au nouveau contexte.

2.4 Remarques sur l'écriture d'un code stable à long terme
Conducteur externe d'un Energy Meter

Les conducteurs externes d'un Energy Meter étaient exécutés sous forme de voie. À partir de
V16, ils sont paramétrés comme des structures basées sur des types de données complexes.
Pour de nouvelles applications, il est recommandé d'utiliser des conducteurs externes sous
forme de structure.
Changement de version
Si vous tenez compte de quelques remarques concernant l'écriture d'un code stable à long
terme, vous serez en mesure d'utiliser votre application avec d'autres versions de TIA Portal
sans modifier son code.
Remarque
V* et *.ap* dans le document est la référence au chemin modifié en fonction de la version
installée de TIA Portal et de l'extension.
Chemin d'accès au registre et fichier appconfig

Des modifications sont nécessaires pour modifier le chemin au registre et au fichier de
configuration de l'application. Exemple :
"C:\Programmes\Siemens\Automation\Portal V14\PublicAPI\V14
SP1\Siemens.Engineering.dll"
doit être modifié en
"C:\ProgrammeSiemens\Automation\Portal V*\PublicAPI\V*\Siemens.Engineering.dll".
Pour écrire un code stable à long terme, le chemin d'accès au registre doit être configurable et
le fichier de configuration de l'application doit être actualisé.
Chemin d'installation
Des modifications sont nécessaires pour modifier le chemin d'installation de TIA Portal.
Exemple :
"C:\Programmes\Siemens\Automation\Portal V14\PublicAPI\V14
SP1\Siemens.Engineering.dll"
doit être changé en
"C:\Programme\Siemens\Automation\Portal V*\PublicAPI\V*\Siemens.Engineering.dll".
Pour écrire un code stable à long terme, le chemin d'installation doit être configurable.

Chemin d'accès de AmiHost

Des modifications sont nécessaires pour modifier le chemin d'accès à AmiHost. Exemple :
"C:\Programmes\Siemens\Automation\Portal V14\bin
\Siemens.Automation.Cax.AmiHost.exe"
doit être changé en "C:\Programmes\Siemens\Automation\Portal V15\bin
\Siemens.Automation.Cax.AmiHost.exe".
Pour écrire un code stable à long terme, le chemin d'accès à AmiHost doit être configurable.
Extensions de fichiers de projet et bibliothèques de TIA Portal

Des modifications sont nécessaires pour modifier les extensions des fichiers de projet et des
bibliothèques de TIA Portal. Exemple :
*.ap14
doit être changé en
*.ap15.
Pour écrire un code stable à long terme, les extensions des fichiers de projet et des
bibliothèques de TIA Portal doivent être configurables.
Ouverture d'un projet

Pour écrire un code stable à long terme, la méthode Projects.OpenWithUpgrade doit être
utilisée au lieu de la méthode Projects.Open.
Hiérarchie lors de la comparaison, la compilation ou le téléchargement de résultats

La hiérarchie et/ou l'ordre lors de la comparaison, de la compilation ou du téléchargement de
résultats peut changer selon la version.
Pour écrire un code stable à long terme, vous devez éviter d'émettre des hypothèses quant à
la profondeur et à l'ordre de certains résultats.
La mise en page de catégorie est conçue pour être stable sur le long terme en ce qui concerne
les noms de type univoques CompilerResult, CompareResult, DownloadResult, et
UploadResult. Il existe également une nouvelle catégorie de résultats : UploadResult. Le
contenu, la hiérarchie et l'ordre suivent l'affichage dans l'interface utilisateur de la version
actuellement exécutée ou installée de TIA Portal

Nouveautés de TIA Portal Openness 3
Compatibilité et stabilité à long terme
● Les assemblages "Siemens.Engineering.dll"
Comme les assemblages "Siemens.Engineering.dll" de V14 SP1, V15, V15.1 et V16 sont
contenues dans la fourniture, les applications basées sur V14 SP1, V15 et V15.1
fonctionnent également sans modification dans V16. Pour pouvoir utiliser les fonctions de
la version V16, vous devez intégrer les DLL de V16 et compiler de nouveau l'application.
Les assemblages "Siemens.Engineering.dll" se trouvent dans le répertoire d'installation
sous "PublicAPI\\[version]\". Par exemple, le fichier dll pour V14 SP1 se trouve sous
"C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V14
SP1\Siemens.Engineering.dll".
● Exportation de fichiers SIMATIC-ML
Avec les assemblages "Siemens.Engineering.dll" de V14 SP1, V15, V15.1 et V16 sont
créés les fichiers SIMATIC-ML de la version V16 de TIA Portal.
● Importation de fichiers SIMATIC-ML
Chaque version d'assemblages "Siemens.Engineering.dll" permet d'importer des fichiers
SIMATIC-ML depuis la même version et depuis toute version antérieure prise en charge.
Exemple : les fichiers SIMATIC-ML de V15 peuvent être importés avec les assemblages
"Siemens.Engineering.dll" de V16. Les fichiers SIMATIC-ML de V16 peuvent être importés
avec les assemblages "Siemens.Engineering.dll" de V15.
Remarque
Le numéro de version V* fait référence à la version installée de l'API TIA Portal Openness.
Pour plus d’informations sur les modifications du modèle d'objet, référez-vous à "Modifications
majeures dans TIA Portal Openness V16".
Nouvelles fonctions
Les nouvelles fonctions et innovations suivantes sont disponibles dans TIA Portal Openness
V16. Vous trouverez des détails sur les thèmes abordés dans les différentes rubriques de la
documentation produit.
● Mémentos spécifiques à l'utilisateur pour l'identification d'appareils et de modules
● Interroger en ligne des totaux de contrôle d'API pour matériels et logiciels
● Prise en charge des unités logicielles
● Prise en charge de l'exportation/importation d'objets technologiques
● Prise en charge de l'interface de gestion des versions (VCI)

Nouveautés de TIA Portal Openness
● Extensions pour les exportations et importations CAx concernant

la prise en charge de l'AR APC V1.1
Utilisation d'objets depuis les bibliothèques
Prise en charge de modules de base ET200SP
● Extension pour la prise en charge de la configuration matérielle quant à
la configuration du serveur OPC UA et la gestion des utilisateurs
Gestion des certificats
Configuration du serveur Web et gestion des utilisateurs
Tables de visualisation pour serveur web et affichage
● Prise en charge de la configuration de WinCC Unified
● Prise en charge de SiVArc par rapport à
l'élaboration et la modification de règles SiVArc
● Prise en charge de la technique de sécurité, même en cas de paramétrage d'un mot de
passe pour le programme de sécurité

notions de base 4
4.1 Conditions requises pour TIA Portal Openness
Conditions préalables à l'utilisation d'applications TIA Openness

● Un produit basé sur TIA Portal est installé sur le PC, tel que "STEP 7 Professional" ou
"WinCC Professional".
● "TIA Portal Openness" est installé sur le PC.
Voir Installation de TIA Portal Openness (Page 30)
Systèmes d'exploitation Windows pris en charge

Le tableau suivant montre les combinaisons du système d'exploitation Windows, de TIA Portal
et de l'application utilisateur qui sont compatibles :
Système d'exploitation Windows TIA Portal Application utilisateur

64 bits 64 bits 32 bits, 64 bits et AnyCPU
Conditions préalables à la programmation d'applications TIA Portal Openness

● Microsoft Visual Studio 2015 Update 1 ou une version supérieure avec .Net Framework
SDK 4.6.2 et le Windows Classic Desktop package
Savoir-faire nécessaire de l'utilisateur

● Connaissances en ingénierie système
● Connaissances avancées de Microsoft Visual Studio 2015 Update 1 ou d'une version
supérieure avec .Net Framework SDK 4.6.2
● Connaissances avancées de C# / VB.net et .Net Framework
● Connaissances sur l'utilisation de TIA Portal
Canaux Remoting TIA Portal Openness

Les canaux Remoting TIA Portal Openness sont enregistrés comme type IpcChannel, le
paramètre "ensureSecurity" étant mis sur "false".
Remarque
Evitez d'enregistrer un autre IpcChannel avec le paramètre "ensureSecurity" différent de
"false" et une priorité supérieure ou égale à "1".

notions de base
4.2 Installation
Les attributs suivants sont définis pour l'IpcChannel :
Attribut Paramètres
"name" et "portName" Mis sur $”{Process.Name}_{Process.Id}” ou $”{Process.Na‐
me}_{Process.Id}_{AppDomain.Id}” si enregistré dans un au‐
tre AppDomain que l'AppDomain par défaut de l'application.
“priority” Mis à la valeur par défaut "1".
“typeFilterLevel” Mis sur "Complet".
“authorizedGroup” Mis sur la chaîne de caractères de la valeur de compte NT
pour le compte d'utilisateur intégré (c.-à-d. Tous)
Voir aussi
Ajouter un utilisateur au groupe d'utilisateurs "Siemens TIA Openness" (Page 31)
4.2 Installation
4.2.1 Installation de TIA Portal Openness
Introduction
"TIA Portal Openness" est installé via la case à cocher pour TIA Portal Openness (sous
Options) lors de l'installation de TIA Portal.
Conditions
● Le matériel et les logiciels de l'appareil de programmation ou du PC sont conformes à la
configuration système requise.
● Vous détenez les droits d'administrateur.
● Les programmes en cours d'exécution ont été fermés.
● La fonction d'exécution automatique est désactivée.
● WinCC et/ou STEP 7 est/sont installé(s).
● Le numéro de version de "TIA Portal Openness" correspond aux numéros de version de
WinCC et STEP 7.
Remarque
Lorsqu'une version antérieure de TIA Portal Openess est déjà installée, la version actuelle est
installée parallèlement.

notions de base
4.2 Installation
Marche à suivre
Pour installer TIA Portal Openness, assurez-vous que la case à cocher pour TIA Portal
Openness est activée pendant l'installation de TIA Portal. Procédez comme suit pour contrôler
l'installation de TIA Openness.
1. Dans le menu "Configuration", sélectionnez le répertoire "Options".
2. Cochez la case pour TIA Portal Openness.
3. Cliquez sur "Next" puis sélectionnez l'option requise.
Suivez la procédure d'installation de TIA Portal pour compléter l'installation de TIA Portal
Openness.
Résultat
TIA Portal Openness est installé sur le PC. En outre, le groupe d'utilisateurs local "Siemens TIA
Openness" est créé.
Remarque
Le complément "TIA Portal Openness" ne suffit pas pour continuer d'avoir accès à TIA Portal.
Vous devez être membre du groupe d'utilisateurs "Siemens TIA Openness" (voir Ajouter un
utilisateur au groupe d'utilisateurs "Siemens TIA Openness" (Page 31)).
4.2.2 Ajouter un utilisateur au groupe d'utilisateurs "Siemens TIA Openness"
Introduction
Lorsque vous installez TIA Portal Openness sur le PC, le groupe d'utilisateurs "Siemens TIA
Openness" est automatiquement créé.
Chaque fois que vous accédez à TIA Portal avec votre application TIA Portal Openness, TIA
Portal vérifie si vous êtes membre du groupe d'utilisateurs "Siemens TIA Openness", soit
directement ou indirectement via un autre groupe d'utilisateurs. Si vous êtes membre du
groupe d'utilisateurs "Siemens TIA Openness", l'application TIA Portal Openness démarre et
établit une liaison à TIA Portal.

notions de base
4.2 Installation
Marche à suivre
Vous ajoutez un utilisateur au groupe d'utilisateurs "Siemens TIA Openness" grâce à des
applications de votre système d'exploitation. Le portail TIA ne prend pas en charge ce
processus.
Remarque
En fonction de la configuration de votre domaine ou de votre PC, les droits d'administrateur
sont requis pour l'extension d'un groupe d'utilisateurs.
Avec le système d'exploitation Windows 7 (avec l'anglais comme langue paramétrée), vous
pouvez par exemple ajouter un utilisateur au groupe d'utilisateurs comme suit :
1. Sélectionnez "Start" > "Control Panel".
2. Double-cliquez dans le panneau de configuration sur "Administrative Tools".

notions de base
4.2 Installation
3. Cliquez sur "Computer Management" pour ouvrir la boîte de dialogue de configuration du

même nom.
4. Sélectionnez "Local Users and Groups > Groups" pour afficher tous les groupes
d'utilisateurs créés.
5. Dans la liste des groupes d'utilisateurs, sélectionnez dans le volet à droite l'entrée "Siemens
TIA Openness".

notions de base
4.2 Installation
6. Sélectionnez la commande de menu "Action > Add to Group...".
La boîte de dialogue des attributs du groupe d'utilisateurs s'ouvre :

notions de base
4.2 Installation
7. Cliquez sur "Add".

Une boîte de dialogue de sélection regroupant les utilisateurs pouvant être sélectionnés
s'ouvre alors :
8. Entrez un nom d'utilisateur valide dans le champ de saisie.

Remarque
Cliquez sur le bouton "Check Names" pour vérifier si l'utilisateur saisi dispose d'un compte
utilisateur valable pour ce domaine ou cet ordinateur.
Le champ "From this location" affiche le domaine ou le nom de l'ordinateur du nom
d'utilisateur saisi. Vous pouvez obtenir des informations supplémentaires auprès de votre
administrateur système.

notions de base
4.2 Installation
9. Confirmez votre sélection par "OK".

Le nouvel utilisateur s'affiche alors dans la boîte de dialogue des attributs du groupe
d'utilisateurs.
Vous saisissez d'autres utilisateurs à l'aide du bouton "Add".

10.Cliquez sur "OK" pour mettre fin à cette opération.
11.Connectez-vous de nouveau au PC pour que les modifications deviennent effectives.

notions de base
4.2 Installation
4.2.3 Accéder au portail TIA
Vue d'ensemble
2UGLQDWHXUGHFRQILJXUDWLRQ
9RWUH 6LHPHQV
SURJUDPPH (QJLQHHULQJGOO
3URFHVVXV 3URMHWSRXU
7,$3RUWDO PDFKLQH
Marche à suivre
1. Pour accéder et lancer TIA Portal, configurez votre environnement de développement.
2. Dans votre programme, créez une instance de l'objet de l'application de TIA Portal pour
démarrer ce dernier.
3. Cherchez le projet souhaité et ouvrez-le.
4. Accédez aux données de projet.
5. Fermez le projet et quittez le portail TIA.
Voir aussi
Etablissement d'une connexion au portail TIA (Page 79)
Mettre fin à la connexion au portail TIA (Page 88)

notions de base
4.3 Tâches d'Openness
4.3 Tâches d'Openness
4.3.1 Possibilités d'utilisation
Introduction
TIA Portal Openness vous offre différentes possibilités d'accès à TIA Portal et une sélection de
fonctions pour des tâches définies.
Vous accédez aux zones suivantes de TIA Portal par le biais de l'interface TIA Portal Openness
API :
● Données de portail
● Données du projet
● Données API
● Données IHM
● Paramètres d'entraînement
Remarque
L'interface TIA Portal Openness API ne doit pas servir à procéder à des contrôles ou à créer
des données utilisées pour la réception/validation d'une installation de sécurité. Seuls une
impression de sécurité réalisée avec le progiciel STEP 7 Safety ou le test fonctionnel
conviennent pour une réception/validation. La TIA Portal Openness API ne saurait les
remplacer.
Accéder à TIA Portal

Avec TIA Portal Openness , vous disposez de différentes possibilités d'accès à TIA Portal. Ce
faisant, vous créez une instance externe de TIA Portal dans le processus, avec ou sans
interface utilisateur. Vous pouvez également accéder en parallèle à des processus en cours de
TIA Portal.
Accéder aux projets et données de projet

Lorsque vous accédez à des projets et des données de projet, vous utilisez TIA Portal
Openness principalement pour les tâches suivantes :
● Ouvrir, fermer et enregistrer un projet
● Enumérer et interroger des objets
● Créer des objets
● Supprimer des objets

notions de base
4.4 Liste d'objets
4.3.2 Exportation/importation
Introduction
TIA Portal Openness prend en charge l'importation et l'exportation de données de projet au
moyen de fichiers XML. La fonction d'importation/exportation permet la configuration externe
de données d'ingénierie existantes. Vous utilisez cette fonction pour rendre votre processus
d'ingénierie plus efficace et éviter les erreurs.
Utilisation
Vous utilisez la fonction d'importation/exportation aux fins suivantes :
● Echange de données
● Copie de parties d'un projet
● Traitement externe de données de configuration, par exemple pour des opérations sur
données de masse avec rechercher et remplacer
● Traitement externe de données de configuration pour de nouveaux projets sur la base de
configurations existantes
● Importation de données de configuration générées en externe, telles que des listes de
textes et des variables
● Mise à disposition de données de projet pour des applications externes
4.4 Liste d'objets
Introduction
Les tableaux suivants indiquent les objets disponibles, y compris Runtime Advanced et si ces
objets sont pris en charge par TIA Portal Openness.
Ni le logiciel de visualisation Runtime Professional ni les fichiers de proxy d'appareil ne sont
pris en charge par TIA Portal Openness dans WinCC.
Objets
Selon le pupitre opérateur que vous utilisez vous pouvez avoir recours aux données de projet
suivantes :
Tableau 4-1 Vues
Objet Basic Panels Comfort Panels Mobile Panels RT Advanced

Vue oui oui oui oui
Vue globale oui oui oui oui
Modèles oui oui oui oui
Fenêtre permanente non oui oui oui

notions de base
4.4 Liste d'objets

Vue contextuelle non oui oui oui
Vue Slide-in non oui oui oui
Tableau 4-2 Objets de vue

Ligne oui oui oui oui
Ligne polygonale non oui oui oui
Polygone non oui oui oui
Ellipse oui oui oui oui
Segment d'ellipse non non non non
Segment de cercle non non non non
Arc d'ellipse non non non non
Affichage caméra non non non non
Arc de cercle non non non non
Cercle oui oui oui oui
Affichage PDF non non non non
Rectangle oui oui oui oui
Connecteur non non non non
Champ de texte oui oui oui oui
Affichage graphique oui oui oui oui
Tuyau non non non non
Double raccord en T non non non non
Raccord en T non non non non
Coude non non non non
Champ d'E/S oui oui oui oui
Champ date/heure oui oui oui oui
Champ d'E/S graphique oui oui oui oui
Champ de texte éditable non non non non
Champ de liste non non non non
Zone de liste déroulante non non non non
Bouton oui oui oui oui
Bouton rond non non non non
Bouton-poussoir lumi‐ non non oui non
neux
Commutateur oui oui oui oui
Champ d'E/S symboli‐ oui oui oui oui
que
Commutateur à clé non non oui non
Bargraphe oui oui oui oui
Bibliothèque d'icônes non oui oui oui

notions de base
4.4 Liste d'objets

Curseur non oui oui oui
Barre de défilement non non non non
Case à cocher non non non non
Bouton d'option non non non non
Instrument à aiguille non oui oui oui
Horloge non oui oui oui
Vue de l'espace mémoi‐ non non non non
re
Touches de fonction oui oui oui oui
Instances de bloc d'affi‐ non oui oui oui
chage
Fenêtre de vues non non non non
Vue des utilisateurs oui oui oui oui
Navigateur HTML non non non non
Travail d'impression/ non non non non
Diagnostic de script
Vue de recette non non non non
Vue des alarmes non non non non
Indicateur d'alarme non non non non
Fenêtre d'alarmes non non non non
Affichage d'analyse des non oui 1)
oui oui
critères
Vue d'ensemble ProDiag non oui 1) oui oui
Vue d'ensemble GRAPH non oui 1)
oui oui
Affichage de code API non oui 1)
oui oui
Vue de courbes f(x) non non non non
Vue de courbes f(t) non non non non
Vue tabellaire non non non non
Table des valeurs non non non non
Media Player non non non non
Diagnostic de voie non non non non
WLAN - Réception non non non non
Zone - Nom non non non non
Zone - Signal non non non non
Nom de la plage d'action non non non non
Nom de la plage d'action non non non non
(RFID)
Signal de la plage d'ac‐ non non non non
tion
Etat de chargement non non non non
Molette non non oui non
Indicateur d'aide non non non non
Vue Sm@rtClient non non non non

notions de base
4.4 Liste d'objets

Visualisation/forçage non non non non
Vue de diagnostic systè‐ non non non non
me
Fenêtre de diagnostic non non non non
système
1) Seuls les Mobile Panels avec une version d'appareil supérieure à 12.0.0.0 prennent en
charge cet objet écran
Tableau 4-3 Dynamiquement

Affichage oui oui oui oui
Commande opérateur non oui oui oui
Visibilité oui oui oui oui
Déplacements oui oui oui oui
Tableau 4-4 Objets supplémentaires

Groupes oui oui oui oui
Touches programma‐ oui oui oui oui
bles
Cycles oui oui oui oui
Scripts VB non oui oui oui
Listes de fonctions oui oui oui oui
Bibliothèque de graphi‐ oui oui oui oui
ques
Tableau 4-5 Variables

Variables multiplex oui oui oui oui
Tableaux oui oui oui oui
Types de données utili‐ oui oui oui oui
sateur
Interne non oui oui oui
Occurrences des types oui oui oui oui
de données élémentai‐
res
Occurrences de types oui oui oui oui
de données utilisateur
Occurrence de ta‐ oui oui oui oui
bleaux

notions de base
4.5 Définir les attributs de blocs, de DB et d'UDT.
En outre, TIA Portal Openness prend en charge toutes les plages de valeurs prises en charge
par les pilotes de communication.
Connexions
TIA Portal Openness prend en charge les connexions non intégrées également prises en
charge par les pupitres opérateur correspondants. Vous trouverez des informations
complémentaires à ce sujet dans l'aide en ligne de TIA Portal sous "Visualisation de processus
> Communication avec les API > Dépendance par rapport à l'appareil".
Tableau 4-6 Listes

Listes de textes oui oui oui oui
Listes de graphiques oui oui oui oui
Tableau 4-7 Textes

Textes multilingues oui oui oui oui
Textes formatés et non oui oui oui
leurs occurrences
Introduction
Il est possible d'écrire et de lire des attributs (généraux) de blocs, DB et UDT (écrits dans
n'importe quel langage de programmation) via l'API Openness.
Les objets technologiques sont des DB internes, c'est pourquoi cette fonction s'applique aussi
aux TO.
Les mêmes règles de vérification doivent également être appliquées au nom à l'aide de
SetAttribute de l'API Openness pour les blocs, DB (TO) et UDT que vous avez utilisés sur la
GUI.
En cas d'infraction à une règle, une exception utilisateur est émise et la valeur d'attribut n'est
pas modifiée.
Cette extension de l'API ne concerne pas l'importation/exportation XML.

notions de base
Attributs généraux
Légende
● X : L'attribut est pertinent, écriture dans XML, accès via l'API possible
● -: L'attribut n'est pas accessible, il n'existe pas
Attributs Type de données Disponibilité via l'API

CodeBlock DB UDT
AutoNumber Bool X (XML); RW (API) X (XML); RW (API) -
CodeModifiedDate DateTime X (XML); R (API) X (XML); R (API) -
CompileDate DateTime X (XML); R (API) X (XML); R (API) -
CreationDate DateTime X (XML); R (API) X (XML); R (API) X (XML); R (API)
HeaderAuthor Chaîne de caractè‐ X (XML); R (API) X (XML); R (API) -
res
HeaderFamily Chaîne de caractè‐ X (XML); R (API) X (XML); R (API) -
res
HeaderName Chaîne de caractè‐ X (XML); R (API) X (XML); R (API) -
res
HeaderVersion System.Version X (XML); R (API) X (XML); R (API) -
InstanceOfName Chaîne de caractè‐ - X (XML); R (API) -
res
Interface Chaîne de caractè‐ X (XML); - (API) X (XML); - (API) X (XML); - (API)
res
InterfaceModifiedDate DateTime X (XML); R (API) X (XML); R (API) X (XML); R (API)
IsConsistent Bool X (XML); R (API) X (XML); R (API) X (XML); R (API)
IsKnowHowProtected Bool X (XML); R (API) X (XML); R (API) X (XML); R (API)
MemoryLayout (jusqu'à MemoryLayout X (XML); R (API) X (XML); R (API) -
présent : Optimization)
ModifiedDate DateTime X (XML); R (API) X (XML); R (API) X (XML); R (API)
Nom Chaîne de caractè‐ X (XML); RW (API) X (XML); RW (API) X (XML); RW (API)
res
Number Int32 X (XML); RW (API) X (XML); RW (API) -
ParameterModified DateTime X (XML); R (API) X (XML); R (API) -
ProgrammingLanguage ProgrammingLan‐ X (XML); R (API) X (XML); R (API) -
guage
SecondaryType Chaîne de caractè‐ X (XML); R (API) - -
res
StructureModified DateTime X (XML); R (API) X (XML); R (API) -

notions de base
4.7 Remarques sur la performance de TIA Portal Openness
4.6 Bibliothèques standard

Pour que les exemples de code fonctionnent, ajoutez les instructions Namespace suivantes au
début de l'exemple de code correspondant :
using System;
using System.Collections.Generic;
using System.IO;
using Siemens.Engineering;
using Siemens.Engineering.Cax;
using Siemens.Engineering.Compiler;
using Siemens.Engineering.Compare;
using Siemens.Engineering.Download;
using Siemens.Engineering.Hmi;
using Siemens.Engineering.Hmi.Cycle;
using Siemens.Engineering.Hmi.Communication;
using Siemens.Engineering.Hmi.Globalization;
using Siemens.Engineering.Hmi.RuntimeScripting;
using Siemens.Engineering.Hmi.Screen;
using Siemens.Engineering.Hmi.Tag;
using Siemens.Engineering.Hmi.TextGraphicList;
using Siemens.Engineering.HW;
using Siemens.Engineering.HW.Extensions;
using Siemens.Engineering.HW.Features;
using Siemens.Engineering.HW.Utilities;
using Siemens.Engineering.Library;
using Siemens.Engineering.Library.MasterCopies;
using Siemens.Engineering.Library.Types;
using Siemens.Engineering.SW;
using Siemens.Engineering.SW.Blocks;
using Siemens.Engineering.SW.ExternalSources;
using Siemens.Engineering.SW.Tags;
using Siemens.Engineering.SW.TechnologicalObjects;
using Siemens.Engineering.SW.TechnologicalObjects.Motion;
using Siemens.Engineering.SW.Types;
using Siemens.Engineering.Upload;
Objet racine
Vous pouvez indiquer plusieurs objets racine dans les fichiers d'importation.
Exemple : vous pouvez créer plusieurs listes de textes dans un fichier XML au lieu d'une liste
de textes par fichier XML.
Fonctions de TIA Portal Openness

Lorsque vous ouvrez une fonction TIA Portal Openness pour la première fois, l'appel peut durer
plus longtemps que les appels suivants de cette fonction TIA Portal Openness.

notions de base
Exemple : si vous exécutez plusieurs exportations de données de configuration les unes après
les autres, la première exportation peut durer plus longtemps que les suivantes.

Introduction 5
Introduction
TIA Portal Openness décrit des interfaces ouvertes pour l'ingénierie avec TIA Portal. Pour plus
d'informations sur "TIA Portal Openness - Efficient generation of program code using code
generators", voir la chaîne YouTube SIEMENS.
Avec TIA Portal Openness, vous pouvez automatiser l'ingénierie en commandant à distance le
TIA Portal à partir d'un programme créé par vos soins.
TIA Portal Openness vous permet d'exécuter les actions suivantes :
● Créer des données de projet
● Modifier des projets et des données de projet
● Supprimer des données de projet
● Lire des données de projet
● Mettre à disposition des projets et des données de projet pour d'autres applications.
Remarque
Siemens n'est pas responsable de la compatibilité des données transmises par le biais de ces
interfaces avec un logiciel tiers et ne fournit aucune garantie à cet égard.
Nous attirons expressément l'attention sur le fait que l'utilisation inadéquate des interfaces peut
entraîner la perte de données ou l'arrêt de la production.
Remarque
Les sections de code contenues dans cette documentation sont rédigées dans la syntaxe C#.
En raison de l'utilisation de sections de code courtes, une grande partie du traitement des
erreurs n'est pas décrite.
Utilisation
Utilisez l'interface TIA Portal Openness aux fins suivantes :
● mettre à disposition des données de projet
● accéder au processus TIA Portal
● utiliser des données de projet
Utilisation de valeurs par défaut du domaine de l'automatisation

● par l'importation de données générées à distance
● par la commande à distance du portail TIA pour la génération de projets

Introduction
Mise à disposition de données de projet du portail TIA pour des applications externes
● par l'exportation de données de projet
Conserver les atouts vis-à-vis de la concurrence par une ingénierie efficace

● Vous n'avez besoin de configurer les données d'ingénierie existantes dans le TIA Portal.
● Les processus d'ingénierie automatisés remplacent l'ingénierie manuelle.
● La réduction des coûts d'ingénierie renforce la position concurrentielle.
Travail en commun sur des données de projet

● Les tests de routine et le traitement groupé des données peuvent avoir lieu parallèlement
à la configuration en cours.

Configurations 6
Vous pouvez travailler avec deux variantes de TIA Portal Openness :
L'application et le TIA Portal se trouvent sur différents ordinateurs
2UGLQDWHXUG
DSSOLFDWLRQ 2UGLQDWHXUGXSURMHW7,$3RUWDO
3& 3&
(FKDQJHGHGRQQ«HV
9RWUH 9RWUH
;0/
SURJUDPPH SURJUDPPH
7UDLWHPHQWGHV
GRQQ«HV
3URFHVVXV
7,$3RUWDO
● Les données sont échangées via des fichiers XML. Les fichiers XML peuvent être exportés
ou importés par vos programmes.
● Les données exportées du portail TIA vers PC2 peuvent être modifiées sur PC1 et
réimportées.
Remarque
Vous devez développer un programme exécutable "Votre programme 2" pour PC2, par
exemple "programm2.exe". Le portail TIA s'exécute avec ce programme en arrière-plan.
L'importation et l'exportation de fichiers XML s'effectuent exclusivement par le biais de la
TIA Portal Openness API.
● Vous pouvez archiver les données échangées à des fins de vérification.

● Les données échangées peuvent être éditées à différents endroits et différents moments.

Configurations
L'application et le TIA Portal se trouvent sur le même ordinateur
'RQQ«HVGH
7,$3RUWDO SURMHW
PDFKLQH
9RWUH 3XEOLF$3,
SURJUDPPH
● Votre programme lance le TIA Portal avec ou sans interface utilisateur. Votre programme
ouvre, enregistre et/ou ferme un projet. Le programme peut également établir une liaison
avec un TIA Portal en cours d'exécution.
● Vous pouvez alors utiliser les fonctionnalités du TIA Portal pour demander, générer et
modifier des données de projet ou pour déclencher des processus d'importation et
d'exportation.
● Les données sont créées sous le contrôle du traitement du portail TIA et enregistrées dans
les données du projet.

Configurations
Un domaine d'application typique est la construction de machines modulaire.
3DUDPªWUHV
SRXU
PDFKLQH *HQHUDWRU
3DUDPªWUHV 7RRO
SRXU
PDFKLQH
3URMHWSRXU
PDFKLQH
3URFHVVXV
7,$3RUWDO
3URMHWSRXU
PDFKLQH
● Un système d'automatisation efficace doit être appliqué sur des machines similaires.
● Un projet comprenant les composants de tous les modèles de machines est disponible dans
le portail TIA.
● L'outil Generator Tool commande la création du projet correspondant à un modèle de
machine donné.
● Il appelle les valeurs par défaut en lisant les paramètres du modèle de machine demandé.
● Il filtre les éléments concernés du projet global du portail TIA, les modifie le cas échéant et
génère le projet de machine demandé.

Configurations

TIA Portal Openness API 7
7.1 Introduction
Vue d'ensemble
TIA Portal Openness prend en charge une sélection de fonctions pour des tâches définies.
Vous pouvez appeler ces fonctions par le biais de TIA Portal Openness API en-dehors de TIA
Portal.
Remarque
Lorsqu'une version antérieure de TIA Portal Openess est déjà installée, la version actuelle est
installée parallèlement.
Vous trouverez ci-après une vue d'ensemble des étapes de programmation typiques. Vous
découvrirez comment les différentes sections de code interagissent et comment intégrer les
différentes fonctions dans un programme complet. En outre, vous verrez quels éléments de
code doivent être adaptés pour chaque tâche.
Exemple de programme
Les différentes étapes de programmation sont expliquées à l'aide de l'exemple de fonction
"Créer l'accès de l'API dans une application console". Dans ce code de programme, vous
intégrez les fonctions mises à disposition et vous adaptez les éléments de code
correspondants pour cette tâche.
Fonctions
La rubrique ci-dessous indique les fonctions pour des tâches définies que vous pouvez appeler
avec TIA Portal Openness en-dehors de TIA Portal.
7.2 Etapes de programmation
Vue d'ensemble
TIA Portal Openness requiert les étapes de programmation suivantes pour l'accès via la TIA
Portal Openness API :
1. Faire connaître TIA Portal dans l'environnement de développement
2. Configurer l'accès du programme à TIA Portal
3. Activer l'accès du programme à TIA Portal
4. Publier et démarrer TIA Portal

TIA Portal Openness API
7.3 Modèle d'objet TIA Portal Openness
5. Ouvrir un projet
6. Exécuter des commandes
7. Enregistrer et fermer un projet
8. Mettre fin à la connexion à TIA Portal
Remarque
Chaînes de caractères autorisées
Seuls certains caractères sont autorisés dans les chaînes de caractères sur TIA Portal. Toutes
les chaînes de caractères transmises à TIA Portal par le biais de l'application TIA Portal
Openness doivent se conformer à ces règles. Si vous transmettez un caractère non autorisé
dans un paramètre, le système déclenche une exception.
Vue d'ensemble
Le schéma suivant illustre le niveau le plus élevé du modèle d'objet TIA Portal Openness :
7LD3RUWDO6HWWLQJ
'HYLFHVQ
6HWWLQJVQ 8QJURXSHG'HYLFHV*URXS 'HYLFH6\VWHP*URXS 'HYLFH,WHPVQ

)ROGHUVQ
'HYLFH*URXS
'HYLFHVQ 'HYLFH 'HYLFH,WHPVQ 'HYLFH,WHP
7LD3RUWDO6HWWLQJV)ROGHU $EVWUDFW!!
'HYLFH*URXSVQ 'HYLFH8VHU*URXS *URXSV 6RIWZDUH&RQWDLQHU

6HWWLQJV)ROGHUVQ 6HUYLFH!!
*UDSKLFVQ 0XOWL/LQJXDO*UDSKLF

6RIWZDUH&RQWDLQHU
7LD3RUWDO 3URMHFWV 3URMHFW +Z8WLOLWLHVQ +DUGZDUH8WLOLW\

6RIWZDUH
+LVWRU$QWULHVQ +LVWRU\(QWU\ 6RIWZDUH

$EVWUDFW!!
*OREDO/LEUDULHVQ 3URMHFW/LEUDU\
/DQJXDJHVQ /DQJXDJH

3OF6RIWZDUH +PL6RIWZDUH +PL7DUJHW
*OREDO/LEUDU\ 3URMHFW/LEUDU\ /DQJXDJH6HWWLQJVQ /DQJXDJH6HWWLQJ
6XEQHWVQ 6XEQHW
8VHG3URGXFWVQ 8VHG3URGXFW
8VHU*OREDO/LEUDU\ &RUSRUDWH*OREDO/LEUDU\ 6\VWHP*OREDO/LEUDU\
Le schéma suivant illustre les objets disponibles sous GlobalLibrary.

0DVWHU&RS\6\VWHP)ROGHU 0DVWHU&RS\8VHU)ROGHU
0DVWHU&RS$ROGHU 0DVWHU&RS\)ROGHU )ROGHUVQ

$EVWUDFW!! 0DVWHU&RSLHVQ 0DVWHU&RS\
*OREDO/LEUDU\
/LEUDU\7\SH)ROGHU 7\SHVQ /LEUDU\7\SH 9HUVLRQVQ /LEUDU\7\SH9HUVLRQ
7\SH)ROGHU $EVWUDFW!! )ROGHUVQ
/LEUDU\7\SH6\VWHP)ROGHU /LEUDU\7\SH8VHU)ROGHU
Le schéma suivant illustre les objets disponibles sous ProjectLibrary.

3URMHFW/LEUDU\
Le schéma suivant illustre les objets disponibles sous HmiTarget.

&RQQHFWLRQVQ &RQQHFWLRQ
&\FOHVQ &\FOH
*UDSKLF/LVWVQ *UDSKLF/LVW
6FUHHQ)ROGHU )ROGHUVQ 6FUHHQ8VHU)ROGHU

6FUHHQ)ROGHU 6FUHHQ6\VWHP)ROGHU
$EVWUDFW!! 6FUHHQVQ 6FUHHQ
6FUHHQ*OREDO(OHPHQWV 6FUHHQ*OREDO(OHPHQWV
6FUHHQ2YHUYLHZ 6FUHHQ2YHUYLHZ
+PL7DUJHW 6FUHHQ3RSXS)ROGHU )ROGHUVQ 6FUHHQ3RSXS8VHU)ROGHU

$EVWUDFW!! 6FUHHQ3RSXSVQ 6FUHHQ3RSXS
6FUHHQ3RSXS)ROGHU 6FUHHQ3RSXS6\VWHP)ROGHU
6FUHHQ6OLGHLQ)ROGHU 6FUHHQ6OLGHLQ6\VWHP)ROGHU 6FUHHQ6OLGHLQV 6FUHHQ6OLGHLQ
6FUHHQ7HPSODWH)ROGHU )ROGHUVQ 6FUHHQ7HPSODWH8VHU)ROGHU

$EVWUDFW!! 6FUHHQ7HPSODWHVQ 6FUHHQ7HPSODWH
6FUHHQ7HPSODWH)ROGHU 6FUHHQ7HPSODWH6\VWHP)ROGHU
7DJ)ROGHU )ROGHUVQ 7DJ8VHU)ROGHU

$EVWUDFW!! 7DJ7DEOHVQ
7DJ)ROGHU 7DJ6\VWHP)ROGHU 7DJ7DEOH 7DJVQ 7DJ
'HIDXOW7DJ7DEOH
7H[W/LVWVQ 7H[W/LVW
9%6FULSW)ROGHU )ROGHUVQ 9%6FULSW8VHU)ROGHU

9%6FULSW)ROGHU 9%6FULSW6\VWHP)ROGHU
$EVWUDFW!! 9%6FULSWVQ 9%6FULSW
Le schéma suivant illustre les objets disponibles sous HmiSoftware.

&ODVVHVG
DODUPHVQ $ODUP&ODVV
$ODUP/RJVQ $ODUP/RJ
$QDORJ$ODUPVQ $QDORJ$ODUP
'DWD/RJVQ 'DWD/RJ
'LVFUHWH$ODUPVQ 'LVFUHWH$ODUP
+PL&RQQHFWLRQVQ +PL&RQQHFWLRQ

+PL6RIWZDUH
+PL7DJ7DEOHVQ +PL7DJ7DEOH
+PL7DJVQ +PL7DJV
5XQWLPH6HWWLQJV
6FUHHQHW 6FUHHQVHW6FUHHQ,WHPV
6FUHHQ,WHPQ
Le schéma suivant illustre les objets disponibles sous PlcSoftware.

6\VWHP%ORFN*URXSV 3OF6\VWHP%ORFN*URXS *URXSVQ

)%
%ORFNVQ &RGH%ORFN

)&
$EVWUDFW!!
2%
3OF%ORFN*URXS %ORFNVQ 3OF%ORFN
$EVWUDFW!! *URXSVQ $EVWUDFW!!
,QVWDQFH'%
%ORFN*URXS 3OF%ORFN6\VWHP*URXS 3OF%ORFN8VHU*URXS 'DWD%ORFN

*OREDO'%
$EVWUDFW!!
$UUD\'%
3OF([WHUQDO6RXUFH*URXS ([WHUQDO6RXUFHVQ

3OF([WHUQDO6RXUFH
$EVWUDFW!! *URXSVQ
([WHUQDO6RXUFH*URXS 3OF([WHUQDO6RXUFH6\VWHP*URXS 3OF([WHUQDO6RXUFH8VHU*URXS
3OF6RIWZDUH
7\SH*URXS 3OF7\SH6\VWHP*URXS 3OF7\SH8VHU*URXS
3OF7\SH6\VWHP*URXS *URXSVQ 3OF7\SH

3OF6WUXFW
$EVWUDFW!! 7\SHVQ $EVWUDFW!!
3OF7DJ
7DJ7DEOH*URXS 3OF7DJ7DEOH6\VWHP*URXS 3OF7DJ7DEOH8VHU*URXS
7DJVQ
3OF7DJ7DEOH*URXS *URXSVQ 3OF8VHU&RQVWDQW
$EVWUDFW!! 7DJ7DEOHVQ 3OF7DJ7DEOH
8VHU&RQVWDQWVQ
3OF&RQVWDQW
$EVWUDFW!!
6\VWHP&RQVWDQWVQ
3OF6\VWHP&RQVWDQW
7HFKQRORJLFDO,QVWDQFH'%
7HFKQRORJLFDO2EMHFW*URXS 7HFKQRORJLFDO,QVWDQFH'%*URXS 7HFKQRORJLFDO2EMHFWV 7HFKQRORJLFDO,QVWDQFH'%&RPSRVLWLRQ %ORFNVQ
'DWD%ORFN
:DWFK$QG)RUFH7DEOH*URXS 3OF:DWFK$QG)RUFH7DEOH6\VWHP*URXS 3OF:DWFK$QG)RUFH7DEOH8VHU*URXS
3OF:DWFK$QG)RUFH7DEOH*URXS *URXSVQ

3OF)RUFH7DEOH )RUFH7DEOH $EVWUDFW!! :DWFK7DEOHQ 3OF:DWFK7DEOH
(QWULHVQ 3OF7DEOH&RPPHQW(QWU\ (QWULHVQ
3OF)RUFH7DEOH(QWU\ 3OF:DWFK7DEOH(QWU\
3OF8QLW3URYLGHU
6HUYLFH!! Openness : Automatisation de la création de projet
3OF8QLW3URYLGHU 3OF8QLWV6\VWHP*URXS 3OF8QLW&RPSRVLWLRQ 8QLWVQ 3OF8QLW

Remarque
* La table de forçage permanent doit se trouver dans PlcWatch et ForceTableSystemGroup
Accéder à des objets de listes

Pour adresser un objet dans une liste, vous avez les options suivantes :
● Adressez via l'index. Le comptage au sein des listes commence à partir de 0.
● Utilisez la méthode Find.
Utilisez cette méthode pour adresser un objet par son nom. Vous pouvez appliquer cette
méthode à une composition ou une liste. La méthode Find n'est pas récursive.
Exemple :
ScreenComposition screens = folder.Screens;
Screen screen = screens.Find("myScreen");
● Utilisez les noms symboliques.
Relation entre TIA Portal et le modèle d'objet TIA Portal Openness

La figure suivante présente la relation entre le modèle d'objet et un projet dans TIA Portal :
1
5
5 5
Project DeviceItem
2 PlcSoftware
HmiTarget
3
HmiUnified
4 Software


7.4 Blocs et types de modèle d'objet TIA Portal Openness
Introduction
Le schéma suivant représente le modèle de domaine des API afin de donner une vue
d'ensemble de la structuration actuelle dans TIA Portal Openness.


)%
%ORFNVQ &RGH%ORFN

)&
$EVWUDFW!!
2%
,QVWDQFH'%

*OREDO'%
$EVWUDFW!!
$UUD\'%

3OF([WHUQDO6RXUFH
$EVWUDFW!! *URXSVQ
3OF6RIWZDUH

3OF6WUXFW
3OF7DJ
7DJ7DEOH*URXS 3OF7DJ7DEOH6\VWHP*URXS 3OF7DJ7DEOH8VHU*URXS
7DJVQ
3OF7DJ7DEOH*URXS *URXSVQ 3OF8VHU&RQVWDQW
8VHU&RQVWDQWVQ
3OF&RQVWDQW
$EVWUDFW!!
6\VWHP&RQVWDQWVQ
3OF6\VWHP&RQVWDQW
7HFKQRORJLFDO,QVWDQFH'%
'DWD%ORFN
:DWFK$QG)RUFH7DEOH*URXS 3OF:DWFK$QG)RUFH7DEOH6\VWHP*URXS 3OF:DWFK$QG)RUFH7DEOH8VHU*URXS
3OF:DWFK$QG)RUFH7DEOH*URXS *URXSVQ

3OF)RUFH7DEOH )RUFH7DEOH $EVWUDFW!! :DWFK7DEOHQ 3OF:DWFK7DEOH
(QWULHVQ 3OF7DEOH&RPPHQW(QWU\ (QWULHVQ
3OF)RUFH7DEOH(QWU\ 3OF:DWFK7DEOH(QWU\
3OF8QLW3URYLGHU
6HUYLFH!! Openness : Automatisation de la création de projet
3OF8QLW3URYLGHU 3OF8QLWV6\VWHP*URXS 3OF8QLW&RPSRVLWLRQ 8QLWVQ 3OF8QLW

Remarque
* La table de forçage permanent doit se trouver dans PlcWatch et ForceTableSystemGroup
Représentation de blocs et types dans la TIA Portal Openness API

L'élément de modèle simplifié des blocs et de la structure est basé sur les attributs dans la TIA
Portal Openness API. Les classes correspondantes mettent à disposition la fonction
d'exportation ainsi que la fonction de compilation pour les blocs.
Diagrammes de classes
Toutes les classes qui ne sont pas directement instanciées sont définies de manière abstraite
dans le modèle d'objet TIA Portal Openness.

Données

3OF%ORFN
*HQHUDODWWULEXWHV
$XWR1XPEHU%RROHDQ
&RGH0RGLILHG'DWH'DWH7LPH
&RPSLOH'DWH'DWH7LPH
&UHDWLRQ'DWH'DWH7LPH
+HDGHU$XWKRU6WULQJ
+HDGHU)DPLO\6WULQJ
+HDGHU1DPH6WULQJ
+HDGHU9HUVLRQ6WULQJ
,QWHUIDFH0RGLILHG'DWH'DWH7LPH
,V&RQVLVWHQW%RROHDQ
,V.QRZ+RZ3URWHFWHG%RROHDQ
0HPRU\/D\RXW0HPRU\/D\RXW
0RGLILHG'DWH'DWH7LPH
1DPH6WULQJ
1XPEHU,QW
3DUDPHWHU0RGLILHG'DWH7LPH
3URJUDPPLQJ/DQJXDJH3URJUDPPLQJ/DQJXDJH
6WUXFWXUH0RGLILHG'DWH7LPH
6HUYLFHV
,&RPSLODEOH
([SRUW
6KRZ,Q(GLWRU
'HOHWH
'DWD%ORFN
6SHFLILFDWWULEXWHV
,V2QO\6WRUHG,Q/RDG0HPRU\%RROHDQ
,V:ULWH3URWHFWHG,Q$6%RROHDQ
$UUD\'% *OREDO'% ,QVWDQFH'%
6SHFLILFDWWULEXWHV 6SHFLILFDWWULEXWHV 1RWH7KHGLIIHUHQFHVEHWZHHQWKHVSHFLILFDWWULE

RI,'%RI)%DQG,'%RIO8'7ZLOOEHKDQGOHGE\FR
'RZQORDG:LWKRXW5HLQLW%RROHDQ
$UUD\'DWD7\SH6WULQJ
,V3/&'%%RROHDQ *HQHUDODWWULEXWHV
$UUD\/LPLW8SSHU%RXQG,QW
,V5HWDLQ0HP5HV(QDEOHG%RROHDQ ,QVWDQFH2I1DPH6WULQJ
5HWDLQ0HPRU\5HVHUYH8,QWSOXV 2I6\VWHP/LE(OHPHQW6WULQJ
2I6\VWHP/LE9HUVLRQ6WULQJ
6SHFLILFDWWULEXWHV
'RZQORDG:LWKRXW5HLQLW%RROHDQ
,QVWDQFH2I1XPEHU,QW
,QVWDQFH2I7\SH%ORFN7\SH
,V5HWDLQ0HP5HV(QDEOHG%RROHDQ
0HPRU\5HVHUYH8,QWSOXV
5HWDLQ0HPRU\5HVHUYH8,QWSOXV
8'$(QDEOH7DJ5HDGEDFN%RROHDQ
8'$%ORFN3URSHUWLHV6WULQJ

Code et type
3OF%ORFN
1RWH$
WKHIROOR
&RGH%ORFN /LEUDU\7\SH,QVWDQFH,QIR &UHDWL

,QWHUID
6SHFLILFDWWULEXWHV ,V&RQV
+DQGOH(UURUV:LWKLQ%ORFN%RROHDQSOXV /LEUDU\7\SH9HUVLRQ/LEUDU\7\SH9HUVLRQ 0RGLIL
,V,(&&KHFN(QDEOHG%RROHDQ /LEUDU\7\SH,QVWDQFH,(QJLQHHULQJ2EMHFW 1DPH
,&RPS
([SRU
6KRZ,
'HOHWH
2%
*HQHUDODWWULEXWHV
6HFRQGDU\7\SH6WULQJ
6SHFLILFDWWULEXWHV
&RQVWDQW1DPH6WULQJ
3URFHVV,PDJH3DUW1XPEHU8,QW
(YHQW&ODVV6WULQJ
3ULRULW\1XPEHU,QW )%
(YHQWV7R%H4XHXHG,QW
5HSRUW(YHQWV%RRO 6SHFLILFDWWULEXWHV
(QDEOH7LPH(UURU%RRO $FNQRZOHGJH(UURUV5HTXLUHG%RROHDQ
(YHQW7KUHVKROG)RU7LPH(UURU,QW &UHDWH0LQLPL]HG'%%RROHDQFODVVLF
&\FOLF7LPH,QW 'RZQORDG:LWKRXW5HLQLW%RROHDQ
3KDVH2IIVHW,QW *UDSK9HUVLRQ6WULQJSOXV
$SSOLFDWLRQ&\FOH6LQJOH ,V0XOWL,QVWDQFH&DSDEOH%RROHDQ
$XWRPDWLF0LQLPXP%RRO
,V5HWDLQ0HP5HV(QDEOHG%RROHDQ
)&
'HOD\7LPH'RXEOH

'LVWULEXWLRQ,21DPH,QW /DQJXDJH,Q1HWZRUNV6WULQJ 6SHFLILFDWWULEXWHV
'LVWULEXWLRQ,21XPEHU,QW /RFN2SHUDWLQJ0RGH%RROHDQ
3DUDPHWHU3DVVLQJ%RROHD
([HFXWLRQ2%([HFXWLRQ 0HPRU\5HVHUYH8,QWSOXV
8'$(QDEOH7DJ5HDGEDFN
6WDUW'DWH'DWH7LPH 3DUDPHWHU3DVVLQJ%RROHDQSOXV
8'$%ORFN3URSHUWLHV6WULQ
7LPH2I'D\'DWH7LPH 3HUPDQHQW,/3URFHVVLQJ,Q0$10RGH%RROHDQ
/LEUDU\&RQIRUPDQFH6WDWXV
7LPH0RGH2%7LPH0RGH 5HWDLQ0HPRU\5HVHUYH8,QWSOXV
'DWD([FKDQJH0RGH2%'DWD([FKDQJH0RGH 6HW(12$XWRPDWLFDOO\%RROHDQSOXV
&\FOLF7LPH'LVWULEXWHG,26LQJOH 6NLS6WHSV%RROHDQ
)DFWRU6LQJOH 8'$(QDEOH7DJ5HDGEDFN%RROHDQ
6\QFKURQRXV$SSOLFDWLRQ&\FOH7LPH6LQJOH 8'$%ORFN3URSHUWLHV6WULQJ
&\FOLF$SSOLFDWLRQ&\FOH7LPH6LQJOH :LWK$ODUP+DQGOLQJ%RROHDQ
/LEUDU\&RQIRUPDQFH6WDWXV6WULQJ
7UDQVIRUPDWLRQ'%1XPEHU8,QW

Représentation de groupes pour blocs et types dans la TIA Portal Openness API
Les deux groupes "PlcBlocks" du niveau supérieur ("Blocs de programme" dans l'interface
utilisateur de TIA Portal) et "PlcTypes" ("Types de données API" dans l'interface utilisateur de
TIA Portal) contiennent des blocs et des définitions de type. Ces groupes mettent la fonction
d'importation et la fonction de compilation à la disposition des blocs. Étant donné que la plupart
des méthodes qui s'appliquent aux fonctionnalités des groupes ne sont accessibles que via des
bibliothèques, il existe une représentation "intégrée" ou "condensée" des bibliothèques et des
méthodes correspondantes dans les classes "Host".

Blocs et types
3OF%ORFN*URXS
3OF6RIWZDUH
&RPSRVLWLRQV
%ORFNV3OF%ORFN&RPSRVLWLRQ 7\SHV3OF7
*URXSV3OF%ORFN8VHU*URXS&RPSRVLWLRQ *URXSV3O
6HUYLFHV
,&RPSLODEOH ,&RPSLODEOH
1DPH6WULQJJHW 1DPH6WUL
0HWKRGVRQ3OF%ORFN&RPSRVLWLRQ
,PSRUW ,PSRUW
0HWKRGVRQ3OF%ORFN8VHU*URXS&RPSRVLWLRQ 0HWK
&UHDWH &UHDWH

3OF%ORFN8VHU*URXS 3OF%ORFN6\VWHP*URXS 3OF7\SH6\VWHP*URXS

&RPSRVLWLRQV
6\VWHP%ORFN*URXSV3OF6\VWHP%ORFN*URXS&RPSRVLWLRQ

3OF6\VWHP%ORFN*URXS
&RPSRVLWLRQV
%ORFNV3OF%ORFN&RPSRVLWLRQ
*URXSV3OF6\VWHP%ORFN*URXS&RPSRVLWLRQ

1DPH6WULQJJHW
0HWKRGVRQ3OF%ORFN&RPSRVLWLRQ
,PSRUW

3OF%ORFN

7.5 Hiérarchie des objets matériels du modèle d'objet
Sources externes
3OF([WHUQDO6RXUFH*URXS
&RPSRVLWLRQV
*URXSV3OF([WHUQDO6RXUFH8VHU*URXS&RPSRVLWLRQ
([WHUQDO6RXUFHV3OF([WHUQDO6RXUFH&RPSRVLWLRQ
3OF6RIWZDUH
1DPH6WULQJJHW
0HWKRGVRQ3OF([WHUQDO6RXUFH&RPSRVLWLRQ
&UHDWH)URP)LOH
0HWKRGVRQ3OF([WHUQDO6RXUFH8VHU*URXS&RPSRVLWLRQ
&UHDWH

3OF([WHUQDO6RXUFH6\VWHP*URXS 3OF([WHUQDO6RXUFH8VHU*URXS 3OF([
1DPH6WULQJ
'HOHWH
*HQHUDWH%ORFN
Relation entre les éléments visibles du portail TIA et les éléments structurés du modèle d'objet
Modèle matériel Explication

Appareil Objet conteneur pour une configuration centralisée ou décentralisée.
(Device)
Élément d'appareil Chaque objet élément d'appareil possède un objet conteneur.
(DeviceItem) La relation logique est "Éléments".
Pour les objets éléments d'appareil, la relation conteneur-élément est similaire à la relation des
modules.
Exemple : un appareil contient un ou plusieurs emplacements. Un emplacement contient des
modules. Un module contient des sous-modules.
Il s'agit de la relation similaire à la représentation dans la vue de réseau et la vue d'appareil de
TIA Portal. L'attribut "PositionNumber" d'un élément d'élément d'appareil est unique dans la
zone du conteneur.

La relation enfant-parent entre les objets élément d'appareil est une relation logique pure dans
le modèle d'objet. Un enfant ne peut exister sans ses parents.
● Si un sous-module est structuré comme une partie d'un module (enfant), le sous-module ne
peut pas être retiré sans le module.
● Si vous ajoutez au module un sous-module, puis vous le retirez du sous-module, cet enfant
a les mêmes parents que le module.
Le diagramme ci-dessous indique la hiérarchie entre des appareils et des éléments d'appareils
API et IHM.
Hiérarchie entre appareils API
Hiérarchie pour le travail avec des .Items Hiérarchie pour le travail avec des .DeviceItems
'HYLFH 'HYLFH
'HYLFH,WHP5DFN 'HYLFH,WHP5DFN
'HYLFH,WHP3/& 'HYLFH,WHP3/&
6RIWZDUH&RQWDLQHU 6RIWZDUH&RQWDLQHU
3OF6RIWZDUH 3OF6RIWZDUH
'HYLFH,WHP'3 'HYLFH,WHP'3
'HYLFH,WHP352),1(7 'HYLFH,WHP352),1(7
'HYLFH,WHP,2&3 'HYLFH,WHP,2&3
Hiérarchie entre appareils IHM
Hiérarchie pour le travail avec des .Items Hiérarchie pour le travail avec des .DeviceItems
'HYLFH 'HYLFH
'HYLFH,WHP+0, 'HYLFH,WHP+0,
'HYLFH,WHP352),1(7 'HYLFH,WHP352),1(7
'HYLFH,WHP03,'3 'HYLFH,WHP03,'3
'HYLFH,WHP+0,57 'HYLFH,WHP+0,57
6RIWZDUH&RQWDLQHU 6RIWZDUH&RQWDLQHU
+PL7DUJHW +PL7DUJHW

7.6 Informations sur les versions de TIA Portal Openness installées
7.6 Informations sur les versions de TIA Portal Openness installées
Conditions
● TIA Portal Openness et TIA Portal sont installés
Utilisation
À partir de TIA Portal Openness V14, chaque version installée dispose d'une clé de Registre
qui contient des informations sur la version. Cela permet de créer automatiquement le fichier
de configuration d'application pour chaque version de TIA Portal Openness installée.
La clé de Registre se trouve dans le chemin suivant :
HKEY_LOCAL_MACHINE\Software\Siemens\Automation\Openness\Vxx.x
\PublicAPI
Remarque
Le numéro de version présent dans ce chemin est toujours identique au numéro de la version
de TIA Portal actuelle installée. En cas de plusieurs installations parallèles, plusieurs jeux
d'entrées correspondant à TIA Portal Openness sont présents dans le registre.
Il existe une clé unique par version de TIA Portal Openness. Les noms des versions sont
identiques à ceux dans l'Assembly décrit, par ex. les entrées de registre pour TIA Portal
Openness :
[HKEY_LOCAL_MACHINE\SOFTWARE\Siemens\Automation\Openness\Vxx.x\PublicAPI
\Vxx.x.x.x]"PublicKeyToken"="d29ec89bac048f84"
"Siemens.Engineering"="C:\Program Files\Siemens\Automation\Portal Vxx\PublicAPI\Vxx
\Siemens.Engineering.dll"
"Siemens.Engineering.Hmi"="C:\Program Files\Siemens\Automation\Portal Vxx\PublicAPI\Vxx
\Siemens.Engineering.Hmi.dll"
"EngineeringVersion"="Vxx"
"AssemblyVersion"="Vxx.x.x.x"
Remarque
Si vous souhaitez créer un fichier de configuration d'application, vous pouvez connaître le
chemin d'accès à Siemens.Engineering.dll, Siemens.Engineering.Hmi.dll et au jeton de la clé
publique grâce à la clé de Registre.

7.7 Exemple d'application : Créer l'accès de l'API dans une application Windows Forms
7.7 Exemple d'application : Créer l'accès de l'API dans une application

Windows Forms
Exemple d'application : Créer l'accès de l'API dans une application

Le code du programme complet de l'exemple d'application est indiqué ci-après. Les étapes
typiques de programmation sont décrites ci-après à l'aide de cet exemple.
Remarque
Un fichier de configuration d'exemple est requis pour l'exemple d'application.

using System;
using Siemens.Engineering.HW;
using Siemens.Engineering.HW.Features;
using Siemens.Engineering.SW;
using Siemens.Engineering.SW.Blocks;
using Siemens.Engineering.SW.ExternalSources;
using Siemens.Engineering.SW.Tags;
using Siemens.Engineering.SW.Types;
using Siemens.Engineering.Hmi;
using HmiTarget = Siemens.Engineering.Hmi.HmiTarget;
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;
using Siemens.Engineering.Library;
using System.IO;
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");
ProjectComposition projects = tiaPortal.Projects;
Console.WriteLine("Opening Project...");
// please adapt the path and the extension apx to the installed version of
TIA Portal
FileInfo projectPath = new FileInfo("C:\Demo\AnyCompanyProject.apx"); //edit
the path according to your project
Project project = null;
try
{
project = projects.OpenWithUpgrade(projectPath);
}
catch (Exception)
{
Console.WriteLine(String.Format("Could not open project {0}",
projectPath.FullName));
Console.WriteLine("Demo complete hit enter to exit");
Console.ReadLine();

return;
}
Console.WriteLine(String.Format("Project {0} is open",

project.Path.FullName));
IterateThroughDevices(project);
project.Close();

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();
}
}
}
Procédure par étapes
1. Faire connaître TIA Portal dans l'environnement de développement

Créez dans votre environnement de développement un renvoi à tous les "fichiers dll" dans le
répertoire "C:\Program Files\Siemens\Automation\PortalV..\PublicAPI\V..".
Cette procédure est illustrée ci-après pour le fichier "Siemens.Engineering.dll".
Le fichier "Siemens.Engineering.dll" se trouve dans le répertoire "C:\Program Files\Siemens
\Automation\PortalV..\PublicAPI\V..". Créez dans votre environnement de développement un
renvoi au fichier "Siemens.Engineering.dll".
Remarque
Affectez la valeur "False" au paramètre "CopyLocal" dans les attributs de référence.

2. Publier la plage de noms pour le TIA Portal

Insérez le code suivant :
3. Publier et démarrer TIA Portal

Pour publier et démarrer TIA Portal, insérez le code suivant :
using (TiaPortal tiaPortal = new TiaPortal())

{
// Add your code here
}
4. Ouvrir un projet
Pour ouvrir un projet, vous pouvez par exemple utiliser le code suivant :
ProjectComposition projects = tiaPortal.Projects;

Console.WriteLine("Opening Project...");
//please adapt the path and the extension apx to the installed version of TIA Portal
FileInfo projectPath = new FileInfo("C:\Demo\AnyCompanyProject.apx");
try
{
project = projects.Open(projectPath);
}
catch (Exception)
{
Console.WriteLine(String.Format("Could not open project {0}", projectPath.FullName));
Console.ReadLine();
return;
}
Console.WriteLine(String.Format("Project {0} is open", project.Path.FullName));

5. Énumérer les appareils d'un projet

Ajoutez le code suivant pour énumérer tous les appareils du projet :
static private void IterateThroughDevices(Project project)

{
{
return;
}
Console.WriteLine(String.Format("Iterate through {0} device(s)",
project.Devices.Count));
{
Console.WriteLine(String.Format("Device: \"{0}\".", device.Name));
}
}
6. Enregistrer et fermer un projet

Insérez le code suivant puis enregistrez et fermez le projet :
project.Save();
project.Close();

7.8 Utilisation des exemples de code
Structure des sections de code

Chaque section de code de cette documentation est réalisée comme fonction sans valeur de
retour avec une référence d'objet comme paramètre de transmission. Pour une meilleure
lisibilité, on renoncera à supprimer des objets. L'accès aux objets de TIA Portal se fait par leur
nom à l'aide de la méthode Find.
//Deletes a single screen from a user folder or a system folder

private static void DeleteScreenFromFolder(HmiTarget hmiTarget)
{
//The screen "MyScreen" will be deleted if it is existing in the folder
"myScreenFolder".
//If "myScreen" is stored in a subfolder of "myScreenFolder" it will not be deleted.
string screenName = "MyScreen";
ScreenUserFolder folder = hmiTarget.ScreenFolder.Folders.Find("myScreenFolder");
Screen screen = screens.Find(screenName);
if (screen != null)
{
screen.Delete();
}
}
Pour exécuter cette section de code, les éléments suivants sont requis :
● Un projet WinCC avec un appareil IHM contenant un groupe avec au moins une vue.
● Une fonction qui est instanciée par le pupitre opérateur.
Remarque
Si vous indiquez des chemins de répertoire, utilisez le chemin absolu, par ex. "C:/path/file.txt".
Les chemins de répertoire relatifs ne sont autorisés que pour les fichiers XML et l'importation/
l'exportation, par ex. "file.txt" ou "C:/path01/.../path02/file.txt".

Exemple d'exécution de la section de code

Pour exécuter la section de code "DeleteScreenFromFolder" dans le cadre de l'exemple de
programme "Hello TIA", utilisez l'exemple suivant :
//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 function definitions before or after the

//function definition of "private static void IterateThroughDevices(Project project)":
private static HmiTarget GetTheFirstHmiTarget(Project project)
{
{
throw new ArgumentNullException("project");
}
//This example looks for devices located directly in the project.
//Devices which are stored in a subfolder of the project will not be affected by this
example.
{
foreach (DeviceItem deviceItem in device.DeviceItems)
{
DeviceItem deviceItemToGetService = deviceItem as DeviceItem;
SoftwareContainer container =
deviceItemToGetService.GetService<SoftwareContainer>();
if (container != null)
{
HmiTarget hmi = container.Software as HmiTarget;
if (hmi != null)
{
return hmi;
}
}
}
}
return null;
}
//Deletes a single screen from a user folder or a system folder

private static void DeleteScreenFromFolder(HmiTarget hmiTarget)
{
string screenName = "MyScreen";
ScreenUserFolder folder = hmiTarget.ScreenFolder.Folders.Find("myScreenFolder");
Screen screen = screens.Find(screenName);
if (screen != null)
{
screen.Delete();
}
}

7.9 Fonctions générales
7.9.1 Prise en charge d'IntelliSense par TIA Portal Openness
Utilisation
Le support IntelliSense pour TIA Portal Openness vous offre de l'aide sur les attributs ou
méthodes disponibles par le biais d'info-bulles. Il peut vous renseigner sur le nombre, les noms
et les types de paramètres requis. Dans l'exemple suivant, le paramètre en gras dans la
première ligne indique le paramètre requis suivant lors de l'entrée de la fonction.
Vous pouvez appeler manuellement des informations sur les paramètres de différentes
manières : Cliquez sur "Edit IntelliSense/Parameter Info", à l'aide de la combinaison de touches
<CTRL + MAJ + ESPACE> ou cliquez sur le bouton "Parameter Info" dans la barre d'outils de
l'éditeur.
7.9.2 Etablissement d'une connexion au portail TIA
Introduction
Vous démarrez TIA Portal avec TIA Portal Openness ou établissez la liaison avec un TIA Portal
en cours d'exécution. Si vous démarrez TIA Portal avec une application TIA Portal Openness,
indiquez si TIA Portal doit être démarré avec ou sans interface utilisateur graphique. Si vous
travaillez avec TIA Portal sans interface utilisateur, TIA Portal est uniquement lancé comme un
processus du système d'exploitation. Si nécessaire, une application TIA Portal Openness vous
permet de créer plusieurs instances de TIA Portal.
Remarque
Si vous utilisez l'application TIA Portal Openness pour accéder à l'interface de TIA Portal, vous
ne pouvez pas utiliser d'éditeur IHM. Vous pouvez ouvrir l'éditeur "Appareils & réseaux" ou
l'éditeur de programmation manuellement ou via TIA Portal Openness API.

Vous disposez des options suivantes pour démarrer TIA Portal avec une application TIA Portal
Openness.
● Utilisez un fichier de configuration d'application (recommandé pour la plupart des
applications).
● Utilisez la méthode "AssemblyResolve" (recommandé pour la copie, etc.).
● Copiez le fichier Siemens.Engineering.dll dans le répertoire de l'application TIA Portal
Openness.
Remarque
Nous vous recommandons de charger Siemens.Engineering.dll à l'aide du fichier de
configuration d'application. Cette méthode permet de tenir compte des noms forts et les
modifications dommageables au Engineering.dll entraînent une erreur de chargement. Ce qui
n'est pas détectable en cas d'utilisation de la méthode AssemblyResolve.
Démarrage de TIA Portal avec un fichier de configuration d'application

Créez dans le fichier de configuration d'application des renvois à toutes les bibliothèques de
programmes requises. Répartissez le fichier de configuration d'application avec l'application
TIA Portal Openness.
Enregistrez le fichier de configuration d'application "app.config" dans le même répertoire que
l'application TIA Portal Openness et intégrez ce fichier dans votre application. Vérifiez dans
chaque code si le chemin d'accès au fichier correspond au chemin d'installation de TIA Portal.
Vous pouvez utiliser l'extrait de code suivant pour le fichier de configuration d'application :
<?xml version="1.0"?>
<configuration>
<runtime>
<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
<dependentAssembly>
<assemblyIdentity name="Siemens.Engineering" culture="neutral"
publicKeyToken="d29ec89bac048f84"/>

<codeBase version="Vxx.x.x.x" href="FILE://C:\Program Files\Siemens
\Automation\Portal Vxx\PublicAPI\Vxx\Siemens.Engineering.dll"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="Siemens.Engineering.Hmi" culture="neutral"
publicKeyToken="d29ec89bac048f84"/>

<codeBase version="Vxx.x.x.x" href="FILE://C:\Program Files\Siemens
\Automation\Portal Vxx\PublicAPI\Vxx\Siemens.Engineering.Hmi.dll"/>
</dependentAssembly>
</assemblyBinding>
</runtime>
</configuration>

Pour ouvrir une nouvelle instance de TIA Portal via le fichier de configuration d'application,
utilisez le code de programme suivant :
//Connect a TIA Portal Openness application via API using

using System;
using System.IO;
namespace UserProgram
{
internal class MyProgram
{
public static void Main(string[] args)
{
// 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))
{
//begin of code for further implementation
//...
//end of code
}
}
}
}
Démarrage de TIA Portal avec la méthode "AssemblyResolve"

Créez le code de programme de TIA Portal Openness de telle sorte que l'enregistrement sur
l'événement "AssemblyResolve" soit effectué le plus tôt possible. Encapsulez l'accès à TIA
Portal dans un objet ou une méthode supplémentaire.
La prudence est de mise lors de la résolution d'Engineering Assembly par la méthode
AssemblyResolve. Lorsque des types de l'Engineering Assembly sont utilisés avant l'exécution
de l'Assembly Resolver, le programme se bloque. Cela est dû au fait que le compilateur Just-
in-time (compilateur JIT) ne compile une méthode qu'au moment où il doit l'exécuter. Lorsque
des types d'un Engineering Assembly sont utilisés par ex. dans "Main", le compilateur JIT
essaie de compiler "Main" pendant l'exécution du programme. Ce qui échoue parce que le
compilateur JIT ne sait pas où trouver l'Engineering Assembly. L'enregistrement de Assembly
Resolver dans Main n'y change rien. La méthode doit être en cours d'exécution avant
l'enregistrement de Assembly Resolver et compilée avant que celui-ci ne puisse être exécuté.
La solution à ce problème consiste à placer la Business Logic, qui utilise les types provenant
de l'Engineering Assembly, dans une méthode séparée. Et la méthode séparée utilise
uniquement des types que le compilateur JIT comprend déjà. L'exemple suivant utilise une
méthode qui fournit en retour "void", ne possède aucun paramètre et contient toutes les
Business Logic. Le compilateur JIT peut maintenant compiler "Main" avec succès parce qu'il
comprend tous les types présents dans Main. Assembly Resolver est déjà enregistré lorsque
RunTiaPortal est appelé pendant l'exécution. Ainsi, le compilateur JIT sait où trouver
l'Engineering Assembly lorsqu'il cherche les types de Business Logic.

Pour ouvrir une nouvelle instance de TIA Portal, utilisez le code de programme suivant.
using System;
using System.IO;
using System.Reflection;
namespace UserProgram
{
static class MyProgram
{
public static void Main(string[] args)
{
AppDomain.CurrentDomain.AssemblyResolve += MyResolver;
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))
{
//...
//end of code
}
}
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";
// Edit the following path according to your installed version of TIA Portal
string path = Path.Combine(@"C:\Program Files\Siemens\Automation\Portal Vxx
\PublicAPI\Vxx\", name);
string fullPath = Path.GetFullPath(path);
if (File.Exists(fullPath))
{
return Assembly.LoadFrom(fullPath);
}
return null;
}
}
}

Accéder à des instances actives de TIA Portal

Pour pouvoir établir une liaison à une instance active de TIA Portal avec une application TIA
Portal Openness, énumérez d'abord les instances de TIA Portal. Vous pouvez vous connecter
à plusieurs instances au cours d'une session Windows. L'instance active peut être TIA Portal
avec ou sans interface utilisateur démarrée :
foreach (TiaPortalProcess tiaPortalProcess in TiaPortal.GetProcesses())

{
//...
}
Si vous connaissez l'ID de processus de l'instance du TIA Portal, utilisez cet ID de processus
pour accéder à l'objet. Le démarrage de TIA Portal nécessite un certain temps avant que vous
ne puissiez le connecter à TIA Portal Openness.
Lors de l'établissement de la liaison à une instance active de TIA Portal, une invite de
commande du pare-feu TIA Portal Openness s'affiche. Vous pouvez choisir parmi ces options
pour la liaison :
● Autoriser la liaison de manière unique
● Ne pas autoriser la liaison
● Toujours autoriser les liaisons de cette application
Pour plus d’informations, voir Pare-feu TIA Portal Openness (Page 84).
Remarque
Si l'invite de commande du registre est rejetée trois fois, le système déclenche une
exception du type EngineeringSecurityException.
Une fois la liaison au processus établie, vous pouvez appeler des informations sur les
instances de TIA Portal à l'aide de l'un des attributs suivants :
Attribut Information
InstalledSoftware as Fournit en retour des informations sur les produits installés.
IList<TiaPortalProduct>
Mode as TiaPortalMode Fournit en retour le mode dans lequel TIA Portal a été démarré (WithoutUserInterface/
WithUserInterface).
AttachedSessions as Fournit en retour une liste d'applications qui sont connectées à TIA Portal.
IList<TiaPortalSession>
ProjectPath as FileInfo Fournit en retour le nom de fichier du projet ouvert dans TIA Portal, y compris le dossier,
par exemple.
"D:\WinCCProjects\ColorMixing\ColorMixing.ap*"
Si aucun projet n'est ouvert, une chaîne de caractères vide est fournie en retour.
ID as int Fournit en retour l'ID de processus de l'instance TIA Portal.
Path as FileInfo Fournit en retour le chemin d'accès au fichier exécutable de TIA Portal.

7.9.3 Pare-feu TIA Portal Openness
Invite de commande du pare-feu TIA Portal Openness

Si vous essayez d'établir une liaison via TIA Portal Openness à une instance de TIA Portal en
cours d'exécution, TIA Portal vous invite à accepter ou à rejeter la liaison, comme représenté
sur la copie d'écran suivante.
Autoriser la liaison à TIA Portal de manière unique

Si vous souhaitez autoriser de manière unique la liaison de votre application TIA Portal
Openness à TIA Portal, cliquez sur "Yes" à l'invite de commande. Lorsque votre application TIA
Portal Openness essaiera d'établir une liaison à TIA Portal la prochaine fois, l'invite apparaîtra
de nouveau.
Ajouter une entrée Whitelist par l'accès à TIA Portal

Pour créer une entrée Whitelist pour votre application TIA Portal Openness, procédez comme
suit :
1. Lorsque vous cliquez sur "Yes to all" à l'invite, une boîte de dialogue s'ouvre pour le contrôle
de compte utilisateur.
2. Dans cette boîte de dialogue, cliquez sur "Yes" pour ajouter votre application pour la
Whitelist dans la base de données d'enregistrement Windows et pour relier l'application à
TIA Portal.

Ajouter une entrée Whitelist sans TIA Portal

Si vous voulez créer une entrée Whitelist sans utiliser TIA Portal, vous pouvez générer un
fichier de Registre comme suit :
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Siemens\Automation\Openness\Vxx.x\Whitelist
\CustomerApplication.exe]
[HKEY_LOCAL_MACHINE\SOFTWARE\Siemens\Automation\Openness\Vxx.x\Whitelist
\CustomerApplication.exe\Entry]
"Path"="E:\\Work\\Openness\\CustomerApplication\\bin\\Release\\CustomerApplication.exe"
"DateModified"="2014/06/10 15:09:44.406"
"FileHash"="0rXRKUCNzMWHOMFrT52OwXzqJef10ran4UykTeBraaY="
L'exemple suivant montre comment calculer la valeur Filehash et la date de dernière

modification :
string applicationPath = @"E:\\Work\\Openness\\CustomerApplication\\bin\\Release\

\CustomerApplication.exe";
string lastWriteTimeUtcFormatted = String.Empty;
DateTime lastWriteTimeUtc;
HashAlgorithm hashAlgorithm = SHA256.Create();
FileStream stream = File.OpenRead(applicationPath);
byte[] hash = hashAlgorithm.ComputeHash(stream);
// this is how the hash should appear in the .reg file
string convertedHash = Convert.ToBase64String(hash);
lastWriteTimeUtc = fileInfo.LastWriteTimeUtc;
// this is how the last write time should be formatted
lastWriteTimeUtcFormatted = lastWriteTimeUtc.ToString(@"yyyy/MM/dd HH:mm:ss.fff");
7.9.4 Gestionnaire d'événements
Gestionnaire d'événements dans l'application TIA Portal Openness

Une instance de TIA Portal propose les événements suivants, auxquels vous pouvez réagir
avec un gestionnaire d'événements dans une application TIA Portal Openness. Vous pouvez
accéder aux attributs de notifications et définir les réactions en conséquence.
Evénement Réponse
Disposed Cet événement vous permet de réagir avec une application TIA Portal Openness à la
fermeture de TIA Portal.
Notification Cet événement vous permet de réagir avec une application TIA Portal Openness aux
notifications de TIA Portal. Les notifications requièrent juste une confirmation, telle que
"OK".
Confirmation Cet événement vous permet de réagir avec une application TIA Portal Openness aux
confirmations de TIA Portal. Les confirmations requièrent toujours une décision, telle que
"Voulez-vous enregistrer le projet ?".

Code de programme
Pour enregistrer un gestionnaire d'événements dans une application TIA Portal Openness,
modifiez le code de programme suivant :
//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)

{
....
}
Attributs des notifications du TIA Portal

Les notifications du TIA Portal possèdent les attributs suivants :
Attribut Description
Caption Fournit en retour le nom de la confirmation.
DetailText Fournit en retour le texte détaillé de la confirmation.
Icon Fournit en retour l'icône de la confirmation.
IsHandled Fournit en retour la confirmation ou indique si le système attend la confirmation.
Text Fournit en retour le texte de la confirmation.

Attributs des confirmations

Les confirmations possèdent les attributs suivants :
Caption Fournit en retour le nom de la confirmation.
Choices Donne les possibilités pour acquitter la confirmation.
DetailText Fournit en retour le texte détaillé de la confirmation.
Icon Fournit en retour l'icône de la confirmation.
IsHandled Fournit en retour la confirmation ou indique si le système attend la confirmation.
Result Fournit ou indique le résultat de l'acquittement.
Text Fournit en retour le texte de la confirmation.
Voir aussi
Confirmer les boîtes de dialogue comportant des alarmes système par commande du
programme (Page 87)
7.9.5 Confirmer les boîtes de dialogue comportant des alarmes système par
commande du programme
Condition requise
● L'application TIA Portal Openness est connectée à TIA Portal.
Voir Etablissement d'une connexion au portail TIA (Page 79)
● Un projet est ouvert.
Voir Ouvrir un projet (Page 109)
● Les gestionnaires d'événements sont enregistrés.
Utilisation
Si vous commandez TIA Portal par le biais de l'interface utilisateur, des boîtes de dialogue
comportant des événements système s'affichent pour certaines séquences du programme. À
l'aide de ces événements système, vous décidez comment continuer.
Si vous accédez à TIA Portal avec une application TIA Portal Openness, ces événements
système doivent être acquittés via les événements ".NET" correspondants.
Les confirmations autorisées figurent dans la liste Choices :
● Abort
● Cancel
● Ignore
● No
● NoToAll

● None
● OK
● Retry
● Yes
● YesToAll
La valeur de ConfirmationEventArgs.Result doit être l'une des entrées
susmentionnées. Faute de quoi, une exception est lancée.
Code de programme
Pour réagir à un événement de confirmation, modifiez le code de programme suivant :
...
tiaPortal.Confirmation += TiaPortalConfirmation;
...
private void TiaPortalConfirmation(object sender, ConfirmationEventArgs e)
{
...
}
Pour informer le concepteur des actions exécutées avec une application TIA Portal Openness,
//Handles notifications
using (TiaPortal tiaPortal = new TiaPortal())
{
tiaPortal.Notification += Notification;
try
{
//perform actions that will result in a notification event
}
finally
{
tiaPortal.Notification -= Notification;
}
}
7.9.6 Mettre fin à la connexion au portail TIA
Introduction
Si vous avez démarré l'instance du TIA Portal sans interface utilisateur et que votre application
est le seul client TIA Portal Openness relié à TIA Portal, vous pouvez fermer cette instance du
TIA Portal via l'application TIA Portal Openness. Sinon, déconnectez l'application TIA Portal
Openness de l'instance du TIA Portal.

Déconnectez ou fermez l'instance active de TIA Portal à l'aide de la méthode

IDisposable.Dispose().
Vous pouvez utiliser la méthode IDisposable.Dispose() comme suit :
● avec un using-Statement.
● Entourez la description de l'objet avec un bloc try-finally et appelez la
méthode IDispose.Dispose() au sein du bloc finally.
Si vous quittez l'instance active du portail TIA, vous ne pouvez plus accéder au portail TIA.
Remarque
Si un concepteur ferme l'instance du TIA Portal en dépit d'un accès en cours d'une application
TIA Portal Openness, une exception de la classe "NonRecoverableException" est déclenchée
lors du prochain accès dans l'application TIA Portal Openness. Vous pouvez vous abonner à
un événement Disposed afin de recevoir un appel lors de la fermeture de TIA Portal.
Code du programme
Pour couper la connexion au portail TIA ou y mettre fin, utilisez le code de programme suivant :
// Add code to dispose the application if the application is still instantiated

if (tiaPortal != null)
{
tiaPortal.Dispose();
}
Voir aussi
Gestionnaire d'événements (Page 85)
7.9.7 Interfaces de diagnostic dans TIA Portal
Utilisation
Vous pouvez appeler certaines informations de diagnostic d'instances de TIA Portal en cours
d'exécution avec une méthode statique. L'interface de diagnostic est réalisée dans l'objet
TiaPortalProcess que vous pouvez appeler pour chaque instance TIA Portal en cours
d'exécution.
L'interface de diagnostic n'est pas bloquée. Vous pouvez donc accéder à l'objet
TiaPortalProcess ainsi qu'à ses membres et ce, que TIA Portal soit occupé ou non. L'interface
de diagnostic comprend les membres suivants :

Classe TiaPortalProcess
Membre Type Fonction

AcquisitionTime DateTime Date et heure auxquelles l'objet
TiaPortalProcess a été saisi.
Comme l'objet TiaPortalProcess
représente un instantané tout à
fait statique de l'état de TIA Por‐
tal à un moment donné, les infor‐
mations qu'il contient peuvent
être obsolètes.
Attach TiaPortal Est relié à TiaPortalProcess don‐
né et fournit en retour une instan‐
ce de TIA Portal.
AttachedSessions IList<TiaPortalSession> Bibliothèque de toutes les autres
sessions actuellement atta‐
chées au même TIA Portal. Cet‐
te bibliothèque peut être vide.
Chaque session est représentée
par un objet TiaPortalSession
décrit comme suit.
Attaching EventHandler<AttachingEven‐ Cet événement permet à l'appli‐
tArgs> cation d'autoriser des tentatives
de lien à TIA Portal. Lorsqu'une
autre application essaie de s'at‐
tacher à TIA Portal, les membres
de cet événement en sont infor‐
més. Les membres ont alors 10
secondes pour autoriser l'opéra‐
tion. Si un membre ignore cet
événement ou n'y réagit pas à
temps, cela est considéré com‐
me un refus et l'opération n'est
pas autorisée à l'application de‐
mandeuse. Les applications blo‐
quées, et donc incapables de
réagir à cet événement, ne peu‐
vent pas refuser à une autre ap‐
plication l'autorisation de s'atta‐
cher.
Dispose void Ferme l'instance de TIA Portal
correspondante.
Id int ID de processus de TIA Portal.
InstalledSoftware IList<TiaPortalProduct> Bibliothèque de tous les produits
actuels installés comme partie
de TIA Portal. Chaque produit
est représenté par un objet Tia‐
PortalProduct décrit comme suit.
Mode TiaPortalMode Fournit en retour le mode dans
lequel TIA Portal a été démarré.
Valeurs actuelles : WithUserIn‐
terface et WithoutUserInterface.


Path FileInfo Chemin d'accès au fichier exécu‐
table de TIA Portal.
ProjectPath FileInfo Chemin d'accès au projet actuel
ouvert dans TIA Portal. Si aucun
projet n'est ouvert, cet attribut a
la valeur zéro.
Classe TiaPortalSession

AccessLevel TiaPortalAccessLevel Niveau d'accès de la session.
Est représenté sous forme d'une
énumération de mémentos et
plusieurs niveaux d'accès sont
possibles. La section qui suit pro‐
pose une description détaillée de
TiaPortalAccessLevel.
AttachTime DateTime Date et heure auxquelles la liai‐
son à TIA Portal été établie.
Id int L'ID de la session actuelle.
IsActive bool Fournit "vrai" en retour lorsque le
traitement d'un appel provenant
de cette session est en cours
d'exécution sur TIA Portal.
Dispose void Met fin à la connexion entre le
processus et TIA Portal. Cette
méthode ne force pas la fin du
processus, comme ce serait le
cas avec System.Diagnos‐
tics.Process.Kill. L'application
dont la connexion est terminée
reçoit malgré tout un événement
Disposed. Toutefois, aucune in‐
dication n'est donnée sur ce qui
a provoqué la fin de la conne‐
xion.
ProcessId int ID du processus attaché.
ProcessPath FileInfo Chemin d'accès au fichier exécu‐
table du processus attaché.
TrustAuthority TiaPortalTrustAuthority Indique si la session actuelle a
été démarrée par un processus
signé et s'il s'agit d'un certificat
TIA Portal Openness ou non.
TrustAuthority est une énuméra‐
tion de mémentos décrite com‐
me suit.


UtilizationTime TimeSpan Période pendant laquelle le pro‐
cessus a été actif dans TIA Por‐
tal. En combinaison avec l'attri‐
but AttachTime, ceci peut servir
à déterminer des pourcentages
de durée de vie ou d'autres infor‐
mations similaires.
Version string Version de Siemens.Engineer‐
ing.dll attaché à la session.
Enum TiaPortalAccessLevel
Valeur d'énumération Fonction

None Cette valeur n'est pas valide. La valeur est indi‐
quée parce que TiaPortalAccessLevel est un mé‐
mento de type Enum et qu'à ce titre, une "valeur
zéro" correspondante est requise pour montrer
qu'aucun mémento n'est mis à 1. Mais elle n'ap‐
paraît jamais dans la pratique, car aucune session
ne peut être démarrée sans accès.
Published La session a accès à la fonctionnalité publiée.
Modify La session a accès en modification.
Enum TiaPortalTrustAuthority
Valeur d'énumération Fonction

None Le module principal du processus attaché n'est
pas signé à l'aide d'un certificat.
Signed Le module principal est signé à l'aide d'un certifi‐
cat, mais il ne s'agit pas d'un certificat TIA Portal
Openness.
Certified Le module principal est signé à l'aide d'un certificat
CertifiedWithExpiration Le module principal est signé à l'aide d'un certificat
TIA Portal Openness qui perd sa validité lorsque
sa durée de vie est écoulée.
Classe TiaPortalProduct

Name string Nom du produit (par ex. STEP 7
Professional).
Options IList<TiaPortalProduct> Une bibliothèque de tous les pro‐
giciels qui font partie du TIA Por‐
tal relié, représentés comme ob‐
jets TiaPortalProduct. Lorsqu'un
progiciel contient, à son tour, des
progiciels, le niveau d'imbrica‐
tion peut être plus important.
Version string Trame de version du produit.

L'exemple de section de code suivant montre comment utiliser l'interface de diagnostic pour
interroger des informations et comment ensuite utiliser ces informations dans votre application.
public void TiaPortalDiagnostics()

{
IList<TiaPortalProcess> tiaPortalProcesses = TiaPortal.GetProcesses();
foreach (TiaPortalProcess tiaPortalProcess in tiaPortalProcesses)
{
Console.WriteLine("Process ID: {0}", tiaPortalProcess.Id);
Console.WriteLine("Path: {0}", tiaPortalProcess.Path);
Console.WriteLine("Project: {0}", tiaPortalProcess.ProjectPath);
Console.WriteLine("Timestamp: {0}", tiaPortalProcess.AcquisitionTime);
Console.WriteLine("UI Mode: {0}", tiaPortalProcess.Mode);
//See method body below.
Console.WriteLine("Installed Software:");
EnumerateInstalledProducts(tiaPortalProcess.InstalledSoftware);
Console.WriteLine("Attached Openness Applications:");
foreach (TiaPortalSession session in tiaPortalProcess.AttachedSessions)
{
Console.WriteLine("Process: {0}", session.ProcessPath);
Console.WriteLine("Process ID: {0}", session.ProcessId);
DateTime attachTime = session.AttachTime;
TimeSpan timeSpentAttached = DateTime.Now - attachTime;
TimeSpan utilizationTime = session.UtilizationTime;
long percentageTimeUsed = (utilizationTime.Ticks / timeSpentAttached.Ticks) *
100;
Console.WriteLine("AttachTime: {0}", attachTime);
Console.WriteLine("Utilization Time: {0}", utilizationTime);
Console.WriteLine("Time spent attached: {0}", timeSpentAttached);
Console.WriteLine("Percentage of attached time spent using TIA Portal: {0}",
percentageTimeUsed);
Console.WriteLine("AccessLevel: {0}", session.AccessLevel);
Console.WriteLine("TrustAuthority: {0}", session.TrustAuthority);
if ((session.TrustAuthority & TiaPortalTrustAuthority.Certified) !=
TiaPortalTrustAuthority.Certified)
{
Console.WriteLine("TrustAuthority doesn't match required level, attempting
to terminate connection to TIA Portal.");
session.Dispose();
}
}
}
}
public void EnumerateInstalledProducts(IEnumerable<TiaPortalProduct> products)
{
foreach (TiaPortalProduct product in products)
{
Console.WriteLine("Name: {0}", product.Name);
Console.WriteLine("Version: {0}", product.Version);
//recursively enumerate all option packages
Console.WriteLine("Option Packages \n:");
EnumerateInstalledProducts(product.Options);
}
}
Information de sécurité

Du fait que l'utilisation de l'interface de diagnostic ne nécessite aucune liaison à TIA Portal, il
est possible d'écrire un service Windows qui se sert de l'événement latéral pour vérifier toute
application qui essaie de s'attacher à TIA Portal. Ainsi, il est possible par ex. de définir que
seules les applications commençant par le nom de votre entreprise sont autorisées à
s'attacher. Une autre option pourrait consister à autoriser systématiquement l'accès mais à
écrire les informations sur les processus latéraux dans un journal. Le code de programme
suivant donne un exemple de gestionnaire d'événements pour vérifier des liaisons entrantes :
public void OnAttaching(object sender, AttachingEventArgs e)

{
string name = Path.GetFileNameWithoutExtension(e.ProcessPath);
TiaPortalAccessLevel requestedAccessLevel = e.AccessLevel &
TiaPortalAccessLevel.Published;
TiaPortalTrustAuthority certificateStatus = e.TrustAuthority
&TiaPortalTrustAuthority.Certified;
if (requestedAccessLevel == TiaPortalAccessLevel.Published &&
certificateStatus == TiaPortalTrustAuthority.Certified &&
name.StartsWith("SampleCustomerName"))
{
e.GrantAccess();
}
}
7.9.8 Accès en exclusivité
Conditions requises
Utilisation
Pour configurer un processus exclusif d'accès à un processus de TIA Portal attaché, la classe
"TIA Portal" propose la méthode "ExclusiveAccess(String text)". L'utilisation d'un accès
exclusif est fortement recommandée même si ce dernier n'est pas obligatoire.
Utilisez "ExclusiveAccess" dans une instruction "using" pour vous assurer que l'accès est
correctement terminé lorsque des exceptions se produisent ou l'application est arrêtée.
Remarque
Toute tentative visant à créer un deuxième accès exclusif dans l'étendue d'un accès exclusif
ouvert, entraîne le déclenchement d'une exception qui peut être restaurée.

Modifiez l'exemple suivant pour avoir "ExclusiveAccess" à une instance :
...
[assembly: AssemblyTitle("MyApplication")]
// This will be used for the exclusive access dialog when present....
TiaPortal tiaPortal = ...;
using (ExclusiveAccess exclusiveAccess = tiaPortal.ExclusiveAccess("My Activity"))
{
...
}
Après la saisie d'une instance "ExclusiveAccess" pour un processus de TIA Portal donné, une
boîte de dialogue s'ouvre. Cette boîte de dialogue affiche le message prévu lors de
l'instanciation. En plus, les informations suivantes sur l'application Client sont également
affichées :
● le titre d'Assembly des données manifestes, s'il est disponible, ou le nom du processus
● l'ID du processus
● la SID (ID de session Openness de l'instance TIA Portal de l'application client)
Remarque
Plusieurs sessions peuvent être actives pour une application Client TIA Portal Openness
donnée parce qu'il existe plusieurs instances de TIA Portal, même si celles-ci sont attribuées
respectivement au même processus TIA Portal.
L'application Client peut également actualiser le contenu affiché dans la boîte de dialogue
d'accès exclusif en remplaçant les valeurs de l'attribut "Texte" par de nouvelles valeurs. Pour
obtenir ce comportement, modifiez le code de programme suivant :
exclusiveAccess = ...;
...
exclusiveAccess.Text = "My Activity Phase 1";
...
exclusiveAccess.Text = "My Activity Phase 2";
...
exclusiveAccess.Text = String.Empty; // or null;
...

Vous pouvez exiger l'annulation de l'accès exclusif à l'aide du bouton "Cancel"/"Annuler". Pour
obtenir ce comportement, modifiez le code de programme suivant :
exclusiveAccess = ...;
...
if (exclusiveAccess.IsCancellationRequested)
{
// stop your activity
...
}
else
{
// continue your activity
...
}
...
7.9.9 Comportement dynamique
Comportement dynamique dans Openness

Les utilisateurs Openness peuvent définir des objets et leurs attributs au cours de l'exécution.
Ils peuvent également appeler des actions et naviguer de façon bidirectionnelle dans la
hiérarchie vers les objets correspondants. Pour la prise en charge du comportement
dynamique, les interfaces suivantes sont mises à disposition et implémentées par les objets
Openness :
IEngineeringInstance
L'interface qui permet la navigation vers le haut dans le modèle d'objet.
Propriétés :
● IEngineeringObject Parent – objet de niveau supérieur à une instance.
IEngineeringCompositionOrObject
L'interface est implémentée par des objets d'ingénierie et des compositions.
IEngineeringObject
L'interface est implémentée par la majorité des objets disponibles pour l'utilisateur Openness.
L'interface IEngineeringObject est dérivée de IEngineeringCompositionOrObject et
IEngineeringInstance.

Méthodes :
● IList<EngineeringCreationInfo> GetCreationInfos(string compositionName) – appelle la
liste des informations de composition disponibles pour l'objet.
● IEngineeringObject Create(string compositionName, Type type,
IEnumerable<KeyValuePair<string, object>> parameters) – crée un IEngineeringObject du
type indiqué initialisé dans les paramètres avec des valeurs comme le compositionName
indiqué.
● object GetAttribute(string name) – appelle un attribut avec le nom indiqué.
● IList<EngineeringAttributeInfo> GetAttributeInfos() – fournit en retour une bibliothèque
d'objets EngineeringAttributeInfo qui décrivent les différents attributs de cet objet.
● IList<object> GetAttributes(IEnumerable<string> names) – appelle une liste d'attributs pour
les noms indiqués.
● IEngineeringCompositionOrObject GetComposition(string name) – appelle un
IEngineeringCompositionOrObject avec le nom indiqué.
● IList<EngineeringInvocationInfo> GetInvocationInfos() – fournit en retour une bibliothèque
d'objets EngineeringAttributeInfo qui décrivent les différentes actions pour cet objet.
● object Invoke(string name, IEnumerable<KeyValuePair<Type, object>> parameters) –
appelle la méthode représentée par l'instance actuelle en utilisant les paramètres indiqués.
● void SetAttribute(string name, object value) – définit un attribut avec le nom et la valeur
indiqués.
● void SetAttributes(IEnumerable<KeyValuePair<string, object>> attributes) – définit les
attributs avec les noms et les valeurs indiqués comme indiqué dans les attributs.
● EngineeringObjectHandle GetHandle() – appelle l'indicateur univoque de l'objet.
IEngineeringRoot
Cette interface est implémentée par des objets TiaPortal et indique que l'utilisateur se trouve
à l'objet de niveau le plus élevé dans la hiérarchie. IEngineeringRoot est dérivé de
IEngineeringObject, IEngineeringCompositionOrObject et IEngineeringInstance.
Méthodes :
● IEngineeringObject GetObject(EngineeringObjectHandle objectHandle) – appelle l'objet
depuis un indicateur.
IEngineeringComposition
L'interface est implémentée par la majorité des objets disponibles pour l'utilisateur Openness.
L'interface IEngineeringObject est dérivée de IEngineeringCompositionOrObject et
IEngineeringInstance. En plus des propriétés et méthodes décrites sous Travailler avec des
compositions (Page 99), les méthodes suivantes sont prises en charge.

Méthodes :
● IEngineeringObject Create(Type type, IEnumerable<KeyValuePair<string, object>>
parameters) – crée un IEngineeringObject du type indiqué initialisé avec des valeurs,
comme indiqué dans les paramètres.
● IList<EngineeringCreationInfo> GetCreationInfos() – appelle une bibliothèque d'objets
EngineeringCreateInfo qui décrivent les différentes CreateInfos pour cet objet.
● IList<EngineeringInvocationInfo> GetInvocationInfos() – fournit en retour une bibliothèque
d'objets EngineeringAttributeInfo qui décrivent les différentes actions pour cet objet.
● object Invoke(string name, IEnumerable<KeyValuePair<Type, object>> parameters) –
appelle la méthode représentée par l'instance actuelle en utilisant les paramètres indiqués.
IEngineeringObjectAssociation
Cette interface est implémentée par la bibliothèque d'objets d'ingénierie correspondants. Cette
interface est dérivée de IEngineeringAssociation et IEngineeringInstance. Voir Travailler avec
des affectations (Page 99)
IEngineeringServiceProvider
L'interface est implémentée par des objets d'ingénierie qui peuvent mettre à disposition des
services.
Méthodes :
● T GetService<T>() where T : class, IEngineeringService – appelle une instance du type T.
● IList<EngineeringServiceInfo> GetServiceInfos() – fournit en retour une bibliothèque
d'objets EngineeringServiceInfo qui décrivent les différents service pour cet objet.
IEngineeringService
L'interface représente un service d'ingénierie mis à disposition par
IEngineeringServiceProvider.
EngineeringObjectHandle
La structure qui fournit un indicateur d'objet univoque.
Voir aussi
Utilisation de compositions (Page 99)
Utilisation d'associations (Page 99)

7.9.10 Utilisation d'associations
Accéder aux affectations

Une affectation décrit la relation entre deux objets ou plus au niveau du type.
TIA Portal Openness prend en charge l'accès aux affectations via l'index et les boucles
"foreach". L'accès direct, par exemple via string name, n'est pas pris en charge.
Attributs
Les attributs suivants sont disponibles :
● int Count
● bool IsReadonly
● IEngineeringObject Parent
● retType this [ int index ] { get; }
Méthodes
TIA Portal Openness prend en charge les méthodes suivantes :
● int IndexOf ( type ) : fournit en retour l'index dans l'affectation pour une instance
transmise :
● bool Contains ( type ) : détermine si l'instance transmise est contenue dans
l'affectation.
● IEnumerator GetEnumerator <retType>() : est utilisé dans des boucles foreach et
permet d'accéder à un objet.
● void Add ( type )1 : ajoute l'instance transmise de l'affectation.
● void Remove ( type )1 : supprime l'instance transmise de l'affectation.
1
: n'est pas prise en charge par toutes les affectations.
7.9.11 Utilisation de compositions
Appel de compositions
Une composition est un cas particulier d'affectation Une composition exprime une relation
sémantique entre deux objets dont l'un est une partie de l'autre.
Attributs
Les attributs suivants sont disponibles :
● int Count
● bool IsReadonly

● IEngineeringObject Parent
● retType this [int index] {get;} : accède de manière indexée à un objet de la
composition.
Vous devez utiliser ce type d'accès de manière ciblée uniquement, car chaque accès
indexé dépasse les limites du processus.
Méthodes
TIA Portal Openness prend en charge les méthodes suivantes :
● retType Create (id, …) : crée une nouvelle instance et l'ajoute à la composition.
La signature de la méthode dépend du type de création de l'instance. Cette méthode n'est
pas prise en charge par toutes les compositions.
● type Find (id, …) : Recherche dans une composition l'instance ayant l'ID transmis.
La recherche n'est pas récursive. La signature de la méthode dépend du type de recherche
de l'instance. Cette méthode n'est pas prise en charge par toutes les compositions.
● IEnumerator GetEnumerator<retType> () : est utilisé dans des boucles foreach et
permet d'accéder à un objet.
● Delete (type)1 : supprime l'instance spécifiée par la référence d'objet actuelle.
● int IndexOf (type) : fournit en retour l'index dans la composition pour une instance
transmise.
● bool Contains (type) : détermine si l'instance transmise est contenue dans la
composition.
● void Import(string path, ImportOptions importOptions)1 : S'applique à
chaque composition comportant des types pouvant être importés.
Chaque signature d'importation contient un paramètre de configuration du type
"ImportOptions (Page 780)" ("None", "Overwrite") qui permet à l'utilisateur de commander
le comportement à l'importation.
1
: Pas prise en charge par toutes les compositions.
7.9.12 Vérifier l'égalité des objets
Utilisation
En tant qu'utilisateur d'une TIA Portal Openness API, vous pouvez vérifier la similitude des
objets à l'aide du code de programme :
● Vous vérifiez alors avec l'opérateur == si deux références d'objet sont identiques.
● La méthode System.Object.Equals() vous permet de vérifier si deux objets sont
réellement identiques en ce qui concerne le portail TIA.

Code du programme
Pour vérifier les types de référence d'objet, modifiez le code de programme suivant :
...
//Composition
DeviceComposition sameCompA = project.Devices;
DeviceComposition sameCompB = project.Devices;
if (sameCompA.Equals(sameCompB))
{
Console.WriteLine("sameCompA is equal to sameCompB");
}
if (!(sameCompA == sameCompB))
{
Console.WriteLine("sameCompA is not reference equal to sameCompB");
}
DeviceComposition sameCompAsA = sameCompA;
if (sameCompAsA.Equals(sameCompA))
{
Console.WriteLine("sameCompAsA is equal to sameCompA");
}
if (sameCompAsA == sameCompA)
{
Console.WriteLine("sameCompAsA is reference equal to sameCompA");
}
MultiLingualGraphicComposition notSameComp = project.Graphics;
if (!sameCompA.Equals(notSameComp))
{
Console.WriteLine("sameCompA is not equal to notSameComp");
}
7.9.13 Opérations de lecture pour attributs
Opérations d'ensemble et opérations de lecture standards pour attributs

TIA Portal Openness prend en charge l'accès aux attributs par les méthodes suivantes,
disponibles au niveau de l'objet :
● Opérations d'ensemble pour l'accès en lecture
● Opérations standard de lecture

Code du programme pour les opérations d'ensemble
//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)
{
Device device = project.Devices[0];
IList<string> attributeNames = new List<string>();
IList<EngineeringAttributeInfo> attributes =
((IEngineeringObject)device).GetAttributeInfos();
foreach (EngineeringAttributeInfo engineeringAttributeInfo in attributes)
{
string name = engineeringAttributeInfo.Name;
attributeNames.Add(name);
}
IList<object> values = ((IEngineeringObject)device).GetAttributes(attributeNames);
for (int i = 0; i < attributes.Count; i++)
{
Console.WriteLine("attribute name: " + attributeNames[i] + " value: " + values[i]);
}
}
Opérations d'ensemble pour l'accès en lecture

Cette méthode est disponible pour chaque objet :
public abstract IList<object> GetAttributes(IEnumerable<string>
names);
Opérations standard de lecture

Les opérations suivantes sont disponibles :
● Appeler les noms des attributs disponibles :
Utilisez la méthode GetAttributeInfos() (Page 106) sur un IEngineeringObject.
● Méthode générique pour la lecture d'un attribut
public abstract object GetAttribute(string name);
Remarque
Les attributs dynamiques ne s'affichent pas dans IntelliSense car leur disponibilité dépend de
l'état de l'instance d'objet.

7.9.14 Traitement des transactions
Conditions
Opération
Une rémanence (projet, bibliothèque, etc.) ouverte au sein d'un processus TIA Portal
correspondant peut être modifiée par une application Client TIA Portal Openness. Vous
pouvez obtenir cette modification avec une opération unique ou une série d'opérations.
Pendant l'action, il est utile de regrouper ces opérations dans une seule pile Undo afin d'obtenir
un déroulement plus logique. En outre, regrouper des opérations dans une pile Undo unique
présente également des avantages en matière de performance. Pour aider à cela, la classe
"ExclusiveAccess" propose la méthode "Transaction(ITransactionSupport persistence, string
undoDescription)". L'appel depuis cette méthode entraîne l'instanciation d'un nouvel objet de
type "Transaction" qui peut être arrêté. Vous devez fournir la description du contenu de la
transaction (l'attribut Texte ne doit pas être nul ou vide). Tant que cette instance n'a pas été
terminée, toutes les opérations des applications Client sont regroupées dans une pile Undo
unique au sein du processus TIA Portal correspondant.
Pour saisir une instance de type "Transaction", modifiez le code de programme suivant :
ExclusiveAccess exclusiveAccess = ...;

Project project = ...;
using (Transaction transaction = exclusiveAccess.Transaction(project, "My Operation"))
{
...
}
Remarque
Utilisez une instruction "using" pour instancier une "Transaction". Cela vous permet d'assurer
que la transaction soit terminée correctement, même si des exceptions se produisent, et
d'annuler ainsi la transaction.
Application cohérente ou annulation

Une "Transaction" dans une application Client vous permet d'assurer qu'il existe un chemin
prévisible pour rendre effectif ou annuler un jeu de modifications. Votre application Client doit
décider si les modifications apportées à une rémanence doivent devenir effectives ou pas.
Pour cela, votre application doit demander que les modifications dans l'étendue d'une
transaction ouvertes deviennent effectives lorsque la transaction est terminée par appel de la
méthode "Transaction.CommitOnDispose()". Si cette méthode n'est jamais appelée dans le
déroulement du code, les modifications apportées dans l'étendue de la transaction ouverte
sont automatiquement annulées à la fin de la transaction.

Si une exception se produit après cette requête, toutes les modifications apportées dans
l'étendue d'une transaction ouverte sont malgré tout annulées à la fin de la transaction.
Pour créer une pile Undo unique dans un processus TIA Portal attaché avec deux modifications
"Create", modifiez le code de programme suivant :
ExclusiveAccess exclusiveAccess = ...;

using (Transaction transaction = exclusiveAccess.Transaction(project, "My Operation")
{
project.DeviceGroups.Create("My Group 1");
project.DeviceGroups.Create("My Group 2");
transaction.CommitOnDispose();
}
Restrictions
Les actions suivantes ne sont pas autorisées dans une transaction. L'appel de ces actions
entraîne une exception récupérables :
● Compile
● Go Online
● Go Offline
● ProjectText Import
● ProjectText Export
● Open Global Library
● Close Global Library
● Project Create
● Project Open
● Project OpenWithUpgrade
● Project Save
● Project SaveAs
● Project Close
Comportement Undo
Les actions exécutées par une application Client TIA Portal Openness peuvent entraîner des
piles Undo au sein du processus TIA Portal attaché. Chacune de ces entrées Undo est
regroupée sous une entrée locale. L'entrée locale est composée des informations suivantes
provenant de l'application Client :
● le titre d'Assembly des données manifestes, s'il est disponible, ou le nom du processus
● l'ID du processus
● la SID (ID de session Openness de l'instance TIA Portal de l'application client)
● un message indiquant que le processus Client est en cours d'exécution

Ces entrées appartiennent à un des deux types suivants :

1. Les opérations, qui sont regroupées dans une transaction Undo comme résultats de
l'utilisation d'une "Transaction", possèdent la description mise à disposition par l'application
Client lorsque la "Transaction" a été instanciée.
– Entrée Undo pour une application Client en cours d'exécution :
– Entrée Undo pour une application Client arrêtée :
2. Pour les opérations qui sont exécutées individuellement, il existe des entrées Undo
séparées pour la description de l'opération telle que définie dans la commande de
métadonnées correspondante.
– Entrée Undo pour une application Client en cours d'exécution :
– Entrée Undo pour une application Client arrêtée :
7.9.15 Créer un objet DirectoryInfo/FileInfo
Utilisation
Les instances des classes DirectoryInfo et FileInfo doivent contenir un chemin absolu.
Dans le cas contraire, les méthodes qui utilisent les objets DirectoryInfo ou FileInfo
provoquent une exception.

Code de programme
Pour créer un objet DirectoryInfo ou FileInfo, modifiez le code de programme suivant :
..
//Create a DirectoryInfo object
string directoryPath = @"D:\Test\Project 1";
DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);
　　
//Create a FileInfo object

string fileName = @"D:\Test\Project 1\Project 1.apx");
FileInfo fileInfo = new FileInfo(fileName);
...
7.9.16 Prise en charge de l'autodescription pour attributs, navigateurs, actions et

services
Utilisation
Dans TIA Portal Openness, chaque IEngineeringServiceProvider de la TIA Portal Openness
API décrit ses capacités pour de potentiels appels.
Prise en charge de l'autodescription pour IEngineeringObject
Nom de la méthode Valeurs retournées

GetCompositionInfos Fournit en retour une bibliothèque d'objets du type
EngineeringCompositionInfo, qui décrivent les dif‐
férentes compositions de ces objets. La section
qui suit propose une description de Engineering‐
CompositionInfo.
GetAttributeInfos Fournit en retour une bibliothèque d'objets du type
EngineeringAttributeInfo, qui décrivent les diffé‐
rents attributs de ces objets. La section qui suit
propose une description deEngineeringAttributeIn‐
fo.
GetInvocationInfos Fournit en retour une bibliothèque d'objets du type
EngineeringInvocationInfo, qui décrivent les diffé‐
rentes actions de ces objets. La section qui suit
propose une description de EngineeringInvocatio‐
nInfo.
Prise en charge de l'autodescription pour IEngineeringServiceProvider

GetServiceInfos Fournit en retour une bibliothèque d'objets du type
EngineeringServiceInfo, qui décrivent les diffé‐
rents services de ces objets. La section qui suit
propose une description de EngineeringServiceIn‐
fo.

Prise en charge de l'autodescription pour IEngineeringComposition

GetCreationInfos Fournit en retour une bibliothèque d'objets du type
EngineeringCreationInfo, qui décrivent les diffé‐
rentes actions de ces objets.
EngineeringcreationInfo est décrit ci-après.
Classe EngineeringCompositionInfo
Nom d'attribut Valeurs retournées

Name Nom de la composition.
Classe EngineeringAttributeInfo

AccessMode Niveau d'accès pris en charge par l'attribut. La
section qui suit propose une description détaillée
de cet attribut.
Name Nom de l'attribut.
Classe EngineeringInvocationInfo

Name Nom de l'action.
ParameterInfos Une bibliothèque d'objets du type EngineeringIn‐
vocationParameterInfo, qui décrivent les paramè‐
tres requis éventuellement pour l'action. La sec‐
tion qui suit propose une description de Enginee‐
ringInvocationParameterInfo.
Classe EngineeringServiceInfo

Type Type de service comme objet System.Type.
Enum AccessMode
Valeur d'énumération Valeurs retournées

None Option invalide.
Read L'attribut peut être lu.
Write L'attribut peut être écrit.
Classe EngineeringInvocationParameterInfo

Name Nom du paramètre.
Type Type du paramètre comme objet System.Type.

Classe EngineeringCreationInfo

Type La propriété Type fournit en retour un objet Sys‐
tem.Type.
ParameterInfos La propriété ParameterInfos fournit en retour une
bibliothèque d'objets EngineeringCreationPara‐
meterInfo .
Classe EngineeringCreationParameterInfo

Name Nom du paramètre concerné
Code de programme
AccessMode est une énumération de mémentos dont les valeurs peuvent être combinées
comme dans le code de programme suivant :
EngineeringAttributeAccessMode value = EngineeringAttributeAccessMode.Read|

EngineeringAttributeAccessMode.Write;
Pour rechercher tous les attributs d'un IEngineeringObject et apporter des modifications au
mode d'accès à ces derniers, modifiez le code de programme suivant :
...
IEngineeringObject engineeringObject = ...;
IList<EngineeringAttributeInfo> attributeInfos = engineeringObject.GetAttributeInfos();
foreach(EngineeringAttributeInfo attributeInfo in attributeInfos)
{
switch (attributeInfo.AccessMode)
{
case EngineeringAttributeAccessMode.Read:
...
break;
case EngineeringAttributeAccessMode.Write:
...
break;
case EngineeringAttributeAccessMode.Read|EngineeringAttributeAccessMode.Write:
...
break;
}
}
...

7.10 Fonctions des projets et données de projet
Modifiez le code de programme suivant indiquant la façon dont Create et GetCreationInfos

doivent être utilisés en commun.
...
Project project = tiaPortal.Projects.Open(projectPath);
IEngineeringComposition deviceGroupComposition = project.DeviceGroups;
EngineeringCreationInfo deviceGroupCreationInfo = deviceGroupComposition.GetCreationInfos()
[0];
EngineeringCreationParameterInfo deviceGroupCreationParameterInfo =
deviceGroupCreationInfo.ParameterInfos[0];
string deviceGroupCreationParameterName = deviceGroupCreationParameterInfo.Name;
string groupName = "Example";
IDictionary<string, object> createParameters = new Dictionary<string, object>
{
{deviceGroupCreationParameterName, groupName }
};
IEngineeringObject group = deviceGroupComposition.Create(deviceGroupCreationInfo.Type,
createParameters);
...
7.10.1 Ouvrir un projet
Conditions
● Le projet à ouvrir n'est ouvert dans aucune autre instance de TIA Portal.
Remarque
Annulation de la mise à niveau d'un projet
Si vous annulez la mise à niveau d'un projet à V14 SP1 après avoir relié ce projet à TIA Portal
Openness, des conflits se produisent.
Utilisation
Utilisez la méthode Projects.Open pour ouvrir un projet. Dans la
méthode Projects.Open, entrez un chemin pour le projet de votre choix.
La méthode Projects.Open ne peut accéder qu'aux projets qui ont été créés ou mis au
niveau à la version la plus récente de TIA Portal . Si vous accédez à un projet d'une version
précédente avec la méthode Projects.Open , vous obtiendrez une exception en retour.

Utilisez la méthode OpenWithUpgrade pour ouvrir les projets qui ont été créés avec une
version précédente de TIA Portal.
Remarque
Pas d'accès aux projets en lecture seule
TIA Portal Openness ne peut accéder qu'aux projets autorisant la lecture et l'écriture.
Code de programme
Pour ouvrir un projet, modifiez le code de programme suivant :
Project project =tiaPortal.Projects.Open(new FileInfo(@"D:\Project_1\Project_1.apXX"));

if (project != null)
{
try
{
...
}
finally
{
project.Close();
}
}
Ouverture d'un projet protégé par UMAC

Vous pouvez également ouvrir un projet protégé par UMAC. La surcharge de la fonction Open
nécessite un paramètre supplémentaire de type UmacDelegate. Ce paramètre supplémentaire
permet à l'appelant d'indiquer un gestionnaire à utiliser pendant l'authentification UMAC. Le
nouveau UmacDelegate est mis en œuvre avec une méthode contenant un paramètre de type
UmacCredentials. UmacCredentials a deux propriétés, 'Name' de type String et 'Type' de type
UmacUserType, ainsi qu'une méthode SetPassword avec un paramètre de type SecureString.
L'utilisation de UmacUserType.Project permet d'indiquer un volume de projet UMAC, alors que
l'utilisation de UmacUserType.Global indique un volume d'application UMAC (c'est-à-dire
commandé par un serveur UMAC).

Code de programme
...
Siemens.Engineering.Project project = tiaPortal.Projects.Open(new
FileInfo(@"D:\Project_3\Project_2.apXX"), MyUmacDelegate);
{
try
{
...
}
finally
{
project.Close();
}
}
...
private static void MyUmacDelegate(UmacCredentials umacCredentials)
{
SecureString password = ...; // Get password from a secure location
umacCredentials.Type = UmacUserType.Project;
umacCredentials.Name = "SomeUser";
umacCredentials.SetPassword(password);
}
...
}
Ouvrir plusieurs projets

Vous pouvez ouvrir dans une instance de TIA Portal un projet primaire et plusieurs projets
secondaires simultanément. Vous devez ensuite décider si un projet doit être ouvert comme
projet principal ou secondaire. Si un projet est ouvert comme projet principal, il est affiché dans
la navigation du projet si l'application Openness est reliée au TIA Portal. Si un projet est ouvert
comme projet secondaire, il n'est pas affiché dans l'interface utilisateur. Les projets
secondaires sont toujours ouverts avec protection en écriture. C'est pourquoi un utilisateur
ayant des droits de lecture/écriture pour les projets protégés UMAC n'aura que des droits de
lecture lorsque le projet est ouvert comme projet secondaire. Il n'est pas nécessaire d'ouvrir un
projet principal pour ouvrir un projet secondaire.
Chaque projet ouvert peut être énuméré à l'aide de la composition du projet dans l'instance du
TIA Portal. L'ordre des projets dans la composition est déterminé par l'ordre dans lequel ils ont
été ouverts. Si un projet est fermé, l'index de tous les projets est recalculé.
Code de programme

Project project1 = tiaPortal.Projects.Open(new
FileInfo(@"D:\Project_1\Project_1.apXX"), null, ProjectOpenMode.Primary);
Project project3 = tiaPortal.Projects.Open(new
FileInfo(@"D:\Project_3\Project_3.apXX"), null, ProjectOpenMode.Secondary);
bool isPrimary = project3.IsPrimary

Ouvrir des projets qui ont été créés avec une version précédente
Utilisez la méthode OpenWithUpgrade pour ouvrir un projet qui a été créé avec la version
précédente de TIA Portal. La méthode crée un nouveau projet actualisé et l'ouvre.
Si vous accédez à un projet créé avec une version plus ancienne, vous obtiendrez une
exception en retour.
Remarque
Si vous accédez à un projet créé avec la version la plus récente, le projet s'ouvre.
Code de programme
Modifiez le code de programme suivant pour ouvrir un projet avec la
méthode OpenWithUpgrade :
Project project = tiaPortal.Projects.OpenWithUpgrade(new FileInfo(@"D:\Some

\Path\Here\Project.apXX"));
{
try
{
...
}
finally
{
project.Close();
}
}
Code de programme pour un projet protégé avec UMAC

Vous pouvez également ouvrir un projet protégé par UMAC qui a été créé avec une version
précédente de TIA Portal. Une fonction de surcharge OpenWithUpgrade nécessite un
paramètre supplémentaire de type UmacDelegate. OpenWithUpgrade est aussi pris en charge
par des projets secondaires.
...
Siemens.Engineering.Project project = tiaPortal.Projects.OpenWithUpgrade(new
FileInfo(@"D:\Project_1\Project.apXX"), MyUmacDelegate);
...

7.10.2 Créer un projet
Conditions
Utilisation
La TIA Portal Openness API permet de créer des projets
● par appel de la méthode Create sur ProjectComposition
● par appel de la méthode Create sur IEngineeringComposition
ProjectComposition.Create
Modifiez le code de programme suivant :

ProjectComposition projectComposition = tiaPortal.Projects;
DirectoryInfo targetDirectory = new DirectoryInfo(@"D:\TiaProjects");
// Create a project with name MyProject

Project project = projectComposition.Create(targetDirectory, "MyProject");
Dans l'exemple utilisé,

● un dossier "D:\TiaProjects\MyProject" est généré.
● un fichier de projet "D:\TiaProjects\MyProject\MyProject.aPXX" est créé.
Remarque
Paramètre targetDirectory
Le paramètre targetDirectory peut également représenter un chemin UNC (Universal Naming
Convention). Un projet peut donc également être créé sur un lecteur validé dans le réseau.

IEngineeringComposition.Create

ProjectComposition projectComposition = tiaPortal.Projects;
//allows the user to give optional create parameters like author, comment in addition to
mandatory create parameters (targetdirectory, projectname)
IEnumerable<KeyValuePair<string, object>> createParameters = new [] {

new KeyValuePair<string, object>("TargetDirectory", new
DirectoryInfo(@"D:\TiaProjects")), // Mandatory
new KeyValuePair<string, object>("Name", "MyProject"), // Mandatory
new KeyValuePair<string, object>("Author", "Bob"), // Optional
new KeyValuePair<string, object>("Comment", "This project was created with
Openness") // Optional };
// Create a project with both mandatory and optional parameters

((IEngineeringComposition)projectComposition).Create(typeof (Project), createParameters);

● un dossier "D:\TiaProjects\MyProject" est généré.
● un fichier de projet "D:\TiaProjects\MyProject\MyProject.aPXX" avec les attributs de projet
Auteur = "Bob" et Commentaire = "This project was created with openness" est créé.
Paramètres pour la création d'un projet avec des attributs de projet optionnels
Paramètre Type de données Obligatoire Description

Author String non Auteur d'un projet.
Comment String non Commentaire relatif au projet.
Name String oui Nom d'un projet.
TargetDirecto‐ DirectoryInfo oui Répertoire contenant le dossier de projet créé.
ry
7.10.3 Accéder à des paramètres généraux de TIA Portal
Conditions

Utilisation
Vous pouvez accéder à des paramètres généraux de TIA Portal à l'aide de TIA Portal
Openness :
● Langue actuelle de l'interface utilisateur
● Option "Rechercher dans le projet" pour créer l'index de recherche requis dans un projet
Le tableau ci-dessous donne les détails des paramètres accessibles dans la section "Général"
des paramètres de TIA Portal. L'instance TiaPortalSettingsFolder porte le nom
"Général".
Nom Type de données Accessible en Description

écriture
"SearchInProj System.Boolean r/w Active ou désactive la création de l'in‐
ect" dex de recherche dans un projet.
"UserInterfac System.CultureInfo r/w Affiche la langue active pour l'interface
eLanguage" utilisateur de TIA Portal.
L'accès à ces paramètres se fait par la classe TiaPortalSettingsFolder. La classe

TiaPortalSettingsFolder est accessible par l'attribut Settings de la classe
TiaPortal.
La figure ci-dessous montre les paramètres spécifiques dans TIA Portal Openness :

7LD3RUWDO

6HWWLQJV)ROGHUV7LD3RUWDO6HWWLQJV)ROGHU&RPSRVLWLRQ

6HWWLQJV)ROGHUV
7LD3RUWDO6HWWLQJV)ROGHU&RPSRVLWLRQ
)LQG6WULQJQDPH7LD3RUWDO6HWWLQJV)ROGHU
)ROGHUV
7LD3RUWDO6HWWLQJV)ROGHU
1DPH 6WULQJ
6HWWLQJV 7LD3RUWDO6HWWLQJ&RPSRVLWLRQ
)ROGHUV 7LD3RUWDO6HWWLQJV)ROGHU&RPSRVLWLRQ
6HWWLQJV
7LD3RUWDO6HWWLQJ&RPSRVLWLRQ
)LQG6WULQJQDPH7LD3RUWDO6HWWLQJ
7LD3RUWDO6HWWLQJ
1DPH6WULQJ
9DOXH2EMHFW

Code de programme : rechercher dans le projet

Pour activer ou désactiver l'option "Rechercher dans le projet", modifiez le code de programme
suivant.
private static void SetSearchInPoject(Project project)

{
TiaPortalSettingsFolder generalSettingsFolder =
tiaPortal.SettingsFolders.Find("General");
TiaPortalSetting searchSetting =
generalSettingsFolder.Settings.Find("SearchInProject");
if (((bool)searchSetting.Value))
{
searchSetting.Value = false;
}
}
Code de programme : langue de l'interface utilisateur

Pour accéder à la langue actuelle de l'interface utilisateur, modifiez le code de programme
suivant :
private static void SetUILanguage(Project project)

{
TiaPortalSettingsFolder generalSettingsFolder =
tiaPortal.SettingsFolders.Find("General");
TiaPortalSetting UILanguageSetting =
generalSettingsFolder.Settings.Find("UserInterfaceLanguage");
if (((CultureInfo)UILanguageSetting.Value) != CultureInfo.GetCultureInfo("de-DE"))
{
UILanguageSetting .Value = CultureInfo.GetCultureInfo("de-DE");
}
Voir aussi
Ouvrir un projet (Page 109)

7.10.4 Archiver et appeler un projet
Condition
Voir Établissement d'une connexion à TIA Portal (Page 79)
● Un projet est enregistré.
Voir Enregistrer le projet (Page 136)
Application
Avec TIA Portal Openness, vous pouvez archiver l'état du projet ouvert et enregistré avant
d'effectuer d'autres modifications et appeler plus tard le projet archivé.
Archiver un projet
Vous pouvez archiver un projet TIA Portal avec l'API TIA Openness disponible dans l'objet
Siemens.Engineering.Project .
public void Archive(System.IO.DirectoryInfo targetDirectory, string targetName,

Siemens.Engineering.ProjectArchivationMode archivationMode)
'targetName' est le nom du fichier créé, indépendamment du fait qu'il soit ou non archivé. Ce
fichier peut comprendre ou non des extensions de fichier. Pour la valeur
ProjectArchivationMode comme Compressed et DiscardRestorableDataAndCompressed,, le
nom de fichier archivé est celui que vous avez indiqué. Si vous n'indiquez aucune extension
ou aucune extension autre que "zap15_1" et "zap14" etc., ce projet archivé ne peut pas être
appelé hors de l'API Openness de TIA Portal. SI vous ne sélectionnez ni Compressed, ni
DiscardRestorableDataAndCompressed, le résultat est la structure de fichiers standard d'un
projet de la version actuelle.
Remarque
Vous devez enregistrer le projet avant l'appel de l'API d'archivage. Si le projet contient des
modifications qui ne sont pas enregistrées, l'archivage fournit en retour une
EngineeringTargetInvocationException.

ProjectArchivationMode
L'énumération ProjectArchivationMode possède quatre valeurs.
ProjectArchivationMode Description
None ● Aucune action spéciale n'est exécutée avec les fichiers
originaux. Le mode ressemble à la procédure "Enregistrer
sous".
● Aucun fichier ZIP comprimé n'est créé dans ce mode.
● La différence par rapport à SaveAs réside dans ce cas
dans le fait que l'archive ne commute pas le lieu d'archi‐
vage persistant sur le nouveau dossier Archived contrai‐
rement à SaveAs.
DiscardRestorableData ● Lors de l'enregistrement de fichier, le projet est stocké
dans un fichier de données interne. La taille de ce fichier
augmente ensuite à chaque modification des données de
projet. En mode DiscardRestorableData, ce fichier de
données est réorganisé (seule la version la plus récente
des objets est alors enregistrée et l'historique est suppri‐
mé du fichier). Les données collectées entre temps, les
données du répertoire IM et du répertoire tmp ne sont pas
copiées dans le lieu de stockage de l'archive.
Compressed ● La structure créée par le processus d'archivage du dos‐
sier de projet TMP est comprimée dans une archive com‐
patible ZIP. La structure de dossier TMP est supprimée
après la création du fichier ZIP.
DiscardRestorableDataAndCompressed ● Dans la structure créée par le processus d'archivage du
dossier de projet TMP, les données restaurables sont re‐
jetées et ensuite comprimées dans une archive compati‐
ble ZIP. La structure de dossier TMP est supprimée après
la création du fichier ZIP.
Code de programme : Archiver un projet

Pour accéder sans extension au projet archivé, modifiez le code de programme suivant :
var tiaPortal = new TiaPortal(TiaPortalMode.WithoutUserInterface);

var projectFilePath = @"E:\Sample1\Sample1.ap15_1";
var project = tiaPortal.Projects.Open(new FileInfo(projectFilePath));
var archiveDirectory = @"E:\Archive";
project.Archive(new DirectoryInfo(archiveDirectory), "ArchiveProjectNameWithoutExtension",
ProjectArchivationMode.Compressed);

Modifiez le code de programme suivant pour accéder au projet archivé avec l'extension
'.archive' :

var projectFilePath = @"E:\Sample1\Sample1.ap15_1";
var project = tiaPortal.Projects.Open(new FileInfo(projectFilePath));
var archiveDirectory = @"E:\Archive";
project.Archive(new DirectoryInfo (archiveDirectory), "ArchiveProjectName.archive",
ProjectArchivationMode.Compressed);
Remarque
Vous pouvez utiliser l'extension souhaitée. Le comportement de l'archive est identique, avec
ou sans extension.
Appeler un projet
Vous pouvez appeler un projet TIA Portal archivé via l'API Openness. L'appel n'est possible
qu'avec une archive comprimée. Pour les projets archivés avec
'ProjectArchivationMode.None' ou 'ProjectArchivationMode.DiscardRestorableData', la valeur
d'énumération ne peut pas être appelée par cette API. Cette API est disponible à l'objet
"Siemens.Engineering.ProjectComposition".
public Siemens.Engineering.Project Retrieve(System.IO.FileInfo sourcePath,

System.IO.DirectoryInfo targetDirectory)
Pour l'appel d'un projet protégé UMAC, une API surchargée avec UmacDelegate est
disponible pour l'interrogation des données de connexion. Puis, la définition suivante est
utilisée :

System.IO.DirectoryInfo targetDirectory, Siemens.Engineering.UmacDelegate umacDelegate)
Lors de l'appel, ProjectOpenMode est aussi pris en charge, pour lequel "Primary" ou
"Secondary" peut être indiqué. Puis, la définition API suivante est utilisée :

System.IO.DirectoryInfo targetDirectory,Siemens.Engineering.UmacDelegate umacDelegate,
Siemens.Engineering.ProjectOpenMode projectOpenMode)
Remarque
UmacDelegate peut être transmis comme nul, si le projet n'est pas protégé.

Si le projet archivé provient d'une version ancienne de TIA Portal, vous devez appeler la
RetrieveWithUpgrade API, . Puis, la définition API suivante est utilisée :
public Siemens.Engineering.Project RetrieveWithUpgrade(System.IO.FileInfo sourcePath,

System.IO.DirectoryInfo targetDirectory);
Si le projet archivé provient d'une version ancienne de TIA Portal et qu'il est protégé UMAC,
une autre API surchargée est disponible avec UmacDelegate. Puis, la définition API suivante
est utilisée :

System.IO.DirectoryInfo targetDirectory, Siemens.Engineering.UmacDelegate umacDelegate)
Si le projet archivé provient d'une version ancienne de TIA Portal et que le mode d'ouverture
du projet doit aussi être indiqué, la définition API suivante est utilisée :

System.IO.DirectoryInfo targetDirectory,Siemens.Engineering.UmacDelegate umacDelegate,
Siemens.Engineering.ProjectOpenMode projectOpenMode)
Remarque
UmacDelegate peut être transmis comme nul, si le projet n'est pas protégé. SI le projet est
protégé, les données utilisateur d'un administrateur sont requises pour effectuer l'action
RetrieveWithUpgrade.
Code de programme : Appeler un projet

Pour accéder au projet à appeler, modifiez le code de programme suivant :
var archivePath = @"E:\Archive\Sample1.zap15_1";

var retrievedProjectsDirectory = @"E:\RetrievedProjects";
tiaPortal.Projects.Retrieve(new FileInfo(archivePath), new
DirectoryInfo(retrievedProjectsDirectory));
Voir aussi
Enregistrer le projet (Page 136)

7.10.5 Ouvrir le projet TIA Portal protégé en écriture
Conditions
Application
À l'aide de TIA Portal Openness, certaines procédures peuvent être réalisées dans un projet
TIA Portal protégé en écriture. Vous pouvez accéder à un projet protégé en écriture, mais ne
pouvez pas utiliser l'ensemble des fonctionnalités dont dispose un utilisateur avec des droits
d'accès en lecture / écriture. Un utilisateur disposant uniquement de droits de lecture peut par
exemple ouvrir un projet avec protection UMAC via Openness comme décrit dans Ouverture
d'un projet (Page 109). Cette fonction n'est cependant pas valable pour des projets de
référence.
La liste des fonctions Openness dont vous disposez à l'accès à un projet protégé en écriture
est divisée en deux groupes : actions intégrées et actions actives non modifiées.
Fonctions intégrées
● GetAttribute(s) ou utilisation de la fonction d'appel pour un attribut quelconque d'un objet
quelconque
● GetComposition pour un objet accessible
● GetService pour un objet accessible
● Actions Find pour un objet accessible
● Navigation pour un objet accessible
● Détermination de la présence d'objets accessibles et accès à ces objets en associations et
affectations
● Méthodes System.Object pour un objet accessible
Actions actives sans modification
● Project.Close (...)
● PlcBlock.ShowInEditor ()
● CaxProvider.Export (Device,...)
● CaxProvider.Export (Project,...)
Voir aussi

7.10.6 Accéder à des langues
Conditions
Utilisation
Dans TIA Portal, vous pouvez déterminer la langue du projet et la gérer dans l'éditeur "Langues
de projet".
TIA Portal Openness prend en charge l'accès suivant aux langues de projet :
● Itération par langues prises en charge
● Recherche dans le recueil de langues prises en charge à l'aide
de System.Globalization.CultureInfo
● Accès à certaines langues. Chaque objet langue contient un attribut unique en lecture
seule Culture du type System.Globalization.CultureInfo..
● Accès à un recueil de langues actives
● Recherche dans le recueil de langues actives à l'aide
● Ajout d'une langue à un recueil de langues actives
● Suppression d'une langue d'un recueil de langues actives
● Choix d'une langue d'édition
● Choix d'une langue de référence
Ces fonctions sont mises à disposition par l'objet LanguageSettings. La figure ci-dessous
montre le modèle dans TIA Portal Openness :

3URMHFW

/DQJXDJH6HWWLQJV/DQJXDJH6HWWLQJV

/DQJXDJH6HWWLQJV
/DQJXDJH6HWWLQJV
(GLWLQJ/DQJXDJH/DQJXDJH
5HIHUHQFH/DQJXDJH/DQJXDJH
$FWLYH/DQJXDJHV/DQJXDJH$VVRFLDWLRQ $FWLYH/DQJXDJHV /DQJXDJHV
/DQJXDJHV/DQJXDJH&RPSRVLWLRQ
/DQJXDJH$VVRFLDWLRQ /DQJXDJH&RPSRVLWLRQ
$GGLWHP/DQJXDJHYRLG )LQGFXOWXUH&XOWXUH,QIR/DQJXDJH

)LQGFXOWXUH&XOWXUH,QIRYRLG
(GLWLQJ/DQJXDJH 5HIHUHQFH/DQJXDJH 5HPRYHLWHP/DQJXDJHERRO
/DQJXDJH
&XOWXUH,QIR&XOWXUHLQIR
Code de programme : déterminer une langue

Modifiez le code de programme suivant pour déterminer une langue. Quand vous définissez
une langue inactive à l'aide de TIA Portal Openness, elle est ajoutée à la liste des langues
actives.
LanguageSettings languageSettings = project.LanguageSettings;
LanguageComposition supportedLanguages = languageSettings.Languages;

LanguageAssociation activeLanguages = languageSettings.ActiveLanguages;
Language supportedGermanLanguage =
supportedLanguages.Find(CultureInfo.GetCultureInfo("de-DE"));
activeLanguages.Add(supportedGermanLanguage);
languageSettings.EditingLanguage = supportedGermanLanguage;
languageSettings.ReferenceLanguage = supportedGermanLanguage;

Code de programme : désactiver une langue active

Pour désactiver une langue active, modifiez le code de programme suivant. Quand vous
désactivez une langue utilisée comme langue de référence ou d'édition, la langue sélectionnée
est cohérente avec le comportement dans l'interface utilisateur.

Language activeGermanLanguage = activeLanguages.Find(CultureInfo.GetCultureInfo("de-
DE"));
activeLanguages.Remove(activeGermanLanguage);
7.10.7 Déterminer la structure et les attributs de l'objet
Conditions requises
● Vous avez ouvert un projet avec votre application TIA Portal Openness.
Utilisation
Vous pouvez déterminer la structure de navigation de la hiérarchie d'objet à l'aide de
l'interface IEngineeringObject. Le résultat est retourné sous forme de liste :
● Objets inférieurs
● Compositions inférieures
● Tous les attributs
Signature
Utilisez la méthode GetAttributeInfos pour déterminer les attributs.
IList<EngineeringAttributeInfo>
IEngineeringObject.GetAttributeInfos();

Code de programme : Déterminer des objets ou compositions

Utilisez le code de programme suivant pour afficher tous les noms de compositions :
public static void DisplayCompositionInfos(IEngineeringObject obj)

{
IList<EngineeringCompositionInfo> compositionInfos = obj.GetCompositionInfos();
foreach (EngineeringCompositionInfo compositionInfo in compositionInfos)
{
Console.WriteLine(compositionInfo.Name);
}
}
Si vous connaissez la valeur de retour, modifiez le code de programme suivant :
public static DeviceItemComposition GetDeviceItemComposition(Device device)

{
IEngineeringCompositionOrObject composition = ((IEngineeringObject)
device).GetComposition("DeviceItems");
DeviceItemComposition deviceItemComposition = (DeviceItemComposition)composition;
return deviceItemComposition;
}

Code de programme : détermination des attributs

Pour fournir en retour les attributs d'un objet aux droits d'accès spécifiques dans une liste,
public static void DisplayAttributenInfos(IEngineeringObject obj)

{
IList<EngineeringAttributeInfo> attributeInfos = obj.GetAttributeInfos();
foreach (EngineeringAttributeInfo attributeInfo in attributeInfos)
{
Console.WriteLine("Attribute: {0} - AccessMode {1} ",
attributeInfo.Name, attributeInfo.AccessMode);
switch (attributeInfo.AccessMode)
{
case EngineeringAttributeAccessMode.Read: Console.WriteLine("Attribute: {0} -
Read Access", attributeInfo.Name);
break;
case EngineeringAttributeAccessMode.Write: Console.WriteLine("Attribute: {0} -
Write Access", attributeInfo.Name);
break;
case EngineeringAttributeAccessMode.Read | EngineeringAttributeAccessMode.Write:
Console.WriteLine("Attribute: {0} - Read and Write Access", attributeInfo.Name);
break;
}
}
}
public static string GetNameAttribute(IEngineeringObject obj)
{
Object nameAttribute = obj.GetAttribute("Name");
return (string)nameAttribute;
}
7.10.8 Accéder au logiciel cible
Conditions

Code du programme
Pour mettre à disposition un logiciel cible, modifiez le code de programme suivant :
SoftwareContainer softwareContainer =
((IEngineeringServiceProvider)deviceItem).GetService<SoftwareContainer>();
if (softwareContainer != null)
{
Software software = softwareContainer.Software;
}
Pour accéder aux attributs du logiciel, modifiez le code de programme suivant :
((IEngineeringServiceProvider)deviceItem).GetService<SoftwareContainer>();
{
PlcSoftware software = softwareContainer.Software as PlcSoftware;
string name = software.Name;
}
7.10.9 Accéder à des textes multilingues et les énumérer
Conditions
Utilisation
Des textes multilingues dans TIA Portal sont, par exemple, Project.Comment,
PlcTag.Comment, etc. Dans TIA Portal Openness, les textes multilingues sont représentés par
l'objet MultilingualText. Un objet MultilingualText se compose
de MultilingualTextItemComposition.
MultilingualTextItemComposition prend en charge la méthode Findsuivante :
● Find(<language:
Siemens.Engineering.Language>):MultilingualTextItem
Chaque MultilingualTextItem a les attributs suivants :
Nom d'attribut Type de données Acces‐ Description

sible en
écriture
Language Siemens.Engineering.Language r/o Langue de cet élément
Text System.String r/w Texte indiqué pour cette langue

Code de programme : déterminer des textes multilingues
...
Language englishLanguage = project.LanguageSettings.Languages.Find(new CultureInfo("en-
US"));
MultilingualText comment = project.Comment;
MultilingualTextItemComposition mltItemComposition = comment.Items;
MultilingualTextItem englishComment = mltItemComposition.Find(englishLanguage);
englishComment.Text = "English comment";
...
Code de programme : Définir des textes multilingues pour les appareils

Modifiez le code de programme suivant pour la définition de textes multilingues pour les
appareils et les éléments d'appareils
...
var mltObject = device.GetAttribute("CommentML");
MultilingualText multilingualText = mltObject as MultilingualText;
if (multilingualText != null)
{
Language englishLanguage = project.LanguageSettings.Languages.Find(new
CultureInfo("en-US"));
MultilingualTextItem multilingualTextItem =
multilingualText.Items.Find(englishLanguage);
if (multilingualTextItem != null)
{
multilingualTextItem.Text = comment;
}
}
...
7.10.10 Actualisation de la propriété de projet "Prise en charge de la simulation"
Conditions
Application
À l'aide de TIA Portal Openness, vous pouvez actualiser la propriété de projet "Prise en charge
de la simulation" afin de pouvoir créer des programmes API qui sont également utilisés dans
un automate SINUMERIK virtuel.

Openness prend en charge les attributs suivants qui permettent de lire/écrire la propriété "Prise
en charge de la simulation" d'un projet TIA Portal. L'API est disponible à l'objet
"Siemens.Engineering.Project".
Nom d'attribut Type de don‐ Écriture Description

nées
IsSimulationDuringBlockCom‐ System.Boo‐ oui Indique si la prise en charge pour la simulation est activée
pilationEnabled lean lors de la compilation de blocs pour le projet.
Code de programme
Modifiez et utilisez le code de programme suivant pour lire/écrire la valeur d'attribut :

// Read the attribute value
var attributeValue = project.IsSimulationDuringBlockCompilationEnabled;
//Write the attribute value to false
project.IsSimulationDuringBlockCompilationEnabled = false;
Voir aussi
7.10.11 Lire des attributs liés au projet
Conditions
Utilisation
Cette fonction vous permet d'appeler des attributs liés au projet issus du TIA Portal Openness
API. Les informations fournies comprennent les attributs du projet, l'historique du projet et les
produits utilisés par le projet.

Attributs du projet
Les attributs du projet fournissent les informations suivantes :
Nom d'attribut Type de données Accessible Description

en écriture
Author System.String r/o Auteur du projet.
Comment Siemens.Engineering.MultilingualText r/o Commentaire du projet.
Copyright System.String r/o Mention de copyright du projet.
CreationTime System.DateTime r/o Date et heure auxquelles le projet a été créé.
Family System.String r/o Famille du projet.
IsModified System.Boolean r/o Affiche vrai si le projet a été modifié.
LanguageSettings Siemens.Engineering.LanguageSettings r/o Gère les langues du projet.
LastModified System.DateTime r/o Date et heure auxquelles le projet a été mo‐
difié pour la dernière fois.
LastModifiedBy System.String r/o Auteur de la dernière modification.
Name System.String r/o Nom du projet.
Path System.IO.FileInfo r/o Chemin absolu du projet.
Size System.Int64 r/o Taille du projet, en Ko.
Version System.String r/o Version du projet.
Pour accéder aux attributs liés au projet, modifiez le code de programme suivant :

string author = project.Author;
string name = project.Name;
string path = project.Path;
DateTime creationTime = project.CreationTime;
DateTime modificationTime = project.LastModified;
string lastModifiedBy = project.LastModifiedBy;
string version = project.Version;
MultilingualText comment = project.Comment;
string copyright = project.Copyright;
string family = project.Family;
Int64 size = project.Size;
Pour énumérer les langues du projet, modifiez le code de programme suivant :

LanguageComposition languages = project.LanguageSettings.Languages;
foreach (Language language in languages)
{
CultureInfo lang = language.Culture;
}

Pour obtenir le texte de commentaire, modifiez le code de programme suivant :

Language english =
project.LanguageSettings.ActiveLanguages.Find(CultureInfo.GetCultureInfo("en-US"));
MultilingualText projectComment = project.Comment;

MultilingualTextItem textItem = project.Comment.Items.Find(english);
string text = textItem.Text;
Historique du projet
L'historique du projet regroupe des objets du type HistoryEntry, qui contiennent les
informations suivantes :
Nom d'attribut Type de données Accessible en écriture Description

Texte System.String r/o Description de l'événe‐
ment.
DateTime System.DateTime r/o Date et heure auxquel‐
les l'événement s'est
produit.
Pour énumérer les HistoryEntries et accéder à leurs attributs, modifiez le code de programme
suivant :

HistoryEntryComposition historyEntryComposition = project.HistoryEntries;
foreach (HistoryEntry historyEntry in historyEntryComposition)
{
string entryText = historyEntry.Text;
DateTime entryTime = historyEntry.DateTime;
}
Remarque
L'attribut Texte de HistoryEntry contient une chaîne de caractères dans la même langue
que l'interface utilisateur. Lorsqu'une application TIA Portal Openness est attachée à un TIA
Portal sans interface utilisateur, la chaîne de caractères est fournie en anglais par défaut.
Produits utilisés
L'objet UsedProduct contient les informations suivantes :
Nom d'attribut Type de données Accessible en écriture Description

Nom System.String r/o Nom du projet utilisé.
Version System.String r/o Version du projet.

Pour énumérer UsedProduct et accéder aux attributs, modifiez le code de programme

suivant :

UsedProductComposition usedProductComposition = project.UsedProducts;
foreach (UsedProduct usedProduct in usedProductComposition)
{
string productName = usedProduct.Name;
string productVersion = usedProduct.Version;
}
7.10.12 Suppression d'un graphique du projet
Conditions requises
Code du programme
Pour supprimer une bibliothèque de graphiques, modifiez le code de programme suivant :
//Deletes a single project graphic entry

public static void DeletesSingleProjectGraphicEntry(Project project)
{
MultiLingualGraphicComposition graphicsAggregation = project.Graphics;
MultiLingualGraphic graphic = graphicsAggregation.Find("Graphic XYZ");
graphic.Delete();
}
7.10.13 Compiler le projet
Conditions
● Tous les appareils sont "hors ligne".

Utilisation
L'interface API prend en charge la compilation d'appareils et de blocs de programme. Le
résultat de la compilation est retourné en tant qu'objet. Selon le type d'objet, la compilation HW,
SW ou HW/SW est mise à disposition. Les types d'objet suivants sont pris en charge :
● Device - HW & SW
– Device avec CPU de de sécurité - SW avec activation de la sécurité désactivée
● DeviceItem - HW
● CodeBlock - SW
● DataBlock - SW
● HmiTarget - SW
● PlcSoftware - SW
● PlcType - SW
● PlcBlockSystemGroup - SW
● PlcBlockUserGroup - SW
● PlcTypeSystemGroup - SW
● PlcTypeUserGroup - SW
Remarque
Format de l'horodatage
Tous les horodatages sont en UTC. Si vous souhaitez afficher l'heure locale, vous pouvez
utiliser DateTime.ToLocalTime().
Signature
Pour la compilation, utilisez la méthode ICompilable.
ICompilable compileService =
iEngineeringServiceProvider.GetService<ICompilable>();
CompilerResult result = compileService.Compile();
Remarque
Tous les appareils doivent être "hors ligne" avant le début de la compilation.

Code de programme
Pour compiler les modifications logicielles d'un objet de type HmiTarget, modifiez le code de
programme suivant :
public static void CompileHmiTarget(HmiTarget hmiTarget)

{
ICompilable compileService = hmiTarget.GetService<ICompilable>();
}
Pour compiler les modifications logicielles d'un objet de type PlcSoftware, modifiez le code
de programme suivant :
public static void CompilePlcSoftware(PlcSoftware plcSoftware)

{
ICompilable compileService = plcSoftware.GetService<ICompilable>();
}
Pour compiler les modifications logicielles d'un objet de type CodeBlock, modifiez le code de
programme suivant :
public static void CompileCodeBlock(PlcSoftware plcSoftware)

{
CodeBlock block = plcSoftware.BlockGroup.Blocks.Find("MyCodeBlock") as CodeBlock;
if (block != null)
{
ICompilable compileService = block.GetService<ICompilable>();
}
}

Pour évaluer le résultat de la compilation, modifiez le code de programme suivant :
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(CompilerResultMessageComposition 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);
}
}
7.10.14 Enregistrer le projet
Conditions requises
Utilisation
Enregistrer un projet
● Utilisez la méthode Save() pour enregistrer un projet.
● Utilisez la méthode SaveAs() pour enregistrer un projet sous un autre nom ou dans un
autre répertoire.

Code du programme
Pour ouvrir et enregistrer un projet, modifiez le code de programme suivant :
public static void SaveProject(TiaPortal tiaPortal)

{
//Use the code in the try block to open and save a project
try
{
project = tiaPortal.Projects.Open(new FileInfo(@"Some\Path\MyProject.apx"));
//...
//end of code
project.Save();
}
//Use the code in the final block to close a project
finally
{
project.Close();
}
}
Modifiez le code de programme suivant pour enregistrer un projet sous un autre nom ou dans
un autre répertoire.
...
TiaPortal portal = new TiaPortal(TiaPortalMode.WithUserInterface);
FileInfo fileInfoExistingProject = new FileInfo(@"D:\SampleProjects
\SampleProject.apXX");
DirectoryInfo dirInfoSaveAsProject = new DirectoryInfo(@"D:\SampleProjects
\SampleProjectSaveAs");
Project sampleProject = portal.Projects.Open(fileInfoExistingProject );
sampleProject.SaveAs(dirInfoSaveAsProject);
...
7.10.15 Fermer un projet
Conditions requises

7.11 Fonctions pour connexions
Code du programme
Pour fermer un projet, modifiez le code de programme suivant :
public static void CloseProject(Project project)

{
project.Close();
}
7.11.1 Attributs configurables d'une liaison port à port
Conditions
Utilisation
Les attributs d'une interconnexion de ports se trouvent dans l'élément d'appareil port. L'accès
en lecture et en écriture des attributs avec TIA Portal Openness est identique à celui dans
l'interface utilisateur.
Paramètres du port
Les attributs suivants sont disponibles pour paramétrer l'interface du port :
Nom d'attribut Type de données Accessible Accès Description

en écriture
MediumAttachmentType MediumAttachmentTy‐ r/o Attribut dyna‐
pe mique
CableName CableName r/w Attribut dyna‐
mique
AlternativePartnerPorts Bool r/w Attribut dyna‐ Disponible uniquement quand
mique la fonction de changeur d'outil
est prise en charge, par ex. pour
la CPU1516.
SignalDelaySelection SignalDelaySelection r/w Attribut dyna‐
mique

Nom d'attribut Type de données Accessible Accès Description

en écriture
CableLength CableLength r/w Attribut dyna‐
mique
SignalDelayTime Double r/w Attribut dyna‐
mique
Les valeurs ENUM suivantes sont disponibles pour l'attribut MediumAttachmentType :
Valeur Description
MediumAttachmentType.None Type de couplage impossible à déterminer.
MediumAttachmentType.Copper Couplage cuivre.
MediumAttachmentType.FibreOp Couplage fibre optique.
tic
Les valeurs ENUM suivantes sont disponibles pour l'attribut CableName :
Valeur Description
CableName.None Aucun nom de câble indiqué
CableName.FO_Standard_Cable_9 Câble standard FO GP (9 µm)
CableName.Flexible_FO_Cable_9 Câble FO souple (9 µm)
CableName.FO_Standard_Cable_GP_50 Câble standard FO GP (50 µm)
CableName.FO_Trailing_Cable_GP Câble traînant FO / GP
CableName.FO_Ground_Cable Conducteur de terre FO
CableName.FO_Standard_Cable_62_5 Câble standard FO (62,5 µm)
CableName.Flexible_FO_Cable_62_5 Câble FO souple (62,5 µm)
CableName.POF_Standard_Cable_GP Câble standard POF GP
CableName.POF_Trailing_Cable Câble traînant POF
CableName.PCF_Standard_Cable_GP Câble standard POF GP
CableName.PCF_Trailing_Cable_GP Câble traînant PCF / GP
CableName.GI_POF_Standard_Cable Câble standard POF GI
CableName.GI_POF_Trailing_Cable Câble traînanr POF GI
CableName.GI_PCF_Standard_Cable Câble standard PCF GI
CableName.GI_PCF_Trailing_Cable Câble traînant PCF GI
Les valeurs ENUM suivantes sont disponibles pour l'attribut SignalDelaySelection :
Valeur Description
SignalDelaySelection.None
SignalDelaySelection.CableLength CableLength sert à déterminer le retard du signal.
SignalDelaySelection.SignalDelayTime CableDelayTime sert à déterminer le retard du si‐
gnal.
Les valeurs ENUM suivantes sont disponibles pour l'attribut CableLength :
Valeur Description
CableLength.None La longueur de câble n'est pas indiquée
CableLength.Length20m Longueur de câble 20 m.

Valeur Description
Options de port
Les attributs suivants sont disponibles pour les options de port :
Nom d'attribut Type de données Acces‐ Accès

sible en
écriture
PortActivation Bool r/w Attribut dynamique
TransmissionRateAndDuplex TransmissionRateAndDuplex r/w Attribut dynamique
PortMonitoring Bool r/w Attribut dynamique
TransmissionRateAutoNegoti Bool r/w Attribut dynamique
ation
EndOfDetectionOfAccessible Bool r/w Attribut dynamique
Devices
EndOfTopologyDiscovery Bool r/w Attribut dynamique
EndOfSyncDomain Bool r/w Attribut dynamique
Les valeurs ENUM suivantes sont disponibles pour l'attribut

TransmissionRateAndDuplex :
Valeur Description
TransmissionRateAndDuplex.None 　
TransmissionRateAndDuplex.Automatic Automatique
TransmissionRateAndDuplex.AUI10Mbps AUI 10 Mbps
TransmissionRateAndDuplex.TP10MbpsHa TP 10 Mbps semi-duplex
lfDuplex
TransmissionRateAndDuplex.TP10MbpsFu TP 10 Mbps duplex intégral
llDuplex
TransmissionRateAndDuplex.AsyncFiber Fibre optique asynchrone 10 Mbps semi-duplex
10MbpsHalfDuplex
TransmissionRateAndDuplex.AsyncFiber Fibre optique asynchrone 10 Mbps duplex intégral
10MbpsFullDuplex
TransmissionRateAndDuplex.TP100MbpsH TP 100 Mbps semi-duplex
alfDuplex
TransmissionRateAndDuplex.TP100MbpsF TP 100 Mbps duplex intégral
ullDuplex
TransmissionRateAndDuplex.FO100MbpsF FO 100 Mbps duplex intégral
ullDuplex
TransmissionRateAndDuplex.X1000MbpsF X1000 Mbps duplex intégral
ullDuplex
TransmissionRateAndDuplex.FO1000Mbps FO 1000 Mbps duplex intégral LD
FullDuplexLD

7.12 Fonctions dans les bibliothèques
Valeur Description
TransmissionRateAndDuplex.FO1000Mbps FO 1000 Mbps duplex intégral
FullDuplex
TransmissionRateAndDuplex.TP1000Mbps TP 1000 Mbps duplex intégral
FullDuplex
TransmissionRateAndDuplex.FO10000Mbp FO 10000 Mbps duplex intégral
sFullDuplex
TransmissionRateAndDuplex.FO100MbpsF FO 100 Mbps duplex intégral LD
ullDuplexLD
TransmissionRateAndDuplex.POFPCF100M POF/PCF 100 Mbps duplex intégral
bpsFullDuplex
Voir aussi
7.12.1 Fonctions pour objets et instances
Accès aux types et instances

L'interface TIA Portal Openness API vous permet d'accéder aux types, versions de types et
copies maîtres dans la bibliothèque du projet ou les bibliothèques globales. Vous pouvez
déterminer des liaisons entre les versions de types et les instances. Vous pouvez également
actualiser les instances dans le projet et synchroniser les modifications entre une bibliothèque
globale et la bibliothèque de projet. En outre, l'interface TIA Portal Openness API prend en
charge la comparaison des versions de type et des instances.

Fonctions pour des objets et des instances

L'interface TIA Portal Openness API vous permet d'accéder aux fonctions suivantes pour les
types, versions de types, copies maîtres et instances :
① Afficher les attributs de types, versions de types, copies maîtres et instances

② Les fonctions suivantes sont disponibles dans la bibliothèque de projet :
● Mettre à jour les instances des types
● Instancier les versions de types dans le projet
● Naviguer à l'intérieur d'un groupe de bibliothèques
● Supprimer un groupe, des types, des versions de types et des copies maîtres
③ Les fonctions suivantes sont disponibles dans la bibliothèque globale :
● Mettre à jour les instances des types
● Instancier la version de type dans le projet
● Naviguer à l'intérieur d'un groupe de bibliothèques
7.12.2 Accès aux bibliothèques globales
Conditions requises
● L'application TIA Portal Openness est reliée à TIA Portal.

Utilisation
Il existe trois types de bibliothèques globales.
● Bibliothèque système globale (Siemens.Engineering.Library.SystemGlobalLibrary) : Ces
bibliothèques globales font partie de l'installation de TIA Portal et utilisent l'extension de
fichier *.asx. Toutes les bibliothèques système globales sont protégées en écriture.
● Bibliothèque d'entreprise globale (Siemens.Engineering.Library.CorporateGlobalLibrary) :
il s'agit de bibliothèques globales qui ont été sélectionnées par l'administrateur et qui sont
chargées préalablement au démarrage de TIA Portal. Toutes les bibliothèques d'entreprise
globales sont protégées en écriture.
● Bibliothèque utilisateur globale (Siemens.Engineering.Library.UserGlobalLibrary) : il s'agit
de bibliothèques globales qui ont été créées par l'utilisateur de TIA Portal. Les bibliothèques
d'entreprise globales peuvent être protégées en écriture ou accessibles avec des droits en
lecture et en écriture.
Si une bibliothèque utilisateur globale est déjà ouverte dans un mode donné, elle ne peut
pas être ouverte dans un autre mode.
Les bibliothèques utilisateur globales des versions précédentes ne peuvent être ouvertes
qu'en mode protégé en écriture.
En plus, les bibliothèques globales ouvertes avec TIA Portal Openness sont ajoutées au
recueil des bibliothèques globales de l'interface utilisateur TIA Portal et affichées dans
l'interface dans TIA Portal tant que celle-ci est présente.
Code de programme : bibliothèques globales disponibles

Pour appeler des informations sur toutes les bibliothèques globales, modifiez le code de
programme suivant :
TiaPortal tia = ...;

var availableLibraries = tia.GlobalLibraries.GetGlobalLibraryInfos();
foreach (GlobalLibraryInfo info in availableLibraries)
{
Console.WriteLine(" Library Name: {0}", info.Name);
Console.WriteLine(" Library Path: {0}", info.Path);
Console.WriteLine(" Library Type: {0}", info.LibraryType);
Console.WriteLine(" Library IsOpen: {0}", info.IsOpen);
}
Attributs de GlobalLibrary
Valeur Type de données Description

Author String Auteur de la bibliothèque globale
Comment MultilingualText Commentaire sur la bibliothèque globale
IsReadOnly Boolean Vrai si la bibliothèque globale est protégée en écri‐
ture.

Valeur Type de données Description

IsModified Boolean Vrai si le contenu de la bibliothèque globale a été
modifié.
Name String Nom de la bibliothèque globale
Path FileInfo Spécification du chemin de la bibliothèque globale
Attributs de GlobalLibraryInfo
Valeur Type de valeur en retour Description

IsReadOnly Boolean Vrai si la bibliothèque globale est protégée en écri‐
ture.
IsOpen Boolean Vrai si la bibliothèque globale est déjà ouverte.
LibraryType GlobalLibraryType Type de la bibliothèque globale :
● System : bibliothèque système globale
● Corporate : bibliothèque d'entreprise globale
● User : bibliothèque utilisateur globale
Name String Nom de la bibliothèque globale
Path FileInfo Spécification du chemin de la bibliothèque globale
Voir aussi
Accéder aux dossiers dans une bibliothèque (Page 154)
7.12.3 Accès à des langues de la bibliothèque globale
Conditions
● Une bibliothèque est ouverte.
Voir Ouvrir des bibliothèques (Page 146)
Application
Vous pouvez accéder aux langues de la bibliothèque globale et les gérer à l'aide du navigateur
pour les paramètres de la langue.
TIA Portal Openness prend en charge l'accès suivant aux langues de la bibliothèque globale :
● Recherche itérative dans les langues prises en charge
● Recherche dans la collection de langues prises en charge à l'aide
● Accès à certaines langues. Chaque objet Langue contient un attribut unique en lecture
seule Culture du type System.Globalization.CultureInfo.

● Accès à une collection de langues actives

● Recherche dans la collection de langues actives à l'aide
● Ajout d'une langue à une collection de langues actives
● Suppression d'une langue d'une collection de langues actives
● Choix d'une langue d'édition
● Choix d'une langue de référence
Attributs de langues de la bibliothèque globale

Les langues de la bibliothèque globale ont les attributs suivants :
Nom d'attribut Type de données Acces‐ Description

sible en
écriture
LanguageSet‐ Siemens.Engineering.Lan‐ Protec‐ Gère les langues de la bibliothèque glo‐
tings guageSettings tion en bale
écriture
Code de programme : Énumérer les langues de la bibliothèque globale

Modifiez le code de programme suivant pour énumérer les langues de la bibliothèque globale :
FileInfo m_GlobalLibrarypath = new FileInfo("bla");

var globalLibrary = portal.GlobalLibraries.Open(m_GlobalLibrarypath, OpenMode.ReadOnly);
LanguageSettings languageSettings = globalLibrary.LanguageSettings;
Code de programme : Accéder à la sélection de la langue

Modifiez le code de programme suivant pour accéder aux paramètres de langue de la
bibliothèque globale :

LanguageComposition languages = globalLibrary.LanguageSettings.Languages;
foreach (Language language in languages)
{
// Work with this language
}

Code de programme : déterminer les langues de la bibliothèque globale

Modifiez le code de programme suivant pour déterminer les langues de la bibliothèque globale :
Quand vous ajoutez une nouvelle langue prise en charge à l'aide de TIA Portal Openness, elle
est ajoutée à la liste des langues actives.

LanguageSettings languageSettings = globalLibrary.LanguageSettings;
LanguageComposition supportedLanguages = languageSettings.Languages;
Language supportedGermanLanguage = supportedLanguages.Find(CultureInfo.GetCultureInfo("de-
DE"));
activeLanguages.Add(supportedGermanLanguage);
languageSettings.EditingLanguage = supportedGermanLanguage;
languageSettings.ReferenceLanguage = supportedGermanLanguage;
Remarque
Si vous ajoutez des langues à la bibliothèque globale ou modifiez les langues qu'elle contient,
les langues des versions publiées de la bibliothèque globale ne sont pas modifiées. Cela est
également valable pour la mise à jour des langues de la bibliothèque globale via l'interface
utilisateur (éditeur de langue) ou le navigateur pour les paramètres de langue
(LanguageSettings).
7.12.4 Ouvrir des bibliothèques
Conditions requises
● Vous avez ouvert un projet avec votre application TIA Portal Openness. Cette condition
s'applique uniquement à l'accès aux bibliothèques de projet.
Utilisation
Vous pouvez ouvrir une bibliothèque globale via System.IO.FileInfo par le biais d'un chemin
d'accès au fichier de bibliothèque sur un support d'enregistrement local ou un dispositif de
stockage réseau. Seules les bibliothèques utilisateur globales peuvent être ouvertes par le
biais d'un chemin d'accès. Vous ne pouvez pas utiliser le chemin d'accès d'une bibliothèque
système globale ou d'une bibliothèque d'entreprise globale pour ouvrir une bibliothèque.
A partir de V14 SP1, GlobalLibraryInfo permet d'ouvrir des bibliothèques globales. OpenMode
est indiquée dans GlobalLibraryInfo.

Vous pouvez mettre à niveau une bibliothèque utilisateur globale issue d'une version
antérieure de TIA Portal et l'ouvrir avec la version actuelle de TIA Portal. Une mise à niveau ne
permet pas d'ouvrir une bibliothèque globale issue de V13 ou d'une version antérieure. Ces
bibliothèques doivent d'abord être mises à jour à V13 SP1.
En plus, les bibliothèques globales ouvertes avec TIA Portal Openness sont ajoutées au
recueil des bibliothèques globales de TIA Portal et affichées dans l'interface utilisateur de TIA
Portal.
Code de programme : ouvrir une bibliothèque au moyen de System.IO.FileInfo

TiaPortal tia = ...

FileInfo fileInfo = ....
UserGlobalLibrary userLib = tia.GlobalLibraries.Open(fileInfo, OpenMode.ReadWrite);
Code de programme : ouvrir une bibliothèque au moyen de GlobalLibraryInfo

TiaPortal tia = ...

IList<GlobalLibraryInfo> libraryInfos = tia.GlobalLibraries.GetGlobalLibraryInfos();
GlobalLibraryInfo libInfo = ...; //check for the info you need from the list, e.g.
GlobalLibrary libraryOpenedWithInfo;
if (libInfo.Name == "myLibrary")
libraryOpenedWithInfo = tia.GlobalLibraries.Open(libInfo);
Code de programme : mettre une bibliothèque à niveau

TiaPortal tia = ...

FileInfo fileInfo = .... //library from previous TIA Portal version
UserGlobalLibrary userLib = tia.GlobalLibraries.OpenWithUpgrade(fileInfo);
OpenMode
Valeur Description
ReadOnly Accès en écriture à la bibliothèque.
ReadWrite Accès en lecture et écriture à la bibliothèque.

7.12.5 Énumérer des bibliothèques ouvertes
Condition requise
Utilisation
Vous pouvez énumérer toutes les bibliothèques globales ouvertes dans TIA Portal, qu'elles
aient été ouvertes via l'API ou l'interface utilisateur.
Les bibliothèques globales issues de versions antérieures de TIA Portal ne sont pas
énumérées lorsqu'elles sont ouvertes avec accès en écriture.
Code du programme
Pour énumérer les bibliothèques globales, modifiez le code de programme suivant :
TiaPortal tia = ...

foreach (GlobalLibrary globLib in tia.GlobalLibraries)
{
////work with the global library
}
Voir aussi
7.12.6 Enregistrer et fermer les bibliothèques
Conditions
Application
Vous pouvez fermer ou enregistrer des bibliothèques utilisateur globales. Toutes les
modifications apportées à la bibliothèque globale ne sont pas enregistrées automatiquement.
Toutes les modifications non enregistrées sont rejetées sans invite utilisateur lorsqu'une
bibliothèque globale est fermée.

Vous ne pouvez fermer ou enregistrer des bibliothèques système globales ni des bibliothèques
d'entreprise globales.
Pour enregistrer et fermer une bibliothèque globale :
● Utilisez la méthode Save ( ) pour l'enregistrement d'une bibliothèque utilisateur globale.
● Utilisez la méthode SaveAs ( ) si vous souhaitez enregistrer une bibliothèque utilisateur
globale dans un autre répertoire.
● Utilisez la méthode Close ( ) pour fermer une bibliothèque utilisateur globale.
Les jetons Feature pour SaveAs () sont :
● Public API : Nécessaire pour toutes les Features publiques
● DenyIfTransaction : Nécessaire, car SaveAs ne peut pas être autorisé dans une
transaction, car il n'est pas restaurable.
Code de programme
Modifiez le code de programme suivant pour enregistrer une bibliothèque utilisateur globale :
UserGlobalLibrary userLib = ...

// save changes and close library
userLib.Save();
userLib.Close();
Modifiez le code de programme suivant pour enregistrer une bibliothèque utilisateur globale à
un autre endroit :

GlobalLibraryComposition globalLibraryComposition = portal.GlobalLibraries;
//please adapt the path and the extension alx to the installed version of TIA Portal
FileInfo existingLibraryfileInfo = new FileInfo(@"D:\GlobalLibraries\MyGlobalLibrary
\MyGlobalLibrary.alx");
DirectoryInfo targetDirectoryInfo = new DirectoryInfo(@"D:\GlobalLibraries
\GlobalLibrarySaveAs");
UserGlobalLibrary userGlobalLibary =
globalLibraryComposition.Open(existingLibraryfileInfo, OpenMode.ReadWrite);
userGlobalLibary.SaveAs(targetDirectoryInfo);
Remarque
La robustesse de la bibliothèque est modifiée après l'opération SaveAs. C'est pourquoi la
bibliothèque nouvellement enregistrée est disponible dans la carte de bibliothèque après
l'exécution de SaveAs. Cependant, la bibliothèque d'origine avec laquelle l'opération SaveAs
a été effectuée n'est plus disponible. La bibliothèque nouvellement enregistrée a le même
mode que la bibliothèque d'origine, pour laquelle SaveAs a été effectué. Cela signifie que la
bibliothèque nouvellement enregistrée peut aussi être ouverte dans le chemin cible en mode
ReadOnly, lorsque la bibliothèque présente a été ouverte en mode ReadOnly. Il en va de même
pour le mode ReadWrite.

Modifiez le code de programme suivant pour fermer une bibliothèque utilisateur globale :
UserGlobalLibrary userLib = ...

// close and discard changes
userLib.Close();
7.12.7 Archiver et appeler une bibliothèque
Conditions
● Une bibliothèque est enregistrée.
Voir Enregistrer et fermer les bibliothèques (Page 148)
Application
Une bibliothèque ouverte et enregistrée peut être archivée avant que d'autres modifications y
soient apportées. De cette manière, vous évitez des modifications involontaires et vous pouvez
récupérer la bibliothèque archivée ultérieurement. Vous pouvez également partager le fichier
archivé sans problème dans le réseau.
Archiver la bibliothèque
Vous pouvez archiver une bibliothèque utilisateur globale par le biais de l'interface TIA Portal
Openness API. L'API est disponible à l'objet "Siemens.Engineering.UserGlobalLibrary".
public void Archive(System.IO.DirectoryInfo targetDirectory, string targetName,

Siemens.Engineering.LibraryArchivationMode archivationMode)
'targetName' est alors le nom du fichier créé pour les bibliothèques archivées ou non archivées.
Ce fichier peut comprendre ou non des extensions de fichier. Si vous n'indiquez aucune
extension de fichier ou une extension de fichier autre que "zalx" ou "zal14" etc., le fichier
archivé ne peut pas être appelé en dehors de l'Openness API à partir de TIA Portal.
Si la valeur indiquée pour LibraryArchivationMode est Compressed et
DiscardRestorableDataAndCompressed, le nom du fichier archivé est identique au nom que
vous avez indiqué. Si LibraryArchivationMode a la valeur None et DiscardRestorableData,

l'extension du fichier de bibliothèque est automatiquement définie par le composant Project

Manager de TIA Portal sur la base de la version actuelle de TIA Portal.
Remarque
Vous devez enregistrer la bibliothèque avant l'appel de l'API Archive. Si la bibliothèque contient
des modifications non enregistrées, l'archive émet une
Mode d'archivage de la bibliothèque

Quatre valeurs peuvent être indiquées pour l'énumération LibraryArchivationMode (mode
d'archivage de la bibliothèque).
LibraryArchivation‐ Description
Mode
Sans ● Aucune action spéciale n'est exécutée avec les fichiers originaux. Le mode ressemble à la pro‐
cédure "Enregistrer sous".
● La différence par rapport à SaveAs réside dans ce cas dans le fait que l'archive ne commute pas
le lieu d'archivage persistent sur le nouveau dossier Archived contrairement à SaveAs.
DiscardRestorable‐ ● Pour l'enregistrement de fichier, la bibliothèque est stockée dans un fichier de données interne. La
Data taille de ce fichier augmente ensuite à chaque modification de la bibliothèque. En mode Discar‐
dRestorableData, ce fichier de données est réorganisé (seule la version la plus récente des objets
est alors enregistrée et l'historique est supprimé du fichier). Les données collectées entre-temps,
les données du répertoire IM et du répertoire tmp (voir la structure des répertoires de bibliothèque)
ne sont pas copiées dans le lieu de stockage de l'archive.
Compressed La structure créée par le processus d'archivage du dossier de bibliothèque TMP est comprimée dans
une archive compatible ZIP. La structure de dossier TMP est supprimée après la création du fichier
ZIP.
DiscardRestorable‐ La structure créée par le processus d'archivage du dossier de bibliothèque TMP rejette les données
DataAndCompres‐ restaurables et est ensuite comprimée dans une archive compatible ZIP. La structure de dossier TMP
sed est supprimée après la création du fichier ZIP.
Code de programme : Archiver la bibliothèque

Modifiez le code de programme suivant pour archiver une bibliothèque utilisateur globale :

//Please adapt the path and the extension alx to the installed version of TIA Portal
var libraryFilePath = @"E:\Sample1\Sample1.alx";
var userGlobalLibrary = tiaPortal.GlobalLibraries.Open(new FileInfo(LibraryFilePath),
OpenMode.ReadWrite);
var archivePath = @"E:\Archive";
var archiveFileName = "SampleArchive";
userGlobalLibrary.Archive(new DirectoryInfo(archivePath), archiveFileName,
LibraryArchivationMode.Compressed);

Appeler la bibliothèque
Vous pouvez appeler une bibliothèque TIA Portal archivée par le biais de l'interface TIA Portal
Openness API. L'appel n'est possible qu'avec une archive comprimée. L'API est disponible à
l'objet "Siemens.Engineering.GlobalLibraryComposition".
public Siemens.Engineering.Library.UserGlobalLibrary Retrieve(System.IO.FileInfo

sourcePath, System.IO.DirectoryInfo targetDirectory, Siemens.Engineering.OpenMode openMode)
Remarque
Il n'est pas possible d'appeler des bibliothèques archivées avec les valeurs d'énumération
'LibraryArchivationMode.None' ou 'LibraryArchivationMode.DiscardRestorableData'.
L'appel de l'API RetrieveWithUpgrade permet de restaurer la bibliothèque archivée d'une

ancienne version de TIA Portal. La définition de l'API est la suivante :
public Siemens.Engineering.Library.UserGlobalLibrary
RetrieveWithUpgrade(System.IO.FileInfo sourcePath, System.IO.DirectoryInfo
targetDirectory, Siemens.Engineering.OpenMode openMode)
Mode d'ouverture
L'énumération OpenMode présente deux valeurs :
OpenMode Description
ReadMode ● Accès en lecture à la bibliothèque. Les données peuvent être lues à partir de la bibliothèque.
ReadWrite ● Accès en écriture à la bibliothèque. Les données peuvent être écrites dans la bibliothèque.
Code de programme : Appeler la bibliothèque

Modifiez le code de programme suivant pour appeler une bibliothèque.
//Please adapt the path and the extension zalx to the installed version of TIA Portal
var archivePath = @"E:\Archive\Sample1.zalx";
var retrievedLibraryDirectory = @"E:\RetrievedLibraries";
tiaPortal.GlobalLibraries.Retrieve(new FileInfo(archivePath), new
DirectoryInfo(retrievedLibraryDirectory), OpenMode.ReadWrite));
Voir aussi
Ouvrir des bibliothèques (Page 146)
Enregistrer et fermer les bibliothèques (Page 148)

7.12.8 Créer des bibliothèques globales
Conditions requises
Utilisation
La TIA Portal Openness API permet de créer des bibliothèques globales par appel de la
méthode Create sur GlobalLibraryComposition. Une bibliothèque utilisateur globale est
affichée.
GlobalLibraryComposition.Create
TiaPortal tia= ...;

DirectoryInfo targetDirectory = new DirectoryInfo(@"D:\GlobalLibraries");
UserGlobalLibrary globalLibrary =
tia.GlobalLibraries.Create<UserGlobalLibrary>(targetDirectory, "Library1")

● un dossier "D:\GlobalLibraries\Library1" est créé
● un fichier de bibliothèque globale "D:\GlobalLibraries\Library1\Library1.alXX" est créé
Paramètres pour créer des bibliothèques globales
Paramètre Type de don‐ Type Description

nées
Author String Obligatoire Auteur d'une bibliothèque globale.
Comment String Optionnel Commentaire d'une bibliothèque globale.
Name String Optionnel Nom d'une bibliothèque globale.
TargetDirecto‐ DirectoryInfo Obligatoire Répertoire dans lequel sera placé le dossier conte‐
ry nant la bibliothèque globale.
Voir aussi

7.12.9 Accéder aux dossiers dans une bibliothèque
Conditions
● Vous avez accès à la bibliothèque requise.
Voir Accès aux bibliothèques globales (Page 142).
Utilisation
L'interface TIA Portal Openness API vous permet d'accéder aux dossiers système pour les
types et copies maîtres dans une bibliothèque. Vous pouvez alors accéder aux types, versions
de types, copies maîtres et dossiers personnalisés dans le dossier système.
La méthode Find, par ex.
libTypeUserFolder.Folders.Find("SomeUserFolder");, vous permet d'accéder à
tout moment à un dossier personnalisé.
Code de programme : accéder au dossier système

Pour accéder au dossier système pour les types dans une bibliothèque, modifiez le code de
programme suivant :
public static void AccessTypeSystemFolder(ILibrary library)

{
LibraryTypeSystemFolder libTypeSystemFolder = library.TypeFolder;
}
Pour accéder au dossier système pour les copies maîtres dans une bibliothèque, modifiez le
code de programme suivant :
public static void AccessMasterCopySystemFolder(ILibrary library)

{
MasterCopySystemFolder libMasterCopySystemFolder = library.MasterCopyFolder;
}
Code de programme : accéder à des dossiers personnalisés avec la méthode Find()

...
LibraryTypeUserFolderComposition userFolderComposition = ...
LibraryTypeUserFolder userFolder = userFolderComposition.Find("Name of user folder");
...

Code de programme : énumérer des dossiers personnalisés

Pour énumérer les sous-dossiers personnalisés dans un dossier système pour des types,
public static void EnumerateUserFoldersInTypeSystemFolder(ILibrary library)

{
// Enumerating user folders in type system folder:
LibraryTypeSystemFolder libTypeSystemFolder = library.TypeFolder;
foreach (LibraryTypeUserFolder libTypeUserFolder in libTypeSystemFolder.Folders)
{
//...
}
}
Pour énumérer les sous-dossiers personnalisés dans un dossier système pour des copies
maîtres, modifiez le code de programme suivant :
public static void EnumerateUserFoldersInMasterCopySystemFolder(ILibrary library)

{
// Enumerating user folders in master copy system folder:
MasterCopySystemFolder libMasterCopySystemFolder = library.MasterCopyFolder;
foreach (MasterCopyUserFolder libMasterCopyUserFolder in
libMasterCopySystemFolder.Folders)
{
//..
}
}
Pour énumérer les sous-dossiers personnalisés dans un dossier personnalisé pour des types,
public static void EnumerateAllUserFolders(LibraryTypeUserFolder libUserFolder)

{
foreach (LibraryTypeUserFolder libSubUserFolder in libUserFolder.Folders)
{
EnumerateAllUserFolders(libSubUserFolder);
}
}
Pour énumérer les sous-dossiers personnalisés dans un dossier personnalisé pour des copies
maîtres, modifiez le code de programme suivant :
public static void EnumerateAllUserFolders(MasterCopyUserFolder libUserFolder)

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

Code de programme : créer des dossiers personnalisés

Pour créer un dossier personnalisé pour des types, modifiez le code de programme suivant :
var typeFolderComposition = ProjectLibrary.TypeFolder.Folders;

var newTypeUserFolder = typeFolderComposition.Create("NewTypeUserFolder");
Pour créer un dossier personnalisé pour des copies maîtres, modifiez le code de programme
suivant :
var masterCopyFolderComposition = projectProjectLibrary.MasterCopyFolder.Folders;

MasterCopyUserFolder newMasterCopyUserFolder =
masterCopyFolderComposition.Create("NewMasterCopyUserFolder);
Code de programme : renommer des dossiers personnalisés

Pour créer un dossier personnalisé pour des types, modifiez le code de programme suivant :
var typeUserFolder =
project.ProjectLibrary.TypeFolder.Folders.Find("SampleTypeUserFolderName");
typeUserFolder.Name = "NewTypeUserFolderName";
var typeUserFolder = ProjectLibrary.TypeFolder.Folders.Find("SampleTypeUserFolderName");

typeUserFolder.SetAttributes(new[] {new KeyValuePair<string,object>("Name",
"NewTypeUserFolderName")});
Pour créer un dossier personnalisé pour des copies maîtres, modifiez le code de programme
suivant :
var masterCopyUserFolder =
project.ProjectLibrary.MasterCopyFolder.Folders.Find("SampleMasterCopyUserFolderName");
masterCopyUserFolder.Name = "NewMasterCopyUserFolderName";
var masterCopyUserFolder =
ProjectLibrary.MasterCopyFolder.Folders.Find("SampleMasterCopyUserFolderName");
masterCopyUserFolder.SetAttributes(new[] {new KeyValuePair<string,object>("Name",
"NewMasterCopyUserFolderName")});
Voir aussi
Accéder à des modèles de copie (Page 168)

7.12.10 Accéder aux types
Conditions requises
● Vous avez accès à un groupe pour les types.
Voir Accéder aux dossiers dans une bibliothèque (Page 154).
Utilisation
Vous pouvez accéder aux types d'une bibliothèque par le biais de l'interface TIA Portal
Openness API.
● Vous pouvez énumérer les types.
● Vous pouvez renommer les types.
● Vous pouvez accéder aux attributs suivants des différents types :
Attribut type de données Description

Author String Fournit le nom de l'auteur :
Comment MultilingualText Fournit en retour le commentaire.
Guid Guid Fournit en retour le GUID du type.1
Name String Fournit en retour le nom du type. 2
1
Cet attribut vous permet de trouver un type précis dans une bibliothèque. La recherche est
récursive.
2
Cet attribut vous permet de trouver un type précis dans un dossier. Les sous-dossiers ne sont pas
pris en compte dans la recherche. Les noms des types ne sont pas univoques. Plusieurs types
avec le même nom peuvent exister dans différents groupes. Le GUID du type est en revanche
univoque.
Sous-classes pour objets de types de bibliothèques

La TIA Portal Openness permet d'accéder à des objets de types de bibliothèque via des sous-
classes. Les sous-classes suivantes sont disponibles :
● Siemens.Engineering.Hmi.Faceplate.FaceplateLibraryType
● Siemens.Engineering.Hmi.Faceplate.FaceplateLibraryTypeVersion
● Siemens.Engineering.Hmi.RuntimeScripting.VBScriptLibraryType
● Siemens.Engineering.Hmi.RuntimeScripting.VBScriptLibraryTypeVersion
● Siemens.Engineering.Hmi.RuntimeScripting.CScriptLibraryType
● Siemens.Engineering.Hmi.RuntimeScripting.CScriptLibraryTypeVersion

● Siemens.Engineering.Hmi.Screen.ScreenLibraryType
● Siemens.Engineering.Hmi.Screen.ScreenLibraryTypeVersion
● Siemens.Engineering.Hmi.Screen.StyleLibraryType
● Siemens.Engineering.Hmi.Screen.StyleLibraryTypeVersion
● Siemens.Engineering.Hmi.Screen.StyleSheetLibraryTypeVersion
● Siemens.Engineering.Hmi.Tag.HmiUdtLibraryType
● Siemens.Engineering.Hmi.Tag.HmiUdtLibraryTypeVersion
● Siemens.Engineering.SW.Blocks.CodeBlockLibraryType
● Siemens.Engineering.SW.Blocks.CodeBlockLibraryTypeVersion
● Siemens.Engineering.SW.Types.PlcTypeLibraryType
● Siemens.Engineering.SW.Types.PlcTypeLibraryTypeVersion
Le code suivant est un exemple d'utilisation de sous-classes pour types de bibliothèques.
ProjectLibrary library = project.ProjectLibrary;

VBScriptLibraryType vbScriptType = ...;
VBScriptLibraryType libraryTypeAsVbScript = libraryType as VBScriptLibraryType;
VBScriptLibraryTypeVersion libraryTypeVersionAsVbScript = libraryTypeVersion as
VBScriptLibraryTypeVersion
Code du programme
Pour énumérer tous les types dans le dossier système d'une bibliothèque, modifiez le code de
programme suivant :
public static void EnumerateTypesInTypesSystemFolder(LibraryTypeSystemFolder

libraryTypeSystemFolder)
{
foreach (LibraryType libraryType in libraryTypeSystemFolder.Types)
{
//...
}
}
Pour énumérer tous les types dans le dossier personnalisé d'une bibliothèque, modifiez le code
public static void EnumerateTypesInTypesUserFolder (LibraryTypeUserFolder

libraryTypeUserGroup)
{
foreach (LibraryType libraryType in libraryTypeUserGroup.Types)
{
//...
}
}

Pour accéder aux attributs d'un type, modifiez le code de programme suivant :
public static void InspectPropertiesOfType (LibraryType libTypeObject)

{
string typeAuthor = libTypeObject.Author;
MultilingualText typeComment = libTypeObject.Comment;
string typeName = libTypeObject.Name;
Guid typeGUID = libTypeObject.Guid;
}
Pour trouver un type précis par son nom ou son GUID, modifiez le code de programme suivant :
public static void FindTypeObjectInLibrary(ILibrary library)

{
// Find type object by its GUID in a given library:
System.Guid targetGuid = ...;
LibraryType libTypeByGUID = library.FindType(targetGuid);
// Find type object by its name in a given group:
LibraryTypeFolder libTypeSystemFolder = library.TypeFolder;
LibraryType libTypeByName = libTypeSystemFolder.Types.Find("myTypeObject");
}
Pour renommer un type, modifiez le code de programme suivant :
// Setting the name attribute

var type = project.ProjectLibrary.TypeFolder.Types.Find("SampleTypeName");
type.Name = "NewTypeName";
//Setting the name attribute dynamically

var type = project.ProjectLibrary.TypeFolder.Types.Find("SampleTypeName");
type.SetAttributes(new[] {new KeyValuePair<string,object>("Name", "NewTypeName")});
7.12.11 Accéder aux types de versions
Conditions
● Vous avez accès à un groupe pour types.

Utilisation
L'interface TIA Portal Openness API vous donne accès aux versions de type.
● Vous pouvez énumérer les versions d'un type.
● Vous pouvez déterminer le type auquel une version appartient.
● Vous pouvez énumérer les instances d'une version de type.
● Vous pouvez créer une nouvelle instance d'une version de type.
● Vous pouvez naviguer d'une instance vers la version d'objet reliée à celle-ci.
● Vous pouvez accéder aux attributs suivants des différentes versions de type :
Attribut Type de données Description

Comment MultilingualText Fournit en retour le commentaire.
Guid Guid Fournit en retour le GUID de la version de type.1
ModifiedDate DateTime Fournit en retour la date et l'heure à laquelle la version de
type a été mise à l'état "Committed".
State LibraryTypeVersionS‐ Fournit en retour l'état de la version :
tate ● InWork : correspond, selon le type affecté, à l'état "En
cours" ou "Test en cours".
● Committed : correspond à l'état "Validé".
TypeObject LibraryType Fournit en retour le type auquel appartient cette version de
type.
VersionNumber Version Fournit en retour le numéro de version sous forme de dé‐
signation à trois chiffres, par ex. "1.0.0".2
1
Cet attribut vous permet de trouver une version de type spécifique dans une bibliothèque.
2
Cet attribut vous permet de trouver une version de type spécifique dans une composition
"LibraryTypeVersion".
Énumérer les versions d'un type

//Enumerate the type versions of a type

public static void EnumerateVersionsInType(LibraryType libraryType)
{
foreach (LibraryTypeVersion libraryTypeVersion in libraryType.Versions)
{
//...
}
}

Appeler les attributs d'une version de type

//Acessing the attributes of a type version

public static void InspectPropertiesOfVersion(LibraryTypeVersion libTypeVersion)
{
string versionAuthor = libTypeVersion.Author;
MultilingualText versionComment = libTypeVersion.Comment;
Guid versionGUID = libTypeVersion.Guid; DateTime versionModifiedDate =
libTypeVersion.ModifiedDate;
LibraryTypeVersionState versionStateLibrary = libTypeVersion.State;
LibraryType versionParentObject = libTypeVersion.TypeObject;
Version versionNumber = libTypeVersion.VersionNumber;
}
Créer une instance d'une version de type

Vous pouvez créer une nouvelle instance d'une version de type. Les objets suivants sont pris
en charge :
● Blocs (FB/FC)
● Types de données personnalisé API
● Vues
● Scripts VB
Une instance d'une version de type peut être créée à partir de la bibliothèque globale ou de la
bibliothèque de projet. Si vous créez une instance d'une version de type depuis une
bibliothèque globale, la version de type est d'abord synchronisée avec la bibliothèque de projet.
Une exception récupérable est déclenchée lorsqu'il n'est pas possible de créer une instance
dans la cible. Causes possibles :
● La version de type de bibliothèque est en cours de traitement
● Une instance de la version de type de bibliothèque existe déjà dans l'appareil cible
VBScriptLibraryTypeVersion scriptVersion = ...;

VBScriptComposition vbscripts = ...;
//Using the CreateFrom method to create an instance of the version in the VBScripts
composition
VBScript newScript = vbscripts.CreateFrom(scriptVersion);

ScreenLibraryTypeVersion screenVersion = ...;

ScreenComposition screens = ...;
//Using the CreateFrom method to create an instance of the version in the screens
composition
Screen newScreen = screens.CreateFrom(screenVersion);
CodeBlockLibraryTypeVersion blockVersion = ...;

PlcBlockComposition blocks = ...;
//Using the CreateFrom method to create an instance of the version in the blocks composition
PlcBlock newBlock = blocks.CreateFrom(blockVersion);
PlcTypeLibraryTypeVersion plcTypVersione=...;
PlcTypeComposition types=...;
//Using the CreateFrom method to create an instance of the version in the types composition
PlcType newType = types.CreateFrom(plcTypeVersion);
Déterminer les utilisations d'une version de type

Les utilisations suivantes sont différenciées pour les versions de type :
● La version de type utilise d'autres versions de types issues de la bibliothèque.
Exemple : un type de données personnalisé est utilisé dans un bloc de programme. Le bloc
de programme doit avoir accès au type de données utilisateur. Cela signifie que le bloc de
programme dépend du type de données utilisateur.
Si vous accédez à l'attribut d'indépendance de CodeBlockLibraryVersion avec la
méthode GetDependencies() , vous obtenez une liste de LibraryTypeVersions en
retour.
● Le type est utilisé par une autre version de type dans la bibliothèque.
Exemple : un type de données personnalisé est utilisé dans un bloc de programme. Le bloc
de programme doit avoir accès au type de données utilisateur. Le type de données
utilisateur a le bloc de programme correspondant. Le bloc de programme dépend du type
de données utilisateur.
Si vous accédez à l'attribut d'indépendance de PlcTypeLibraryTypeVersion avec la
méthode GetDependents() , vous obtenez une liste de LibraryTypeVersions en retour.

Une liste contenant des objets du type LibraryTypeVersion est fournie en retour pour les
deux attributs. Si aucune utilisation n'existe, une chaîne vide est fournie en retour.
Remarque
Une exception peut être déclenchée si vous appliquez ces attributs aux versions de type avec
l'état "InWork".
//Determine the uses of a type version in a library

public static void GetDependenciesAndDependentsOfAVersion(LibraryTypeVersion
libTypeVersion)
{
IList<LibraryTypeVersion> versionDependents = libTypeVersion.Dependents();
IList<LibraryTypeVersion> versionDependencies = libTypeVersion.Dependencies();
}
Code de programme
Pour déterminer le type auquel appartient une version de type, modifiez le code de programme
suivant :
public static void GetParentTypeOfVersion(LibraryTypeVersion libTypeVersion)

{
LibraryType parentType = libTypeVersion.TypeObject;
}
Pour déterminer les copies maîtres contenant des instances d'une version de type, modifiez le
public static void GetMasterCopiesContainingInstances(LibraryTypeVersion libTypeVersion)

{
MasterCopyAssociation masterCopies = libTypeVersion.MasterCopiesContainingInstances;
}
Pour trouver une version de type précise par son numéro de version, modifiez le code de
programme suivant :
public static void FindVersionInLibrary(ILibrary library, Guid versionGUID)

{
LibraryTypeVersion libTypeVersionByVersionNumber = library.FindVersion(versionGUID);
}

7.12.12 Accès aux blocs dans les bibliothèques
Conditions
Voir Établir une connexion à TIA Portal (Page 79)
Application
Vous pouvez appeler avec TIA Portal Openness la version depuis l'objet de bibliothèque, sans
instancier ou compiler l'objet.
La nouvelle action d'exportation suivante est mise à disposition dans l'objet d'ingénierie
LibraryTypeVersion pour l'exportation du contenu de version.
L'action crée le fichier XML exporté à la version indiquée avec exportFileInfo.
void Export('''FileInfo''' exportFileInfo, '''ExportOptions''' exportOptions)
Une exception est retournée :

● Si l'exception utilisateur est "Les données de version ne peuvent pas être exportées car
elles sont en cours de travail" et que la version à exporter présente l'état "En test".
● Si une exception utilisateur DataExchange générale est présente, par ex.
"FileAlreadyExists", et que le message suivant est émis : "L'exportation ne peut pas être
réalisée car le fichier 'D:\\*.xml' existe déjà.".
Objet d'ingénierie Version de type de bibliothèque

Les ajouts suivants sont effectués à l'objet Library TypeVersion engineering :
1. L'action d'exportation est mise à disposition dans LibraryTypeVersion.
2. Un navigateur permettant la navigation dans le contenu de version disponible à la
recherche.
– Nom de navigation : ContentObject
– ReadPublicationLevel : System
– Nom de relation : Engineering.Library.DefaultVersionContentObject
– Le navigateur de base offre une implémentation standard pour mettre à disposition une
bibliothèque vide comme contenu de version disponible à la recherche. Le client peut
écraser ce navigateur et mettre à disposition le contenu de la version.
3. "LibraryTypeName" et "LibraryTypeGuid" au niveau de l'objet LibraryTypeVersion.
Attributs ReadPublicationLevel
LibraryTypeName System
LibraryTypeGuid System

Remarque
Cela s'avère nécessaire car sans cette information, il ne serait pas possible de savoir
clairement à quel type correspond la version exportée (d'après la version dans le fichier XML
exporté).
Contenu exporté
Le contenu suivant est affiché dans le fichier exporté :
● Version exportée de la bibliothèque
Attributs SimaticMLAAccess
Author ReadWrite
Guid ReadOnly
Modified Data ReadOnly
VersionNumber ReadWrite
LibraryTypeName ReadOnly
Library TypeGuid ReadOnly
Navigateurs exportés :
● Comment
Remarque
Les attributs avec SimaticMLAccess protégé en écriture sont exportés uniquement si vous
sélectionnez l'option d'exportation "ExportOptions.WithReadOnly".
Code de programme
Modifiez le code de programme suivant pour exporter la version du contenu exporté :
Guid g = new Guid("35ad9996-d6d7-40c9-989f-0f0c7e21a7b2");

//Block1
var version = m_Project.ProjectLibrary.FindType(g).Versions[0];
version.Export(new FileInfo(@"D:\ExportCodeBlock.xml"),ExportOptions.WithReadOnly);
Voir aussi

7.12.13 Accéder aux instances
Conditions
● Vous avez accès à un groupe pour types.
Utilisation
L'interface TIA Portal Openness API vous donne accès aux instances de versions de type.
Vous pouvez déterminer toutes les instances d'une version de type par la méthode
FindInstances(IInstanceSearchScope searchScope).
Le paramètre searchScope vous permet d'indiquer le champ de recherche au sein du projet.
Les classes suivantes implémentent l'interface IInstanceSearchScope et peuvent être
utilisées pour la recherche d'instances :
● PlcSoftware
● HmiTarget
Cette méthode fournit en retour une liste comprenant des objets du type
LibraryTypeInstanceInfo. Si aucune instance n'existe, une chaîne vide est fournie en
retour.
Remarque
Les instances des blocs d'affichage et des types de données utilisateur HMI sont toujours
associées à la version de type correspondante.
Les instances de tous les autres objets tels que les blocs de programme ou les vues peuvent
être associées à une version de type.

Énumérer les instances d'une version de type

//Enumerate the instances of a type version in the project

LibraryTypeVersion version = ...;
PlcSoftware plcSoftware = ...;
IInstanceSearchScope searchScope = plcSoftware as IInstanceSearchScope;
if(searchScope==null)
{
//No search possible
}
IList<LibraryTypeInstanceInfo> instanceInfos = version.FindInstances(searchScope);

IEnumerable<IEngineeringObject> instances = instanceInfos.Select(instanceInfo =>
instanceInfo.LibraryTypeInstance);
Naviguer d'une instance vers la version d'objet reliée à celle-ci

Utilisez l'attribut LibraryTypeVersion du service LibraryTypeInstanceInfo pour naviguer d'une
instance vers la version d'objet reliée à celle-ci.
Les objets suivants offrent le service LibraryTypeInstanceInfo :
● Blocs FB
● Blocs FC
● Types de données personnalisé API
● Vues
● Scripts VB
Lorsque l'objet d'une instance n'est pas relié à une version d'objet, il ne propose pas le service
"LibraryTypeInstanceInfo".
FC fc = ...;
//Using LibraryTypeInstanceInfo service
LibraryTypeInstanceInfo instanceInfo = fc.GetService<LibraryTypeInstanceInfo>();

if(instanceInfo != null)
{
LibraryTypeVersion connectedVersion = instanceInfo.LibraryTypeVersion;
FC parentFc = instanceInfo.LibraryTypeInstance as FC; //parentFc == fc
}

7.12.14 Accéder à des modèles de copie
Conditions requises
Voir Accès aux bibliothèques globales (Page 142)
● Vous avez accès à un groupe pour les copies maîtres.
Voir Accéder aux dossiers dans une bibliothèque (Page 154)
Utilisation
L'interface TIA Portal Openness API prend en charge l'accès aux copies maîtres dans une
bibliothèque globale et la bibliothèque de projet :
● Créer des copies maîtres
● Enumérer des copies maîtres dans des dossiers système et des dossiers personnalisés
● Renommer des copies maîtres
● Interroger les informations des copies maîtres
● Interroger les informations des objets dans une copie maître

ContentDescriptions MasterCopyContentDescrip‐ Fournit en retour une description du contenu de la copie maître.
tionComposition
CreationDate DateTime Fournit en retour la date de création.
Name String Fournit en retour le nom de la copie maître.
Code du programme
Pour énumérer toutes les copies maître dans le dossier système d'une bibliothèque, modifiez
le code de programme suivant :
public static void EnumerateMasterCopiesInSystemFolder

(MasterCopySystemFolder masterCopySystemFolder)
{
foreach (MasterCopy masterCopy in masterCopySystemFolder.MasterCopies)
{
//...
}
}

Pour accéder à une copie maître individuelle par la méthode "Find", modifiez le code de
programme suivant :
...
MasterCopySystemFolder systemFolder = projectLibrary.MasterCopyFolder;
MasterCopyComposition mastercopies = systemFolder.MasterCopies;
MasterCopy masterCopy = mastercopies.Find("Copy of ...");
...
Pour énumérer les groupes et sous-groupes des copies maîtres, modifiez le code de
programme suivant :
private static void EnumerateFolder(MasterCopyFolder folder)

{
EnumerateMasterCopies(folder.MasterCopies);
foreach (MasterCopyUserFolder subFolder in folder.Folders)
{
EnumerateFolder(subFolder); // recursion
}
}
private static void EnumerateMasterCopies(MasterCopyComposition masterCopies)
{
foreach (MasterCopy masterCopy in masterCopies)
{
...
}
}
Pour accéder à un MasterCopyUserFolder par la méthode "Find", modifiez le code de

programme suivant :
...
MasterCopyUserFolderComposition userFolderComposition = ...
MasterCopyUserFolder userFolder = userFolderComposition.Find("Name of user folder");
...
Pour renommer une copie maître, modifiez le code de programme suivant :
//Setting the name attribute

var masterCopy = projectLibrary.MasterCopyFolder.MasterCopies.Find("SampleMasterCopyName");
masterCopy.Name = "NewMasterCopyName";
//Setting the name attribute dynamically

var masterCopy = projectLibrary.MasterCopyFolder.MasterCopies.Find("SampleMasterCopyName");
masterCopy.SetAttributes(new[] {new KeyValuePair<string,object>("Name",
"NewMasterCopyName")});

Interroger les informations des copies maîtres

Pour appeler les informations d'une copie maître, modifiez le code de programme suivant :
public static void GetMasterCopyInformation(MasterCopy masterCopy)

{
string author = masterCopy.Author;
DateTime creationDate = masterCopy.CreationDate;
string name = masterCopy.Name;
}
Interroger les informations des objets dans une copie maître

L'objet MasterCopy contient le navigateur ContentDescriptions qui est une composition de
MasterCopyContentDescriptions.
Une copie maître peut contenir plusieurs objets. L'objet MasterCopy contient des
ContentDescriptions pour chaque objet existant directement dans la copie maître. Lorsque la
copie maître comporte un dossier qui contient également quelques éléments, l'objet
MasterCopy ne contient qu'une ContentDescription du dossier.
MasterCopy multiObjectMasterCopy = ...;
//Using ContentDescriptions
MasterCopyContentDescriptionComposition masterCopyContentDescriptions =
multiObjectMasterCopy.ContentDescriptions;
MasterCopyContentDescription contentDescription= masterCopyContentDescriptions.First();
string name = contentDescription.ContentName;

Type type = contentDescription.ContentType;
7.12.15 Créer la copie maîtresse d'un projet dans la bibliothèque
Conditions requises

Utilisation
Lorsqu'il s'agit d'une bibliothèque en lecture/écriture, vous pouvez créer une copie maître issue
d'une IMasterCopySource sur l'emplacement cible.
MasterCopy
MasterCopyComposition.Create(Siemens.Engineering.Library.MasterCopies.IMasterCopySource
sourceObject);
Une exception EngineeringException est déclenchée dans les cas suivants :

● L'emplacement cible est accessible en lecture seule
● Le système refuse la génération d'une copie maître issue de la source
Les éléments suivants sont définis comme IMasterCopySources :
● Device - HW
● DeviceItem - HW
● DeviceUserGroup - HW
● CodeBlock - SW
● DataBlock - SW
● PlcBlockUserGroup - SW
● PlcTag - SW
● PlcTagTable - SW
● PlcTagTableUserGroup - SW
● PlcType - SW
● PlcTypeUserGroup - SW
● VBScript - HMI
● VBScriptUserFolder - HMI
● Screen - HMI
● ScreenTemplate - HMI
● ScreenTemplateUserFolder - HMI
● ScreenUserFolder - HMI
● Tag - HMI
● TagTable - HMI
● TagUserFolder - HMI

Code du programme
Utilisez le code de programme suivant :
// create a master copy from a code block in the project library

public static void Create(Project project, PlcSoftware plcSoftware)
{
MasterCopySystemFolder masterCopyFolder = project.ProjectLibrary.MasterCopyFolder;
CodeBlock block = plcSoftware.BlockGroup.Groups[0].Blocks.Find("Block_1") as CodeBlock;
MasterCopy masterCopy = masterCopyFolder.MasterCopies.Create(block);
}
7.12.16 Créer un objet à partir d'une copie maîtresse
Conditions
● L'API n'est pas en ligne.
Utilisation
L'interface TIA Portal Openness API prend en charge l'utilisation de copies maîtres dans le
projet. Avec la méthode CreateFrom, vous pouvez créer un objet dans la composition de l'objet
issu d'une copie maître dans une bibliothèque du projet ou une bibliothèque globale.
Le type fourni correspond à celui de la composition respective.
La méthode CreateFrom ne prend en charge que les copies maîtres contenant des objets
isolés. Quand la composition dans laquelle l'action est appelée et la copie maître source sont
incompatibles (par ex. quand la copie maître source contient une table de variables API et que
la composition est celle d'un bloc API), une exception récupérable est lancée.
Les compositions suivantes sont prises en charge :
● Siemens.Engineering.HW.DeviceComposition
● Siemens.Engineering.HW.DeviceItemComposition
● Siemens.Engineering.SW.Blocks.PlcBlockComposition
● Siemens.Engineering.SW.Tags.PlcTagTableComposition
● Siemens.Engineering.SW.Tags.PlcTagComposition
● Siemens.Engineering.SW.Types.PlcTypeComposition
● Siemens.Engineering.SW.TechnologicalObjects.TechnologicalInstanceDBComposition
● Siemens.Engineering.SW.Tags.PlcUserConstantComposition
● Siemens.Engineering.Hmi.Tag.TagTableComposition

● Siemens.Engineering.Hmi.Tag.TagComposition
● Siemens.Engineering.Hmi.Screen.ScreenComposition
● Siemens.Engineering.Hmi.Screen.ScreenTemplateComposition
● Siemens.Engineering.Hmi.RuntimeScripting.VBScriptComposition
● Siemens.Engineering.HW.SubnetComposition
● Siemens.Engineering.HW.DeviceUserGroupComposition
● Siemens.Engineering.SW.Blocks.PlcBlockUserGroupComposition
● Siemens.Engineering.SW.ExternalSources.PlcExternalSourceUserGroupComposition
● Siemens.Engineering.SW.Tags.PlcTagTableUserGroupComposition
● Siemens.Engineering.SW.Types.PlcTypeUserGroupComposition
Code de programme : créer un bloc API à partir d'une copie maître

Pour créer un bloc API à partir d'une copie maître dans une bibliothèque, modifiez le code de
programme suivant :
var plcSoftware = ...;

MasterCopy copyOfPlcBlock = ...;
PlcBlock plcSoftware.BlockGroup.Blocks.CreateFrom(copyOfPlcBlock);
Code de programme : créer un appareil à partir d'une copie maître

Pour créer un appareil à partir d'une copie maître dans une bibliothèque, modifiez le code de
programme suivant :

MasterCopy copyOfDevice = ...;
Device newDevice = project.Devices.CreateFrom(copyOfDevice);
Code de programme : créer un élément d'appareil à partir d'une copie maître

Pour créer un élément d'appareil à partir d'une copie maître dans une bibliothèque, modifiez le
Device device = ...;

MasterCopy copyOfDeviceItem = ...;
DeviceItem newDeviceItem = device.DeviceItems.CreateFrom(copyOfDeviceItem);

Code de programme : créer un sous-réseau à partir d'une copie maître

Pour créer un sous-réseau à partir d'une copie maître dans une bibliothèque, modifiez le code

MasterCopy copyOfSubnet = ...;
Subnet newSubnet = project.Subnets.CreateFrom(copyOfSubnet);
Code de programme : créer un dossier d'appareils à partir d'une copie maître

Pour créer un dossier d'appareils à partir d'une copie maître dans une bibliothèque, modifiez

MasterCopy copyOfDeviceGroup = ...;
DeviceGroup newDeviceGroup= project.DeviceGroups.CreateFrom(copyOfDeviceGroup);
Voir aussi
7.12.17 Copier des copies maîtresse
Conditions requises
Utilisation
L'interface TIA Portal Openness API prend en charge la copie de copies maître au sein d'une
même bibliothèque et d'une bibliothèque vers une autre à l'aide de l'action CreateFrom.
L'action crée un nouvel objet sur la base de la copie maître source et le place dans la
composition là où l'action a été appelée. L'action essaie de créer la nouvelle copie maître sous
un nom identique à celui de la copie maître source. Lorsque ce nom n'est pas disponible, le
système attribue un nouveau nom à la nouvelle copie maître. Ensuite, il affiche la copie maître.
Lorsque la composition dans laquelle l'action "CreateFrom" est appelée se trouve dans une
bibliothèque globale protégée en écriture, une exception récupérable est déclenchée.

Code de programme
ProjectLibrary projectLibrary = ...;
MasterCopy copiedMasterCopy =
projectLibrary.MasterCopyFolder.MasterCopies.CreateFrom(sampleMasterCopy)
Voir aussi
7.12.18 Déterminer les instances de type obsolètes
Conditions requises
Voir Accès aux bibliothèques globales (Page 142)
● Vous avez accès à un dossier pour les types.
Utilisation
L'interface TIA Portal OpennessAPI prend en charge la détermination des versions de types
faisant partie des instances dans le projet ouvert. L'interface TIA Portal OpennessAPI fournit
l'un des deux états suivants pour chaque instance :
● L'instance se rapporte à une version de type obsolète.
● L'instance se rapporte à la version de type actuelle.
Les règles applicables pour la détermination de version sont les suivantes :
● La détermination de version est basée sur une bibliothèque et le projet que vous souhaitez
ouvrir via l'interface TIA Portal OpennessAPI.
● Aucune instance n'est actualisée dans le cadre de la détermination de version.
Signature
Vous pouvez déterminer les instances d'une version de type par la méthode UpdateCheck :
UpdateCheck(Project project, UpdateCheckMode updateCheckMode)

Paramètres Fonction
Project Définit le projet dans lequel les versions de types des instances sont déter‐
minées.
UpdateCheckMode Indique les versions qui sont déterminées :
● ReportOutOfDateOnly : fournit en retour seulement l'état de type
"obsolète".
● ReportOutOfDateAndUpToDate :
fournit en retour l'état des types "obsolète" et "actuel" :
Résultat
Lors de la détermination de version, les appareils du projet sont interrogés de haut en bas. La
présence d'une instance d'une version de type issue de la bibliothèque indiquée dans les
données de configuration de l'appareil est contrôlée pour chaque appareil. La
méthode UpdateCheck fournit le résultat de la vérification de version selon un ordre
hiérarchique.
Le tableau ci-après montre le résultat d'une vérification de version avec le paramètre
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
Up-to-date
Update check for: HMI_2
Update check of library element Screen_4 0.0.3
Out-of-date
\Screens folder1 Screen_02 0.0.1
Up-to-date
Code du programme
Il n'existe aucune différence entre les bibliothèques de projet et les bibliothèques globales
concernant la manipulation du contrôle de la mise jour.

Pour déterminer les versions de type d'une bibliothèque globale ou d'une bibliothèque de projet
pour les instances dans le projet, modifiez le code de programme suivant :
public static void UpdateCheckOfGlobalLibrary(Project project, ILibrary library)

{
// check for out of date instances and report only out of date instances in the returned
feedback
UpdateCheckResult result = library.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 = library.UpdateCheck(project,
UpdateCheckMode.ReportOutOfDateAndUpToDate);
//Show result
// Alternatively, show result and access single message parts

RecursivelyWriteMessageParts(result.Messages);
}
Pour afficher le résultat de la détermination de version et parcourir les messages un par un,
private static void RecursivelyWriteMessages (UpdateCheckResultMessageComposition

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

Pour accéder à certaines parties de message dans le résultat de la détermination de version,

private static void RecursivelyWriteMessageParts (UpdateCheckResultMessageComposition

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);
}
}
7.12.19 Actualiser un projet
Conditions
● Vous avez accès à un dossier pour types.
Utilisation
L'interface TIA Portal Openness API vous permet de mettre à jour des instances d'un type
sélectionné dans un dossier de types d'un projet.

Lors de l'actualisation, les instances utilisées dans le projet sont actualisées sur la base de la
dernière version de type validée. Si vous actualisez les instances d'une bibliothèque globale,
une synchronisation est d'abord exécutée.
Signature
Utilisez la méthode UpdateProject pour actualiser des instances.
Pour les classes implémentant l'interface LibraryTypes, utilisez l'appel suivant :
void UpdateProject(IUpdateProjectScope updateProjectScope)
Pour les classes implémentant l'interface ILibrary, utilisez l'appel suivant :
void UpdateProject(IEnumerable<ILibraryTypeOrFolderSelection>
selectedTypesOrFolders, IEnumerable <IUpdateProjectScope>
updateProjectScope)
Chaque appel est entré dans le fichier-journal du répertoire de projet.
Paramètre Fonction
IEnumerable<ILibraryTypeOrFolderSele Indique les dossiers ou types devant être synchro‐
ction> selectedTypesOrFolders nisés ou dont les instances doivent être actuali‐
sées dans le projet.
IUpdateProjectScope Indique dans le projet les objets dans lesquels les
updateProjectScope utilisations des instances sont actualisées. Les ob‐
IEnumerable <IUpdateProjectScope> jets suivants sont pris en charge :
updateProjectScope ● PlcSoftware
● HmiTarget
Code de programme
Pour actualiser les instances de types sélectionnés dans un dossier de types, modifiez le code
private static void UpdateInstances(ILibrary myLibrary, LibraryTypeFolder

singleFolderContainingTypes, LibraryType singleType, PlcSoftware plcSoftware, HmiTarget
hmiTarget)
{
//Update Instances of multiple types (subset of types and folders)
IUpdateProjectScope[] updateProjectScopes =
{
plcSoftware as IUpdateProjectScope, hmiTarget as IUpdateProjectScope
};
myLibrary.UpdateProject(new ILibraryTypeOrFolderSelection[] {singleType,
singleFolderContainingTypes}, updateProjectScopes);
//Update Instances of multiple types (all types in library)
myLibrary.UpdateProject(new[] {myLibrary.TypeFolder}, updateProjectScopes);
}

7.12.20 Actualiser une bibliothèque
Conditions
● Vous avez accès à un dossier pour types.
Utilisation
L'interface TIA Portal Openness API prend en charge les actualisations suivantes dans la
bibliothèque de projet :
● Synchronisation des types sélectionnés entre les bibliothèques.
La structure des dossiers n'est pas adaptée lors de la synchronisation. Les types à actualiser
sont déterminés et actualisés à l'aide de leur GUID :
● Si un type d'une bibliothèque comporte une version de type manquant dans la bibliothèque
devant être actualisée, la version de type est copiée.
● L'opération est annulée et une Exception est émise, si un type d'une bibliothèque comporte
une version de type avec différents GUID.
Signature
Pour synchroniser les versions de type, utilisez la méthode UpdateLibrary.
Pour les classes implémentant l'interface LibraryTypes, utilisez l'appel suivant :
void UpdateLibrary(ILibrary targetLibrary)
Pour les classes implémentant l'interface ILibrary, utilisez l'appel suivant :
void UpdateLibrary(IEnumerable<LibraryTypeOrFolderSelection>
selectedTypesOrFolders, ILibrary targetLibrary)
Paramètre Fonction
IEnumerable<ILibraryTypeOrFolderSele Indique les dossiers ou types devant être synchro‐
ction> selectedTypesOrFolders nisés ou dont les instances doivent être actuali‐
sées dans le projet.
ILibrary targetLibrary Indique la bibliothèque dont le contenu doit être
synchronisé avec une bibliothèque.
Si la bibliothèque source et la bibliothèque cible
sont identiques, une exception est lancée.

Code de programme
Pour synchroniser un type d'une bibliothèque de projet avec une bibliothèque globale, modifiez
sourceType.UpdateLibrary(projectLibrary);
Pour synchroniser des types sélectionnés dans un dossier de types entre une bibliothèque
globale et la bibliothèque de projet, modifiez le code de programme suivant :
globalLibrary.UpdateLibrary(new[]{globalLibrary.TypeFolder}, projectLibrary);
7.12.21 Supprimer les contenus de bibliothèque
Conditions requises
● Vous avez accès à un dossier pour les types.
Utilisation
L'interface TIA Portal Openness API vous permet de supprimer les contenus suivants dans la
bibliothèque du projet :
● Types
● Version de type
● Dossiers personnalisés pour types
● Copies maître
● Dossiers personnalisés pour copies maître
Remarque
Suppression de types et de dossiers avec des types personnalisés
Si vous souhaitez supprimer un type ou un dossier avec des types personnalisés, les "Règles
de suppression de versions" doivent être respectées. Vous pouvez supprimer un dossier de
type vide à tout moment.

Remarque
Règles de suppression de versions
Seules les versions au statut "Committed" peuvent être supprimées. Pour la suppression de
versions, les règles à respecter sont les suivantes :
● Si vous venez de créer une version au statut "InWork" depuis une version au statut
"Committed", vous ne pouvez supprimer la version au statut "Committed" que lorsque la
nouvelle version est annulée ou obtient le statut "Committed".
● Si un type ne possède qu'une seule version, le type est également supprimé.
● Si la version A dépend de la version B d'un autre type, supprimez d'abord la version A, puis
la version B.
● Si des instances de la version A existent, vous ne pouvez supprimer la version A que si vous
supprimez également les instances. De plus, si une instance se trouve dans une copie
maître, celle-ci est également supprimée.
Code du programme
Pour supprimer des types ou des dossiers avec des types personnalisés, modifiez le code de
programme suivant :
public static void DeleteMultipleTypesOrTypeUserFolders(ILibrary library)

{
LibraryType t1 = library.TypeFolder.Types.Find("type1");
LibraryTypeUserFolder f1 = library.TypeFolder.Folders.Find("folder1");
t1.Delete();
t2.Delete();
f1.Delete();
}
Pour supprimer un type ou dossier avec des types personnalisés en particulier, modifiez le
public static void DeleteSingleTypeOrTypeUserFolder(ILibrary library)

{
//Delete a single type
t1.Delete();
//Delete a single folder

LibraryTypeFolder parentFolder = library.TypeFolder;
LibraryTypeUserFolder f1 = parentFolder.Folders.Find("folder1");
f1.Delete();
}

7.13 Fonctions pour l'appel d'appareils, de réseaux et de liaisons
Pour supprimer une version, modifiez le code de programme suivant :
public static void DeleteVersion(ILibrary library)

{
LibraryType singleType = library.TypeFolder.Types.Find("type1");
LibraryTypeVersion version1 = singleType.Versions.Find(new System.Version(1, 0, 0));
version1.Delete();
}
Pour supprimer une copie maître ou un dossier avec des copies maîtres personnalisées,
public static void DeleteMasterCopies(ILibrary library)

{
// Delete master copy
MasterCopy masterCopy = library.MasterCopyFolder.MasterCopies.Find("myMasterCopy");
masterCopy.Delete();
// Delete master copy user folder

MasterCopyUserFolder masterUserFolder =
library.MasterCopyFolder.Folders.Find("myFolder");
masterUserFolder.Delete();
}
Voir aussi
7.13.1 Ouvrir l'éditeur "Appareils & réseaux"
Conditions

Utilisation
Vous pouvez ouvrir l'éditeur "Appareils & réseaux" avec l'interface API grâce à l'une des deux
méthodes suivantes :
● ShowHwEditor(View.Topology ou View.Network ou View.Device) : Ouvre
l'éditeur "Appareils & Réseaux" depuis le projet.
● ShowInEditor(View.Topology ou View.Network ou View.Device) : Affiche
l'appareil indiqué dans l'éditeur "Appareils & Réseaux".
Le paramètre View vous permet de définir la vue qui est affichée lors de l'ouverture de
l'éditeur :
● View.Topology
● View.Network
● View.Device
Code du programme
Pour ouvrir l'éditeur "Appareils & Réseaux", modifiez le code de programme suivant :
// Open topology view from project

private static void OpenEditorDevicesAndNetworksFromProject(Project project)
{
project.ShowHwEditor(Siemens.Engineering.HW.View.Topology);
}
Pour ouvrir l'éditeur "Appareils & Réseaux" pour un appareil, modifiez le code de programme
suivant :
// Open topology view for given device

private static void OpenEditorDevicesAndNetworksFromDevice(Device device)
{
device.ShowInEditor(Siemens.Engineering.HW.View.Topology);
}
Voir aussi
Importation de données de configuration (Page 780)

7.13.2 Interroger PLC Target et HMI Target
Conditions requises
Utilisation
Vous pouvez définir si un logiciel de base peut être utilisé comme PLC Target (PlcSoftware) ou
HMI Target dans la TIA Portal Openness API.
Code du programme : PLC Target

Pour vérifier si un élément d'appareil peut être utilisé comme PLC Target, utilisez le code de
programme suivant :
// Returns PlcSoftware
private PlcSoftware GetPlcSoftware(Device device)
{
DeviceItemComposition deviceItemComposition = device.DeviceItems;
foreach (DeviceItem deviceItem in deviceItemComposition)
{
SoftwareContainer softwareContainer = deviceItem.GetService<SoftwareContainer>();
{
Software softwareBase = softwareContainer.Software;
PlcSoftware plcSoftware = softwareBase as PlcSoftware;
return plcSoftware;
}
}
return null;
}

Code du programme : HMI Target

Pour vérifier si un élément d'appareil peut être utilisé comme HMI Target, modifiez le code de
programme suivant :
//Checks whether a device is of type hmitarget

private HmiTarget GetHmiTarget(Device device)
{
{
{
Software softwareBase = softwareContainer.Software;
HmiTarget hmiTarget = softwareBase as HmiTarget;
return hmiTarget;
}
}
return null;
}
Voir aussi
Énumérer des appareils (Page 236)
7.13.3 Accéder à des attributs d'un objet adresse
Conditions
● L'API est hors ligne pour l'accès en écriture.
Utilisation
L'interface TIA Portal Openness API vous permet d'appeler ou de déterminer des attributs de
l'objet adresse.
En outre, vous pouvez affecter la mémoire image actuelle à un OB.

Il est possible d'accéder aux attributs suivants :
Nom d'attribut Type de don‐ Acces‐ Accès Description

nées sible en
écriture
IsochronousMode BOOL r/w Attribut dynamique Activer/désactiver le mode
isochrone
ProcessImage Int32 r/w Attribut dynamique Déterminer/appeler le numé‐
ro de partition de la mémoire
image
InterruptObNumber Int64 r/w Attribut dynamique Déterminer/appeler le numé‐
ro du bloc d'organisation
d'alarme (uniquement contrô‐
leur classique)
StartAddress Int32 r/w Attribut modélisé Déterminer/appeler nouvelle
valeur pour StartAddress
Restrictions
● Attribut StartAddress
– Déterminer StartAddress peut modifier implicitement la StartAddress du type d'E/
S opposé dans le module nom. La modification de l'adresse d'entrée modifie l'adresse
de sortie.
– L'accès en écriture n'est pas pris en charge pour tous les appareils.
– Les adresses comprimées ne sont pas prises en charge dans TIA Portal Openness.
– Les variables affectées ne sont pas recâblées par une modification de l'adresse avec
● Attribut InterruptObNumber
– Accessible uniquement dans les paramétrages avec contrôleurs S7-300 ou S7-400.
L'accès en écriture est pris en charge pour les contrôleurs S7-400.
Code de programme : appeler ou déterminer des attributs d'un objet adresse

Pour accéder au mode isochrone d'un objet adresse, modifiez le code de programme suivant :
Address address= ...;
// read attribute
bool attributeValue = (bool)address.GetAttribute("IsochronousMode");
// write attribute
address.SetAttribute("IsochronousMode", true);

Pour accéder à l'attribut ProcessImage d'un objet adresse, modifiez le code de programme
suivant :
// read attribute
int attributeValue = (int)address.GetAttribute("ProcessImage");
// write attribute
address.SetAttribute("ProcessImage", 7);
Pour accéder à l'attribut InterruptObNumber d'un objet adresse, modifiez le code de

programme suivant :
// read attribute
long attributeValue = (long)address.GetAttribute("InterrruptObNumber");
// write attribute
address.SetAttribute("InterrruptObNumber", 42L);
//default value = 40
Pour accéder à l'attribut StartAddress d'un objet adresse, modifiez le code de programme
suivant :
// read attribute
int attributeValue = (int)address.GetAttribute("StartAddress");
// write attribute
address.StartAddress = IntValueStartAddress;

Code de programme : Affecter la mémoire image actuelle à un OB

Pour affecter la mémoire image actuelle à un OB, modifiez le code de programme suivant :
OB obX =…
// assign PIP 5 to obX
address.SetAttribute("ProcessImage", 5);
try
{
address.AssignProcessImageToOrganizationBlock(obX);
} catch(RecoverableException e) {
Console.WriteLine(e.Message);
}
// remove this PIP-OB assignment
try
{
address.AssignProcessImageToOrganizationBlock(null);
} catch(RecoverableException e) {
}
7.13.4 Appeler une voie de module
Conditions
Utilisation
Les modules d'entrées-sorties tels que les modules d'entrées analogiques comportent
normalement plusieurs voies par module. Habituellement, ces voies offrent plusieurs fonctions
simultanées, par exemple un module d'entrées analogiques à quatre voies peut mesurer
quatre valeurs de tension en même temps.
Pour appeler toutes les voies d'un module, on utilise l'attribut de voie d'un élément d'appareil.

Code de programme : Attributs des voies

Pour accéder aux attributs d'une voie, modifiez le code de programme suivant :
DeviceItem aiModule = ...

ChannelComposition channels = aiModule.Channels;
foreach (Channel channel in channels)
{
... // Work with the channel
}
Code de programme : déterminer des attributs

Pour appeler les attributs d'identification pour les différentes voies, modifiez le code de
programme suivant :
Channel channel = ...

int channelNumber = channel.Number;
ChannelType type = channel.Type;
ChannelIoType ioType = channel.IoType;
Code de programme : appeler une voie particulière

Pour utiliser les attributs d'identification pour l'accès direct à une voie, modifiez le code de
programme suivant :
DeviceItem aiModule = ...

Channel channel = aiModule.Channels.Find(ChannelType.Analog, ChannelIoType.Input, 0);
... // Work with the channel
Types de voie
Valeur Description
ChannelType.None Type de voie non valable.
ChannelType.Analog Type de voie analogique.
ChannelType.Digital Type de voie TOR.
ChannelType.Technology Type de voie technologique.
Types ES de voie
Valeur Description
ChannelIOType.None Type ES de voie non valable.
ChannelIOType.Input Une voie d'entrée.
ChannelIOType.Output Une voie de sortie.
ChannelIOType.Complex Types ES complexes, par ex. pour voies technologiques.

7.14 Fonctions dans les réseaux
7.14.1 Créer un sous-réseau
Conditions
Utilisation
Il y a deux manières différentes de créer des sous-réseaux :
● Création d'un sous-réseau qui est relié à une interface : le type de l'interface pour laquelle
le sous-réseau est créé détermine alors le type du sous-réseau.
● Création d'un sous-réseau qui n'est pas relié à une interface.
Code de programme : Création d'un sous-réseau relié à un abonné :

Pour créer un sous-réseau, modifiez le code de programme suivant :
Node node = ...;

Subnet subnet = node.CreateAndConnectToSubnet("NameOfSubnet");
Les identifiants de type suivants sont utilisés :

● System:Subnet.Ethernet
● System:Subnet.Profibus
● System:Subnet.Mpi
● System:Subnet.Asi
Code de programme : créer un sous-réseau qui n'est pas relié à une interface
Pour créer un sous-réseau, modifiez le code de programme suivant :

SubnetComposition subnets = project.Subnets;
Subnet newSubnet = subnets.Create("System:Subnet.Ethernet", "NewSubnet");

Les identifiants de type suivants peuvent être utilisés :

● System:Subnet.Ethernet
● System:Subnet.Profibus
● System:Subnet.Mpi
● System:Subnet.Asi
7.14.2 Accéder aux sous-réseaux
Conditions
Utilisation
Pour plusieurs caractéristiques relatives aux sous-réseaux, par ex. pour leur affecter des
interfaces, vous devez appeler des sous-réseaux dans le projet. Normalement, les sous-
réseaux sont réunis directement au niveau du projet.
Code de programme : accéder à tous les sous-réseaux d'un projet

Pour accéder à tous les sous-réseaux à l'exception des sous-réseaux internes d'un projet,
Project project = ...

foreach (Subnet net in project.Subnets)
{
... // Work with the subnet
}
Code de programme : accéder à un sous-réseau spécifique

Pour accéder à un sous-réseau précis grâce à son nom, modifiez le code de programme
suivant :

Subnet net = project.Subnets.Find("PROFIBUS_1");
{
... // Work with the subnet
}

Attributs d'un sous-réseau

Un sous-réseau possède les attributs suivants :
Subnet net = ...;

string name = net.Name;
NetType type = net.NetType;
Types de réseau
Valeur Description
NetType.Unknown Le type du réseau est inconnu.
NetType.Ethernet Le type du réseau est Ethernet.
NetType.Profibus Le type du réseau est Profibus.
NetType.Mpi Le type du réseau est MPI.
NetType.ProfibusIntegrated Le type du réseau est Profibus intégré.
NetType.Asi Le type du réseau est ASi.
NetType.PcInternal Le type du réseau est PC interne.
NetType.Ptp Le type du réseau est PtP.
NetType.Link Le type du réseau est Link.
NetType.Wan Le type du réseau est Wide Area Network.
7.14.3 Accéder à des sous-réseaux internes
Conditions
Utilisation
Quand un élément d'appareil peut former un sous-réseau, il dispose de la fonction
supplémentaire "Propriétaire de sous-réseau". Pour accéder à cette fonction supplémentaire,
il faut utiliser un certain service de l'élément d'appareil.

Code de programme : appeler le rôle de propriétaire de sous-réseau

Pour appeler le rôle de propriétaire de sous-réseau, modifiez le code de programme suivant :
SubnetOwner subnetOwner =
((IEngineeringServiceProvider)deviceItem).GetService<SubnetOwner>();
if (subnetOwner != null)
{
// work with the role
}
Code de programme : Attributs d'un propriétaire de sous-réseau

Pour accéder aux sous-réseaux d'un propriétaire de sous-réseau, utilisez le code de
programme suivant :
foreach(Subnet subnet in subnetOwner.Subnets)

{
Subnet interalSubnet = subnet;
}
7.14.4 Appeler l'identifiant de type de sous-réseaux
Conditions
Utilisation
L'attribut TypeIdentifier est utilisé pour identifier un sous-réseau. TypeIdentifier est
une chaîne de caractères composée de plusieurs
parties : <TypeIdentifierType>:<SystemIdentifier>
Les valeurs possibles pour TypeIdentifierType sont :
● System
SystemIdentifier
Type de sous-réseau Identifiant du système

PROFIBUS Subnet.Profibus
MPI Subnet.Mpi
Industrial Ethernet Subnet.Ethernet

Type de sous-réseau Identifiant du système

ASI Subnet.Asi
PtP Subnet.Ptp
PROFIBUS - intégré Subnet.ProfibusIntegrated
PC - interne null
Code de programme
Pour appeler l'identifiant de type des objets pour GSD que l'utilisateur peut créer séparément
et gérer, modifiez le code de programme suivant :
Subnet subnet = ...;

string typeIdentifier = subnet.TypeIdentifier;
7.14.5 Appeler les attributs d'un sous-réseau
Conditions
Utilisation
Un sous-réseau possède certains attributs obligatoires pouvant être lus et/ou écrits. Les
attributs ne sont disponibles que s'ils sont visibles dans l'interface utilisateur. En règle
générale, l'opération d'écriture n'est autorisée que sur un attribut que l'utilisateur peut
également modifier dans l'UI. Cela peut varier en fonction du type de sous-réseau. L'utilisateur
ne peut définir DpCycleTime que si IsochronousMode est vrai et
DpCycleMinTimeAutoCalculation est faux.
Attributs de sous-réseaux de type ASI
Attribut Type de données Acces‐ Accès Description

sible
en
écritu‐
re
Name String r/w Nom du sous-réseau.
NetType NetType r Type du sous-réseau.
SubnetId String r Dyna‐ ID univoque du sous-réseau. L'ID de sous-réseau S7
mique est composée de deux nombres reliés par un trait
d'union. Un nombre pour le projet et un pour le sous-
réseau, par exemple 4493-1.

Attributs de sous-réseaux de type Ethernet

sible
en
écritu‐
re
SubnetId String r/w Dyna‐ ID univoque du sous-réseau. L'ID de sous-réseau S7
DefaultSubnet Bool r/w Dyna‐ Vrai s'il s'agit d'un sous-réseau par défaut. Dans un
mique projet, il existe un sous-réseau par défaut au maximum.
Attributs de sous-réseaux de type MPI

sible
en
écritu‐
re
HighestAddress Int r/w Dyna‐ Adresse MPI la plus élevée du sous-réseau.
mique
TransmissionSpeed BaudRate r/w Dyna‐ Vrai s'il s'agit d'un sous-réseau par défaut. Dans un
mique projet, il existe un sous-réseau par défaut au maximum.
Attributs de sous-réseaux de type PC internal

sible
en
écritu‐
re
Name String r Nom du sous-réseau.
SubnetId String r Dyna‐ ID univoque du sous-réseau. L'ID de sous-réseau S7

Attributs de sous-réseaux de type PROFIBUS
Attribut Type de don‐ Acces‐ Accès Description

nées sible
en
écritu‐
re
SubnetId String r/w Dyna‐ ID univoque du sous-réseau. L'ID de sous-ré‐
mique seau S7 est composée de deux nombres reliés
par un trait d'union. Un nombre pour le projet et
un pour le sous-réseau, par exemple 4493-1.
HighestAddress Int r/w Dyna‐ Adresse PROFIBUS la plus élevée du sous-ré‐
mique seau.
TransmissionSpeed BaudRate r/w Dyna‐ Vrai s'il s'agit d'un sous-réseau par défaut. Dans
mique un projet, il existe un sous-réseau par défaut au
maximum.
BusProfile Profil de bus r/w Dyna‐ Le profil PROFIBUS.
mique
PbCableConfiguration Bool r/w Dyna‐ Vrai, pour activer des paramètres réseau PRO‐
mique FIBUS supplémentaires
PbRepeaterCount Int r/w Dyna‐ Nombre de répéteurs pour conducteur en cuivre
mique
PbCopperCableLength double r/w Dyna‐ La longueur du conducteur en cuivre
mique
PbOpticalComponentCount Int r/w Dyna‐ Nombre de OLM et OBT du câble en fibre opti‐
mique que.
PbOpticalCableLength double r/w Dyna‐ La longueur en km du câble en fibre optique pour
mique le réseau PROFIBUS.
PbOpticalRing Bool r/w Dyna‐ Vrai si des paramètres du bus sont repris pour
mique un anneau optique.
PbOlmP12 Bool r/w Dyna‐ Vrai si OLM/P12 est activé pour le calcul du pa‐
mique ramètre du bus.
PbOlmG12 Bool r/w Dyna‐ Vrai si OLM/G12 est activé pour le calcul du pa‐
mique ramètre du bus.
PbOlmG12Eec Bool r/w Dyna‐ Vrai si OLM/G12-EEC est activé pour le calcul
mique du paramètre du bus.
PbOlmG121300 Bool r/w Dyna‐ Vrai si OLM/G12-1300 est activé pour le calcul
mique du paramètre du bus.
PbAdditionalNetworkDevices Bool r/w Dyna‐ Vrai, si des appareils de bus supplémentaires
mique existant dans le projet sont pris en compte pour
le calcul des cycles de bus.
PbAdditionalDpMaster Int r/w Dyna‐ Nombre de maîtres DP non configurés.
mique
PbTotalDpMaster Int r Dyna‐ Nombre total de maîtres DP
mique
PbAdditionalPassiveDevice Int r/w Dyna‐ Nombre d'esclaves DP non configurés ou d'ap‐
mique pareils passifs.


nées sible
en
écritu‐
re
PbTotalPassiveDevice Int r Dyna‐ Nombre total d'esclaves DP ou d'appareils pas‐
mique sifs.
PbAdditionalActiveDevice Int r/w Dyna‐ Nombre d'appareils actifs non configurés avec
mique charge de communication FDL/FMS/S/.
PbTotalActiveDevice Int r Dyna‐ Nombre total d'appareils actifs avec charge de
mique communication FDL/FMS/S/.
PbAdditionalCommunicationLoad Communica‐ r/w Dyna‐ Estimation approximative de la charge de com‐
tionLoad mique munication
PbDirectDateExchange Bool r/w Dyna‐ Optimisation pour échange direct de données.
mique
PbMinimizeTslotForSlaveFailure Bool r/w Dyna‐ Réduction du temps d'affectation pour erreurs
mique d'esclave.
PbOptimizeCableConfiguration Bool r/w Dyna‐ Optimisation de la configuration des câbles.
mique
PbCyclicDistribution Bool r/w Dyna‐ Vrai, si le partage cyclique des paramètres de
mique bus est activé.
PbTslotInit Int r/w Dyna‐ Valeur par défaut de Tslot.
mique
PbTslot Int r Dyna‐ Temps d'attente de réception (slot time)
mique
PbMinTsdr Int r/w Dyna‐ Temps minimal d'exécution du protocole
mique
PbMaxTsdr Int r/w Dyna‐ Temps maximal d'exécution du protocole
mique
PbTid1 Int r Dyna‐ Temps de repos 1
mique
PbTid2 Int r Dyna‐ Temps de repos 2
mique
PbTrdy Int r Dyna‐ Temps de disponibilité
mique
PbTset Int r/w Dyna‐ Temps de configuration
mique
PbTqui Int r/w Dyna‐ Temps d'atténuation du modulateur
mique
PbTtr int64 r/w Dyna‐ La valeur Ttr dans t_Bit.
mique
PbTtrTypical int64 r Dyna‐ Temps de réponse moyen sur le bus
mique
PbWatchdog int64 r/w Dyna‐ Surveillance de réponse
mique
PbGapFactor Int r/w Dyna‐ Facteur d'actualisation GAP
mique
PbRetryLimit Int r/w Dyna‐ Nombre maximum de tentatives
mique


nées sible
en
écritu‐
re
IsochronousMode Bool r/w Dyna‐ Vrai, si le temps de cycle de bus constant est
mique activé.
PbAdditionalPassivDeviceForIso‐ Int r/w Dyna‐ Nombre de OP/PG/TD, etc. supplémentaires
chronousMode mique non configurés dans cette vue de réseau.
PbTotalPassivDeviceForIsochro‐ Int r Dyna‐ Somme d'appareils configurés et non configu‐
nousMode mique rés, par exemple OP/PG/TD, etc.
DpCycleMinTimeAutoCalculation Bool r/w Dyna‐ Vrai, si le calcul automatique et le réglage du
mique temps de cycle DP le plus court sont activés.
DpCycleTime double r/w Dyna‐ Le temps de cycle DP.
mique
IsochronousTiToAutoCalculation Bool r/w Dyna‐ Vrai, si le calcul automatique et le réglage des
mique valeurs IsochronousTi et IsochronousTo sont
activés.
IsochronousTi double r/w Dyna‐ Time Ti (temps de lecture des valeurs de pro‐
mique cess)
IsochronousTo double r/w Dyna‐ Time To (temps de sortie des valeurs de pro‐
mique cess)
Attributs de sous-réseaux de type PROFIBUS Integrated

sible
en
écritu‐
re
IsochronousMode Bool r Dyna‐ Temps de cycle de bus constant activé.
mique
DpCycleMinTimeAutoCal‐ Bool r/w Dyna‐ Vrai, si le calcul automatique et le réglage du temps de
culation mique cycle DP le plus court sont activés.
DpCycleTime double r/w Dyna‐ Le temps de cycle DP.
mique
IsochronousTiToAutoCalcu‐ Bool r/w Dyna‐ Vrai, si le calcul automatique et le réglage des valeurs
lation mique IsochronousTi et IsochronousTo sont activés.
IsochronousTi double r/w Dyna‐ Time Ti (temps de lecture des valeurs de process)
mique
IsochronousTo double r/w Dyna‐ Time To (temps de sortie des valeurs de process)
mique

Code de programme
Pour appeler ou définir les attributs d'un sous-réseau, modifiez le code de programme suivant :
string nameValue = subnet.Name;

NetType nodeType = (NetType)subnet.NetType;
string subnetId = ((IEngineeringObject)subnet).GetAttribute("SubnetId");
subnet.Name = "NewName";
subnet.SetAttribute("Name", "NewName");
bool isDefaultSubnet = ((IEngineeringObject)subnet).GetAttribute("DefaultSubnet");
Débit en bauds
Valeur Description
BaudRate.None Le débit en bauds est inconnu.
BaudRate.Baud9600 9,6 kBaud
BaudRate.Baud500000 500 bauds
BaudRate.Baud1500000 1,5 MBaud
BaudRate.Baud3000000 3 MBaud
Profils de bus
Valeur Description
BusProfile.None Le profil du bus est inconnu.
BusProfile.DP Le type du réseau est DP.
BusProfile.Standard Le type du réseau est Standard.
BusProfile.Universal Le type du réseau est Universal.
BusProfile.UserDefined Le type du réseau est personnalisé.
Charge due à la communication
Valeur Description
CommunicationLoad.None Aucune charge de communication valide.
CommunicationLoad.Low Typique pour la DP, pas de communication de données im‐
portante en dehors de la DP.

Valeur Description
CommunicationLoad.Medium Typique pour l'exploitation mixte de la DP et d'autres services
de communication (p. ex. communication S7), si les exigences
de la DP en matière de temps sont élevées et que le volume de
communication acyclique est moyen.
CommunicationLoad.High Pour l'exploitation mixte de la DP et d'autres services de com‐
munication (p. ex. communication S7), si les exigences de la
DP en matière de temps sont faibles et que le volume de com‐
munication acyclique est élevé.
7.14.6 Supprimer un sous-réseau global
Conditions
Code de programme
Pour supprimer un sous-réseau global d'un projet, modifiez le code de programme suivant :

SubnetComposition subnets = projects.Subnets;
// delete subnet
Subnet subnetToDelete = ...;
subnetToDelete.Delete();
7.14.7 Énumérer tous les abonnés d'un sous-réseau
Conditions
Utilisation
Énumeration de tous les abonnés d'un sous-réseau

Code de programme
Pour énumérer les réseaux maître DP du sous-réseau, modifiez le code de programme
suivant :

foreach (Node node in subnet.Nodes)
{
// work with the node
}
7.14.8 Énumérer les réseaux IO d'un sous-réseau
Conditions
Utilisation
L'énumération de IoSystem fournit tous les réseaux IO qui se trouvent dans le sous-réseau. Le
système maître et le réseau IO sont représentés tous deux par la classe IoSystem.
Code de programme
suivant :

foreach (IoSystem ioSystem in subnet.IoSystems)
{
// work with the io system
}

7.14.9 Accéder aux abonnés
Conditions
Utilisation
L'interface de rôle agrège les abonnés : Pour accéder aux attributs qui sont liés à l'affectation
d'adresse et de sous-réseau d'une interface.
Le nom d'un abonné s'affiche dans les attributs d'une interface dans TIA Portal. L'identifiant
d'abonné est un identifiant unique pour chaque abonné répertorié sur une interface. Cette
valeur ne peut s'afficher qu'avec TIA Portal Openness.
Code de programme
Pour accéder à tous les abonnés d'une interface, modifiez le code de programme suivant :
NetworkInterface itf = ...

foreach (Node node in itf.Nodes)
{
... // Work with the node
}
La plupart des interfaces n'ont qu'un seul abonné, c'est pourquoi le premier abonné est utilisé
normalement.

Node node = itf.Nodes.First();
{
... // Work with the node
}
Les abonnés mettent à disposition leur nom, type et ID d'abonné en tant qu'attributs :
Node node = ...

string name = node.Name;
NetType type = node.NodeType;
string id = node.NodeId;

7.14.10 Appeler les attributs d'un abonné
Conditions
Utilisation
Un élément d'appareil possède certains attributs obligatoires pouvant être lus et/ou écrits. Les
attributs ne sont disponibles que s'ils sont visibles dans l'interface utilisateur. En règle
générale, l'opération d'écriture n'est autorisée que sur un attribut que l'utilisateur peut
également modifier dans l'UI. Cela peut varier en fonction du type d'élément d'appareil.
L'utilisateur ne peut définir RouterAddress que si RouterUsed est vrai. Si l'utilisateur modifie le
SubnetMask sur le contrôleur IO, le masque de sous-réseau est également modifié à la même
valeur sur tous les périphériques IO.
Attributs d'un abonné de type ASI
Attributs Type de données Acces‐ Accès Description

sible
en
écritu‐
re
Name String r Nom de l'abonné.
NodeId String r ID de l'abonné.
NodeType NetType r Un abonné appelle son type du sous-réseau.
Address String r/w Dyna‐ Autres attributs pour des esclaves AS-i.
mique
Attributs d'un abonné de type Ethernet

sible
en
écritu‐
re
NodeType NetType r/w Un abonné appelle son type du sous-réseau.
par‐
fois r/o
UseIsoProtocol Bool r/w Dyna‐ True si le protocole ISO doit être utilisé
mique


sible
en
écritu‐
re
MacAddress String r/w Dyna‐ Par exemple 01-80-C2-00-00-00
mique
UseIpProtocol Bool r/w Dyna‐ Cette valeur peut être lue même si elle n'est pas visible
mique sur la commande TIA IU correspondante.
IpProtocolSelection Enum r/w Dyna‐
mique
Address String r/w Dyna‐ Seul IPv4 est pris en charge, pas IPv6
mique
SubnetMask String r/w Dyna‐
mique
UseRouter Bool r/w Dyna‐
mique
RouterAddress String r/w Dyna‐
mique
DhcpClientId String r/w Dyna‐
mique
PnDeviceNameSetDirectly Bool r/w Dyna‐ Le nom d'appareil PROFINET est défini directement sur
mique l'appareil. Pas disponible sur chaque appareil.
PnDeviceNameAutoGene‐ Bool r/w Dyna‐ Le nom d'appareil PROFINET est créé automatique‐
ration mique ment.
PnDeviceName String r/w Dyna‐ Nom univoque dans le sous-réseau.
mique
PnDeviceNameConverted String r Dyna‐ Le nom d'appareil est converti pour une utilisation en
mique interne par le système.
Attributs d'un abonné de type MPI

sible
en
écritu‐
re
Address String r/w Dyna‐
mique

Attributs d'un abonné de type PC internal

sible
en
écritu‐
re
Attributs d'un abonné de type PROFIBUS

sible
en
écritu‐
re
Address String r/w Dyna‐ Adresse de réseau du nœud. Le type de l'adresse dé‐
mique pend du type de nœud (par ex. adresse IP pour nœud
PROFINET, adresse PROFIBUS pour nœud PROFI‐
BUS)
Attributs d'un abonné de type PROFIBUS integrated

sible
en
écritu‐
re
Address String r Dyna‐
mique
Code de programme : attributs d'un abonné

Pour appeler ou définir les attributs d'un abonné, modifiez le code de programme suivant :
Node node = ...;

string nameValue = node.Name;
NetType nodeType = (NetType)node.NodeType;
node.NodeType = NetType.Mpi;

Code de programme : Attributs dynamiques

Pour appeler ou définir les attributs dynamiques d'un abonné, modifiez le code de programme
suivant :
Node node = ...;

var attributeNames = new[]
{
"Address", "SubnetMask", "RouterAddress", "UseRouter", "DhcpClientId",
"IpProtocolSelection"
};
foreach (var attributeName in attributeNames)
{
object attributeValue = ((IEngineeringObject)node).GetAttribute(attributeName);
}
Sélection de protocole
Valeur Description
IpProtocolSelection.None Valeur d'erreur
IpProtocolSelection.Project Suite IP configurée dans le projet.
IpProtocolSelection.Dhcp Suite IP gérée à l'aide du protocole DHCP. ID du client DHCP
nécessaire.
IpProtocolSelection.UserProgram Suite IP définie à l'aide d'un FB (bloc fonctionnel).
IpProtocolSelection.OtherPath Suite IP définie par d'autres méthodes, par exemple PST Tool.
IpProtocolSelection.ViaIoController Suite IP définie à l'aide du contrôleur IO au Runtime.
Type de réseau
Valeur Description
NetType.Asi Il s'agit d'un réseau de type ASI.
NetType.Ethernet Il s'agit d'un réseau de type Ethernet.
NetType.Link Il s'agit d'un réseau de type Link.
NetType.Mpi Il s'agit d'un réseau de type MPI.
NetType.PcInternal Il s'agit d'un réseau de type PC Internal.
NetType.Profibus Il s'agit d'un réseau de type PROFIBUS.
NetType.ProfibusIntegrated Il s'agit d'un réseau du type PROFIBUS integrated.
NetType.Ptp Il s'agit d'un réseau de type PTP.
NetType.Wan Il s'agit d'un réseau de type Wide Area Network (WAN).
NetType.Unknown Le type de réseau est inconnu.

7.14.11 Relier l'abonné à un sous-réseau
Condition
Code du programme
Pour affecter un abonné (appareil, interface) à un réseau, modifiez le code de programme
suivant :
Node node = ...;

node.ConnectToSubnet(subnet);
7.14.12 Déconnecter un abonné d'un sous-réseau
Condition
Code du programme
Pour déconnecter un abonné (appareil, interface) d'un réseau, modifiez le code de programme
suivant :
Node node = ...;

node.DisconnectFromSubnet();

7.14.13 Créer un réseau IO
Condition
Utilisation
Pour créer un réseau IO, appelez une action IoController.CreateIoSystem("name") sur un objet
du type IoController. Lorsque name a zéro comme valeur ou String.Empty, c'est le nom par
défaut qui est utilisé. Le contrôleur IO est détecté lors de l'accès à l'objet de l'attribut
IoControllers sur NetworkInterface. Le navigateur de l'IoController retourne un objet
IoController.
Conditions préalables à la création d'un réseau IO :
● L'interface du contrôleur IO est reliée à un sous-réseau.
● Le contrôleur IO ne possède aucun réseau IO.
Code du programme
Pour créer un réseau IO, modifiez le code de programme suivant :
using System.Linq;
...
NetworkInterface interface = ...;

IoSystem ioSystem = null;
// Interface is configured as io controller

if((interface.InterfaceOperatingMode & InterfaceOperatingModes.IoController) != 0)
{
IoControllerComposition ioControllers = interface.IoControllers;
IoController ioController = ioControllers.First();
if(ioController != null)
{
ioSystem = ioController.CreateIoSystem("io system");
}
}

7.14.14 Appeler les attributs d'un réseau IO
Conditions
Utilisation
Le système maître et le réseau IO sont représentés tous deux par la classe IoSystem.
Code de programme : Attributs d'un réseau IO

Pour appeler les attributs de l'IoSystem, modifiez le code de programme suivant :

foreach (IIoController ioController in itf.IoControllers)
{
IoSystem ioSystem = ioController.IoSystem;
int ioSystemNumber = ioSystem.Number;
string ioSystemName = ioSystem.Name;
}
Code de programme : sous-réseau d'un réseau IO

Pour naviguer jusqu'au sous-réseau associé au réseau IO, modifiez le code de programme
suivant :
Subnet subnet = ioSystem.Subnet;
7.14.15 Relier IO-Connector à un réseau IO
Conditions

Utilisation
Utilisez l'action ConnectToIoSystem(IoSystem ioSystem) de IoConnector pour relier un
IoConnector Profinet ou DP à un réseau IO existant.
Utilisez l'action GetIoController pour naviguer jusqu'au IoController décentralisé. Pour plus
d'informations sur la navigation vers l'IoConnector local et le réseau IO, voir Appeler le système
maître ou le réseau IO d'une interface (Page 211).
Conditions
● IoConnector n'est pas encore relié à un réseau IO.
● L'interface IoConnector est reliée au même sous-réseau que l'interface de l'IoController
souhaité.
Code de programme
IoSystem ioSystem = ...;

IoConnector ioConnector = ...;
ioConnector.ConnectToIoSystem();
IoController ioController = ioConnector.GetIoController();
7.14.16 Appeler le système maître ou le réseau IO d'une interface
Conditions
Utilisation
Le service NetworkInterface fournit au navigateur des IoControllers et chaque IoController
fournit à son tour un IoSystem au navigateur. Le système maître et le réseau IO sont
représentés tous deux par la classe IoSystem. L'esclave et le périphérique IO sont dénommés
tous deux "périphérique IO".
● Le navigateur du IoControllers retourne des objets d'IoController quand l'interface de
réseau peut avoir un réseau IO. Pour l'instant, seul un contrôleur IO est retourné.
● Le navigateur du IoConnectors retourne des objets d'IoConnector quand l'interface de
réseau peut être reliée à un réseau IO en tant que périphérique IO. Pour l'instant, seul un
connecteur IO est retourné.

Code de programme : appeler le réseau IO du IoController

Pour appeler le réseau IO du IoController, modifiez le code de programme suivant :

foreach (IoController ioController in itf.IoControllers)
{
}
Code de programme : appeler le réseau IO du IoConnector

Pour appeler le réseau IO du IoConnector, modifiez le code de programme suivant :
NetInterface itf = ...

foreach (IoConnector ioConnector in itf.IoConnectors)
{
IoSystem ioSystem = ioConnector.ConnectedIoSystem;
}
7.14.17 Appeler un contrôleur IO
Conditions
Code de programme
Actuellement, seules des configurations avec un IoController sont possibles. Un IoController
ne dispose pas d'attributs modélisés ni d'actions.
Code de programme
Pour appeler le contrôleur IO, modifiez le code de programme suivant :

foreach (IoController ioController in itf.IoControllers)
{
// work with the io controller
}

7.14.18 Appeler un connecteur IO
Conditions
Utilisation
Un IoConnector fournit les attributs ou les actions modélisés.
Les attributs et les actions suivants sont disponibles sur l'IoConnector :
Actions
Action Signature Description

ConnectToIoSystem void ConnectToIoSystem(Sie‐ Pour la liaison d'un IoConnector
mens.Engineering.HW.IoSys‐ avec un réseau maître DP pré‐
tem ioSystem sent
DisconnectFromIoSystem void DisconnectFromIoSystem() Pour la déconnexion d'un IOCon‐
nector d'un réseau IO présent
GetIoController Siemens.Engineering.HW.Io‐ Fournit en retour le contrôleur IO
Controller GetIoController() pour ce Connector
Gauche
Lien Type Accès

ConnectedToIoSystem Siemens.Engineering.HW.Io‐ protégé en écriture
System
Code de programme
Pour appeler le connecteur IO, modifiez le code de programme suivant :

foreach (IoConnector ioConnector in itf.IoConnectors)
{
// work with the IoConnector
}

7.14.19 Déconnecter IO-Connector d'un réseau IO ou d'un réseau maître DP
Conditions
Utilisation
Utilisez l'action DisconnectFromIoSystem() de IoConnector pour déconnecter un IoConnector
d'un réseau IO existant ou d'un réseau maître DP existant.
Pour plus d'informations sur la navigation vers l'IoConnector local et le réseau IO, voir Appeler
le système maître ou le réseau IO d'une interface (Page 211).
Code de programme

ioConnector.DisconnectFromIoSystem();
7.14.20 Appeler un réseau maître DP
Condition
Utilisation
Un réseau maître DP possède certains attributs pouvant être lus et/ou écrits. Les attributs ne
sont disponibles que s'ils sont visibles dans l'IU. En règle générale, l'opération d'écriture n'est
autorisée que sur un attribut que l'utilisateur peut également modifier dans l'UI. Cela peut varier
en fonction du maître DP et des esclaves DP qui sont attribués à ce réseau maître DP.

Attributs d'un réseau maître DP

sible
en
écritu‐
re
Name String r/w
Number Int r/w L'attribut Number reprend les valeurs qui ne peuvent
pas être définies via l'interface utilisateur. Dans un tel
cas, la compilation échoue.
Code de programme : appeler des attributs

Pour appeler les attributs, modifiez le code de programme suivant :
IoSystem dpMastersystem = ...;
string name = dpMastersystem.Name;

int number = dpMastersystem.Number;
Code de programme : définir des attributs

Pour définir les attributs, modifiez le code de programme suivant :
IoSystem dpMastersystem = ...;
dpMastersystem.Name ="myDpMastersystem"
dpMastersystem.Number=42;
7.14.21 Appeler les attributs d'un réseau PROFINET IO
Condition
Utilisation
Un réseau IO possède certains attributs pouvant être lus et/ou écrits. Les attributs ne sont
disponibles que s'ils sont visibles dans l'IU. En règle générale, l'opération d'écriture n'est
autorisée que sur un attribut que l'utilisateur peut également modifier dans l'UI. Cela peut varier
en fonction du contrôleur IO et des périphériques IO qui sont attribués à ce réseau IO.

Attributs d'un réseau PROFINET IO
Attribut Type de Acces‐ Accès Description

données sible
en
écritu‐
re
MultipleUseIoSystem Bool r/w Dyna‐
mique
Name String r/w
Number Int r/w L'attribut Number reprend les valeurs qui ne peuvent
pas être définies via l'interface utilisateur. Dans un tel
cas, la compilation échoue.
UseIoSystemNameAsDeviceNa‐ Bool r/w Dyna‐ Lorsque MultipleUseIoSystem est défini sur TRUE,
meExtension mique UseIoSystemNameAsDeviceNameExtension est défini
sur FALSE et l'accès en écriture n'est plus possible.
MaxNumberIWlanLinksPerSeg‐ Int r/w Dyna‐
ment mique
Code du programme : appeler des attributs


string name = ioSystem.Name;
Code du programme : définir des attributs


ioSystem.Name = "IOSystem_1";
Code du programme : appeler les attributs pour l'accès dynamique

Pour appeler les valeurs d'attributs dynamiques, modifiez le code de programme suivant :

var attributeNames = new[]
{
"MultipleUseIoSystem", "UseIoSystemNameAsDeviceNameExtension",
"MaxNumberIWlanLinksPerSegment"
};
{
object attributeValue = ((IEngineeringObject)ioSystem).GetAttribute(attributeName);
}

Code du programme : définir les attributs pour l'accès dynamique

Pour définir les valeurs des attributs dynamiques, modifiez le code de programme suivant :

((IEngineeringObject)ioSystem).SetAttribute("MultipleUseIoSystem", true);
7.14.22 Supprimer un réseau maître DP
Condition
Code du programme : supprimer le réseau PROFINET IO

Pour supprimer un réseau PROFINET IO, modifiez le code de programme suivant :
IoController ioController = ...;

ioSystem.Delete();
7.14.23 Supprimer un réseau Profinet IO
Conditions
Code de programme
Pour supprimer un réseau Profinet IO, modifiez le code de programme suivant :
IoController ioController = ...;

ioSystem.Delete();

7.14.24 Créer un réseau maître DP
Condition
Utilisation
Pour créer un réseau maître DP, appelez une action CreateIoSystem(string nameOfIoSystem)
sur un objet du type IoController. Le contrôleur IO est détecté lors de l'accès à l'objet de l'attribut
IoControllers sur la NetworkInterface.
Conditions préalables à la création d'un réseau maître DP :
● L'interface du contrôleur IO est reliée à un sous-réseau.
● Le contrôleur IO ne possède aucun réseau IO.
Code du programme
Pour créer un réseau maître DP, modifiez le code de programme suivant :
using System.Linq;
...
NetworkInterface interface = ...;
IoSystem dpMasterSystem = null;
// Interface is configured as master or as master and slave

if((interface.InterfaceOperatingMode & InterfaceOperatingModes.IoController) != 0)
{
IoControllerComposition ioControllers = interface.IoControllers;
IoController ioController = ioControllers.First();
if(ioController != null)
{
dpMasterSystem = ioController.CreateIoSystem("dp master system");
}
}

7.14.25 Appeler les informations de lien des ports de l'élément d'appareil du port
Conditions
Utilisation
NetworkPort offre la liaison ConnectedPorts, qui est une énumération de ports, permettant
d'accéder à tous les ports partenaires connectés à un port.
Vous ne pouvez connecter ensemble que des ports pouvant également être connectés dans
TIA UI. Par exemple, vous ne pouvez pas connecter ensemble deux ports d'une même
interface Ethernet. Une exception récupérable est déclenchée dans les situations suivantes :
● une connexion avec le même port partenaire existe déjà,
● vous essayez de connecter deux ports qui ne peuvent pas être connectés ensemble,
● vous essayez de créer une deuxième connexion vers un port qui ne prend pas en charge
d'autres partenaires.
Code de programme : appeler une connexion de port

Pour appeler les informations de lien des ports d'un l'élément d'appareil du port, modifiez le
NetworkPort port = ...;

foreach (NetworkPort partnerPort in port.ConnectedPorts)
{
// work with the partner port
}
Code de programme : créer des connexions de port

NetworkPort port1 = ...;

port1.ConnectToPort(port2);
// port supports alternative partners


Code de programme : supprimer une connexion de port


port1.DisconnectFromPort(port2);
7.14.26 Attributs de la connexion de port
Attributs pour la connexion de port

TIA Portal Openness prend en charge les attributs suivants pour les connexions de port. Si les
attributs sont disponibles dans l'interface utilisateur, les attributs correspondants sont
également accessibles via TIA Portal Openness . Si l'utilisateur dispose d'un accès et peut
donc modifier les attributs dans l'interface utilisateur, il peut également modifier ces derniers
dans Openness TIA Portal Openness .
Nom d'attribut Type de données Accessible en écriture Accès Description

MediumAttachmentTy‐ MediumAttachmentTy‐ Protégé en écriture Attribut dynamique
pe pe
CableName CableName Lecture/écriture Attribut dynamique
AlternativePartner‐ Bool Lecture/écriture Attribut dynamique Disponible unique‐
Ports ment si la fonction de
changeur d'outil est pri‐
se en charge.
SignalDelaySelection SignalDelaySelection Lecture/écriture Attribut dynamique
CableLength CableLength Lecture/écriture Attribut dynamique
SignalDelayTime Double Lecture/écriture Attribut dynamique
Valeurs d'énumération d'attributs de connexion de port

L'énumération MediumAttachmentType a les valeurs suivantes.
Valeur Description
MediumAttachmentType.None Type de couplage impossible à déterminer.
MediumAttachmentType.Copper Couplage cuivre.
MediumAttachmentType.FiberOptic Couplage fibre optique.
L'énumération CableName a la valeur suivante.

Valeur Description
CableName.None Aucun nom de câble indiqué
CableName.FO_Standard_Cable_9 Câble standard FO GP (9 µm)
CableName.Flexible_FO_Cable_9 Câble FO souple (9 µm)
CableName.FO_Standard_Cable_GP_50 Câble standard FO GP (50 µm)
CableName.FO_Trailing_Cable_GP Câble traînant FO / GP
CableName.FO_Ground_Cable Câble de mise à la terre FO
CableName.FO_Standard_Cable_62_5 Câble standard FO (62,5 µm)
CableName.Flexible_FO_Cable_62_5 Câble FO souple (62,5 µm)
CableName.POF_Standard_Cable_GP Câble standard POF GP
CableName.POF_Trailing_Cable Câble traînant POF
CableName.PCF_Standard_Cable_GP Câble traînant PCF / GP
CableName.GI_POF_Trailing_Cable Câble traînant POF GI
CableName.GI_POF_Trailing_Cable Câble traînant POF GI
L'énumération SignalDelaySelection a les valeurs suivantes.
Valeur Description
SignalDelaySelection.None
SignalDelaySelection.CableLength CableLength sert à déterminer le retard de signal.
SignalDelaySelection.SignalDelayTime CableDelayTime sert à déterminer le retard de si‐
gnal.
L'énumération CableLength a les valeurs suivantes.
Valeur Description
CableLength.None La longueur de câble n'est pas indiquée.
CableLength.Length1000m Longueur de câble 1 000 m.
CableLength.Length3000m Longueur de câble 3 000 m.

Attributs d'options de port

Les attributs d'options de port sont représentés ci-après.
Nom d'attribut Type de données Accessible en écriture Accès

PortActivation Bool Lecture/écriture Attribut dynamique
TransmissionRateAnd‐ TransmissionRateAnd‐ Lecture/écriture Attribut dynamique
Duplex Duplex
PortMonitoring Bool Lecture/écriture Attribut dynamique
TransmissionRateAuto‐ Bool Lecture/écriture Attribut dynamique
Negotiation
EndOfDetectionOfAc‐ Bool Lecture/écriture Attribut dynamique
cessibleDevices
EndOfTopologyDisco‐ Bool Lecture/écriture Attribut dynamique
very
EndOfSyncDomain Bool Lecture/écriture Attribut dynamique
L'énumération TransmissionRateAndDuplex a les valeurs suivantes.
Valeur Description
TransmissionRateAndDuplex.None
TransmissionRateAndDuplex.Automatic Automatique
TransmissionRateAndDuplex.AUI10Mbps AUI 10 Mbps
TransmissionRateAndDuplex.TP10MbpsHalfDu‐ TP 10 Mbps semi-duplex
plex
TransmissionRateAndDuplex.TP10MbpsFullDu‐ TP 10 Mbps duplex intégral
plex
TransmissionRateAndDuplex.AsyncFi‐ Fibre optique asynchrone 10 Mbps semi-duplex
ber10MbpsHalfDuplex
TransmissionRateAndDuplex.AsyncFi‐ Fibre optique asynchrone 10 Mbps duplex intégral
ber10MbpsFullDuplex
TransmissionRateAndDuplex.TP100MbpsHalfDu‐ TP 100 Mbps semi-duplex
plex
TransmissionRateAndDuplex.TP100MbpsFullDu‐ TP 100 Mbps duplex intégral
plex
TransmissionRateAndDuplex.FO100MbpsFullDu‐ FO 100 Mbps duplex intégral
plex
TransmissionRateAndDuplex.X1000MbpsFullDu‐ X1000 Mbps duplex intégral
plex
TransmissionRateAndDuplex.FO1000MbpsFull‐ FO 1 000 Mbps duplex intégral LD
DuplexLD
TransmissionRateAndDuplex.FO1000MbpsFull‐ FO 1 000 Mbps duplex intégral
Duplex
TransmissionRateAndDuplex.TP1000MbpsFull‐ TP 1 000 Mbps duplex intégral
Duplex

Valeur Description
TransmissionRateAndDuplex.FO10000MbpsFull‐ FO 10 000 Mbps duplex intégral
Duplex
TransmissionRateAndDuplex.FO100MbpsFullDu‐ FO 100 Mbps duplex intégral LD
plexLD
TransmissionRateAndDu‐ POF/PCF 100 Mbps duplex intégral
plex.POFPCF100MbpsFullDuplexLD
7.14.27 Appeler les attributs d'un port
Conditions
Utilisation
Un élément d'appareil qui est en même temps un port offre des fonctions supplémentaires par
rapport à un élément d'appareil simple.
● Il est possible d'accéder aux ports partenaires qui lui sont associés.
● Il est possible d'accéder à l'interface du port.
Pour accéder à ces fonctions supplémentaires, il faut utiliser la fonction NetworkPort, un
service particulier de l'élément d'appareil.
Code de programme : accéder à un port

Pour accéder aux attributs d'une voie, modifiez le code de programme suivant :
NetworkPort port = ((IEngineeringServiceProvider)deviceItem).GetService<NetworkPort>();

if (port != null)
{
... // Work with the port
}
Attributs d'un port

Un port possède les attributs suivants :
NetworkPort port = ...;

var connectedPorts = port.ConnectedPorts;
var myInterface = port.Interface;

7.14.28 Énumérer les systèmes maître DP d'un sous-réseau
Conditions
Utilisation
L'énumération d'un IoSystem fournit tous les systèmes maître DP qui se trouvent dans le sous-
réseau. Le système maître et le réseau IO sont représentés tous deux par la classe IoSystem.
Code de programme
suivant :

foreach (IoSystem ioSystem in subnet.IoSystems)
{
}
7.14.29 Énumérer les connecteurs IO affectés
Conditions
Utilisation
Le système maître et le réseau IO sont représentés tous deux par la classe IoSystem.
Est utilisé pour :
● Énumération des connecteurs IO affectés du système maître DP
● Énumération des connecteurs IO affectés du réseau Profinet IO

Code de programme
Pour énumérer les connecteurs IO affectés du réseau maître DP, modifiez le code de
programme suivant :

foreach (IoConnector ioConnector in ioSystem.ConnectedIoDevices)
{
// work with the io connector
}
7.14.30 Relier IO-Connector DP à un réseau maître DP
Conditions
Utilisation
Utilisez l'action ConnectToIoSystem(IoSystem ioSystem) de IoConnector pour relier un
IoConnector à un réseau maître DP existant.
Utilisez l'action GetIoController pour naviguer jusqu'au IoController décentralisé. Pour plus
d'informations sur la navigation vers l'IoConnector local et le réseau IO, voir Appeler le système
maître ou le réseau IO d'une interface (Page 211).
Conditions
● IoConnector n'est pas encore relié à un réseau IO.
● L'interface IoConnector est reliée au même sous-réseau que l'interface de l'IoController
souhaité.
Code de programme

ioConnector.ConnectToIoSystem(ioSystem);
IoController ioController = ioConnector.GetIoController();

7.14.31 Accès au profil AS-i et aux attributs de paramètre des esclaves virtuels
Conditions
Application
TIA Portal Openness prend en charge les paramètres supplémentaires suivants du profil AS-i
pour les esclaves virtuels de l'esclave AS-i CTT5 en utilisant les noms StructuredData :
Nom Description
AsiProfileVirtualSlave1 Contient les paramètres de profil AS-i pour l'escla‐
ve virtuel 1
ve virtuel 2
ve virtuel 3
Les paramètres AS-i pour les esclaves virtuels sont listés ci-après :
Nom Description
AsiParameterVirtualSlave1 Contient les paramètres AS-i pour l'esclave virtuel
1
2
3

Code de programme
Modifiez le code de programme suivant pour appeler et définir les attributs des esclaves AS-i :
DeviceItem slaveModule= ...;

var structuredDataNamesProfile = new[]
{
"AsiProfileVirtualSlave1", "AsiProfileVirtualSlave2", "AsiProfileVirtualSlave3"
};
var structuredDataNamesAsiParameter = new[]
{
"AsiParameterVirtualSlave1", "AsiParameterVirtualSlave2", "AsiParameterVirtualSlave3"
};
var attributeNamesProfile = new[]{"AsiProfileID", "AsiProfileIO", "AsiProfileID2",
"AsiProfileID1"};
string attributeNameAsiParameter = "AsiSlaveParameter"
foreach (var structuredDataName in structuredDataNamesProfile)
{
foreach (var attributeName in attributeNamesProfile)
{
StructuredData structuredData =
(StructuredData)slaveModule.GetAttribute(structuredDataName);
//get
UInt32 attributeValue = (UInt32)structuredData.GetAttribute(attributeName);}
//set
slaveHead.SetAttribute(attributeName, (UInt32)5);
}
}
foreach (var structuredDataName in structuredDataNamesAsiParameter)
{
StructuredData structuredData =
(StructuredData)slaveModule.GetAttribute(structuredDataName);
//get
UInt32 attributeValue = (UInt32)structuredData.GetAttribute(attributeNameAsiParameter);
//set
slaveHead.SetAttribute(attributeName, (UInt32)5);
}
Voir aussi

7.15 Fonctions sur les appareils
7.15.1 Attributs obligatoires d'appareils
Conditions
Utilisation
Chaque appareil ou élément d'appareil possède certains attributs obligatoires pouvant être lus
et/ou écrits. Ces attributs sont toujours les mêmes que dans l'interface utilisateur de TIA Portal.
Les attributs suivants sont pris en charge dans Openness :
Nom d'attribut Type de don‐ Accessible en Accès Commentaire

nées écriture
Author String read/write Dynamique
Comment String read/write Dynamique Parfois accès protégé en écriture
CommentML MultilingualTex‐ read/write Dynamique Parfois accès protégé en écriture
tItem
IsGsd Bool read VRAI quand la description d'appareil
est installée avec GSD/GSDML
Name Chaîne de ca‐ read/write Parfois accès protégé en écriture
ractères
TypeIdentifier String read
TypeName String read Dynamique
Code de programme : Attributs obligatoires d'un appareil

Pour appeler les attributs obligatoires d'un appareil, modifiez le code de programme suivant :

string nameValue = device.Name;
bool isGsdValue = device.IsGsd;

Code de programme : attributs obligatoires pour accès dynamique

Pour appeler les attributs pour un accès dynamique, modifiez le code de programme suivant :

var attributeNames = new[] {
"TypeName", "Author", "Comment"
};
foreach (var attributeName in attributeNames) {
object attributeValue = ((IEngineeringObject)device).GetAttribute(attributeName);
}
7.15.2 Appeler l'identifiant de type des appareils et des éléments d'appareil
Conditions
Utilisation
L'attribut TypeIdentifier est utilisé pour identifier un objet matériel qui peut être créé avec
la TIA Portal Openness API. TypeIdentifier est une chaîne de caractères composée de
plusieurs parties : <TypeIdentifierType>:<Identifier>
Les valeurs possibles pour TypeIdentifierType sont :
● OrderNumber
● GSD
● System

OrderNumber
OrderNumber est le TypeIdentifier général pour tous les modules présents dans le
catalogue du matériel.
Format de l'identifiant de type Exemple Particularités

<OrderNumber> OrderNumber:3RK1 200-0CE00-0AA2
<OrderNumber>/<FirmwareVersion> OrderNumber:6ES7 510-1DJ01-0AB0/ La version du firmware est facultati‐
V2.0 ve quand elle n'est pas dans le sys‐
tème ou qu'il n'y en a qu'une seule.
Veuillez noter
<OrderNumber>// OrderNumber:6AV2 L'identifiant de type supplémentaire
<AdditionalTypeIdentifier> 124-2DC01-0AX0//Landscape peut être nécessaire
quand OrderNumber
et FirmwareVersion ne donnent
pas de résultat univoque dans le
système.
Remarque
Pour un petit nombre de modules dans le catalogue du matériel, le numéro d'article contient
des caractères de remplacement qui représentent un certain groupe de matériel réel, comme
par ex. les différentes longueurs des châssis de S7-300. Dans ce cas, vous pouvez utiliser non
seulement l'OrderNumber, mais aussi l'OrderNumber avec caractères de remplacement
pour créer une instance de l'objet matériel. Mais les caractères de remplacement ne doivent
pas figurer à n'importe quelle position.
GSD
C'est l'identifiant utilisé pour les modules qui sont ajoutés à TIA Portal au moyen de GSD ou de
GSDML.

<GsdName>/<GsdType> GSD:SIEM8139.GSD/DAP GsdName est le nom de GSD ou de GSDML en ma‐
<GsdName>/<GsdType>/<GsdId> GSD:SIEM8139.GSD/M/4 juscules.
GsdType est l'un des suivants :
● D : appareil (device)
● R : châssis (rack)
● DAP : module de tête
● M : module
● SM : sous-module
GsdId est l'identifiant de type.

System
C'est l'identifiant pour les objets ne pouvant être déterminés au moyen de OrderNumber ou
de GSD.

<SystemTypeIdentifier> System:Device.S7300 SystemTypeIdentifier est l'identifiant
<SystemTypeIdentifier>/ GSD:SIEM8139.GSD/ primaire d'un objet.
<AdditionalTypeIdentifier> M/4 AdditionalTypeIdentifier peut être
nécessaire
quand SystemTypeIdentifier n'est
pas univoque. Les préfixes pour certains
types d'objet sont :
● Connection.
● Subnet.
● Device.
● Rack.
Code de programme
Pour appeler l'identifiant de type des objets pour GSD que l'utilisateur peut créer séparément
et gérer, modifiez le code de programme suivant :
HardwareObject hardwareObject = ...;

string typeIdentifier = hardwareObject.TypeIdentifier;

Afficher les identifiants de type dans TIA Portal

Lorsque vous devez connaître un identifiant de type, vous le déterminez comme suit dans TIA
Portal :
1. Activez le paramètre "Affichage de l'identifiant de type pour les appareils et les modules"
sous "Options > Paramètres > Configuration matérielle > Affichage de l'identifiant de type".
2. Ouvrez l'éditeur "Appareils & Réseaux".
3. Sélectionnez un appareil dans le catalogue.
L'identifiant de type s'affiche sous "Information".
7.15.3 Paramétrer l'ID d'application dans l'appareil et les éléments d'appareils
Conditions
Voir Établir une connexion à TIA Portal
Voir Ouvrir un projet
Introduction
Vous pouvez paramétrer avec TIA Portal Openness l'ID d'application dans l'appareil et dans les
éléments d'appareils d'un projet TIA Portal, afin d'enregistrer ces ID d'application dans la
session TIA Portal actuelle pour une utilisation ultérieure.
Vous paramétrez l'ID d'application dans TIA Portal Openness en fournissant à l'API la paire
constituée de la "clé d'application" et de la "valeur d'application".

Les conditions suivantes s'appliquent à l'ID d'application de l'objet appareil et élément

d'appareil :
● L'objet d'un type prenant en charge cette fonction ne peut posséder plus de 64 ID
d'application disponibles.
● La longueur de la clé et/ou de la valeur d'ID d'application ne doit pas dépasser 128
caractères.
● La clé de l'ID d'application d'un objet défini doit être unique.
● Une seule ID d'application peut être paramétrée avec la même "clé d'application".
● Si une autre valeur d'application est paramétrée avec la même "clé d'application", c'est la
valeur d'application paramétrée en dernier qui est enregistrée.
Code de programme
Modifiez le code de programme suivant pour paramétrer l'ID d'application de l'objet appareil et
élément d'appareil :

// Ask for Service CustomIdentityProvider on the device/device item
var customIdentityProviderService = device.GetService<CustomIdentityProvider>();
//Set the Application ID (Key-Value) pair
customIdentityProviderService.Set("Application_Key", "Application_Value");
7.15.4 Appeler l'ID d'application dans l'appareil et les éléments d'appareil
Conditions
Introduction
Vous pouvez appeler avec TIA Portal Openness l'ID d'application dans l'appareil et dans les
éléments d'appareils d'un projet TIA Portal lorsqu'une ID d'application a déjà été paramétrée
pour l'appareil ou les éléments d'appareils.
Les ID d'application sont enregistrées par paires constituées de la "clé d'application" et de la
"valeur d'application" comme partie intégrante de TIA Portal. TIA Portal Openness vous permet
d'appeler la valeur de l'ID d'application par saisie de la "clé d'application".

Code de programme
Modifiez le code de programme suivant pour appeler la valeur de l'ID d'application d'un objet
qui a déjà été paramétré avec la clé d'application :

customIdentityProviderService.Set("Application_Key", "Application_Value");
//Get the Application ID (Value) for the given Application Key
var applicationValue = customIdentityProviderService.Get("Application_Key");
Voir aussi
7.15.5 Supprimer l'ID d'application dans l'appareil et les éléments d'appareil
Conditions
Principe
Vous pouvez supprimer avec TIA Portal Openness l'ID d'application (identifiant défini par
l'utilisateur) dans l'appareil et dans les éléments d'appareils d'un projet TIA Portal, afin
d'actualiser l'appareil et les éléments d'appareils possédant l'ID d'application correspondante.
Une CustomIdentityNotFoundException est retournée si l'ID d'application qui a été transmise
comme argument est inexistante.

Code de programme
Modifiez le code de programme suivant pour supprimer l'ID d'application de l'appareil et des
éléments d'appareils :

//Remove the CustomIdentity corresponding to Application ID
try
{
customIdentityProviderService.Remove("Application_Key");
}
catch(CustomIdentityNotFoundException ex)
{
// When CustomIdentity is not found for a the given key "Application_Key".
}
Voir aussi
7.15.6 Créer un appareil
Conditions
Utilisation
Il y a deux manières de créer un appareil, dans un projet ou dans un groupe d'appareils :
● Créer un appareil au moyen d'un identifiant de type d'élément d'appareil comme dans le
catalogue du matériel de TIA
Device CreateWithItem(DeviceItemTypeId, DeviceItemName,
DeviceName)
● Créer uniquement l'appareil
Device Create(DeviceTypeId, DeviceName)
Nom Type Description

DeviceItemTypeId String Identifiant de type de l'élément d'appareil
DeviceTypeId String Identifiant de type de l'appareil


DeviceItemName String Nom de l'élément d'appareil créé
DeviceName String Nom de l'appareil créé
Voir : Identifiant de type (Page 229)
Code de programme : créer un appareil avec l'identifiant de type

Pour créer un objet appareil au moyen d'un identifiant de type, modifiez le code suivant :
DeviceComposition devices = ...;

Device device = devices.CreateWithItem("OrderNumber:6ES7 510-1DJ01-0AB0/V2.0", "PLC_1",
"NewDevice");
Device gsdDevice = devices.CreateWithItem("GSD:SIEM8139.GSD/M/4 ", "GSD Module",
"NewGsdDevice");
Code de programme : créer uniquement un appareil

Pour ne créer que l'objet appareil, modifiez le code suivant :
DeviceComposition devices = ...;

Device deviceOnly = devices.Create("System:Device.S7300", "S7300Device");
Device gsdDeviceOnly = devices.Create("GSD:SIEM8139.GSD/D", "GSD Device");
7.15.7 Énumérer des appareils
Conditions
Utilisation : énumérer des appareils

La TIA Portal Openness API classe les appareils à l'instar de la navigation du projet dans TIA
Portal. PNV
● Les appareils qui sont directement subordonnés à un projet sont classés par groupes dans
la composition "Devices" du projet.
● Les appareils qui se trouvent dans des dossiers d'appareils sont classés par groupes dans
la composition "Devices" du dossier.

Remarque
Tenir compte de AUTOHOTSPOT.
Utilisez l'une des possibilités suivantes pour énumérer les appareils d'un projet :
● Énumérer tous les appareils du premier niveau
● Énumérer tous les appareils en groupes ou sous-groupes
● Énumérer tous les appareils d'un projet ne contenant aucun groupe d'appareils
● Énumérer tous les appareils des groupes système d'appareils non groupés
Exemples d'appareils pouvant être énumérés :
● Central station
● PB-Slave / PN-IO device
● HMI Device
Code de programme : énumérer les appareils du premier niveau

Pour énumérer les appareils du premier niveau, utilisez le code de programme suivant :
private static void EnumerateDevicesInProject(Project project)

{
DeviceComposition deviceComposition = project.Devices;
foreach (Device device in deviceComposition)
{
// add code here
}
}
Pour accéder à un appareil en particulier, modifiez le code de programme suivant :
private static void AccessSingleDeviceByName(Project project)

{
DeviceComposition deviceComposition = project.Devices;
// The parameter specifies the name of the device
Device device = deviceComposition.Find("MyDevice");
}
Code de programme : énumérer des appareils en groupes ou sous-groupes

Pour accéder aux appareils d'un groupe, vous devez d'abord naviguer jusqu'au groupe, puis
jusqu'à l'appareil.

//Enamerate devices in groups or sub-groups

private static void EnumerateDevicesInGroups(Project project)
{
foreach (DeviceUserGroup deviceUserGroup in project.DeviceGroups)
{
EnumerateDeviceUserGroup(deviceUserGroup);
}
}
private static void EnumerateDeviceUserGroup(DeviceUserGroup deviceUserGroup)
{
EnumerateDeviceObjects(deviceUserGroup.Devices);
foreach (deviceUserGroup subDeviceUserGroup in deviceUserGroup.Groups)
{
// recursion
EnumerateDeviceUserGroup(subDeviceUserGroup);
}
}
private static void EnumerateDeviceObjects(DeviceComposition deviceComposition)
{
foreach (Device device in deviceComposition)
{
// add code here
}
}
Code de programme : trouver des appareils spécifiques

Pour rechercher un appareil en particulier avec son nom, modifiez le code de programme
suivant :
//Find a specific device by name

Device plc1 = project.Devices.First(d => d.Name == "Mydevice");
... // Work with the device
Pour rechercher un appareil en particulier avec la méthode "Find", modifiez le code de

programme suivant :
//Find a specific device via "Find" method

Device plc1 = project.Devices.Find("MyDevice");

Code de programme : énumérer les appareils d'un projet ne contenant aucun groupe d'appareils
//Enumerate all devices which are located directly under a project that contains no device
groups
{
... // Work with the devices
}
Code de programme : énumérer tous les appareils dans un dossier

//Enumerate all devices located in a folder

DeviceUserGroup sortingGroup = project.DeviceGroups.Find ("Sorting");
Device plc1 = sortingGroup.Devices.First(d => d.Name == "MyStationName");
Code de programme : énumérer les appareils des groupes système d'appareils non groupés
Pour structurer les projets, des appareils décentralisés ont été ajoutés dans le groupe
UngroupedDevices. Pour accéder à ce groupe, naviguez d'abord jusqu'au groupe, puis jusqu'à
l'appareil.
//Enumerate devices of the ungrouped device system group

DeviceSystemGroup group = project.UngroupedDevicesGroup;
Device plc1 = group.Devices.First(d => d.Name == "MyStationName");
7.15.8 Accéder à des appareils
Conditions

Utilisation
Chaque appareil basé sur GSD ou sur GSDML dispose d'attributs. Certains servent à la
détermination du type exact de l'appareil.
Nom Type de données Accessible en écri‐ Accès Description

ture
Comment String read/write Dynamique
GsdName String read Dynamique Nom du fichier GSD ou GSDML.
GsdType String read Dynamique Type de l'objet matériel. La valeur de l'ap‐
pareil est toujours "D".
GsdId String read Dynamique Identifiant spécifique de l'objet matériel.
Toujours vide pour les appareils.
IsGsd Bool read VRAI pour appareil GSD ou appareil
GSDML
Name String read/write
Code de programme : appeler les attributs d'identification


"GsdName", "GsdType", "GsdId"
;
object attributeValue = device.GetAttribute(attributeName);
}
Code de programme : Attributs


string nameValue = device.Name;
bool isGsdValue = device.IsGsd;

Code de programme : attributs pour accès dynamique


"GsdName", "GsdType", "GsdId"
;
object attributeValue = device.GetAttribute(attributeName);
}
Particularités des appareils GSD

Un appareil qui est en même temps appareil GSD offre des fonctions supplémentaires. Pour
appeler la fonction GsdDevice, utilisez la méthode GetService.
GsdDevice gsdDevice = ((IEngineeringServiceProvider)deviceItem).GetService<GsdDevice>();

if (gsdDevice != null) {
... // work with the GSD device
};
Code de programme : attributs d'un appareil GSD


GsdDevice gsdDevice = ...;
string gsdId = gsdDevice.GsdId;
string gsdName = gsdDevice.GsdName;
string gsdType = gsdDevice.GsdType;
bool isProfibus = gsdDevice.IsProfibus;
bool isProfinet = gsdDevice.IsProfinet;
7.15.9 Supprimer un appareil
Conditions

7.16 Fonctions d'éléments d'appareils
Code de programme
Pour supprimer un appareil, modifiez le code de programme suivant :

Device deviceToDelete = project.UngroupedDevices.Devices.Find("......");
// delete device
deviceToDelete.Delete();
7.16.1 Attributs obligatoires des éléments d'appareil
Conditions
Utilisation
Chaque appareil ou élément d'appareil possède certains attributs obligatoires pouvant être lus
et/ou écrits. Ces attributs sont toujours les mêmes que dans l'interface utilisateur de TIA Portal.
Les attributs suivants sont pris en charge dans TIA Portal Openness :
Nom d'attribut Type de données Acces‐ Accès Commentaire

sible en
écriture
Author String read/write Dynami‐
que
Classification DeviceItemClassi‐ read
fication
Comment String read/write Dynami‐ Parfois accès protégé en écriture
que
CommentML MultilingualTextI‐ read/write Dynami‐ Parfois accès protégé en écriture
tem que
FirmwareVersion String read Dynami‐
que
InterfaceOpera‐ InterfaceOpera‐ read/write Dynami‐ Pour éléments d'appareil avec la
tingMode tingModes que fonction NetworkInterface
InterfaceType NetType readwrite Dynami‐ Pour éléments d'appareil avec la
que fonction NetworkInterface

Nom d'attribut Type de données Acces‐ Accès Commentaire

sible en
écriture
IsBuiltIn Bool read FAUX pour les objets pouvant être créés par l'utilisateur
IsGsd Bool read VRAI quand la description d'appareil est installée avec
GSD/GSDML
IsPlugged Bool read VRAI pour les appareils enfichés
Label String read Dynami‐ Pour les éléments d'appareil avec la
que fonction NetworkPort ou NetworkInterface.
Lorsque l'interface ou le port ne possède pas de "Label",
alors Label est String.Empty.
LocationIdentifier String read/write Dynami‐
que
Name String read/write Parfois accès protégé en écriture
OrderNumber String read/write Dynami‐ Parfois accès protégé en écriture
que
PlantDesignation String read/write Dynami‐
que
PositionNumber int read
TypeName String read Dynami‐ Le nom de type indépendant de la langue. (Optionnel pour
que les éléments d'appareil que l'utilisateur ne peut pas gérer
en tant qu'éléments automatiquement créés ou sous-mo‐
dules fixes).
InstallationDate DateTime read/write Dynami‐
que
AdditionalInfor‐ Chaîne de carac‐ read/write Dynami‐
mation tères que
Classification de l'élément d'appareil
Valeur Description
Siemens.Engineering.HW.DeviceI‐ Pas de classification.
temClassifications.None
Siemens.Engineering.HW.DeviceI‐ L'élément d'appareil est une CPU.
temClassifications.CPU
Siemens.Engineering.HW.DeviceI‐ L'élément d'appareil est un module de tête.
temClassifications.HM

Code de programme : attributs obligatoires d'un élément d'appareil

Pour appeler les attributs obligatoires d'un élément d'appareil, modifiez le code de programme
suivant :
DeviceItem deviceItem = ...;

string nameValue = deviceItem.Name;
string typeIdentfierValue = deviceItem.TypeIdentifier;
int positionNumberValue = deviceItem.PositionNumber;
bool isBuiltInValue = deviceItem.IsBuiltIn;
bool isPluggedValue = deviceItem.IsPlugged;
Code de programme : attributs obligatoires pour accès dynamique

Pour appeler les attributs pour un accès dynamique, modifiez le code de programme suivant :

"TypeName", "Author", "Comment", "OrderNumber", "FirmwareVersion", "PlantDesignation",
"LocationIdentifier"
};
object attributeValue = ((IEngineeringObject)deviceItem).GetAttribute(attributeName);
}

((IEngineeringObject)deviceItem).SetAttribute("Comment", "This is a comment.");
7.16.2 Créer et enficher un élément d'appareil
Conditions
Utilisation
L'action PlugNew(string typeIdentifier, string name, int positionNumber)
de HardwareObject est utilisée pour
● créer un nouvel élément d'appareil et l'enficher dans un objet matériel existant,
● créer un nouveau sous-élément d'appareil, par exemple un sous-module et l'enficher dans
un élément d'appareil existant.

Quand l'action réussit, elle fournit l'objet "élément d'appareil" créé. Sinon, une exception
récupérable est lancée.
Avec l'action CanPlugNew(string typeIdentifier, string name, int
positionNumber), vous pouvez déterminer si la création et l'enfichage seront possibles.
Quand son exécution n'est pas possible, l'action fournit false.
L'action peut échouer pour les raisons imprévisibles suivantes, même si la méthode retourne
la valeur True.
● un numéro de position est déjà utilisé par un autre élément d'appareil,
● l'élément d'appareil actuel ne peut pas être enfiché à la position alors quelle est libre,
● le conteneur ne met pas le numéro de position à disposition,
● le nom de l'élément d'appareil est déjà utilisé par un autre élément d'appareil existant dans
le même conteneur,
● l'élément d'appareil ne peut pas être enfiché dans le conteneur,
● l'appareil est en ligne.
Le tableau ci-dessous indique les paramètres de méthode requis :

typeIdentifier String Identifiant de type de l'élément d'appa‐
reil créé
name String Nom de l'élément d'appareil créé
positionNumber int Numéro de position de l'élément d'ap‐
pareil créé
Code de programme
Pour enficher un élément d'appareil dans un objet matériel existant, modifiez le code de
programme suivant :
HardwareObject hwObject = ...;

string typeIdentifier = ...;
string name = ...;
int positionNumber = ...;
if(hwObject.CanPlugNew(typeIdentifier, name, positionNumber))
{
DeviceItem newPluggedDeviceItem = hwObject.PlugNew(typeIdentifier, name,
positionNumber);
}

Accès aux informations sur les modules

L'utilisateur de TIA Portal Opennesspeut accéder aux informations sur les modules enfichables
via l'objet ModuleInformationProvider . L'utilisateur a accès
● aux types de conteneur dans lesquels un module donné doit être enfiché (par ex. un
appareil ou un châssis) – via la méthode FindContainerTypes ;
● aux versions disponibles d'un module donné indiqué en partie – via la méthode
FindModuleTypes.
Code de programme : accès à l'objet ModuleInformationProvider.

HardwareUtilityComposition extensions = project.HwUtilities;
var result = extensions.Find("ModuleInformationProvider") as ModuleInformationProvider;
Code de programme : accès à des types de conteneur avec la méthode FindContinerTypes

La méthode FindContinerTypes renvoie les types de conteneur d'un module indiqué. Le
module est indiqué via le paramètre typeIdentifier. La liste qui en résulte contient des
identificateurs de type (TypeIdentifier) de tous les types de conteneur du type demandé. Elle
comprend généralement un appareil et un châssis, et les conteneurs sont indiqués dans leur
ordre dans la hiérarchie dans le projet en commençant à l'appareil.
Nom du paramètre Type Description

typeIdentifier String Identifiant de type d'un élément
d'appareil
IMPORTANT
Cette méthode fonctionne uniquement pour les modules visibles dans la vue de réseau.
Cette méthode fonctionne uniquement pour les modules et non pour les sous-modules.
string typeIdentifier = ...;

string[] containerTypes = moduleInformationProvider.FindContainerTypes(typeIdentifier);
Code de programme : accès à des versions avec la méthode FindModuleTypes

La méthode FindModuleTypes renvoie toutes les versions possibles d'un objet matériel avec
l'utilisation de l'identifiant de type partiel de l'élément d'appareil. Cette méthode permet de sortir
une liste de chaînes de caractères. Chaque chaîne de caractères correspond au TypeIdentifier
complet d'une correspondance possible pour un TypeIdentifier partiel.

Un identifiant de type partiel ne peut comprendre que des parties complètes, chaque partie de
l'identifiant de type étant séparée par le caractère "/". Les caractères génériques ou les parties
incomplètes ne sont pas pris en charge. Vous devez également tenir compte des limitations
suivantes concernant le nombre minimum de parties indiquées :
● N° de référence : au moins une partie. Exemple : OrderNumber:6ES7 317-2EK14-0AB0
● GSD : au moins deux parties. Exemple : GSD:SI05816A.GSD/M
● Système : au moins une partie. Exemple : System:Rack.ET200SP

partialTypeIdentifier String Identifiant de type partiel d'un
élément d'appareil
string partialTypeIdentifier = ...;

string[] moduleTypes = moduleInformationProvider.FindModuleTypes(partialTypeIdentifier);
Code de programme : accès aux emplacements d'enfichage avec la méthode GetPlugLocations

La méthode GetPlugLocations renvoie des informations sur les emplacements d'enfichage,
notamment l'emplacement, le numéro de position (désignation d'un emplacement) et les
emplacements libres pour l'objet matériel.
La classe PlugLocation présente les caractéristiques suivantes.
Nom de la propriété Type Description

PositionNumber Int Le numéro de position de l'em‐
placement libre
Label String La désignation de l'emplace‐
ment libre
● Si aucune "label" n'est disponible pour un numéro de position spécifique, la représentation

en chaîne de caractères du numéro de position est utilisée.
● Les objets PlugLocationne sont mis à disposition que pour des emplacements libres.
HardwareObject hardwareObject = ...;

IList<PlugLocation> result = hardwareObject.GetPlugLocations();
foreach (PlugLocation item in result)
{
Console.WriteLine("{0} - {1}", item.PositionNumber, item.Label);
}

7.16.3 Déplacer un élément d'appareil dans un autre emplacement d'enfichage
Conditions
Utilisation
Avec l'action PlugMove(DeviceItem deviceItem, int positionNumber) de HardwareObject , vous
pouvez déplacer un élément d'appareil existant pour l'enficher dans un objet matériel existant.
La méthode PlugMove ajoute les éléments d'appareil à l'endroit où le module n'a pas pu
enficher l'interface utilisateur. Dans ce cas, l'action PlugMove est terminée avec des erreurs de
compilation.
L'action CanPlugMove(DeviceItem deviceItem, int positionNumber) sert à déterminer la
possibilité de déplacement. Si le déplacement n'est pas possible, CanPlugMove fournit la
valeur False en retour. L'action peut échouer pour les raisons imprévisibles suivantes, même
si la méthode retourne la valeur True.
● l'élément d'appareil actuel ne peut pas être enfiché dans l'emplacement alors qu'il est libre,
le même conteneur,
● l'élément d'appareil ne peut pas être enfiché par l'utilisateur,
● l'élément d'appareil ne peut pas être supprimé par l'utilisateur,
● l'appareil est en ligne.
Code de programme

DeviceItem deviceItemToMove = ...;
if(hwObject.CanPlugMove(deviceItemToMove, positionNumber)
{
DeviceItem movedDeviceItem = hwObject.PlugMove(deviceItemToMove, positionNumber);
}

7.16.4 Copier l'élément d'appareil
Conditions
Utilisation
Utilisez l'action PlugCopy(DeviceItem deviceItem, int positionNumber) de HardwareObject
pour copier un appareil au sein d'un projet et l'enficher dans du matériel existant. Dans de rares
cas, la méthode PlugCopy peut fonctionner même si un module ne peut pas être enfiché dans
UI. Dans ce cas, des erreurs de compilation surviennent après l'opération de copie. Quand
PlugCopy réussit, la copie de l'objet élément d'appareil est fournie en retour. Sinon, une
exception récupérable est lancée.
Causes possibles de l'échec d'une action :
● l'élément d'appareil actuel ne peut pas être enfiché dans l'emplacement alors qu'il est libre,
le même conteneur,
● l'élément d'appareil ne peut pas être enfiché dans UI,
● ...
Avec l'actionCanPlugCopy(DeviceItem deviceItem, int positionNumber), vous pouvez
déterminer si l'opération de copie sera possible. Quand l'opération de copie ne peut pas être
exécutée, CanPlugCopy fournit la valeur False en retour. Toutefois, l'action peut échouer pour
des raisons imprévisibles même si la méthode retourne la valeur True.

deviceItem DeviceItem Élément d'appareil à copier
positionNumber Int Numéro de position pour la copie
de l'élément d'appareil

Code de programme

DeviceItem deviceItemToCopy = ...;
if(hwObject.CanPlugCopy(deviceItemToCopy, positionNumber))
{
DeviceItem copiedDeviceItem = hwObject.PlugCopy(deviceItemToCopy, positionNumber);
}
7.16.5 Supprimer un élément d'appareil
Conditions
Code de programme
Pour supprimer un élément d'appareil, modifiez le code de programme suivant :

var device = project.UngroupedDevicesGroup.Devices.Find("......");
var deviceItem = deviceItem.DeviceItems.First();
// delete device item

deviceItem.Delete();
7.16.6 Énumérer des éléments d'appareil
Conditions

Utilisation
Pour appeler un élément d'appareil, utilisez le HardwareObject. Les éléments d'un objet
matériel sont les parties enfichées dans l'objet matériel que l'utilisateur peut voir dans TIA
Portal :
● châssis dans un appareil
● module dans un châssis
● sous-module dans un module
● sous-module dans un sous-module
Remarque
Pour plus d'informations à ce sujet, voir la rubrique AUTOHOTSPOT.
Code de programme : énumérer les éléments d'un appareil

Pour énumérer les éléments d'appareil d'un objet matériel, modifiez le code de programme
suivant :
private static void EnumerateDeviceItems(HardwareObject hardwareObject)

{
foreach (DeviceItem deviceItem in hardwareObject.Items)
{
// add code here
}
}
Code de programme : énumérer au moyen de la hiérarchie de composition

Pour énumérer les éléments d'un appareil au moyen de la hiérarchie de composition, modifiez
//Enumerates devices using an composition

private static void EnumerateDeviceItems(Device device)
{
{
// add code here
}
}

Code de programme : énumérer des éléments d'appareils avec affectation

Pour énumérer des éléments d'appareils au moyen d'une affectation, modifiez le code de
programme suivant :
//Enumerates devices using an association

private static void EnumerateDeviceItemsWithAssociation(Device device)
{
DeviceItemAssociation deviceItemAssociation = device.Items;
foreach (DeviceItem deviceItem in deviceItemAssociation)
{
// add code here
}
}
7.16.7 Appeler des éléments d'appareil
Conditions
Utilisation : appeler des éléments d'appareil

Pour appeler des objets de type "DeviceItem", utilisez les attributs suivants :
● Nom (string) : nom de l'élément d'appareil
● Conteneur (HardwareObject) : conteneur dans lequel l'élément d'appareil est enfiché

ture
Comment String read/write Dynamique
FirmwareVersion String read Dynamique Uniquement pour modules de tête
GsdName String read Dynamique Nom du fichier GSD.
GsdType String read Dynamique Type de l'objet matériel. La valeur de l'ap‐
pareil est toujours "D".
GsdId String read Dynamique Identifiant spécifique de l'objet matériel.
Toujours vide pour les appareils.
IsBuiltIn Bool read
IsGsd Bool read VRAI pour appareil GSD ou appareil
GSDML
IsPlugged Bool read
IsProfibus Bool read


ture
IsProfinet Bool read
Name String read/write
OrderNumber String read Dynamique Uniquement pour modules de tête
PositionNumber Bool read
Code de programme : appeler un élément d'appareil

Pour appeler un élément d'appareil, modifiez le code de programme suivant :
public static DeviceItem AccessDeviceItemFromDevice(Device device)

{
DeviceItem deviceItem = device.DeviceItems[0];
return deviceItem;
}
Code de programme : accéder à un élément d'appareil d'un élément d'appareil

Pour accéder à un élément d'appareil d'un élément d'appareil, modifiez le code de programme
suivant :
public static DeviceItem AccessDeviceItemFromDeviceItem(DeviceItem deviceItem)

{
DeviceItem subDeviceItem = deviceItem.DeviceItems[0];
return subDeviceItem;
}
Code de programme : naviguer jusqu'au conteneur d'un élément d'appareil

Modifiez le code de programme suivant avec l'attribut "Container" de DeviceItem pour
retourner au conteneur d'un élément d'appareil :

HardwareObject container = deviceItem.Container;

Code de programme : appeler les attributs d'identification


"GsdName", "GsdType", "GsdId" };
object attributeValue = ((IEngineeringObject)deviceItem).GetAttribute(attributeName);
}
Code de programme : appeler des attributs


GsdDeviceItem gsdDeviceItem =
((IEngineeringServiceProvider)deviceItem).GetService<GsdDeviceItem>();
string gsdName = gsdDeviceItem.GsdName;

string gsdType = gsdDeviceItem.GsdType;
string gsdId = gsdDeviceItem.GsdId;
bool isProfinet = gsdDeviceItem.IsProfinet;
bool isProfibus = gsdDeviceItem.IsProfibus;;
Code de programme : appeler les attributs pour l'accès dynamique



"TypeName", "Author", "Comment", ...
;
object attributeValue =
((IEngineeringObject)gsdDeviceItem).GetAttribute(attributeName);
}
Code de programme : définir des attributs


((IEngineeringObject)deviceItem).SetAttribute("Comment", "This is a comment.");

Code de programme : appeler les données prm d'un module de tête

Pour appeler les données prm, modifiez le code de programme suivant :

int dsNumber = 0; // For Profibus GSDs, dataset number zero must be used!
int byteOffset = 0;
int lengthInBytes = 5;
// read complete data set:

byte[] prmDataComplete = gsdDeviceItem.GetPrmData(dsNumber, byteOffset, lengthInBytes);
// read partial data set (only second byte):

byteOffset = 1;
lengthInBytes = 1;
byte[] prmDataPartial = gsdDeviceItem.GetPrmData(dsNumber, byteOffset, lengthInBytes);
Code de programme : paramétrer les données prm d'un module de tête

Pour paramétrer les données prm, modifiez le code de programme suivant :

// The parameters byteOffset and the length of the byte array prmData define the range
within the
// dataset which is written to.
// For Profibus GSDs, dataset number zero must be used!
// Change the highlighted bytes 2-4 from 0x0 to 0x1

// to write only the first two bytes: byte[] prmData = {0x05, 0x21};
int dsNumber = 0;
int byteOffset = 0;
byte[] prmData = {0x05, 0x21, 0x01, 0x01, 0x01};
gsdDeviceItem.SetPrmData(dsNumber, byteOffset, prmData);

7.16.8 Accès à l'élément d'appareil en tant qu'interface
Conditions
Utilisation
Si un élément d'appareil est une interface, il offre des fonctions supplémentaires par rapport à
un élément d'appareil simple. Cette interface permet à l'utilisateur d'accéder aux abonnés et au
mode de fonctionnement de l'interface. Grâce à cette fonctionnalité, l'élément d'appareil peut
être utilisé comme IoDevice (esclave) ou comme IoController (maître) via la fonction
NetworkInterface (un service spécifique de l'élément d'appareil).
L'énumération InterfaceOperatingModes permet d'accéder aux propriétés de l'interface.
Valeur Description
InterfaceOperatingModes.None Valeur par défaut
InterfaceOperatingModes.IoDevice Mode de fonctionnement de l'interface "IoDevice"
(esclave).
InterfaceOperatingModes.IoController Mode de fonctionnement de l'interface "IoControl‐
ler" (maître).
InterfaceOperatingModes.IoDevice Mode d'interface : les deux modes ci-dessus.
or
InterfaceOperatingModes.IoController

Code de programme : accès à la fonction d'interface réseau

Pour appeler la fonction d'interface réseau, modifiez le code de programme suivant :
NetworkInterface itf =
((IEngineeringServiceProvider)deviceItem).GetService<NetworkInterface>();
if (itf != null)
{
... // work with the interface
}
//Accessing nodes and operating mode

NodeComposition nodes = itf.Nodes;
InterfaceOperationModes mode = itf.InterfaceOperatingMode;
//Accessing the type of interface

NetType itfType = itf.InterfaceType;
//Modififying the operating mode and interface type

itf.InterfaceOperatingMode = InterfaceOperatingModes.IoDevice;
itf.InterfaceType = NetType.Profibus
//Accessing the ports linked to an interface.

NetworkPortAssociation nodes = itf.Ports;
7.16.9 Accéder aux attributs d'une interface d'appareil I/O
Conditions
Utilisation
L'interface TIA Portal Openness API vous permet d'appeler ou de déterminer des attributs pour
IRT et le mode isochrone sur l'interface d'appareil IO.

Accès à l'interface d'un contrôleur IO

Les attributs suivants permettent d'accéder à l'interface d'un contrôleur IO. Le contrôleur doit
être le maître de synchronisation :
Nom d'attribut Type de don‐ Acces‐ Accès Description

nées sible en
écriture
PnSendClock Int64 r/w Attribut dynamique Envoyer la cadence en nano‐
secondes
Accès à l'interface d'un réseau IO

Les attributs suivants permettent d'accéder à l'interface d'un réseau IO. Les valeurs Ti/To
peuvent être utilisées par tous les modules et sous-modules faisant partie du réseau IO.
Nom d'attribut Type de données Accessible en écri‐ Accès

ture
IsochronousTiToAutoCalculation BOOL r/w Attribut dynamique
IsochronousTi DOUBLE r/w Attribut dynamique
IsochronousTo DOUBLE r/w Attribut dynamique
Accès à l'interface d'un périphérique IO

Les attributs suivants permettent d'accéder à l'interface d'un périphérique IO. Les valeurs Ti/To
peuvent être utilisées par tous les modules et sous-modules faisant partie du réseau IO.
Nom d'attribut Type de données Accessible en écri‐ Accès

ture
IsochronousMode BOOL r/w Attribut dynamique
IsochronousTiToCalculationMode IsochronousTiToCal‐ r/w Attribut dynamique
culationMode
IsochronousTi DOUBLE r/w Attribut dynamique
IsochronousTo DOUBLE r/w Attribut dynamique
Les valeurs ENUM suivantes sont disponibles pour l'attribut

IsochronousTiToCalculationMode :
Valeur Description
IsochronousTiToCalculationMode.None
IsochronousTiToCalculationMode.FromOB Les valeurs Ti/To de l'OB (configurées sur le réseau IO) sont
utilisées.
IsochronousTiToCalculationMode.FromSubnet Cette valeur n'est pas utilisée par les interfaces PROFINET.
IsochronousTiToCalculationMode.AutomaticMini Les valeurs Ti/To sont calculées automatiquement pour le
mum périphérique IO.
IsochronousTiToCalculationMode.Manual L'utilisateur peut saisir des valeurs Ti/To manuellement pour
ce périphérique IO.

Code de programme : appeler ou déterminer les attributs d'une interface d'appareil IO

Pour accéder à la cadence d'émission, modifiez le code de programme suivant :
DeviceItem pnInterface = ...;

// read attribute
long attributeValue = (long)pnInterface.GetAttribute("PnSendClock");
// write attribute
long sendClock = 2000000;
pnInterface.SetAttribute("PnSendClock", sendClock);
Pour accéder aux valeurs Ti/To d'un OB, modifiez le code de programme suivant :

bool titoAutoCalculation = (bool)ioSystem.GetAttribute("IsochronousTiToAutoCalculation");
ioSystem.SetAttribute("IsochronousTiToAutoCalculation", true);
Pour accéder au réglage isochrone d'une interface d'appareil IO, modifiez le code de
programme suivant :
DeviceItem pnInterface = ...;

bool isochronousMode = (bool)pnInterface.GetAttribute("IsochronousMode");
pnInterface.SetAttribute("IsochronousMode", true);
7.16.10 Accès aux attributs de l'IoController
Conditions
Utilisation
l'IoController. Les attributs suivants sont disponibles sous PROFINET IoController (sous une
interface PROFINET). Si l'utilisateur peut modifier un attribut dans l'interface utilisateur, il peut
également modifier l'attribut correspondant via TIA Portal Openness .

Nom d'attribut Type de données Type Accès Description

SyncRole SyncRole Lecture/écriture Attribut dynamique
PnDeviceNumber Int Protégé en écriture Attribut dynamique Cette propriété est
disponible dans la
TIA Portal UI sous
le nœud Ethernet
(section PROFI‐
NET)
La propriété Synchronication role est disponible dans l'interface PROFINET de la TIA Portal UI.
L'Enum SyncRole a les valeurs suivantes :
Valeur d'énumération Valeur numérique

SyncRole.NotSynchronized 0
SyncRole.SyncMaster 1
SyncRole.SyncSlave 2
SyncRole.RedundantSyncMaster 4
Code de programme : définir les attributs de l'IoController
IoController ioController= ...;

SyncRole syncRole = (SyncRole)((IEngineeringObject)ioController).GetAttribute("SyncRole");
((IEngineeringObject)ioController).SetAttribute("SyncRole", SyncRole.SyncMaster);
7.16.11 Accès aux attributs de l'IoConnector
Conditions

Utilisation
l'IoConnector. Les attributs suivants sont disponibles sous PROFINET IoController (sous une
interface PROFINET). Si l'utilisateur peut modifier un attribut dans l'interface utilisateur, il peut
également modifier l'attribut correspondant via TIA Portal Oopenness .
Il existe quatre types d'attribut tels que des attributs pour le temps d'actualisation, des attributs
pour le temps de surveillance, des attributs pour la synchronisation et des attributs pour le
numéro d'appareil.
Attributs pour le temps d'actualisation

Les attributs pour le temps d'actualisation sont indiqués ci-dessous.

PnUpdateTimeAuto‐ Bool Lecture/écriture Attribut dynamique Si cet attribut est vrai,
Calculation le temps d'actualisa‐
tion est calculé auto‐
matiquement.
PnUpdateTime Int64 Lecture/écriture Attribut dynamique Le temps d'actualisa‐
tion est mesuré en na‐
nosecondes.
PnUpdateTimeAdap‐ Bool Lecture/écriture Attribut dynamique
tion
Attributs pour le temps de surveillance

Les attributs pour le temps de surveillance sont indiqués ci-dessous.

PnWatchdogFactor Int32 Lecture/écriture Attribut dynamique
PnWatchdogTime Int64 Protégé en écriture Attribut dynamique Le temps de surveillan‐
ce est mesuré en nano‐
secondes.
Attributs pour la synchronisation

Les attributs pour la synchronisation sont indiqués ci-dessous.

RtClass RtClass Lecture/écriture Attribut dynamique
SyncRole SyncRole Protégé en écriture Attribut dynamique

L'énumération RtClass a les valeurs suivantes.

RtClass.None 0
RtClass.RT 1
RtClass.IRT 2
L'énumération SyncRole a les valeurs suivantes.

SyncRole.NotSynchronized 0
SyncRole.SyncMaster 1
SyncRole.SyncSlave 2
SyncRole.RedundantSyncMaster 4
Attributs pour le numéro d'appareil

Les attributs pour le numéro d'appareil sont indiqués ci-dessous.

PnDeviceNumber Int Lecture/écriture Attribut dynamique Indique le numéro d'ap‐
pareil
Code de programme : appeler et définir les attributs de l'IoConnector
IoConnector connector = ...

"PnUpdateTimeAutoCalculation", "PnUpdateTime", "PnUpdateTimeAdaption", "PnWatchdogFactor",
"PnWatchdogTime", "RtClass", "SyncRole"
};

{
object attributeValue = ((IEngineeringObject)connector ).GetAttribute(attributeName);
}
connector.SetAttribute("PnUpdateTimeAutoCalculation", true);
Voir aussi

7.16.12 Accéder à un contrôleur d'adresse
Conditions
Utilisation
Un élément d'appareil qui est en même temps contrôleur d'adresse offre des fonctions
supplémentaires. Pour accéder aux adresses enregistrées du contrôleur d'adresse, il faut
utiliser le rôle AddressController.
Code de programme : appeler un contrôleur d'adresse

Pour appeler le rôle de contrôleur d'adresse, modifiez le code de programme suivant :
AddressController addressController =
((IEngineeringServiceProvider)deviceItem).GetService<AddressController>();
if (addressController != null)
{
... // work with the address controller
}
Attributs d'un contrôleur d'adresse

Un contrôleur d'adresse possède les attributs suivants :
● RegisteredAddresses
Pour appeler les attributs d'un contrôleur d'adresse, modifiez le code de programme suivant :
AddressController addressController = ...;

foreach (Address registeredAddress in addressController.RegisteredAddresses)
{
...
}

7.16.13 Accéder à des adresses
Conditions
Utilisation
Les objets adresse sont appelés à l'aide du lien de composition Addresses d'un élément
d'appareil. L'attribut Addresses retourne un recueil de AddressComposition qui peut être
énuméré.
Code de programme : appeler l'adresse d'un élément d'appareil

Pour appeler l'adresse d'un élément d'appareil, modifiez le code de programme suivant :
AddressComposition addresses = deviceItem.Addresses;

foreach(Address address in addresses)
{
// work with the address
}
Code de programme : appeler l'adresse d'un contrôleur IO

Pour appeler l'adresse d'un contrôleur IO, modifiez le code de programme suivant :
AddressComposition addresses = ioController.Addresses;

foreach(Address address in addresses)
{
// work with the address
}
Attributs
L'adresse prend en charge les attributs suivants :
Nom d'attribut Type de données Accessible Accès Commentaire

en écriture
AddressControl‐ AddressControllerAsso‐ read
lers ciation
Context enum: AddressContext read Dynamique Uniquement pour adresses de diagnostic et
pour éléments d'appareil spécifiques
IoType enum: AddressIoType read


en écriture
StartAdress Int32 read/write
Length Int32 read
Valeur Description
AddressIoType.Diagnosis Le type IO d'adresse est diagnostic.
AddressIoType.Input Le type IO d'adresse est entrée.
AddressIoType.Output Le type IO d'adresse est sortie.
AddressIoType.Substitute Le type IO d'adresse est remplacement.
AddressIoType.None Le type IO d'adresse n'est pas indiqué.
Valeur Description
AddressContext.None Le contexte d'adresse n'est pas valable.
AddressContext.Device Contexte d'adresse d'appareil.
AddressContext.Head Contexte d'adresse de tête.
Code de programme : Lire les attributs

AddressControllerAssociation addressControllers = address.AddressControllers;

Int32 startAddress = address.StartAddress;
AddressIoType addressType = address.IoType;
Int32 adressLength = address.Length;
Code de programme : écrire les attributs

Pour écrire les attributs, modifiez le code de programme suivant :
Address addressControllers = ...;
address.StartAddress = intValueStartAddress;
Code de programme : attributs pour accès dynamique

object attributeValue = ((IEngineeringObject)address).GetAttribute("Context");

7.16.14 Accéder à l'"identifiant de matériel"
Conditions
Utilisation
Les objets "Identifiant de matériel" sont appelés par les objets suivants :
● Device
● DeviceItem
● IoSystem
L'identifiant de matériel est représenté par la classe HwIdentifier et appelé avec
l'attributHwIdentifiers..
Code de programme : appeler l'identifiant de matériel

Pour mettre à disposition HwIdentifier, modifiez le code de programme suivant :
var hwObject = ...

foreach(HwIdentifier hardwareIdentifier in hwObject.HwIdentifiers)
{
// Work with the HwIdentifer
}
Attributs d'un identifiant de matériel
HwIdentifierControllerAssociation controllers = hwIdentifier.HwIdentifierControllers;

Int64 Identifier = hwIdentifier.Identifier;
7.16.15 Accéder au contrôleur d'identifiant de matériel
Conditions

Utilisation
Quand un élément d'appareil est en même temps contrôleur d'identifiant de matériel, il est
possible d'accéder aux identifiants de matériel enregistrés. Pour accéder à ces
HwIdentifierController, il faut utiliser un certain service de l'élément d'appareil.
Code de programme : appeler le contrôleur d'identifiant de matériel

Pour appeler le HwIdentifierController, modifiez le code de programme suivant :
HwIdentifierController hwIdentifierController =
((IEngineeringServiceProvider)deviceItem).GetService<HwIdentifierController>();
if (hwIdentifierController != null)
{
... // work with the hardware identifier controller
}
Code de programme : attributs d'un contrôleur d'identifiant de matériel

Un contrôleur d'adresse possède les attributs suivants :
● RegisteredHwIdentifiers : les contrôleurs d'identifiant de matériel sur lesquels
l'identifiant de matériel est enregistré.
Pour appeler les attributs d'un contrôleur d'adresse, modifiez le code de programme suivant :
HwIdentifierController hwIdentifierController = ...;

HwIdentifierAssociation controllers = hwIdentifierController.RegisteredHwIdentifiers;
7.16.16 Accéder aux voies d'éléments d'appareil
Conditions
Utilisation
Une voie est représentée par la classe Channel. Les voies sont appelées par un élément
d'appareil au moyen de l'attribut Channels de la classe DeviceItem. L'attribut Channels
retourne une implémentation de ChannelComposition qui peut être énumérée. Quand
l'élément d'appareil n'a pas de voie, l'attribut Channels retourne un recueil vide.

Attributs obligatoires
Une voie prend en charge les attributs obligatoires suivants :

en écriture
IoType ChannelIoType read
Type ChannelType read
Number Int32 read
ChannelAddress Int32 read Dynamique Adresse de la voie en bits
ChannelWidth UInt32 read Dynamique Largeur de la voie en bits
Code de programme : appeler les voies d'un élément d'appareil

Pour appeler les voies d'un élément d'appareil, modifiez le code de programme suivant :
ChannelComposition channels = deviceItem.Channels

foreach(Channel channel in channels)
{
// work with the channel
}
Code de programme : attributs obligatoires d'une voie

Pour appeler les voies d'un élément d'appareil, modifiez le code de programme suivant :
Channel channel = ...;

int channelNumber = channel.Number;
ChannelType type = channel.Type;
ChannelIoType ioType = channel.IoType;
Code de programme : appeler les valeurs des attributs pour l'accès dynamique
Pour appeler les valeurs d'attributs dynamiques, modifiez le code de programme suivant :

Int32 channelAddress = (Int32)((IEngineeringObject)channel).GetAttribute("ChannelAddress");
UInt32 channelWidth = (UInt32)((IEngineeringObject)channel).GetAttribute("ChannelWidth");
Code de programme : déterminer la valeur d'un attribut dynamique

Pour déterminer la valeur d'un attribut dynamique accessible en écriture, modifiez le code de
programme suivant :

((IEngineeringObject)channel).SetAttribute("AnAttribute", 1234);

7.16.17 Importation et exportation d'un fichier PSC
Condition
● Ouvrir un projet
Application
Vous pouvez créer un fichier PSC et charger un appareil dans le fichier par le biais de l'interface
TIA Portal Openness API. Pour créer un fichier PSC et charger une configuration de l'appareil
dans le fichier, vous pouvez utiliser la méthode Export d'un service CardReaderPscProvider.
Le service est présent dans l'espace de nom Siemens.Engineering.HW.Utilities.
Code de programme
Modifiez le code de programme suivant pour créer et exporter un fichier PSC :
// preconditions
Device ipcDevice = myProject.Devices.Find("IPC427D");
FileInfo exportFile = new FileInfo(@"C:\Users\Ertan\Documents\Automation\PC system
configuration74.psc");
// get the card reader provider from hardware utilities
HardwareUtilityComposition utilities = myProject.HwUtilities;
HardwareUtility utility = utilities.Find("CardReaderPscProvider");
CardReaderPscProvider crp = (CardReaderPscProvider)utility;
// do the export
crp.Export(ipcDevice, exportFile);
La création et l'ouverture d'un fichier PSC avec des commandes distinctes ne sont pas prises
en charge. Si vous indiquez un fichier PSC déjà présent comme paramètre, le fichier n'est pas
écrasé et une exception est retournée. Si le fichier PSC n'est pas encore présent, il est créé et
l'opération de chargement est effectuée.
Vous devez vous assurer que le projet peut être compilé sans problème. Faute de quoi, une
exception est retournée.
Remarque
Pour des raisons de sécurité, l'opération d'exportation pour les appareils activés F n'est pas
prise en charge dans V15.1 (à l'exportation, une exception est retournée).

7.17 Fonctions sur les données d'un appareil HMI
7.16.18 Gestion de connexions pour les châssis d'extension
Conditions
Application
À l'aide de TIA Portal Openness vous pouvez appeler, ajouter et supprimer des relations pour
les châssis d'extension. Vous pouvez ainsi aussi utiliser la prise en charge de TIA Portal
Openness pour la réalisation de relations pour des châssis d'extension lors de l'importation/
exportation CAx.
Code de programme
ImConnection imConnection = portDeviceItem.GetService<ImConnection>();

imConnection.Connect(partnerport);
imConnection.Disconnect();
imConnection.GetPartnerPort();
var imConnectionOwner = imConnection.OwnedBy;
Voir aussi
7.17.1 Vues
7.17.1.1 Créer des dossiers de vues personnalisés
Conditions

Code du programme
Pour créer un dossier de vues personnalisé, modifiez le code de programme suivant :
//Creates a screen folder

private static void CreateScreenFolder(HmiTarget hmitarget)
{
ScreenUserFolder myCreatedFolder =
hmitarget.ScreenFolder.Folders.Create("myScreenFolder");
}
7.17.1.2 Supprimer la vue d'un dossier
Conditions requises
Utilisation
Remarque
Vous ne pouvez pas supprimer une fenêtre permanente. Une fenêtre permanente est une vue
système toujours existante.
Code du programme
Pour supprimer une vue d'un certain dossier, modifiez le code de programme suivant :
public static void DeleteScreenFromFolder(HmiTarget hmiTarget)

{
ScreenUserFolder screenUserFolder =
hmiTarget.ScreenFolder.Folders.Find("myScreenFolder");
ScreenComposition screens = screenUserFolder.Screens;
Screen screen = screens.Find("myScreenName");
if (screen != null)
{
screen.Delete();
}
}

7.17.1.3 Supprimer un modèle de vue d'un dossier
Conditions requises
● Un appareil IHM existe dans le projet.
Code du programme
Pour supprimer un modèle de vue d'un certain dossier, modifiez le code de programme suivant :
private static void DeleteScreenTemplateFromFolder(HmiTarget hmiTarget)

{
string templateName = "MyScreenTemplate";
ScreenTemplateUserFolder folder =
hmiTarget.ScreenTemplateFolder.Folders.Find("myScreenTemplateFolder");
ScreenTemplateComposition templates = folder.ScreenTemplates;
ScreenTemplate template = templates.Find(templateName);
if (template != null)
{
template.Delete();
}
}
7.17.1.4 Supprimer toutes les vues d'un dossier
Conditions requises
Utilisation
Remarque
Vous ne pouvez pas supprimer une fenêtre permanente. Une fenêtre permanente est une vue
système toujours existante.

Code du programme
Pour supprimer toutes les vues d'un certain dossier, modifiez le code de programme suivant :
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;
List<Screen> list = new List<Screen>();
foreach(Screen screen in screens)
{
list.Add(screen);
}
foreach (Screen screen in list)
{
screen.Delete();
}
}
7.17.2 Cycles
7.17.2.1 Suppression de cycle
Conditions requises
Utilisation
Vous ne pouvez pas supprimer les cycles prédéfinis.
À l'aide de la composition dans le modèle objet (composition count) du cycle concerné, vous
pouvez déterminer si des cycles ont effectivement été supprimés. Il n'est plus possible
d'accéder à ces cycles.

Code du programme
Pour supprimer un cycle d'un appareil IHM, modifiez le code de programme suivant :
public static void DeleteCycle(HmiTarget hmiTarget)

{
CycleComposition cycles = hmiTarget.Cycles;
Cycle cycle = cycles.Find("myCycle");
cycle.Delete();
}
7.17.3 Listes de textes
7.17.3.1 Suppression de la liste de textes
Conditions requises
Code du programme
Pour supprimer une liste de textes sélectionnée et toutes les entrées de liste correspondantes
d'un appareil IHM, modifiez le code de programme suivant :
public static void DeleteTextList(HmiTarget hmiTarget)

{
TextListComposition textLists = hmiTarget.TextLists;
TextList textList = textLists.Find("myTextList");
textList.Delete();
}

7.17.4 Listes de graphiques
7.17.4.1 Suppression d'une liste de graphiques
Conditions requises
Code du programme
Pour supprimer une liste de graphiques sélectionnée et toutes les entrées de liste
correspondantes d'un appareil IHM, modifiez le code de programme suivant :
private static void DeleteGraphicList(HmiTarget hmiTarget)

{
GraphicListComposition graphicLists = hmiTarget.GraphicLists;
GraphicList graphicList = graphicLists.Find("myGraphicList");
graphicList.Delete();
}
7.17.5 Connexions
7.17.5.1 Suppression de la liaison
Conditions requises

Code du programme
Pour supprimer une liaison de communication sélectionnée d'un appareil IHM, modifiez le code
private static void DeleteConnection(HmiTarget hmiTarget)

{
ConnectionComposition connections = hmiTarget.Connections;
Connection connection = connections.Find("HMI_connection_1");
connection.Delete();
}
7.17.6 Table des variables
7.17.6.1 Générer des dossiers personnalisés pour variables IHM
Conditions requises
Code du programme
Pour créer un dossier personnalisé pour variables HMI, modifiez le code de programme
suivant :
private static void CreateUserfolderForHMITags(HmiTarget hmitarget)

// Creates an HMI tag user folder
{
TagSystemFolder folder = hmitarget.TagFolder;
TagUserFolder myCreatedFolder = folder.Folders.Create("MySubFolder");
}
7.17.6.2 Enumérer les variables d'une table de variables IHM
Conditions requises

Code du programme
Pour énumérer toutes les variables d'une table de variables IHM, modifiez le code de
programme suivant :
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;
TagComposition tagComposition = table.Tags;

foreach (Tag tag in tagComposition)
{
// Add your code here
}
}
7.17.6.3 Suppression de variables individuelles d'une table de variables IHM
Conditions requises
Code du programme
Pour supprimer une variable déterminée d'une table des variables IHM, modifiez le code de
programme suivant :
private static void DeleteATag(HmiTarget hmiTarget)

{
string tagName = "MyTag";
TagTable defaultTagTable = hmiTarget.TagFolder.DefaultTagTable;
TagComposition Variablen = defaultTagTable.Tags;
Tag tag = tags.Find(tagName);
tag.Delete();
}

7.17.6.4 Supprimer une table de variables d'un dossier
Conditions requises
Utilisation
Vous ne pouvez pas supprimer la table des variables standard.
Code du programme
// Delete a tag table from a specific folder

private static void DeleteTagTable(HmiTarget hmiTarget)
{
string tableName = "myTagTable";
TagSystemFolder tagSystemFolder = hmiTarget.TagFolder;
TagTableComposition tagTables = tagSystemFolder.TagTables;
TagTable tagTable = tagTables.Find(tableName);
tagTable.Delete();
}
7.17.7 Scripts VB
7.17.7.1 Créer des dossiers personnalisés pour les scripts
Conditions requises

Code du programme
Pour créer un sous-dossier personnalisé pour scripts dans un dossier système ou un autre
dossier personnalisé, modifiez le code de programme suivant :
private static void CreateFolderInScriptfolder(HmiTarget hmitarget)

//Creates a script user subfolderVBScriptSystemFolder
{
VBScriptSystemFolder vbScriptFolder = hmitarget.VBScriptFolder;
VBScriptUserFolderComposition vbScriptFolders = vbScriptFolder.Folders;
VBScriptUserFolder vbScriptSubFolder = vbScriptFolder.Folders.Create("mySubfolder");
}
7.17.7.2 Supprimer les scripts VB d'un dossier
Conditions requises
Code du programme
Pour supprimer un script VB d'un certain dossier, modifiez le code de programme suivant :
//Deletes a vbscript from a script folderVBScriptSystemFolder

private static void DeleteVBScriptFromScriptFolder(HmiTarget hmitarget)
{
VBScriptUserFolder vbscriptfolder =
hmitarget.VBScriptFolder.Folders.Find("MyScriptFolder");
var vbScripts = vbscriptfolder.VBScripts;
if (null != vbScripts)
{
var vbScript = vbScripts.Find("MyScript");
vbScript.Delete();
}
}

7.18 Fonctions permettant l'accès à un appareil HMI (Unified)
7.17.8 Supprimer le dossier personnalisé d'un pupitre opérateur
Conditions requises
Code de programme
Pour supprimer un dossier personnalisé d'un pupitre opérateur, modifiez le code de
programme suivant :
HmiTarget hmiTarget = ...;

ScreenUserFolder screenUserGroup = hmiTarget.ScreenFolder.Folders.Find("MyUserFolder");
screenUserGroup.Delete();
7.18.1 Liste d'objets
Introduction
Les tableaux suivants indiquent les objets disponibles et si ces objets sont pris en charge par
Objets
Vous pouvez gérer les données de projet suivantes pour les appareils Unified WinCC :
Objet WinCC Scada Runtime Unified

Alarmes analogiques oui
Alarmes de bit oui
Classes d'alarmes Oui
Archives de données Oui
Archives d'alarmes Oui
Variables d'archive Oui
Variable Oui
Connexions oui
Paramètres Runtime des appareils oui

Objet WinCC Scada Runtime Unified

Vues et objets graphiques oui
Vue de l'installation oui
Objet d'installation oui
Noeud vue de l'installation oui
Interface Objet d'installation oui
Membre Interface Objet d'installation oui
Variable d'archive Objet d'installation oui
7.18.2 Objet logiciel HMI-Unified
Introduction
Il est nécessaire qu'un objet logiciel HMI puisse également accéder à d'autres éléments tels
que des variables, des liaisons, des alarmes et des vues.
Conditions
Établissement d'une connexion à TIA Portal (Page 79)
Ouverture d'un projet (Page 109)

Code de programme
Modifiez le code de programme suivant de manière à ce qu'un accès à un objet logiciel HMI soit
possible :
private HmiSoftware GetHmiSoftware()

{
HmiSoftware hmiSoftware = null;
IList<TiaPortalProcess> tiaProcessList = TiaPortal.GetProcesses();
//If no TIA Application instance is running, then following using statement will start it or
//if already running then will attach to it.
TiaPortal tiaApp = tiaProcessList.Count > 0? tiaProcessList[0].Attach(): new
TiaPortal(TiaPortalMode.WithUserInterface);
//If there is device projects are present in given TIA instance, then take first one to work
upon.
if (tiaApp.Projects.Count > 0)
project = tiaApp.Projects[0];
else
{
//if there is no device project in given TIA instance, open the existing project.
FileInfo file = new FileInfo(@"d:\Automation\Project1\Project1.apx");
if (!file.Exists)
throw new FileNotFoundException("Project1.apx not found");
project = tiaApp.Projects?.Open(file);
}
//After getting project, get the object representing UA software HMI device.
var devices = project.Devices;
if (devices != null)
{
var device = devices[0];
var deviceItems = device.DeviceItems;
if (deviceItems != null)
{
foreach (DeviceItem deviceItem in deviceItems)
{
hmiSoftware = softwareContainer?.Software as HmiSoftware;
}
}
}
return hmiSoftware;
}
Remarque
L'extension .apx dans le code de programme ci-dessus se réfère à la version de TIA Portal
installée.

7.18.3 Interroger les erreurs
Introduction
TIA Portal Openness permet d'interroger via les propriétés les informations d'erreur pour les
objets WinCC suivants :
● Alarme analogique
● Alarme de bit
● Classe d'alarmes
● Archive de données
● Archive d'alarmes
● Variable
● Connexion
● Variable d'archive
● Paramètres Runtime des appareils
● Vues et objets graphiques
● Vue de l'installation
● Objet d'installation
● Noeud vue de l'installation
● Interface Objet d'installation
● Membre Interface Objet d'installation
● Variable d'archive Objet d'installation
Remarque
La fonction ne peut pas être appliquée aux variables système et tables de variables, car celles-
ci n'ont pas de propriétés pouvant se trouver à l'état d'erreur.
Condition
Voir Etablissement d'une connexion au portail TIA (Page 79).
Voir Ouvrir un projet (Page 109).
● Accès à un objet logiciel HMI-Unified
Voir Objet logiciel HMI-Unified (Page 281)

Code de programme
Modifiez le code de programme suivant afin d'interroger des erreurs concernant des variables,
des alarmes, des paramètres d'exécution et des vues :

private void ValidateMultipleHmiObjects()

{
HmiSoftware hmiSoftware = GetHmiSoftware();
IList<IValidator> objectsToValidate = new List<IValidator>();
//Put tags in validation list.
HmiTagComposition hmiTags = hmiSoftware.HmiTags;
foreach (HmiTag hmiTag in hmiTags)
{
objectsToValidate.Add(hmiTag);
}
//Put alarms in validation list.
DiscreteAlarmComposition discreteAlarms = hmiSoftware.DiscreteAlarms;
foreach (DiscreteAlarm discreteAlarm in discreteAlarms)
{
objectsToValidate.Add(discreteAlarm);
}
//Put RuntimeSettings in validation list.
objectsToValidate.Add(hmiSoftware.RuntimeSettings);
foreach (IValidator validator in objectsToValidate)
{
IList<HmiValidationResult> validationResult = validator.Validate();
if (validationResult != null && validationResult.Count > 0)
{
foreach (HmiValidationResult propertyErrors in validationResult)
{
//browse error for different property
string propertyName = propertyErrors.PropertyName;
foreach (string propertyError in propertyErrors.Errors)
{
//work with property errors
}
}
}
}
//Put screens in validation list.
foreach (var screen in hmiSoftware.Screens)
{
objectsToValidate.Add(screen);
}
{
IList<HmiValidationResult> errors = validator.Validate();
if (errors != null && errors.Count > 0)
{
foreach (var errornotification in errors)
{
var propName = errornotification.PropertyName;
foreach (var errormessage in errornotification.Errors)
{
Console.WriteLine(errormessage);
}
}
}
}

//Put screenitems in validation list.

foreach (var screenitem in ScreenObject.ScreenItems)
{
objectsToValidate.Add(screenitem);
}
{
{
{
foreach (var errormessage in errornotification.Errors)
{
Console.WriteLine(errormessage);
}
}
}
}
}
Voir aussi
Objet logiciel HMI-Unified (Page 281)
7.18.4 Alarmes
7.18.4.1 Utilisation des alarmes analogiques
Introduction
Lors de l'utilisation de TIA Portal Openness, les alarmes analogiques vous permettent
d'exécuter les actions suivantes :
● Créer des alarmes analogiques
● Énumérer des alarmes analogiques
● Supprimer les alarmes analogiques
● Accéder aux propriétés d'alarmes analogiques

Propriétés
Les propriétés suivantes sont prises en charge par les alarmes analogiques :
Nom de la propriété Type de données Description Accès

EventText MultilingualText Indique l'événement/ R/W
le texte de l'alarme
Id uint32 Indique le numéro per‐ R/W
mettant d'identifier
l'alarme. Il s'agit d'une
valeur unique pour
chaque alarme analo‐
gique.
AlarmClass String Indique la classe d'alar‐ R/W
mes
Name String Indique le nom de R/W
l'alarme
Priority byte Indique la priorité de R/W
l'alarme
Origin String Indique l'origine de R/W
l'alarme
Area String Indique la zone à l'ori‐ R/W
gine de l'alarme
RaisedStateTag String Indique la variable ay‐ R/W
ant déclenché l'alarme
ConditionValue object Supported type: Double, Valeur de condition R/W
int16, , uint16, int32, uint32, pouvant être indiquée
int64, uint64, byte comme valeur constan‐
te
Condition HmiAlarmCondition Indique le mode de li‐ R/W
mitation.
InfoText MultilingualText Affiche un texte d'infor‐ R/W
mation
AlarmParameterTags Object SupportedType: Dans un tableau de dix R/W
IList<string> paramètres, la variable
indiquant le paramètre
de l'alarme Chaque pa‐
ramètre utilise le nom
de variable comme
chaîne de caractère.
Ces paramètres peu‐
vent être utilisés dans
le texte de l'événe‐
ment.
EventText1 MultilingualText Texte d'événement de R/W
HmiAnalogAlarm
HmiAnalogAlarm
HmiAnalogAlarm
HmiAnalogAlarm


HmiAnalogAlarm
HmiAnalogAlarm
HmiAnalogAlarm
HmiAnalogAlarm
HmiAnalogAlarm
Conditions
● Accès à un objet logiciel HMI
Code de programme
Vous pouvez modifier et utiliser l'exemple de code de programme lors de l'utilisation des
alarmes.
Créer des alarmes analogiques

Modifiez le code de programme suivant pour créer une alarme analogique :
private void AnalogAlarmCreate()

{
//Create Analog Alarm
AnalogAlarmComposition analogAlarms = hmiSoftware.AnalogAlarms;
AnalogAlarm analogAlarm = analogAlarms.Create("Alarm_1");
}
Supprimer les alarmes analogiques

Pour supprimer une alarme analogique, modifiez le code de programme suivant :
private void AnalogAlarmDelete()

{
//Delete Analog Alarm
hmiSoftware = GetHmiSoftware();
AnalogAlarm analogAlarm = analogAlarms.Find("Alarm_1");
if (analogAlarm != null)
{
analogAlarm.Delete();
}
}
Énumérer des alarmes analogiques

Modifiez le code de programme suivant pour énumérer des alarmes analogiques :
private void AnalogAlarmBrowse()

{
//Browse Analog Alarms
foreach (AnalogAlarm analogAlarm in analogAlarms)
{
//work with analog alarms.
}
//Other way to get alarm by using Find function on Alarm Composition. AnalogAlarm
analogAlarmObj = analogAlarms.Find("Alarm_1");
}
Accéder aux propriétés d'alarmes analogiques

Modifiez le code de programme suivant pour définir et appeler les propriétés d'alarmes
analogiques :
private void AnalogAlarmPropertiesAcess()

{
AnalogAlarm analogAlarm = analogAlarms.Find("Alarm_1");
int id = analogAlarm.Id
analogAlarm.Id = 10;
int priority = analogAlarm.Priority; analogAlarm.Priority = 7;
analogAlarm.Area = "Area_1";
string area = analogAlarm.Area;
analogAlarm.Name = "NewAlarm";
string name = analogAlarm.Name;
}

7.18.4.2 Utilisation des alarmes de bit individuels
Introduction
Pendant l'utilisation de TIA Portal Openness, les alarmes de bit vous permettent d'exécuter les
actions suivantes :
● Créer des alarmes de bit
● Supprimer les alarmes de bit
● Énumérer des alarmes de bit
● Accéder aux propriétés d'alarmes de bit
Propriétés
Les propriétés suivantes sont prises en charge par les alarmes analogiques :

EventText MultilingualText Indique l'événement/ le texte R/W
de l'alarme
Id uint32 Indique le numéro permettant R/W
d'identifier l'alarme. Il s'agit
d'une valeur unique pour cha‐
que alarme de bit.
AlarmClass String Indique la classe d'alarmes R/W
Name String Indique le nom de l'alarme R/W
Priority byte Indique la priorité de l'alarme R/W
Origin String Indique l'origine de l'alarme R/W
Area String Indique la zone à l'origine de R/W
l'alarme
RaisedStateTag String Indique la variable ayant dé‐ R/W
clenché l'alarme
RaisedStateTagBitNumber uint32 Bit de déclenchement dans la R/W
variable de déclenchement
TriggerMode HmiDiscreteAlarmTiggerMo‐ Indique le mode de déclen‐ R/W
de chement de l'alarme de bit
InfoText MultilingualText Affiche un texte d'information R/W
AlarmParameterTags Object Dans un tableau de dix para‐ R/W
mètres, la variable indiquant
le paramètre de l'alarme Cha‐
que paramètre utilise le nom
de variable comme chaîne de
caractère. Ces paramètres
peuvent être utilisés dans le
texte de l'alarme.
EventText1 MultilingualText Texte d'événement de HmiDi‐ R/W
screteAlarm
screteAlarm


screteAlarm
screteAlarm
screteAlarm
screteAlarm
screteAlarm
screteAlarm
screteAlarm
Condition
Code de programme
Vous pouvez modifier et utiliser l'exemple de code de programme lors de l'utilisation des
alarmes.
Créer des alarmes de bit

Modifiez le code de programme suivant pour créer une alarme de bit :
HmiSoftware hmiSoftware = ...;

DiscreteAlarm discreteAlarm = discreteAlarms.Create("Alarm_1");
Supprimer les alarmes de bit

Modifiez le code de programme suivant pour supprimer une alarme de bit :
public void Delete()

//User wants to delete a discrete alarm with the alarm name Alarm_1
{
HmiSoftware hmiSoftware = ...:
DiscreteAlarm discreteAlarm = discreteAlarms.Find("Alarm_1");
discreteAlarm.Delete();
}
Énumérer des alarmes de bit

Modifiez le code de programme suivant pour énumérer des alarmes de bit :
private void DiscreteAlarmBrowse()

{
//Browse Discrete Alarms
foreach (DiscreteAlarm discreteAlarm in discreteAlarms)
{
//work with discrete alarms.
}
//Other way to get alarm by using Find function on Alarm Composition.
DiscreteAlarm discreteAlarmObj = discreteAlarms.Find("Alarm_1");
}
Accéder aux propriétés d'alarmes de bit

Modifiez le code de programme suivant pour accéder aux propriétés d'alarmes de bit :

DiscreteAlarm discreteAlarm = hmiSoftware.DiscreteAlarms[0];
int id = discreteAlarm.Id;
discreteAlarm.Id = 10;
int priority =discreteAlarm.Priority;

discreteAlarm.Priority = 7;
discreteAlarm.area = "Aread1";
string area = discreteAlarm.Area;
discreteAlarm.Name = "NewAlarm";
string name = discreteAlarm.Name;

7.18.4.3 Utilisation des classes d'alarmes
Introduction
Lors de l'utilisation de TIA Portal Openness, les classes d'alarmes vous permettent d'exécuter
les actions suivantes :
● Créer des classes d'alarmes
● Supprimer les classes d'alarmes
● Énumérer des classes d'alarmes
● Accéder aux propriétés de classes d'alarmes
Propriétés
Les propriétés suivantes sont prises en charge par les classes d'alarmes :

Name String Nom de la classe d'alarmes En fonction du type de classe
d'alarmes (système/utilisa‐
teur)
Priority byte Priorité de la classe d'alarmes R/W
IsSystem Bool Indique si la classe d'alarmes R
est définie par le système
StateMachine HmiAlarmStateMachine Indique l'état de la machine En fonction du type de classe
pour la classe d'alarmes d'alarmes (système/utilisa‐
teur)
RaisedState HmiRaisedState État alarme apparaissante ou R
déclenchée
RaisedState.BackColor Color Indique la couleur d'arrière- R/W
plan
RaisedState.TextColor Color Indique la couleur d'arrière- R/W
plan
RaisedState.Flashing Bool Indique le clignotement R/W
ClearedState HmiClearedState Indique l'état alarme appa‐ R
raissante, disparaissante ou
supprimée
ClearedState.BackColor Color Indique la couleur d'arrière- R/W
plan
ClearedState.TextColor Color Indique la couleur du texte R/W
ClearedState.Flashing Bool Indique le clignotement R/W
AcknowledgedState HmiAcknowledgedState Indique l'état acquitter alarme R
apparaissante ou alarme ap‐
paraissante acquitée
AcknowledgedState.BackCo‐ Color Indique la couleur d'arrière- R/W
lor plan
AcknowledgedState.TextCo‐ Color Indique la couleur du texte R/W
lor
AcknowledgedState.Flashing Bool Indique le clignotement R/W


AcknowledgedClearedState HmisAcknowledgedClea‐ Indique l'état alarme appa‐
redState raissante, acquitter disparais‐
sante ou acquittée/supprimée
AcknowledgedClearedSta‐ Color Indique la couleur d'arrière- R/W
te.BackColor plan
AcknowledgedClearedSta‐ Color Indique la couleur du texte R/W
te.TextColor
AcknowledgedClearedSta‐ Bool Indique le clignotement R/W
te.Flashing
Id uint32 Indique l'ID identifiant la clas‐ R
se d'alarmes. Il s'agit d'une
valeur unique pour chaque
classe d'alarmes.
Log System.String Archive de la classe d'alar‐ R/W
mes
CommonAlarmClass System.String Classe générale d'alarmes R
Condition
Code de programme
Vous pouvez modifier et utiliser l'exemple de code de programme suivant lors de l'utilisation
des classes d'alarmes.
Créer des classes d'alarmes

Modifiez le code de programme suivant pour créer une classe d'alarmes :
private void AlarmClassCreate()

{
//Create Alarm Class
AlarmClassComposition alarmClasses = hmiSoftware.AlarmClasses;
AlarmClass alarmClass = alarmClasses.Create("AlarmClass_1");
}
Supprimer les classes d'alarmes

Modifiez le code de programme suivant pour supprimer une classe d'alarmes :

//User wants to delete an alarm class with the alarm name AlarmClass_1
{
AlarmClass alarmClass = alarmClasses.Find("AlarmClass_1");
alarmClass.Delete();
}
Énumérer des classes d'alarmes

Modifiez le code de programme suivant pour énumérer des classes d'alarmes :
//User wants to enumerate all discrete alarms of device with following code
{
foreach (AlarmClass alarmClass in alarmClasses)
}
{
...
}
Accéder aux propriétés de classes d'alarmes

Modifiez le code de programme suivant pour accéder aux propriétés de classes d'alarmes :

AlarmClass alarmClass = hmiSoftware.AlarmClasses.Find("MostCritical");
int priority = alarmClass.Priority;

alarmClass.Priority = 10;
alarmClass.Acknowledgement = StateMachine.AlarmWithDualModeAcknowledgement;
alarmClass.IncomingOutgoingAcknowledgeStatus.BackColor = Color.Red;
alarmClass.IncomingOutgoingAcknowledgeStatus.TextColor = Color.Black;
alarmClass.IncomingOutgoingAcknowledgeStatus.Flashing = true;

7.18.5 Logs
7.18.5.1 Utilisation d'archives de données
Introduction
Lors de l'utilisation de TIA Portal Openness, les archives de données vous permettent
● Créer une archive de données
● Supprimer une archive de données
● Énumérer une archive de données
● Accéder aux propriétés d'archives de données
Propriétés
Les propriétés suivantes sont prises en charge par une archive de données :

Name String Indique le nom de l'archive de données R/W
Set‐ LogSettings Propriété complexe. A les propriétés R
tings (StorageFolder, LogMaxSize et LogTi‐
mePeriod) comme membres définis‐
sant l'archive.
StorageFolder String Chemin pour l'archivage R/W
LogMaxSize Unsigned int Définit la taille maximale de l'archive R/W
sur le support de mémoire en mégaoc‐
tets
LogTimePeriod LogDuration Définit la période maximale qu'englobe R/W
l'archive
StorageDevice DeviceNode Définit le support de données R/W
Seg‐ LogSegment Propriété complexe. A les propriétés
ment (SegmentMaxSize, StartTime et Seg‐
mentTimePeriod) comme membres
définissant le segment.
SegmentMaxSi‐ Unsigned int Définit la taille maximale du segment R/W
ze d'archive en mégaoctets
SegmentStartTi‐ DateTime Définit l'heure précise du début du seg‐ R/W
me ment
SegmentTime‐ SegmentDuration Définit la période maximale qu'englobe R/W
Period le segment d'archive
Backup LogBackup Propriété complexe. A les propriétés R
(PrimaryPath et BackupMode) comme
membres définissant la sauvegarde de
l'archive.
BackupMode HmiBackupMode Définit le mode de sauvegarde R/W
PrimaryPath String Chemin pour la sauvegarde R/W

Condition
Code de programme
des archives de données.
Créer une archive de données
Modifiez le code de programme suivant pour créer une archive de données :
private void DatalogCreate()

{
//Create Datalog
DataLogComposition dataLogs = hmiSoftware.DataLogs;
DataLog dataLog = dataLogs.Create("Datalog_1");
}
Supprimer une archive de données

Modifiez le code de programme suivant pour supprimer une archive de données :
private void DatalogDelete()

{
//user wants to delete datalog with name "Datalog_1"
DataLog dataLog = dataLogs.Find("Datalog_1");
dataLog.Delete();
}
Énumérer une archive de données

Modifiez le code de programme suivant pour énumérer une archive de données :
private void DatalogBrowse()

{
//Browse Datalog.
foreach (DataLog dataLog in dataLogs)
{
//work with data log.
}
//Other way to get data log by using Find function on datalog Composition.
DataLog dataLogObj = dataLogs.Find("Datalog_1");
}
Accéder aux propriétés d'archives de données

Vous pouvez modifier et utiliser le code de programme suivant pour accéder aux propriétés
d'archives de données :
private void DatalogProperties()

{
//Set/Get Data Log properties.
DataLog dataLog = dataLogs.Find("Datalog_1");
string name = dataLog.Name;
dataLog.Settings.StorageFolder = @"C:\Logs\Log";
dataLog.Settings.LogMaxSize = Int32.MaxValue;
dataLog.Settings.LogMaxSize = 2000;
LogDuration duration = dataLog.Settings.LogTimePeriod;
double durationInDouble = duration.GetDoubleLogDuration();
string durationInString = duration.GetStringLogDuration();
duration.Days = 7;
duration.Hours = 23;
duration.Minutes = 50;
duration.Seconds = 0;
duration.Ticks = 1;
//Method to set log duration.
duration.SetLogDuration(10, 12, 4, 5, 0);
dataLog.Backup.BackupMode = BackupMode.NoBackup;
dataLog.Backup.BackupMode = BackupMode.PrimaryPath;
dataLog.Backup.PrimaryPath = @"C:\Logs\Backup";
dataLog.Segment.SegmentMaxSize = 500;
dataLog.Segment.SegmentStartTime = DateTime.Now;
dataLog.Segment.SegmentStartTime = DateTime.Now.Date;
}

7.18.5.2 Utilisation d'archives d'alarmes
Introduction
Lors de l'utilisation de TIA Portal Openness, les archives d'alarmes vous permettent d'exécuter
● Créer une archive d'alarmes
● Supprimer une archive d'alarmes
● Énumérer une archive d'alarmes
● Accéder aux propriétés d'archives d'alarmes
Propriétés
Les propriétés suivantes sont prises en charge par une archive d'alarmes :

Name String Indique le nom de l'archive d'alarmes R/W
Settings LogSettings Propriété complexe. A les propriétés R
(StorageFolder, LogMaxSize et LogTi‐
mePeriod) comme membres définis‐
sant l'archive.
StorageFolder String Chemin pour l'archivage R/W
LogMaxSize Unsigned int Définit la taille maximale de l'archive R/W
sur le support de mémoire en mégaoc‐
tets
LogTimePe‐ LogDuration Définit la période maximale qu'englobe R/W
riod l'archive
Segment LogSegment Propriété complexe. A les propriétés
(SegmentMaxSize, StartTime et Seg‐
mentTimePeriod) comme membres
définissant le segment.
SegmentMax‐ Unsigned int Définit la taille maximale du segment R/W
Size d'archive en mégaoctets
SegmentStart‐ DateTime Définit l'heure précise du début du seg‐ R/W
Time ment
SegmentTi‐ SegmentDuration Définit la période maximale qu'englobe R/W
mePeriod le segment d'archive
Backup LogBackup Propriété complexe. A les propriétés R
(PrimaryPath et BackupMode) comme
membres définissant la sauvegarde de
l'archive.
BackupMode HmiBackupMode Définit le mode de sauvegarde R/W
PrimaryPath String Chemin pour la sauvegarde R/W

Condition
Code de programme
des archives d'alarmes.
Créer des archives d'alarmes
Modifiez le code de programme suivant pour créer une archive d'alarmes :
private void AlarmLogCreate()

{
//Create Alarmlog
AlarmLogComposition alarmLogs = hmiSoftware.AlarmLogs;
AlarmLog alarmLog = alarmLogs.Create("Alarmlog_1");
}
Supprimer des archives d'alarmes

Modifiez le code de programme suivant pour supprimer une archive d'alarmes :
private void AlarmLogDelete()

{
//User wants to delete alarm log with name "Alarmlog_1"
AlarmLog alarmLog = alarmLogs.Find("Alarmlog_1");
alarmLog.Delete();
}
Énumérer des archives d'alarmes

Modifiez le code de programme suivant pour énumérer des archives d'alarmes :
private void AlarmLogBrowse()

{
//Browse alarm log.
foreach (AlarmLog alarmLog in alarmLogs)
{
//work with alarm log.
}
//Other way to get alarmlog by using Find function on alarmlog Composition.
AlarmLog alarmLogObj = alarmLogs.Find("Alarmlog_1");
}
Accéder aux propriétés d'archives d'alarmes

Vous pouvez modifier et utiliser le code de programme suivant pour accéder aux propriétés
d'archives d'alarmes :
private void AlarmLogProperties()

{
//Set/Get alarm log properties.
AlarmLog alarmLog = alarmLogs.Find("Alarmlog_1");
string name = alarmLog.Name;
alarmLog.Settings.StorageFolder = @"C:\Logs\Log";
alarmLog.Settings.LogMaxSize = Int32.MaxValue;
alarmLog.Settings.LogMaxSize = 2000;
LogDuration duration = alarmLog.Settings.LogTimePeriod;
double durationInDouble = duration.GetDoubleLogDuration();
string durationInString = duration.GetStringLogDuration();
duration.Days = 7;
duration.Hours = 23;
duration.Minutes = 50;
duration.Seconds = 0;
duration.Ticks = 1;
//Log duration can be set by using function also.
duration.SetLogDuration(10, 12, 4, 5, 0);
alarmLog.Backup.BackupMode = BackupMode.NoBackup;
alarmLog.Backup.BackupMode = BackupMode.PrimaryPath;
alarmLog.Backup.PrimaryPath = @"C:\Logs\Backup";
alarmLog.Segment.SegmentMaxSize = 500;
alarmLog.Segment.SegmentStartTime = DateTime.Now;
alarmLog.Segment.SegmentStartTime = DateTime.Now.Date;
}
Voir aussi

7.18.5.3 Utilisation de variables d'archive
Introduction
Lors de l'utilisation de TIA Portal Openness, les variables d'archive vous permettent d'exécuter
● Créer une variable d'archive
● Supprimer une variable d'archive
● Énumérer une variable d'archive
● Accéder aux propriétés de variables d'archive
Propriétés
Les propriétés suivantes sont prises en charge par une variable d'archive :

AggregationDelay System.TimeSpan Valeur pour le retard d'agré‐ R/W
gation
AggregationMode HmiAggregationMode Valeur pour le mode d'agré‐ R/W
gation
Cycle System.String Cycle d'archivage de la varia‐ R/W
ble d'archive
CycleFactor System.UInt32 Valeur du facteur de cycle R/W
d'archivage
DataLog System.String Archive de données de la va‐ R/W
riable d'archive
HighLimit System.Object Valeur limite supérieure de la R/W
variables d'archive
LimitScope HmiLimitScope Limitation de la portée de la R/W
variable d'archive
LoggingMode HmiLoggingMode Mode de journalisation de la R/W
variable d'archive
LowLimit System. Object Valeur limite inférieure de la R/W
variable d'archive
Name System.string Nom de la variable d'archive R/W
SmoothingDeltaValue System.Double Delta de la variable d'archive R/W
SmoothingMaxTime System. TimeSpan Durée maximale de la varia‐ R/W
ble d'archive
SmoothingMinTime System.TimeSpan Durée minimale de la varia‐ R/W
ble d'archive
SmoothingMode HmiSmoothingMode Mode de lissage de la varia‐ R/W
ble d'archive
Source System.string Source de la variable d'archi‐ R/W
ve


TriggerMode HmiTriggerMode Mode de déclenchement de R/W
la variable d'archive
TriggerTag System.String Valeur de la variable de dé‐ R/W
clenchement
TriggerTagBitNumber System.UInt32 Valeur de TriggerTagBitNum‐ R/W
ber
Condition
Code de programme
Vous pouvez modifier et utiliser l'exemple de code de programme suivant lors de l'utilisation de
variables d'archive.
Créer des variables d'archive
Vous pouvez modifier et utiliser le code de programme suivant pour créer des variables
d'archive.
private void LoggingTagCreate()

{
//Create Logging Tag for given tag.
//Tag_1 exists in TIA project.
HmiTag hmiTag = hmiTags.Find("Tag_1");
LoggingTagComposition loggingTags = hmiTag.LoggingTags;
LoggingTag loggingTag = loggingTags.Create("LoggingTag_1");
}
Supprimer des variables d'archive

Modifiez le code de programme suivant pour supprimer une variable d'archive :
private void LoggingTagDelete()

{
//user wants to delete Logging tag with name "LoggingTag_1" for tag "Tag_1";
//LoggingTag_1 exists in TIA project.
LoggingTag loggingTag = loggingTags.Find("LoggingTag_1");
loggingTag.Delete();
}
Énumérer des variables d'archive

Modifiez le code de programme suivant pour énumérer des variables d'archive :
private void LoggingTagBrowse()

{
foreach (LoggingTag loggingTag in loggingTags)
{
//...
}
LoggingTag loggingTagObj = loggingTags.Find("LoggingTag_1");
}

Accéder aux propriétés de variables d'archive

Vous pouvez modifier et utiliser le code de programme suivant pour accéder aux propriétés de
variables d'archive :
private void LoggingTagProperties()

{
//Set/Get LoggingTag properties.
LoggingTag loggingTag = loggingTags.Find("LoggingTag_1");
string name = loggingTag.Name;
SmoothingMode smoothingMode = loggingTag.SmoothingMode;

loggingTag.SmoothingMode = SmoothingMode.SwingingDoor;
LimitScope limitScope = loggingTag.LimitScope;

loggingTag.LimitScope = LimitScope.WithinLimits;
string lowLimit = loggingTag.LowLimit;

loggingTag.LowLimit = "-32768";
string highLimit = loggingTag.HighLimit;

loggingTag.HighLimit = "-3";
TimeSpan smotthingMinTime = loggingTag.SmoothingMinTime;

TimeSpan tsMin = TimeSpan.Parse("500");
loggingTag.SmoothingMinTime = tsMin;
TimeSpan smotthingMaxTime = loggingTag.SmoothingMaxTime;

TimeSpan tsMax = TimeSpan.Parse("1000");
loggingTag.SmoothingMaxTime = tsMax;
double smoothingDeltaValue = loggingTag.SmoothingDeltaValue;

loggingTag.SmoothingDeltaValue = 5;
string dataLog = loggingTag.DataLog;

loggingTag.DataLog = "Datalog_1";
}
Voir aussi

7.18.6 Variables et tables de variables
7.18.6.1 Utilisation des tables des variables
Introduction
Lors de l'utilisation de TIA Portal Openness, les tables des variables vous permettent
● Création des tables des variables
● Supprimer les tables des variables
● Énumérer des tables des variables
● Accéder aux propriétés de tables des variables
Propriétés
Les propriétés suivantes sont prises en charge par une table des variables :

Name String Indique le nom de l'alarme R/W
Tags HmiTagComposition Liste des variables R
Condition
Code de programme
des tables des variables.
Création des tables des variables
Modifiez le code de programme suivant pour créer une table des variables :
private void TagTableCreate()

{
//Create Tag Table
HmiTagTableComposition tagTables = hmiSoftware.HmiTagTables;
HmiTagTable hmiTagTable = tagTables.Create("TagTable_1");
}
Supprimer les tables des variables

Modifiez le code de programme suivant pour supprimer une table des variables :
private void TagTableDelete()

{
//User wants to delete tag table with name "TagTable_1"
HmiTagTable tagTable = tagTables.Find("TagTable_1");
tagTable.Delete();
}
Énumérer des tables des variables

Modifiez le code de programme suivant pour énumérer des tables des variables :
private void TagTableBrowse()

{
//Browse Tag Tables
foreach (HmiTagTable tagTable in tagTables)
{
//Work with tag table
}
//Other way to get tag table by using Find function on tag table Composition.
HmiTagTable tagTableObj = tagTables.Find("TagTable_1");
}
Accéder aux propriétés de tables des variables

Modifiez le code de programme suivant pour accéder aux propriétés d'une table des variables :
private void TagTableProperties()

{
//Set/Get Tag Table properties.
HmiTagTable tagTable = tagTables.Find("TagTable_1");
tagTable.Name = "NewTagTable";
string name = tagTable.Name;
}

7.18.6.2 Utilisation de variables IHM
Introduction
Lors de l'utilisation de TIA Portal Openness, les variables IHM vous permettent d'exécuter les
actions suivantes :
● Créer des variables IHM
● Supprimer des variables IHM
● Énumérer des variables IHM
● Accéder à des variable IHM
● Accéder aux propriétés de variables IHM
● Utilisation du type de données UDT pour des variables
● Propriétés de variables membres d'UDT
Propriétés
Les propriétés suivantes sont prises en charge par une variable IHM :

AccessMode HmiAccessMode Mode d'accès de la variable R/W
IHM
AcquisitionCycle String Attribut pour le cycle d'acqui‐ R/W
sition
AcquisitionMode HmiTagAcquisitionMode Mode d'acquisition de la va‐ R/W
riable IHM
Comment MultilingualText Appeler/définir le commentai‐ R/W
re de la variable
Connection String Liaison IHM R/W
DataType String Type de données de la varia‐ R/W
ble
MaxLength UInt32 HMI-Variable DataType‐ R/W
Length
DisplayName MultilingualText Interroger/définir le nom de la R/W
variable
Address String HMI-Variable Addressattribut R/W
InitialMinValue LowerRange Valeur limite inférieure R
Name String Nom de la variable IHM R/W
Persistent Boolean Attribut persistance R/W
PlcName String Attribut nom d'API R
PlcTag String Attribut variable API R/W
InitialValue Object Attribut de la valeur initiale R/W
SubstituteValue HmiSubstituteValue Valeur de remplacement R
UpdateId UInt32 Attribut ID d'actualisation R/W
InitialMaxValue UpperRange Valeur limite supérieure R


TagTableName String Nom de la table des variables R
à laquelle appartient la varia‐
ble
HmiDataType String Type de données IHM de la
variable
LinearScaling Boolean Mise à l'échelle linéaire R/W
HmiStartValue Object R/W
HmiEndValue Object R/W
PlcStartValue Object R/W
PlcEndValue Object R/W
Les propriétés suivantes sont disponibles dans la plage des valeurs inférieures/supérieures :

Value Object Valeur supérieure/inférieure R/W
ValueType HmiLimitValueType Interroger et déterminer le ty‐ R/W
pe de la valeur
Les propriétés suivantes sont disponibles pour une valeur de remplacement :

Value Object Interroger et déterminer R/W
le type de la valeur
SubstituteValueUsage Hmi SubstituteValueU‐ Indique quand la valeur R/W
sage de remplacement est
utilisée
Condition
● Accès à un objet logiciel IHM
Code de programme
variables IHM.
Créer des variables IHM

Modifiez le code de programme suivant pour créer une variable IHM :
private void CreateTag(

{
//Four ways to create tag.

//1. Create tag by accessing HmiTags property at HmiSoftware level, by using Create method
with two parameters.
HmiTagComposition hmiTags1 = hmiSoftware.HmiTags;
//TagTable1 exists in TIA project.
HmiTag hmiTag1 = hmiTags1.Create("Tag1", "TagTable1");
//2. Create tag by accessing HmiTags property at HmiSoftware level, by using Create method
with single parameter.
HmiTag hmiTag2 = hmiTags1.Create("Tag2");
//Tags will be created in default tag table.
//3. Creation of tag by accessing HmiTags property at Tag Table, by using Create method with
two parameters.
//Tag creation will fail and it will result in recoverable exception,
HmiTagComposition hmiTags2 = hmiSoftware.HmiTagTables.Find("Default tag table").HmiTags;
HmiTag hmiTag3 = hmiTags2.Create("Tag_3", "TableTableName");
//4. Create tag by accessing HmiTags property at Tag Table, by using Create method with
single parameter.
HmiTag hmiTag4 = hmiTags2.Create("Tag_4");
}
Supprimer des variables IHM

Modifiez le code de programme suivant pour supprimer une variable IHM :
private void DeleteTag()

{
//1. Delete tag at HmiSoftware level.
HmiTagComposition hmiTags1 = hmiSoftware.HmiTags;
HmiTag hmiTag1 = hmiTags1.Find("Tag1");
hmiTag1.Delete();
//2. Delete tag at tag table level.
HmiTag hmiTag2 = hmiTags1.Find("Tag2");
hmiTag2.Delete();
}
Énumérer des variables IHM

Modifiez le code de programme suivant pour énumérer des variables IHM :
private void BrowseTag()

{
//1. User can navigate all tag of device with following code.
{
//...
}
//2. User can navigate all tags of given tag table with following code.
foreach (HmiTag hmiTag2 in hmiTags2)
{
//...
}
}
Accéder à des variable IHM

Modifiez le code de programme suivant pour accéder à une variable IHM particulière via son
nom :
private void AccessTag()

{
//User can search tag present in UA device with following code.
HmiTag hmiTag3 = hmiSoftware.HmiTags.Find("Tag1");
}
Modifiez le code de programme suivant pour accéder à une variable IHM via le nom de tableau :
{
// User can search tag present in given tag table with following code.
HmiTag hmiTag4 = hmiSoftware.HmiTagTables.Find("Default tag
table").HmiTags.Find("Tag1");
}

Accéder aux propriétés de variables IHM

Modifiez le code de programme suivant pour accéder aux propriétés de variables IHM :
private void TagProperties()

{
//Tag_1 exists in TIA device project.
HmiTag hmiTag = hmiSoftware.HmiTags.Find("Tag_1");
//Enumeration type properties
AccessMode accessMode = hmiTag.AccessMode;
UpdateScope scope = hmiTag.UpdateScope;
//Substitute value depends on data type of tag.
hmiTag.SubstituteValue.Value = "144";
hmiTag.SubstituteValue.OnCommunicationError = false;
hmiTag.Name = "Tag_2";
//Assign valid cycle name.
hmiTag.AcquisitionCycle = "T1s";
hmiTag.DataType = "int";
hmiTag.PlcTag = "PlcTag_1";
//Start value depends on data type of tag.
hmiTag.StartValue = "1";
hmiTag.LowerLimit.ValueType = LimitValueType.Constant;
hmiTag.LowerLimit.Value = "HmiTag_1";
//Comment property (multilingual text)
string culture = "en-US";
//get the language based on given culture. Culture is standard and it should have correct
value.
Language language = GetDeviceProject().LanguageSettings.Languages.Find(new
System.Globalization.CultureInfo(culture));
//get comment as multilingual text.
MultilingualText multiLingualComment = hmiTag.Comment;
//get all text items from comment property.
MultilingualTextItemComposition texts = multiLingualComment.Items;
//find text from text list based on language.
MultilingualTextItem textItemEnglish = texts.Find(language);
//get value in selected culture.
string commentEng = textItemEnglish.Text;
}
Utilisation du type de données UDT pour des variables

Vous pouvez modifier et utiliser le code de programme suivant pour affecter le type de données
UDT à des variables et accéder à des variables membres :
Affecter le type de données UDT à des variables IHM
Modifiez le code de programme suivant pour affecter le type de données UDT à des variables
IHM sans liaison :

HmiTagComposition tags = hmiSoftware.HmiTags;
tags[0].Data Type = @"\Project library\Types\New folder_3\HmiUdt_string\V
0.0.1";

Modifiez le code de programme suivant pour affecter le type de données UDT à des variables
IHM avec liaison :

tags[0].Connection = "Connection_1";
tags[0].Data Type = @"\Project library\Types\New folder_3\HmiUdt_string\V
0.0.1";
Remarque
Vous pouvez utiliser des chemins complets pour affecter des UDT à l'IHM
Modifiez le code de programme suivant pour affecter le type de données PLC UDT à des
variables IHM avec liaison :

tags[0].Connection = "HMI_Connection_1";
tags[0].Data Type = "PlcTag_1";
Accéder à des propriétés de membre du type de données pour variable IHM

Modifiez le code de programme suivant pour accéder à des propriétés de membre du type de
données pour variable IHM
private static void GetProperties(HmiTagComposition hmiTags)

{
{
switch(hmiTag.TagType)
{
case HmiTagType.Simple
Console.WriteLine("Name : "+ hmiTag.Name);
GetSimpleTagProperties(HmiTag hmiTag)
break;
case HmiTagType.UDT;
case HmiTagType.Array;
GetProperties(hmiTag.Members); //recursive call to current function.
break;
}
}
}
private static void GetSimpleTagProperties(HmiTag hmiTag)
{
Console.WriteLine("Name : " +hmiTag.Name);
Console.WriteLine("Date type : " +hmiTag.DataType);
// List the properties of hmi tag
//
//...
}
private static void GetProperties(HmiTag hmiTag.Members)
{
Console.Writeline("Name : " +hmiTag.Members.Name);
Console.Writeline("Date type: " +hmiTag.Members.DataType);
// List the properties of hmi tag members
//...
//...
}
Propriétés de variables membres d'UDT

Vous pouvez modifier et utiliser le code de programme suivant pour définir et appeler les
propriétés de variables membres de type de données UDT (User Defined Datatype) :

Modifiez le code de programme suivant pour définir les propriétés de variables membres de
type de données défini par l'utilisateur :
public HmiTag GetTag()

{
DeviceItem deviceItem = Tiaproject.Devices[0].DeviceItems[1];
SoftwareContainer softCont = deviceItem.GetService<SoftwareContainer>();
HmiSoftware hmiSoftware = softCont.Software as HmiSoftware;
if (hmiSoftware == null)
{
Device device = Tiaproject.Devices.Find("PC-System_1");
DeviceItem deviceItem1 = device.DeviceItems[1];
SoftwareContainer softCont1 = deviceItem1.GetService<SoftwareContainer>();
hmiSoftware = softCont1.Software as HmiSoftware;
}
HmiTagComposition tagComposition = hmiSoftware.Tags;
var tag = tagComposition.Create("Test_Tag");
return tag;
}
public void ReadWrite_HMIUDTTagDisplayNamePropertyWithInternalConn_Succeeds()
{
HmiTag tag = GetTag();
tag.DataType = "HmiUdt_1_WithInternalConn V 0.0.1";
for (int i = 0; i < tag.Members.Count; i++)
{
for (int j = 0; j < tag.Members[i].DisplayName.Items.Count; j++)
{
tag.Members[i].DisplayName.Items[j].Text = "DisplayNameTest" + j;
Console.WriteLine("Display Name : ", tag.Members[i].DisplayName.Items[j].Text);
}
}
}
/// <summary>
/// HMI UDT Tag Display Name Property with S7 1500 PLC Connection.
/// </summary>
public void ReadWrite_HMIUDTTagDisplayNamePropertyWithS71500_Succeeds()
{
tag.Connection = "HMI_Connection_1";
tag.DataType = "HmiUdt_1_WithS71500Conn V 0.0.1";
{
for (int j = 0; j < tag.Members[i].DisplayName.Items.Count; j++)
{
tag.Members[i].DisplayName.Items[j].Text = "DisplayNameTest" + j;
Console.WriteLine("Display Name : ", tag.Members[i].DisplayName.Items[j].Text);
}
}
}

Modifiez le code de programme suivant pour accéder aux propriétés de variables membres de
type de données défini par l'utilisateur :
public HmiTag GetTag()

{
DeviceItem deviceItem = Tiaproject.Devices[0].DeviceItems[1];
SoftwareContainer softCont = deviceItem.GetService<SoftwareContainer>();
HmiSoftware hmiSoftware = softCont.Software as HmiSoftware;
if (hmiSoftware == null)
{
Device device = Tiaproject.Devices.Find("PC-System_1");
DeviceItem deviceItem1 = device.DeviceItems[1];
SoftwareContainer softCont1 = deviceItem1.GetService<SoftwareContainer>();
hmiSoftware = softCont1.Software as HmiSoftware;
}
HmiTagComposition tagComposition = hmiSoftware.Tags;
var tag = tagComposition.Create("Test_Tag");
return tag;
}
public void Read_HMIUDTTagNamePropertyWithInternalConn_Succeeds()
{
tag.DataType = "HmiUdt_1_WithInternalConn V 0.0.1";
{
var name = tag.Members[i].Name;
Console.WriteLine("Name : ", name );
}
}
/// <summary>
/// HMI UDT Tag Display Name Property with S71500 connection
/// </summary>
public void Read_HMIUDTTagNamePropertyWithS71500Conn_Succeeds()
{
tag.Connection = "HMI_Connection_1";
tag.DataType = "HmiUdt_1_WithS71500Conn V 0.0.1";
{
var name = tag.Members[i].Name;
Console.WriteLine("Name : ", name );
}
}
Voir aussi

7.18.6.3 Utilisation de variables système
Introduction
Lors de l'utilisation de TIA Portal Openness, les variables système vous permettent d'exécuter
● Accéder à une variable système
● Accéder aux propriétés de variables système
Propriétés
Les propriétés suivantes sont prises en charge par une variable système :

Name String Indique le nom de la variable R
système
DataType String Indique le type de données R
de la variable système
Condition
Code de programme
Accéder à une variable système
Modifiez le code de programme suivant pour accéder à une variable système particulière via
son nom :
private void SystemTagName()

{
HmiSystemTagComposition hmiSystemTags = hmiSoftware.HmiSystemTags;
//Find system tag by using its name.
HmiSystemTag hmiSystemTagObj = hmiSystemTags.Find("@UserName");
}

Accéder aux propriétés de variables système

Modifiez le code de programme suivant pour accéder aux propriétés de variables système :
private void SystemTagProperties()

{
HmiSystemTagComposition hmiSystemTags = hmiSoftware.HmiSystemTags;
HmiSystemTag hmiSystemTag = hmiSystemTags.Find("@UserName");
string name = hmiSystemTag.Name;
string dataType = hmiSystemTag.DataType;
}
Voir aussi
7.18.7 Connexions
7.18.7.1 Utilisation de compositions
Introduction
Lors de l'utilisation de TIA Portal Openness, les connexions vous permettent d'exécuter les
actions suivantes :
● Établir des connexions
● Supprimer des connexions
● Énumérer des connexions
● Accéder aux propriétés de connexions
Propriétés
Les propriétés suivantes sont prises en charge par les liaisons IHM :

Name String Nom de la liaison R/W
DisabledAtStartup Boolean La connexion est au runtime R/W
d'abord en ligne ou non.
CommunicationDriver String Indique le pilote de communi‐ R/W
cation
Node String Affiche le point d'accès du R
partenaire (p. ex. API)
Partner String Nom de l'API connecté R


Station String Nom de la station à laquelle R
l'API est affecté
Comment String Commentaire éventuel R/W
InitialAddress String Paramètres de la connexion R/W
tels que le type d'interface
(DP, TCP/IP), l'adresse IP, le
châssis, etc.
Condition
Code de programme
connexions.
Établir des connexions
Modifiez le code de programme suivant pour créer une connexion :
private void ConnectionCreate()

{
//Create Connection
HmiConnectionComposition connections = hmiSoftware.HmiConnections;
HmiConnection connection = connections.Create("Connection_1");
}
Supprimer des connexions

Modifiez le code de programme suivant pour supprimer une connexion :
private void ConnectionDelete()

{
//User wants to delete connection with name "Connection_1"
HmiConnection connection = connections.Find("Connection_1")
connection.Delete();
}
Énumérer des connexions

Modifiez le code de programme suivant pour énumérer des connexions :
private void ConnectionBrowse()

{
//Browse Connections
foreach (HmiConnection connection in connections)
{
//Work with connections
}
//Other way to get connection by using Find function on connection Composition
HmiConnection connectionObj = connections.Find("Connection_1");
}

Accéder aux propriétés de connexions

Modifiez le code de programme suivant pour accéder aux propriétés de connexions :
private void ConnectionProperties()

{
//Set/Get Connection properties.
HmiConnection connection = connections.Find("Connection_1");
string name = connection.Name;
connection.Name = "Connection_2";
bool online = connection.DisabledAtStartup;
connection.DisabledAtStartup = true;
string node = connection.Node;
string station = connection.Station;
string partner = connection.Partner;
string communicationDriver = connection.CommunicationDriver;
connection.CommunicationDriver = "SIMATIC S7 300/400";
//valid Initial Address strings
connection.InitialAddress = "PlcRack = 4";
connection.InitialAddress = "HostAddress = 127.157.2.2";
connection.InitialAddress = "hostAddress = 127.157.2.2";//key name is case insensitive so
it is valid"
connection.IntialAddress = "CommunicationInterface = Industrial Ethernet; HostAddress =
127.157.8.1; HostAccessPoint = S7ONLINE; PlcExpansionSlot = 1; PlcRack = 1;
PlcIsCyclicOperation = false";
connection.InitialAddress = "CommunicationInterface = Industrial Ethernet; HostAddress =
127.157.8.1; HostAccessPoint = S7ONLE; PlcRack = 5; PlcIsCyclicOperation = true";
//Below are Wrong Value or Wrong Formats which leads to recorverable exceptions.
//Wrong Value
connection.InitialAddress = null;
connection.InitialAddress = string.Empty;
connection.InitialAddress = "HostAddress = 127.157.2.2.1";
connection.InitialAddress = "HostAddress = 127.157.2.2.1; PlcRack = 5";
//key value format is not followed.
connection.InitialAddress = "HostAccessPoint = S7ONINE; PlcAddress * 155.166.8.2;
PlcExpansionSlot ; 1; PlcRack = 5; PlcIsCyclicOperation = true";
//semicolon with empty key value pair
connection.InitialAddress = ";;CommunicationInterface = Industrial Ethernet; HostAddress =
127.157.0.1";
connection.InitialAddress = ";CommunicationInterface = Industrial Ethernet; HostAddress =
127.157.0.1";
connection.InitialAddress = "CommunicationInterface = Industrial Ethernet; HostAddress =
127.157.0.1;";
connection.InitialAddress = "CommunicationInterface = Industrial Ethernet;; HostAddress =
127.157.0.1;";
connection.CommunicationDriver = "SIMATIC S7 1500";
//wrong as PlcRack is not valid key / property for Simatic S71500 connection.
connection.InitialAddress = "PlcRack = 4";
}

7.18.8 Paramètres d'exécution
7.18.8.1 Utilisation de paramètres d'exécution
Introduction
Lors de l'utilisation de TIA Portal Openness, les paramètres d'exécution vous permettent
● Lire/écrire des paramètres d'exécution
Propriétés
Les propriétés suivantes sont prises en charge par les paramètres Runtime :

HmiSoftware.RuntimeSet‐ HmiRuntimeSetting Objet Paramètre Runtime R
tings
RuntimeSettings.StartScreen String Écran initial R/W
RuntimeSettings.OperateA‐ Boolean Indique qu'un appareil donné R/W
sOpcServer servira de serveur OPC
RuntimeSettings.Langua‐ HmiLanguageAndFont Asso‐ Liste des langues et des poli‐ R
geAndFonts ciation ces
RuntimeSettings. Langua‐ Boolean Activer/désactiver la langue R/W
geAndFonts [index].Enable de Runtime
RuntimeSettings.Langua‐ Boolean Indique la langue d'archivage R/W
geAndFonts [index].Enable‐ en runtime
ForLogging
RuntimeSettings. Langua‐ Short Envoie l'ordre de transmis‐ R
geAndFonts [index].Order sion des polices sur l'appareil
RuntimeSettings. Langua‐ String Nom de la langue R
geAndFonts [index].Langua‐
ge
RuntimeSettings. Langua‐ String Famille de polices prédéfinie R
geAndFonts [index].Fixed‐ disponible pour la configura‐
Font1 tion des polices
RuntimeSettings.Langua‐ String Famille de polices prédéfinie R
geAndFonts[index].Fixed‐ disponible pour la configura‐

Conditions
● Accès à l'objet logiciel IHM
Code de programme
private void RuntimeSettingsPropertiesAcccess()

{
hmiSoftware.RuntimeSettings.OperateAsOpcServer = true;
hmiSoftware.RuntimeSettings.StartScreen = "Screen_1";
hmiSoftware.RuntimeSettings.LanguageAndFonts[0].Enable = true;
hmiSoftware.RuntimeSettings.LanguageAndFonts[0].EnableForLogging = true;
}
7.18.9 Vues et dynamisations
7.18.9.1 Utilisation de vues
Introduction
Lors de l'utilisation de TIA Portal Openness, les vues vous permettent d'exécuter les actions
suivantes :
● Créer des vues
● Supprimer des vues
● Énumérer des vues
● Accéder aux propriétés de vues
Conditions

Code de programme
vues.
Créer des vues

Modifiez le code de programme suivant pour créer des vues :
HmiSoftware hmisoftware = GetHMISoftware();

HmiScreenComposition objScreens = hmisoftware.Screens;
HmiScreen objHmiScreen = objScreens.Create("TestScreen");
Recoverable Exception est déclenchée quand la méthode Create est appelée avec un nom de
vue pour lequel une vue existe déjà dans TIA Portal.
Supprimer des vues

Modifiez le code de programme suivant pour supprimer des vues :

//Case 1
if (objHmiScreen != null)
{
objHmiScreen.Delete();
}
//Case 2
objScreens.Create("TestScreen1");
IEngineeringObject alarmClassEnggObj = (IEngineeringObject)objScreens[0];
if (alarmClassEnggObj != null)
{
alarmClassEnggObj.Invoke("Delete", null);
}
Énumérer des vues

Modifiez le code de programme suivant pour énumérer toutes les vues d'un appareil :
HmiSoftware hmiSoftware = GetHMISoftware();

HmiScreenComposition objScreens = hmiSoftware.Screens;
foreach (HmiScreen ObjHmiScreen in objScreens);
{
//work with Screens
}

Modifiez le code de programme suivant pour rechercher des vues dans des listes de vues à
l'aide du nom :
HmiScreen objHmiScreen = objScreens.Find("TestScreen3");
Modifiez le code de programme suivant pour trouver des vues dans des listes de vues à l'aide
de l'indice :
HmiScreen objHmiScreen = hmiSoftware.Screens[0];
Modifiez le code de programme suivant pour déterminer avec la méthode Contains si un objet
graphique précis se trouve dans une liste d'objets graphiques :

HmiScreen screen1 = objScreen.Create("TestScreen1");
bool isExist = objScreens.Contains(screen1);
Accéder aux propriétés de vues

Modifiez le code de programme suivant pour définir et appeler les propriétés d'une vue :
HmiSoftware hmisoftware = GetHmiSoftware();

objHmiScreen.Width = 50;
objHmiScreen.ScreenNumber = 1;
objHmiScreen.BackGraphic = "DownArrow";
objHmiScreen.DisplayName.Items[0].Text = "screen";
objHmiScreen.Name = "ScreenTest";
objHmiScreen.Enabled = true;
objHmiScreen.Height = 123;
Modifiez et utilisez le code de programme suivant pour appeler avec GetAttributes ( ) toutes les
propriétés d'une vue :

HmiScreen objHmiScreen = objscreens.Create("TestScreen");
List<string> getlststring = new List<string>();
{
"AlternateBackColor", "BackColor", "BackFillPattern", "BackGraphic",
"BackGraphicStretchMode", "BackgroundFillMode", "DisplayName", "Dynamization", "Enabled",
"EnabledExplicitRelease", "Height", "HorizontalAlignment", "Layers", "Name", "Parent",
"ScreenElements", "ScreenItems", "ScreenNumber", "VerticalAlignment", "Width"
};
var getallpropValue = objHmiScreen.GetAttributes(getlsstring);

Modifiez le code de programme suivant pour définir et appeler avec SetAttributes( ) toutes les
propriétés d'une vue :

HmiScreen objHmiScreen = objscreens.Create("TestScreen");
Dictionary<string, object> setPropertyName = new Dictionary<string, object>();
setPropertyName.Add("AlternateBackColor", Color.Aqua);
setPropertyName.Add("BackColor", Color.Aqua);
setPropertyName.Add("BackFillPattern", HmiFillPattern.GradientHorizontalTricolor);
setPropertyName.Add("BackGraphic", "DownArrow");
setPropertyName.Add("BackGraphicStretchMode", HmiGraphicStretchMode.Fill);
setPropertyName.Add("BackgroundFillMode", HmiBackgroundFillMode.Screen);
setPropertyName.Add("DisplayName", "AnalogAlarmByDiffMethod");
setPropertyName.Add("Enabled", "AnalogAlarmByDiffMethod");
setPropertyName.Add("EnabledExplicitRelease", "AnalogAlarmByDiffMethod");
setPropertyName.Add("Height", "AnalogAlarmByDiffMethod");
setPropertyName.Add("HorizontalAlignment", "AnalogAlarmByDiffMethod");
setPropertyName.Add("Name", "AnalogAlarmByDiffMethod");
setPropertyName.Add("ScreenNumber", "AnalogAlarmByDiffMethod");
setPropertyName.Add("VerticalAlignment", "AnalogAlarmByDiffMethod");
setPropertyName.Add("Name", "AnalogAlarmByDiffMethod");
setPropertyName.Add("Width", "AnalogAlarmByDiffMethod");
objHmiScreen.SetAttributes(setPropertyName);

Modifiez et utilisez le code de programme suivant pour appeler la valeur d'une propriété avec
les IEngineeringObject's GetAttribute :

HmiScreen objHmiScreen = objScreens.Create("Testscreen");
IEngineeringObject obj = objHmiScreen;
Color clraltntvbk = (Color)obj.GetAttribute("AlternateBackColor");
Color clrbk = (Color)obj.GetAttribute("BackColor");
HmiFillPattern filptrns = (HmiFillPattern)obj.GetAttribute("BackFillPattern");
string bkgrphic = (string)obj.GetAttribute("BackGraphic");
HmiGraphicStretchMode strmode =
(HmiGraphicStretchMode)obj.Getattribute("BackGraphicStretchmode");
HmiBackgroundFillMode bkgrndfilmode = (HmiBackgroun
dFillMode)obj.GetAttribute("BackgroundFillMode");
string dsplyName = (string)obj.GetAttribute("DisplayName");
DynamizationBaseComposition dymztns =
(DynamizationBaseComposition)obj.GetAttribute("Dynamizations");
b00l enble = (b00l)obj.GetAttritute("Enabled");
SomRef objsom = (SomRef)obj.GetAttribute("EnableExplicitRelease");
uint fight = (uint)obj.GetAttribute("Height");
HmiHorizontalAlignment hrzntl =
(HmiHorizontalAlIgnment)obj.GetAttribute("HorizontalAlignment");
HmiverticalAlignment vrtcle = (HmiverticalAlignment)obj.GetAttribute("VerticalAlignment");
HmiLayerPartComposition objlyrs = (HmiLayerPartComposition)Obj.GetAttribute("layers");
string name = (string)obj.GetAttribute("Name");
IEngineeringObject objparen = (IEngineeringobject)obj.GetAttribute("Parent");
HmiscreenElementBaseComposition objelemnt =
(HmiscreenElementBaseComposition)obj.GetAttribute("ScreenElements");
HmiScreenItemBaseComposition objitems =
(HmiScreenItemBaseComposition)obj.GetAttribute("ScreenItems");
byte scrnmumber = (byte)obj.GetAttribute("ScreenNumber");
uint width = (uint)obj.GetAttribute(Width");

Modifiez le code de programme suivant pour détecter si toutes les propriétés ont des valeurs
valides :
HmiSoftware hmiSoftware = GetHMISoftware ();

HmiScreen objHmiScreen = hmiSoftware.Screens.Create("HmiScreen_1");
objHmiScreen.DisplayName.Items[0].Text = GetMorethan512BoundaryString();
IList<IValidator> objectsToValidate = new List<IValidator>();
foreach (var item in hmiSoftware.Screens)
{
objectsToValidate.Add(item);
}
{
{
{
foreach (var errormasage in errornotification.Errors)
{
Console.WriteLine(errormasage);
}
}
}
}
Remarque
Lors de la définition de propriétés, si la valeur ne peut pas être définie par l'opération d'écriture,
une Recoverable exception est déclenchée.
7.18.9.2 Objets graphiques de base
Utilisation d'objets graphiques de base
Introduction
Lors de l'utilisation de TIA Portal Openness, les objets graphiques de base vous permettent
● Créer des objets graphiques (de base)
● Supprimer des objets graphiques (de base)
● Énumérer des vues (de base)

Les objets graphiques de base ci-dessous sont pris en charge par TIA Portal Openness.
Tableau 7-1 Types et espace(s) de noms
Objet graphique Classe Espace(s) de noms

Ligne HmiLine Siemens.Engineering.HmiUnified.UI.Shapes
Ligne polygonale HmiPolyline Siemens.Engineering.HmiUnified.UI.Base
Polygone HmiPolygon
Ellipse HmiEllipse
Segment d'ellipse HmiEllipseSeg‐
ment
Segment de cercle HmiCircleSegment
Arc d'ellipse HmiEllipticalArc
Arc de cercle HmiCircularArc
Cercle HmiCircle
Rectangle HmiRectangle
Vue de graphique HmiGraphicView
Conditions
● Il existe un accès à l'objet logiciel IHM
Code de programme
d'objets graphiques de base.
Créer des objets graphiques (de base)

Modifiez le code de programme suivant pour créer des objets graphiques de base :

HmiScreen hmiScreen = hmiSoftware.Screens.Create("Screen_1");
HmiScreenItemBaseComposition screenitems = hmiSoftware.Screens[0].ScreenItems;
HmiLine hmiLine = screenitems.Create<HmiLine>("ScreenItem_1");
Remarque
L'exemple ci-dessus s'applique à tous les objets graphiques qui ont été définis en haut dans le
tableau de types. La HmiLine doit être définie avec un type/des types qui est/sont défini(s) dans
le tableau "Types et espace(s) de noms".

Recoverable Exception est déclenchée si la méthode Create est appelée avec le nom d'un
objet graphique qui existe déjà dans TIA Portal.
Supprimer des objets graphiques (de base)

Modifiez le code de programme suivant pour supprimer des objets graphiques de base :

//Case 1
HmiScreenItemBaseComposition screenitems = hmiSoftware.Screen[0].ScreenItems;
if (hmiLine != null)
{
hmiLine.Delete();
}
//Case 2
HmiScreen hmiScreen = hmiSoftware.Screens.Create("Scren1");
IEngineeringObject ObjhmiLineEnggObj = hmiLine;
if (ObjhmiLineEnggObj != null)
{
ObjHmiScreenItemssEnggObj.Invoke("Delete", null);
}
Remarque
L'exemple ci-dessus s'applique à tous les objets graphiques qui ont été définis en haut dans le
tableau de types. La HmiLine doit être définie avec un type/des types qui est/sont défini(s) dans
Énumérer des vues (de base)

Modifiez le code de programme suivant pour énumérer tous les objets graphiques d'une vue :

foreach (var item in screenitems)
{
//work with screenitems
}
Modifiez le code de programme suivant pour trouver des objets graphiques dans une liste
d'objets graphiques à l'aide du nom :
HmiScreenItemBase screenitems = hmiSoftware.Screens[0].ScreenItems.Find("ScreenItems_1");

d'objets graphiques à l'aide de l'indice :
HmiScreenItemBase screenitem = hmiSoftware.Screens[0].ScreenItems[0];

HmiLine hmiLine = screenitems.Create<HmiLine>("ScreenItems_1);
bool isexists = screenitems.Contains(hmiLine);
Remarque
L'exemple ci-dessus s'applique à tous les objets graphiques qui ont été définis dans le tableau
de types. La HmiLine doit être définie avec un type/des types qui est/sont défini(s) dans le
tableau "Types et espace(s) de noms".
Voir aussi
Accéder aux propriétés de lignes
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une ligne dans
l'objet graphique.
Les propriétés suivantes d'une ligne sont prises en charge dans l'objet graphique :
Nom de la propriété Type de propriété Accessibilité

X1 int False
Y1 int False
X2 int False
Y2 int False
Enabled Bool True
CurrentQuality HmiQuality False
LineColor Color False
AlternateLineColor Color False
DashType HmiDashType False
EndType HmiLineEndType False
StartType HmiLineStartType False


CapType HmiCapType False
LineWidth byte False
Top int False
Left int False
Width uint False
Height uint False
RotationAngle short False
RotationCenterX float False
RotationCenterY float False
RotationCenterPlacement HmiRotationCenterPlacement False
Opacity float False
Name string False
Visible bool False
TabIndex ushort False
ToolTipText MultilingualText False
Authorization string False
Conditions
● Une vue et un objet graphique sont créés
Voir Utilisation d'objets graphiques de base (Page 328)
Code de programme
Modifiez le code suivant pour accéder aux propriétés de base de lignes :
//Name
var name = hmiline.Name;
hmiline.Name = "Default Value";
//AlternateLineColor
var linecolor = hmiline.AlternateLineColor;
hmiline.AlternateLineColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//Height
var height = hmiline.Height;
hmiline.Height = 100;

Modifiez le code suivant pour accéder à une propriété multilingue :
//ToolTipText
var tooltip = hmiline.ToolTipText;
var tooltiptext = hmiline.ToolTipText.Items[0].Text;
hmiline.ToolTipText.Items[0].Text = "<body>TestforMultilinugualProperty</body>";
Modifiez le code suivant pour accéder à une autre propriété typique de la ligne :
//DashType
var dashtype = hmiline.DashType;
hmiline.DashType = HmiDashType.DashDotDot;
Voir aussi
Utilisation d'objets graphiques de base (Page 328)
Accéder aux propriétés d'une ligne polygonale
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une ligne
polygonale.
Les propriétés suivantes d'une ligne polygonale sont prises en charge dans l'objet graphique :

Enabled Bool False
CurrentQuality HmiQuality True
JoinType HmiLineJoinType False
Top int False
Left int False
Width uint False
Height uint False


Opacity float False
Name string False
Visible bool False
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une ligne
polygonale :
//Name
var name = polyline.Name;
polyline.Name = "Default Value";
//AlternateLineColor
var linecolor = polyline.AlternateLineColor;
polyline.AlternateLineColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//Height
var height = polyline.Height;
polyline.Height = 100;
Modifiez le code de programme suivant pour accéder à une propriété multilingue :
//ToolTipText
var tooltip = polyline.ToolTipText;
var tooltiptext = polyline.ToolTipText.Items[0].Text;
polyline.ToolTipText.Items[0].Text = "TestforMultilingualProperty";

Modifiez le code de programme suivant pour accéder à une autre propriété typique :
//Joint Type
var dashtype = polyline.JoinType;
polyline.JoinType = HmiLineJoinType.Miter;
//Points
var points = polyline.Points;
var point = points[0];
var x = point.X;
point.X = 10;
var y = point.Y;
point.Y = 10;
var newPoint = points.Create(15, 100);
Voir aussi
Accéder aux propriétés d'une ellipse
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une ellipse dans
l'objet graphique.
Les propriétés suivantes d'une ellipse sont prises en charge dans l'objet graphique :

BorderColor Color False
AlternateBorderColor Color False
BackColor Color False
AlternateBackColor Color False
BorderWidth byte False
Enabled Bool False
BackFillPattern HmiFillPattern False
FillLevel byte False
FillDirection HmiFillDirection False
ShowFillLevel bool False
RadiusX uint False
RadiusY uint False


CenterX int False
CenterY int False
Opacity float False
Name string False
Visible bool False
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une ellipse :
//Name
var name = ellipse.Name;
ellipse.Name = "Default Value";
//AlternateBorderColor
var bordercolor = ellipse.AlternateBorderColor;
ellipse.AlternateBorderColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//BorderWidth
var borderwidth = ellipse.BorderWidth;
ellipse.BorderWidth = 10;
//ToolTipText
var tooltip = ellipse.ToolTipText;
var tooltiptext = ellipse.ToolTipText.Items[0].Text;
ellipse.ToolTipText.Items[0].Text = "TestforMultilingualProperty";

Modifiez le code de programme suivant pour accéder à une autre propriété typique d'une
ellipse :
//BackFillPattern
var backfill = ellipse.BackFillPattern;
ellipse.BackFillPattern = HmiFillPattern.GradientBackwardDiagonal;
Voir aussi
Accéder aux propriétés d'un segment d'ellipse
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un segment
d'ellipse.
Les propriétés suivantes d'un segment d'ellipse sont prises en charge dans l'objet graphique :

StartAngle int False
AngleRange int False
RadiusX uint False
RadiusY uint False
CenterX int False
CenterY int False


Opacity float False
Name string False
Visible bool False
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un segment
d'ellipse :
//Name
var name = ellipsesegment.Name;
ellipsesegment.Name = "Default Value";
var bordercolor = ellipsesegment.AlternateBorderColor;
ellipsesegment.AlternateBorderColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//BorderWidth
var borderwidth = ellipsesegment.Height;
ellipsesegment.BorderWidth = 10;
//ToolTipText
var tooltip = ellipsesegment.ToolTipText;
var tooltiptext = ellipsesegment.ToolTipText.Items[0].Text;
ellipsesegment.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//BackFillPattern
var backfill = ellipsesegment.BackFillPattern;
ellipsesegment.BackFillPattern = HmiFillPattern.GradientBackwardDiagonal;

Voir aussi
Accéder aux propriétés d'un segment de cercle
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un segment de
cercle.
Les propriétés suivantes d'un segment de cercle sont prises en charge dans l'objet graphique :

Enabled Bool False
Radius uint False
CenterX int False
CenterY int False
Opacity float False
Name string False
Visible bool False

Conditions
Programme
Modifiez le code de programme suivant pour accéder à une propriété de base d'un segment de
cercle :
//Name
var name = circlesegment.Name;
circlesegment.Name = "Default Value";
var bordercolor = circlesegment.AlternateBorderColor;
circlesegment.AlternateBorderColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//BorderWidth
var borderwidth = circlesegment.BorderWidth;
circlesegment.BorderWidth = 10;
//ToolTipText
var tooltip = circlesegment.ToolTipText;
var tooltiptext = circlesegment.ToolTipText.Items[0].Text;
circlesegment.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//ToolTipText
var tooltip = circlesegment.ToolTipText;
var tooltiptext = circlesegment.ToolTipText.Items[0].Text;
circlesegment.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
Voir aussi

Accéder aux propriétés d'un arc d'ellipse
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un arc d'ellipse.
Les propriétés suivantes d'un arc d'ellipse sont prises en charge dans l'objet graphique :

Enabled Bool False
RadiusX uint False
RadiusY uint False
CenterX int False
CenterY int False
Opacity float False
Name string False
Visible bool False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder à une propriété de base d'arcs d'ellipses :
//Name
var name = ellipticalarc.Name;
ellipticalarc.Name = "Default Value";
//LineColor
var linecolor = ellipticalarc.LineColor;
ellipticalarc.LineColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//LineWidth
var linewidth = ellipticalarc.LineWidth;
ellipticalarc.LineWidth = 10;
//ToolTipText
var tooltip = ellipticalarc.ToolTipText;
var tooltiptext = ellipticalarc.ToolTipText.Items[0].Text;
ellipticalarc.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//CapType
var captype = ellipticalarc.CapType;
ellipticalarc.CapType = HmiCapType.Round;
Voir aussi
Accéder aux propriétés d'un arc de cercle
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un arc de cercle.
Les propriétés suivantes d'un arc de cercle sont prises en charge dans l'objet graphique :



StartType HmiLineEndType False
Enabled Bool False
Radius uint False
CenterX int False
CenterY int False
Opacity float False
Name string False
Visible bool False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder à une propriété de base d'un arc de
cercle :
//Name
var name = circulararc.Name;
circulararc.Name = "Default Value";
//LineColor
var linecolor = circulararc.LineColor;
circulararc.LineColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//LineWidth
var linewidth = circulararc.LineWidth;
circulararc.LineWidth = 10;
//ToolTipText
var tooltip = circulararc.ToolTipText;
var tooltiptext = circulararc.ToolTipText.Items[0].Text;
circulararc.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//CapType
var captype = circulararc.CapType;
circulararc.CapType = HmiCapType.Round;
Voir aussi
Accéder aux propriétés d'un cercle
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un cercle.
Les propriétés suivantes d'un cercle sont prises en charge dans l'objet graphique :



Enabled Bool False
Radius uint False
CenterX int False
CenterY int False
Opacity float False
Name string False
Visible bool False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder à une propriété de base d'un cercle :
//Name
var name = circle.Name;
circle.Name = "Default Value";
//BorderColor
var bordercolor = circle.BorderColor;
circle.BorderColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//BorderWidth
var borderwidth = circle.BorderWidth;
circle.BorderWidth = 10;
//ToolTipText
var tooltip = circle.ToolTipText;
var tooltiptext = circle.ToolTipText.Items[0].Text;
circle.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//DashType
var dashtype = circle.DashType;
circle.DashType = HmiDashType.Solid;
Voir aussi
Accéder aux propriétés d'un rectangle
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un rectangle.
Les propriétés suivantes d'un rectangle sont prises en charge dans l'objet graphique :



Enabled Bool False
Corners HmiCornersPart True
Top int False
Left int False
Width uint False
Height uint False
Opacity float False
Name string False
Visible bool False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder à des propriétés de base :
//Name
var name = rectangle.Name;
rectangle.Name = "Default Value";
//BorderColor
var bordercolor = rectangle.BorderColor;
rectangle.BorderColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//BorderWidth
var borderwidth = rectangle.BorderWidth;
rectangle.BorderWidth = 10;
//ToolTipText
var tooltip = rectangle.ToolTipText;
var tooltiptext = rectangle.ToolTipText.Items[0].Text;
rectangle.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//Corners
var corner = rectangle.Corners;
var bottomleftradius = corner.BottomLeftRadius;
corner.BottomLeftRadius = 50;
var bottomrightradius = corner.BottomRightRadius;
corner.BottomRightRadius = 30;
var topleftradius = corner.TopLeftRadius;
corner.TopLeftRadius = 50;
var toprightradius = corner.TopRightRadius;
corner.TopRightRadius = 30;
Voir aussi
Accéder aux propriétés d'une vue de graphique
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une vue de
graphique.

Les propriétés suivantes d'un rectangle sont prises en charge dans l'objet graphique :

GraphicStretchMode HmiGraphicStretchMode False
Enabled Bool False
Top int False
Left int False
Width uint False
Height uint False
Padding HmiPaddingPart True
Opacity float False
Name string False
Visible bool False
Graphic string False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder à une propriété de base :
//Name
var name = graphicview.Name;
graphicview.Name = "Default Value";
//AlternateBackColor
var backcolor = graphicview.AlternateBackColor;
graphicview.AlternateBackColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//Height
var height = graphicview.height;
graphicview.Height = 10;
//ToolTipText
var tooltip = graphicview.ToolTipText;
var tooltiptext = graphicview.ToolTipText.Items[0].Text;
graphicview.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//Padding
var padding = graphicview.Padding;
var bottom = padding.Bottom;
padding.Bottom = 50;
var left = padding.Left;
padding.Left = 60;
var right = padding.Right;
padding.Right = 70;
var top = padding.Top;
padding.Top = 50;
Voir aussi

7.18.9.3 Objets graphiques élément
Utilisation d'objets graphiques élément
Introduction
Pendant l'utilisation de TIA Portal Openness, les objets graphiques (élément) vous permettent
● Créer un objet graphique (élément)
● Supprimer un objet graphique (élément)
● Énumérer un objet graphique (élément)
Les objets graphiques suivants sont pris en charge par TIA Portal Openness. Utilisez les
espaces de noms et types de données suivants pour accéder aux classes et types de données
en rapport avec des objets graphiques :

Champ d'E/S HmiIOField Siemens.Engineering.HmiUnified.ModernUI.Widgets
Bouton HmiButton Siemens.Engineering.HmiUnified.ModernUI.Base
Commutateur HmiToggleSwitch
Case à cocher HmiCheckBoxGroup
Bargraphe HmiBar
Instrument à aiguille HmiGauge
Curseur HmiSlider
Bouton d'option HmiRadioButtonGroup
Champ de liste HmiListBox
Horloge HmiClock
Champ de texte HmiTextBox
Conditions
Code de programme
d'objets graphiques élément.

Créer des objets graphiques (élément)

Modifiez le code de programme suivant pour créer des objets graphiques élément :

HmiScreenItemBaseComposition screenitems = hmiSoftware.Screen[0].ScreenItems;
HmiIOField hmiIOField = screenitems.Create<HmiIOField>("ScreenItem_1");
Remarque
L'exemple ci-dessus s'applique à tous les objets graphiques définis dans le tableau de types ci-
dessus. Le HmiIOField doit être défini avec un type/des types qui est/sont défini(s) dans le
Supprimer des objets graphiques (élément)

Modifiez le code de programme suivant pour supprimer un objet graphique élément :

//Case 1
HmiIOField hmiIOField = screenitems.Create<HmiIOField>("ScreenItems_1");
if (hmiIOField != null)
{
hmiIOField.Delete();
}
//Case 2
HmiIOField hmiIOField = screenitems.Create<HmiIOField>("ScreenItem_1");
IEngineeringObject ObjhmiIOFieldEnggObj = hmiIOField;
if (ObjhmiIOFieldEnggObj != null)
{
ObjhmiIOFieldEnggObj.Invoke("Delete", null);
}
Remarque

Énumérer des objets graphiques (élément)


{
}
Modifiez le code de programme suivant pour rechercher des objets graphiques dans une liste

HmiIOField hmiIOField = screenitems.Create<HmiIOField>("ScreenItems_1);
bool isexists = screenitems.Contains(hmiIOField);
Remarque
Voir aussi
Accéder aux propriétés d'un champ d'E/S
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un champ d'E/S.

Les propriétés suivantes de champs d'E/S sont prises en charge dans l'objet graphique :

Enabled Bool False
Authorization String True
Font HmiFontPart False
ForegroundColor Color False
Height uint False
HorizontalTextAlignment HmiHorizontalAlignment False
IOFieldType HmiIOFieldType False
Top int False
Left int False
Rotation short False
VisualizeQuality bool False
TextTrimming HmiTextTrimming False
Opacity float False
Name string False
OutputFormat string False
ProcessValue string False
VerticalTextAlignment HmiVerticalAlignment False
Visible bool False
Width uint False
Require Explixit Release bool False
InputBehavior HmiInputBehaviorPart True
Conditions


Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un champ d'E/
S:
//Name
var name = iofield.Name;
iofield.Name = "DefaultName";
var altbackcolor = iofield.AlternateBackColor;
iofield.AlternateBackColor = Color.Beige;
//Height
var height = iofield.Height;
iofield.Height = 100;
//ToolTipText
HmiIOField ioField = createdscreen.ScreenItems.Create<HmiIOField>("hmiIOField");
Language lang = Tiaproject.LanguageSettings.Languages.Find(new CultureInfo(culture));
MultilingualText mltprop = ioField.ToolTipText;
MultilingualTextItemComposition textItemComp = mltprop.Items;
MultilingualTextItem mlttextitem = textItemComp.Find(lang);
mlttextitem.Text = "CommentInEnglish";
Modifiez le code de programme suivant pour accéder à d'autres propriétés typiques :
//Padding
var padding = iofield.Padding;
padding.Left = 60;
padding.Right = 70;
padding.Top = 50;
Voir aussi
Utilisation d'objets graphiques élément (Page 351)

Accéder aux propriétés d'un bouton
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un bouton dans
des objets graphiques.
Les propriétés suivantes d'un bouton sont prises en charge dans des objets graphiques :

AlternateBackgroundColor Color False
Authorization String True
BackgroundColor Color False
Contents HmiContentPart False
Enabled bool False
Height uint False
Top int False
Left int False
Style Item Appearance HmiStyleItem Appearance False
Opacity float False
Name string False
Padding HmiPaddingPart False
Text MultiLingualText True
ToolTipText MultilingualText True
Visible bool False
Width uint False
Require Explixit bool False
AlternateGraphic string False
AlternateText MultiLingualText False

Conditions
Voir Utilisation d'objets graphiques élément (Page 351)
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un bouton :
//Name
var name = hmiButton.Name;
hmiButton.Name = "Default Value";
var altbackcolor = hmiButton.AlternateBackColor;
hmiButton.AlternateBackColor = Color.Beige;
//Height
var height = hmiButton.Height;
hmiButton.Height = 100;
//ToolTipText
Language lang = Tiaproject.LanguageSettings.Languages.Find(new CultureInfo(culture));
MultilingualText mltprop = hmiButton.ToolTipText;
MultilingualTextItemComposition textItemComp = mltprop.Items;
MultilingualTextItem mlttextitem = hmiButton.Find(lang);
mlttextitem.Text = "TestforMultilingualProperty";
//Padding
var padding = hmiButton.Padding;
padding.Left = 60;
padding.Right = 70;
padding.Top = 50;
Voir aussi


Accéder aux propriétés d'un commutateur
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un commutateur
dans des objets graphiques.
Les propriétés suivantes de commutateurs sont prises en charge dans des objets graphiques :

IsAlternateState bool False
Authorization string True
Contents HmiContentPart False
Enabled bool False
Height uint False
Top int False
Left int False
Text MultiLingualText True
Opacity float False
Name string False
Visiblity bool False
Width uint False
AlternateGraphic string False


AlternateText MultiLingualText True
SystemItemClass HmiButtonStyleItemClass True
Remarque
La propriété StyleItemClass étant protégée en écriture, l'appel est pris en charge pour elle
tandis que l'opération d'écriture déclenche une exception.
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un
commutateur :
//Name
var name = toggleswitch.Name;
toggleswitch.Name = "Default Value";
var altbackcolor = toggleswitch.AlternateBackColor;
toggleswitch.AlternateBackColor = Color.Beige;
//Height
var height = toggleswitch.Height;
toggleswitch.Height = 100;
//ToolTipText
var tooltip = toggleswitch.ToolTipText;
var tooltiptext = toggleswitch.ToolTipText.Items[0].Text;
toggleswitch.ToolTipText.Items[0].Text = "TestforMultilingualProperty";

Modifiez le code de programme suivant pour accéder à une autre propriété typique d'un
commutateur :
//Font
var font = toggleswitch.Font;
var italic = font.Italic;
font.Italic = false;
var fontname = font.FontName;
font.FontName = HmiFontName.SimSun;
var size = font.Size;
font.Size = 10.2f;
var stike = font.StrikeOut;
font.StrikeOut = true;
var.underline = font.Underline;
font.Underline = false;
font.Bold = true;
Voir aussi
Accéder aux propriétés de cases à cocher
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une case à
cocher dans des objets graphiques.
Les propriétés suivantes de cases à cocher sont prises en charge dans des objets graphiques :

BorderColor Color True
Content HmiContentPart False
Enabled bool False
Font HmiFontPart True
Height uint False


Top int False
Left int False
Name string False
Opacity float False
Process value string False
SelectionItemHeight uint16 False
SelectionItems HmiSelectionItemPartComposition True
ToolTipText MultilingualText True
Visible bool False
Width uint False
SelectionPosition HmiHorizontalAlignment False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une case à
cocher :
//Name
var name = chkbox.Name;
chkbox.Name = "DefaultName";
var altbackcolor = chkbox.AlternateBackColor;
chkbox.AlternateBackColor = Color.Beige;
//Height
var height = chkbox.Height;
chkbox.Height = 100;
//ToolTipText
var tooltip = chkbox.ToolTipText;
var tooltiptext = chkbox.ToolTipText.Items[0].Text;
chkbox.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
Modifiez le code de programme suivant pour accéder à une autre propriété typique d'une case
à cocher :
//Font
var font = chkbox.Font;
font.Size = 10.2f;
font.Bold = true;
//Selection Items
var selectionItem = chkbox.SelectionItems;
var newselectionitem = selectionItem.Create("NewSelectionItem");
var graphic = newselection.Graphic;
newselectionitem.Graphic = "abcd";
newselectionitem.Isselected = false;
newselectionitem.Text.Item[0].Text = "Testformultilingual";
Voir aussi


Accéder aux propriétés d'un bargraphe
Introduction
L'API TIA Openness V16 vous permet d'appeler et de paramétrer les propriétés de bargraphes
Les propriétés suivantes de bargraphes sont prises en charge dans des objets graphiques :

BarMode HmiBarMode False
Enabled bool False
Label HmiTextPart
Height uint False
StraightScale HmiStraightScalePart
Top int False
Left int False
Name string False
NormalRangeColor Color False
OriginValue double False
PeakIndicators HmiPeakIndicator False
Process Value string False
ProcessValueIndicatorBackColor Color False
ProcessValueIndicatorForeColor Color False
ProcessValueIndicatorMode HmiProcessIndicatorMode False
Opacity float False
ScaleBackColor uint16 False


ScaleForeColor Color False
ShowTrendIndicator bool False
Visible bool False
Width uint False
TrendIndicateColor Color False
Title HmiTextPart True
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un bargraphe :
//Name
var name = bar.Name;
bar.Name = "Default Value";
//RotationCenterPlacement
var rotation = bar.RotationCenterPlacement;
bar.RotationCenterPlacement = HmiRotationCenterPlacement.AbsoluteToContainer;
//Width
var width = bar.Width;
bar.Width = 100;
//ToolTipText
var tooltip = bar.ToolTipText;
var tooltiptext = bar.ToolTipText.Items[0].Text;
bar.ToolTipText.Items[0].Text = "TestforMultilingualProperty";

bargraphe :
//Font
var title = bar.Title;
title.Text.items[0].Text = "teststing";
title.Visible = false;
title.Forecolor = Color.Black;
var font = title.Font;
font.Size = 10.2f;
var underline = font.Underline;
font.Bold = true;
Voir aussi
Accéder aux propriétés d'un instrument à aiguille
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un instrument à
aiguille dans des objets graphiques.
Les propriétés suivantes d'un instrument à aiguille sont prises en charge dans l'objet
graphique :

AlternativebackgroundBackColor Color False
AlternativeBorderColor Color False
RelativeToOrigin bool False


Enabled bool False
Label HmiTextPart True
Height uint False
Top int False
Left int False
Name string False
Opacity float False
ScaleBackgroundColor Color False
ScaleForegroundColor Color False
TrendIndicatorColor Color False
Visible bool False
Width uint False
ToolTipText string False
CurvedScale HmiCurvedScalePart True
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un instrument
à aiguille :
//Name
var name = gauge.Name;
gauge.Name = "Default Value";
//RotationalCenterPlacement
var rotation = gauge.RotationCenterPlacement;
gauge.RotationCenterPlacement = HmiRotationCenterPlacement.AbsoluteToContainer;
//Width
var width = gauge.Width;
gauge.Width = 100;
//ToolTipText
var tooltip = gauge.ToolTipText;
var tooltiptext = gauge.ToolTipText.Items[0].Text;
gauge.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
instrument à aiguille :
//Font
var title = gauge.Title;
font.Size = 10.2f;
font.Bold = true;
Voir aussi

Accéder aux propriétés d'un curseur
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un curseur dans
Les propriétés suivantes de curseurs sont prises en charge dans des objets graphiques :

AlternativeBackColor Color False
BarMode HmiBarMode False
RelativeToOrigin bool False
Enabled bool False
Label HmiTextPart True
Height uint False
Top int False
Left int False
Name string False
Opacity float False
ScaleBackgroundColor Color False
ScaleForegroundColor Color False
TrendIndicatorColor bool False
Visible bool False


Width uint False
ValuePosition HmiSimplePosition False
WriteDuringChange(Write process va‐ bool False
lue Immediatly)
ShowValue bool False
ThumbBackColor color False
ThumbForeColor color False
StraightScale HmiStraightScalePart True
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un curseur :
//Name
var name = slider.Name;
slider.Name = "Default Value";
//RotationalCenterPlacement
var rotation = slider.RotationCenterPlacement;
slider.RotationCenterPlacement = HmiRotationCenterPlacement.AbsoluteToContainer;
//Width
var width = slider.Width;
slider.Width = 100;
//ToolTipText
var tooltip = slider.ToolTipText;
var tooltiptext = slider.ToolTipText.Items[0].Text;
slider.ToolTipText.Items[0].Text = "TestforMultilingualProperty";

Modifiez le code de programme suivant pour accéder à d'autres propriétés typiques d'un
curseur :
//Font
var title = slider.Title;
font.Size = 10.2f;
font.Bold = true;
Voir aussi
Accéder aux propriétés d'un bouton d'option
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un bouton
d'option dans des objets graphiques.
Les propriétés suivantes de boutons d'option sont prises en charge dans des objets
graphiques :



Enabled bool False
Height uint False
Top int False
Left int False
Name string False
SelectionItems IList<IHmiSelectionItemPart> True
SelectorPosition HmiHorizontalAlignment
Opacity float False
Visible bool False
Width uint False
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un bouton
d'option :
//Name
var name = radio.Name;
radio.Name = "Default Value";
var altbackcolor = radio.AlternateBackColor;
radio.AlternateBackColor = Color.Beige;
//Height
var height = radio.Height;
radio.Height = 100;
//ToolTipText
var tooltip = radio.ToolTipText;
var tooltiptext = radio.ToolTipText.Items[0].Text;
radio.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
Modifiez le code de programme suivant pour accéder à d'autres propriétés typiques d'un
bouton d'option :
//Font
var font = radio.Font;
font.Size = 10.2f;
font.Bold = true;
//Selection Items
var selectionItem = radio.SelectionItems;
var graphic = newselectionitem.Graphic;
newselectionitem.IsSelected = false;
newselectionitem.Text.Items[0].Text = "Testformultilingual";
Voir aussi


Accéder aux propriétés d'une zone de liste
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une zone de liste
Les propriétés suivantes de zones de liste sont prises en charge dans des objets graphiques :

Enabled bool False
ForeGroundColor Color False
Top int False
Left int False
Name string False
SelectionItems IList<IHmiSelectionItemPart> True
SelectionMode HmiSelectionMode False
SelectorPosition HmiHorizontalAlignment
Opacity float False
Visible bool False
Width uint False

Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une zone de
liste :
//Name
var name = listbox.Name;
listbox.Name = "Default Value";
var altbackcolor = listbox.AlternateBackColor;
listbox.AlternateBackColor = Color.Beige;
//Height
var height = listbox.Height;
listbox.Height = 100;
//ToolTipText
var tooltip = listbox.ToolTipText;
var tooltiptext = listbox.ToolTipText.Items[0].Text;
listbox.ToolTipText.Items[0].Text = "TestforMultilingualProperty";

Modifiez le code de programme suivant pour accéder à une autre propriété typique d'une zone
de liste :
//Font
var font = listbox.Font;
font.Size = 10.2f;
font.Bold = true;
//Selection Items
var selectionItem = listbox.SelectionItems;
var graphic = newselectionitem.Graphic;
newselectionitem.Isselected = false;
newselectionitem.Text.Item[0].Text = "Testformultilingual";
Voir aussi
Accéder aux propriétés d'un champ de texte
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un champ de
texte dans des objets graphiques.
Les propriétés suivantes de champs de texte sont prises en charge dans des objets
graphiques :

ReadOnly bool False
TextWrapping HmiTextWrapping False
VerticalTextAlignment HmiVerticalAlignment False
HorizontalTextAlignment HmiHorizontalAlignment False
TextTrimming HmiTextTrimming False
ForeColor Color False


Enabled bool False
Height uint False
Top int False
Left int False
Name string False
Opacity float False
Visible bool False
Width uint False
Text MultilingualText True
Conditions

Code de programme
Modifiez le code de programme suivant pour accéder à une propriété de base d'un champ de
texte :
//Name
var name = textbox.Name;
texttbox.Name = "Default Value";
//BorderColor
var bordercolor = textbox.BorderColor;
textbox.BorderColor = Color.FromArgb(0xCC, 0xF0, 0x80, 0x80);
//BorderWidth
var borderwidth = textbox.BorderWidth;
textbox.BorderWidth = 10;
//ToolTipText
var tooltip = textbox.ToolTipText;
var tooltiptext = textbox.ToolTipText.Items[0].Text;
textbox.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
Modifiez le code de programme suivant pour accéder à une autre propriété typique d'un champ
de texte :
//Font
var font = textbox.Font;
font.Size = 10.2f;
font.Bold = true;
Voir aussi

Accéder aux propriétés d'une horloge :
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une horloge dans
Les propriétés suivantes d'une horloge sont prises en charge dans un objet graphique :

AlternativeBackgroundColor Color False
DialBackColor Color False
DialLabelColor Color False
DialMode HmiScaleMode False
DialTickColor Color False
Enabled bool False
Height uint False
Top int False
Left int False
Name string False
ShowHours bool False
ShowMinutes bool False
ShowSeconds bool False
Opacity float False
TimeSource string False
Visiblility bool False
Width uint False
ToolTipText MultiLingualText False
DialLabelFont HmiFontPart True

Conditions
Code de programme
Modifiez le code de programme suivant pour accéder à une propriété de base d'une horloge :
//Name
var name = clock.Name;
clock.Name = "Default Value";
var altbackcolor = clock.AlternateBackColor;
clock.AlternateBackColor = Color.Beige;
//Height
var height = clock.Height;
clock.Height = 100;
//ToolTipText
var tooltip = clock.ToolTipText;
var tooltiptext = clock.ToolTipText.Items[0].Text;
clock.ToolTipText.Items[0].Text = "TestforMultilingualProperty";
//DialLabelFont
var dialfont = clock.DialLabelFont;
dialfont.Italic = false;
var fontname = dialfont.FontName;
dialfont.FontName = HmiFontName.SimSun;
var size = dialfont.Size;
dialfont.Size = 10.2f;
var stike = dialfont.StrikeOut;
dialfont.StrikeOut = true;
var underline = dialfont.Underline;
dialfont.Underline = false;
dialfont.Bold = true;
//ShowHours
var showhour = clock.ShowHours;
clock.ShowHours = false;

Remarque
Lors de la définition de propriétés, si la valeur ne peut pas être définie par l'opération d'écriture,
une Recoverable exception est déclenchée. Si des valeurs en dehors de la plage autorisée ne
sont pas définies, une exception Recoverable est déclenchée. Si ces valeurs sont définies, la
propriété est mise à un état non valide.
Voir aussi
7.18.9.4 Objets graphiques de commande
Utilisation d'objets graphiques de commande
Introduction
Lors de l'utilisation de TIA Portal Openness, les objets graphiques de commande vous
permettent d'exécuter les actions suivantes :
● Créer des objets graphiques (contrôles)
● Supprimer des objets graphiques (contrôles)
● Énumérer des objets graphiques (contrôles)

Les objets graphiques suivants sont pris en charge par TIA Portal Openness. Utilisez les
espaces de noms et types de données suivants pour accéder aux classes et types de données
en rapport avec des objets graphiques :

Vue des alarmes HmiAlarmControl Siemens.Engineering.HmiUnified.ModernUI.Controls
Media Player HmiMediaControl Siemens.Engineering.HmiUnified.ModernUI.Base
Fenêtre de vue HmiScreenWindow
Vue de courbes HmiTrendControl
Table des valeurs HmiTrendCompanion
Vue tabellaire HmiProcessControl
Vue de courbes HmiFunctionTrendControl
f(x)
Navigateur HmiWebControl
Vue Jeu de para‐ HmiDetailedParameter‐
mètres Control
Conditions
Code de programme
d'objets graphiques de commande.
Créer des objets graphiques (contrôles)

Modifiez le code de programme suivant pour créer des objets graphiques de commande :

HmiAlarmControl hmiAlarmControl = screenitems.Create<HmiAlarmControl>("ScreenItem_1");

Remarque
dessus. La HmiAlarmControl doit être définie avec un type/des types qui est/sont défini(s) dans
Supprimer des objets graphiques (contrôles)

Modifiez le code de programme suivant pour supprimer des objets graphiques de commande :

//Case 1
if (hmiAlarmControl != null)
{
hmiAlarmControl Delete();
}
//Case 2
IEngineeringObject ObjhmiAlarmControlEnggObj = hmiAlarmControl;
if (ObjhmiAlarmControlEnggObj != null)
{
ObjhmiAlarmControlEnggObj.Invoke("Delete", null);
}
Remarque
dessus. La HmiAlarmControl doit être définie avec un type/des types qui est/sont défini(s) dans
Énumérer des objets graphiques (contrôle)


{
}

Modifiez le code de programme suivant pour rechercher des objets graphiques dans une liste

HmiAlarmControl hmiAlarmControl = screenitems.Create<HmiAlarmControl>("ScreenItems_1);
bool isexists = screenitems.Contains(hmiAlarmControl);
Remarque
dessus. Le HmiAlarmControl doit être défini avec un type/des types qui est/sont défini(s) dans
Voir aussi
Accéder aux propriétés d'une fenêtre de vue
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une fenêtre de
vue dans des objets graphiques de commande.
Les propriétés suivantes d'une fenêtre de vue sont prises en charge dans des objets
graphiques de commande :

TabIntoWindow bool False
Screen string False
ScreenName string True
ScreenNumber byte True
System byte False


CurrentZoomFactor double False
VerticalScrollBarVisibility HmiScrollBarVisibility False
VerticalScrollBarPosition int False
HorizontalScrollBarVisibility HmiScrollBarVisibility False
HorizontalScrollBarPosition int False
Adaption HmiScreenWindowAdaption False
InteractiveZooming bool True
Caption MultilingualProperty False
WindowFlags HmiWindowFlag False
Icon string False
Top int False
Left int False
Width uint False
Height uint False
RequireExplicitRelease bool False
Name string False
Visible bool False
Enabled bool False
Conditions
Voir Utilisation d'objets graphiques de commande (Page 380)

Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une fenêtre de
vue :
//Width
var autoplay = hmiscreenwindow.Width;
hmiscreenwindow.Width = 1;
//HorizontalScrollBarVisibility
var horizontalscrollbarvisibilityValue = hmiscreenwindow.HorizontalScrollBarVisibility;
hmiscreenwindow.HorizontalScrollBarVisibility = HmiScrollBarVisibility.Visible;
//Name
var name = hmiscreenwindow.Name;
hmiscreenwindow.Name = "DefaultName";
//Caption
var caption = hmiscreenwindow.Caption.Items[0].Text;
hmiscreenwindow.Caption.Items[0].Text = "<body>TestforMultilingualProperty</body>";
Voir aussi
Utilisation d'objets graphiques de commande (Page 380)
Accéder aux propriétés d'un navigateur
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un navigateur
dans des objets graphiques de commande.
Les propriétés suivantes d'un navigateur sont prises en charge dans des objets graphiques de
commande :

Url string False
Icon string False
Top Int False
Left int False
Width uint False


Height uint False
Name string False
Visible bool False
Enabled bool False
ToolBar HmiToolBarPart True
StatusBar HmiStatusBarPart True
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un navigateur :
//Width
var autoplay = hmiwebcontrol.width;
hmiwebcontrol.Width = 1;
//BackColor
var backcolor = hmiwebcontrol.BackColor;
hmiwebcontrol.BackColor = Color.Beige;
//Name
var name = hmiwebcontrol.Name;
hmiwebcontrol.Name = "DefaultName";
//Caption
var caption = hmiwebcontrol.Caption.Items[0].Text;
hmiwebcontrol.Caption.Items[0].Text= "<body>TestforMultilingualProperty</body>";

//Status bar
var statusBar = hmiwebcontrol.StatusBar;
var backColor = statusBar.BackColor;
statusBar.BackColor = Color.Aqua;
var enabled = statusBar.Enabled;
statusBar.Enabled = true;
var visible = statusBar.Visible;
statusBar.Visible = true;
Voir aussi
Accéder aux propriétés d'une vue Jeu de paramètres
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une vue Jeu de
paramètres dans des objets graphiques de commande.
Les propriétés suivantes d'une vue Jeu de paramètres sont prises en charge dans des objets

ParameterSetTypeFixed string False
Icon string False
Top int False
Left int False
Width uint False
Height uint False
Name string False
Visible bool False
Enabled bool False


EditMode HmiEditMode False
TimeZone int False
ParameterView HmiDataGridViewPart True
SelectionBackColor Color False
SelectionForeColor Color False
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une vue Jeu de
paramètres :
//Width
var autoplay = hmidetailedparametercontrol.Width;
hmidetailedparametercontrol.Width = 1;
//BackColor
var backcolor = hmidetailedparametercontrol.BackColor;
hmidetailedparametercontrol.BackColor = Color.Beige;
//Name
var name = hmidetailedparametercontrol.Name;
hmidetailedparametercontrol.Name = "Default";
//Caption
var caption = hmidetailedparametercontrol.Caption.Items[0].Text;
hmidetailedparametercontrol.Caption.Items[0].Text=
"<body>TestforMultilingualProperty</body>";

//Status bar
var statusBar = hmidetailedparametercontrol.StatusBar;
Voir aussi
Accéder aux propriétés d'une vue des alarmes
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une vue des
alarmes dans des objets graphiques de commande.
Les propriétés suivantes d'une vue des alarmes sont prises en charge dans des objets

UseAlarmColors bool False
Filter string False
AlwaysShowRecent bool False
AlarmSourceType HmiAlarmSourceType False
Icon string False
Top Int False
Left int False
Width uint False
Height uint False
Name string False
Visible bool False


Enabled bool False
TimeZone int False
AlarmDefinitionViewSetup HmiVisibleAlarms False
ActiveAlarmsViewSetup HmiVisibleAlarms False
SuppressFlashing bool False
AcknowledgmentFlashingRate HmiFlashingRate False
ResetFlashingRate HmiFlashingRate False
DefaultSortDirection HmiSortDirection False
AlarmView HmiDataGridViewPart True
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une vue des
alarmes :
//Width
var autoplay = hmialarmcontrol.Width;
hmialarmcontrol.Width = 1;
//BackColor
var backcolor = hmialarmcontrol.BackColor;
hmialarmcontrol.BackColor = Color.Beige;
//Name
var name = hmialarmcontrol.Name;
hmialarmcontrol.Name = "DefaultName";

//Caption
var caption = hmialarmcontrol.Caption.Items[0].Text;
hmialarmcontrol.Caption.Items[0].Text = "<body>TestforMultilingualProperty</body>";
//Status bar
var statusBar = hmialarmcontrol.StatusBar;
Voir aussi
Accéder aux propriétés d'une table des valeurs
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une table des
valeurs dans des objets graphiques de commande.
Les propriétés suivantes d'une table des valeurs sont prises en charge dans des objets

TrendCompanionMode HmiTrendCompanionMode False
UseSourceControlTrendColors bool False
ShowAlways bool False
UseSourceControlBackColor bool False
Icon string False
Top int False
Left int False
Width uint False
Height uint False


Name string False
Visible bool False
Enabled bool False
SourceTrendControl string False
TimeZone int False
SnapToSourceControl bool False
TrendRulerView HmiDataGridViewPart True
TrendStatisticAreaView HmiDataGridViewPart True
TrendStatisticResultView HmiDataGridViewPart True
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une table des
valeurs :
//Width
var autoplay = hmitrendcompanion.Width;
hmitrendcompanion.Width = 1;
//BackColor
var backcolor = hmitrendcompanion.BackColor;
hmitrendcompanion.BackColor = Color.Beige;
//Name
var name = hmitrendcompanion.Name;
hmitrendcompanion.Name = "DefaultName";

//Caption
var caption = hmitrendcompanion.Caption.Items[0].Text;
hmitrendcompanion.Caption.Items[0].Text = "<body>TestforMultilingualProperty</
body>";
Modifiez le code de programme suivant pour accéder à d'autres propriétés typiques d'une table
des valeurs :
//Status bar
var statusBar = hmitrendcompanion.StatusBar;
Voir aussi
Accéder aux propriétés d'une vue de courbes
Introduction
courbes dans des objets graphiques de commande.
Les propriétés suivantes d'une vue de courbes sont prises en charge dans des objets

ShowStatisticRulers bool False
AreaSpacing ushort False
Online bool False
ExtendRulerToAxis bool False
Icon string False
Top int False
Left int False


Width uint False
Height uint False
Name string False
Visible bool False
Enabled bool False
TimeZone int False
ShowRuler bool False
ShiftAxes bool False
Legend HmiLegendPart True
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une vue de
courbes :
//Width
var autoplay = hmitrendcontrol.Width;
hmitrendcontrol.Width = 1;
//BackColor
var backcolor = hmitrendcontrol.BackColor;
hmitrendcontrol.BackColor = Color.Beige;
//Name
var name = hmitrendcontrol.Name;
hmitrendcontrol.Name = "DefaultName";

//Caption
var caption = hmitrendcontrol.Caption.Items[0].Text;
hmitrendcontrol.Caption.Items[0].Text = "<body>TestforMultilingualProperty</body>";
//Status bar
var statusBar = hmitrendcontrol.StatusBar;
Voir aussi
Accéder aux propriétés d'un Media Player
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'un Media Player
dans des objets graphiques de commande.
Les propriétés suivantes d'un Media Player sont prises en charge dans des objets graphiques
de commande :

Url string False
AutoPlay bool False
VideoOutput HmiVideoOutput False
Icon string False
Top int False
Left int False
Width uint False
Height uint False


Name string False
Visible bool False
Enabled bool False
EventHandlers HmiMediaControlEventHandlerCompo‐ True
sition
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'un Media
Player :
//Autoplay
var autoplay = hmimediacontrol.AutoPlay;
hmimediacontrol.AutoPlay = true;
//BackColor
var backcolor = hmimediacontrol.BackColor;
hmimediacontrol.BackColor = Color.Beige;
//Name
var name = hmimediacontrol.Name;
hmimediacontrol.Name = "DefaultName";
//Caption
var caption = hmimediacontrol.Caption.Items[0].Text;
hmimediacontrol.Caption.Items[0].Text = "<body>TestforMultilingualProperty</body>";

var statusBar = hmimediacontrol.StatusBar;

Voir aussi
Accéder aux propriétés d'une vue tabellaire
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une vue
tabellaire dans des objets graphiques de commande.
Les propriétés suivantes d'une vue tabellaire sont prises en charge dans des objets graphiques
de commande :

Online bool False
TimeStepSmoothingBase HmiTimeRangeBase False
TimeStepSmoothingFactor int False
Icon string False
Top int False
Left int False
Width uint False
Height uint False
Name string False
Visible bool False
Enabled bool False


TimeZone int False
ProcessView HmiDataGridViewPart True
EventHandlers HmiProcessControlEventHandlerCom‐ True
position
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une vue
tabellaire :
//Width
var autoplay = hmiprocesscontrol.Width;
hmiprocesscontrol.Width = 1;
//BackColor
var backcolor = hmiprocesscontrol.BackColor;
hmiprocesscontrol.BackColor = Color.Beige;
//Name
var name = hmiprocesscontrol.Name;
hmiprocesscontrol.Name = "DefaultName";
//Caption
var caption = hmiprocesscontrol.Caption.Items[0].Text;
hmiprocesscontrol.Caption.Items[0].Text= "<body>TestforMultilingualProperty</
body>";

//status bar
var statusBar = hmiprocesscontrol.StatusBar;
Voir aussi
Accéder aux propriétés d'une vue de courbes f(x)
Introduction
courbes f(x) dans des objets graphiques de commande.
Les propriétés suivantes d'une vue de courbes f(x) sont prises en charge dans des objets

ShowStatisticRulers bool False
AreaSpacing ushort
Online bool
ExtendRulerToAxis bool
Icon string False
Top Int False
Left int False
Width uint False
Height uint False


Name string False
Visible bool False
Enabled bool False
TimeZone int False
ShowRuler bool False
ShiftAxes bool False
Legend HmiLegendPart True
EventHandlers HmiFunctionTrendControl EventHand‐ True
lerComposition
FunctionTrendAreas HmiFunctionTrendAreaPartComposi‐ True
tion
Conditions
Code de programme
Modifiez le code de programme suivant pour accéder aux propriétés de base d'une vue de
courbes f(x) :
//Width
var autoplay = hmifunctiontrendcontrol.Width;
hmifunctiontrendcontrol.Width = 1;
//BackColor
var backcolor = hmifunctiontrendcontrol.BackColor;
hmifunctiontrendcontrol.BackColor = Color.Beige;
//Name
var name = hmifunctiontrendcontrol.Name;
hmifunctiontrendcontrol.Name = "DefaultName";

//Caption
var caption = hmifunctiontrendcontrol.Caption.Items[0].Text;
hmifunctiontrendcontrol.Caption.Items[0].Text =
"<body>TestforMultilingualProperty</body>";
Modifiez le code de programme suivant pour accéder à d'autres propriétés typiques d'une vue
de courbes f(x) :
//Status bar
var statusBar = hmifunctiontrendcontrol.StatusBar;
Code de programme : TrendArea in FunctionTrendControl using part

Modifiez le code de programme suivant pour créer une plage de courbes dans un
HmiFunctionTrendControl utilisant des objets Part :

var screen = hmiSoftware.Screens;
var createdscreen = screen.Create("TestScreen_1");
HmiFunctionTrendControl funtntrend =
hmiSoftware.Screens[0].ScreenItems.Create<HmiFunctionTrendControl>("CTrendControl_1");
HmiFunctionTrendAreaPart part = funtntrend.FunctionTrendAreas.Create("part1");
Modifiez le code de programme suivant pour rechercher une plage de courbes dans un
HmiFunctionTrendAreaPart part = funtntrend.FunctionTrendAreas.Find("part1");
Modifiez le code de programme suivant pour vérifier une plage de courbes dans un

HmiFunctionTrendControl funtntrend =
hmiSoftware.Screens[0].ScreenItems.Create<HmiFunctionTrendControl>("CTrendControl_1");
HmiFunctionTrendAreaPart part = funtntrend.FunctionTrendAreas.Create("part1");
bool bPresent = funtntrend.FunctionTrendAreas.Contains(part);

Voir aussi
7.18.9.5 Objets graphiques Instance de bloc d'affichage
Utilisation d'instances de bloc d'affichage dans des objets graphiques de commande
Introduction
Lors de l'utilisation de TIA Portal Openness, les instances de bloc d'affichage vous permettent
● Créer des instances de bloc d'affichage (contrôles)
● Supprimer des instances de bloc d'affichage (contrôles)
● Énumérer des instances de bloc d'affichage (contrôles)
Conditions
● Le type d'objet d'installation doitr être créé
Code de programme
d'instances de bloc d'affichage.
Créer des instances de bloc d'affichage

Modifiez le code de programme suivant pour créer des objets graphiques instance de bloc
d'affichage :

HmiScreen hmiScreen= hmiSoftware.Screens.Create ("Screen_1");
HmiScreenItemBaseComposition screenitems = hmiSoftware.Screens [0].ScreenItems;
HmiFaceplateContainer faceplate = hmiScreen.ScreenItems.Create<HmiFaceplateContainer>
("abcd");

Recoverable Exception est déclenchée quand la méthode Create est appelée avec un nom de
vue pour lequel une vue existe déjà dans TIA Portal.
Supprimer des instances de bloc d'affichage

Modifiez le code de programme suivant pour supprimer des objets graphiques instance de bloc
d'affichage :
//Case 1
HmiScreen hmiScreen = hmiSoftware.Screens.Create ("Screen_1");
HmiFaceplateContainer faceplate = hmiScreen .ScreenItems.Create<HmiFaceplateContainer>
("abcd");
If (faceplate! = null)
{
faceplate.Delete ();
}
//Case 2
HmiFaceplateContainer faceplate = hmiScreen .ScreenItems.Create<HmiFaceplateContainer>
("abcd");
IEngineeringObject ObjhmiLineEnggObj = faceplate;
if (ObjhmiLineEnggObj != null)
{
ObjhmiLineEnggObj.Invoke ("Delete", null);
}
Énumérer des instances de bloc d'affichage

Modifiez le code de programme suivant pour énumérer des objets graphiques Instance de bloc
d'affichage d'une vue :

{
}
Modifiez le code de programme suivant pour rechercher des instances de bloc d'affichage dans
une liste d'objets graphiques à l'aide du nom :
HmiScreenItemBase screenitems = hmiSoftware.Screens [0].ScreenItems.Find ("ScreenItems_1");
Modifiez le code de programme suivant pour trouver des instances de bloc d'affichage dans
une liste d'objets graphiques à l'aide de l'indice :
HmiScreenItemBase screenitem = hmiSoftware.Screens [0].ScreenItems [0];

Modifiez le code de programme suivant pour déterminer avec Contains si une instance de bloc
d'affichage précise se trouve dans une liste d'objets graphiques :

HmiFaceplateContainer faceplate = screenitems .Create<HmiFaceplateContainer> ("abcd");
bool isexists = screenitems.Contains(faceplate);
Voir aussi
Accéder aux propriétés d'une instance de bloc d'affichage
Introduction
TIA Portal Openness vous permet d'appeler et de paramétrer les propriétés d'une instance de
bloc d'affichage dans des objets graphiques de commande.
Les propriétés suivantes d'une instance de bloc d'affichage sont prises en charge dans des
objets graphiques de commande :
Nom de la propriété Type de données Description Accessibilité

Name System.String Nom de l'instance de bloc d'affi‐ R/W
chage
ContainedType System.String Indique le type de bloc d'affichage R/W
contenu.
Authorization System.String Informations d'autorisation pour R/W
l'instance de bloc d'affichage
Enabled System.Boolean Autoriser commande R/W
CurrentQuality Siemens.Engineer‐ État de la connexion R
ing.HmiUni‐
fied.UI.Enum.HmiQua‐
lity
Height System.UInt32 Indique la hauteur de la fenêtre de R/W
commande
Icon System.String Indique l'icône dans la fenêtre de R/W
commande
Caption Siemens.Engineer‐ Dans le titre d'une fenêtre de vue R
ing.MultilingualTex ou d'un élément de commande de
la fenêtre (repère) du texte à affi‐
cher


RequireExplicitRelease System.Boolean Si elle est définie sur "True", l'objet R/W
graphique configuré dans la vue
(ou dans une vue de niveau supé‐
rieure si elle n'est pas configurée
localement) n'est activé que lors‐
que vous relâchez le bouton de la
souris
TabIndex System.UInt16 Les objets graphiques qui affec‐ R/W
tent un indice de tabulation 0 ne
font pas partie de l'ordre des tabu‐
lations
Visible System.Boolean Indique la visibilité d'un objet gra‐ R/W
phique
Width System.UInt32 Indique la largeur d'une fenêtre de R/W
commande
WindowFlags Siemens.Engineering Indique la configuration de la fenê‐ R/W
miUnified.UI.Enum tre, par exemple ShowCaption,
ShowBorder, AlwaysOnTop.
WindowFlag
Top System.Int32 Indique la valeur de la coordonnée R/W
Y de la fenêtre de commande
Left System.Int32 Indique la valeur de la coordonnée R/W
X de la fenêtre de commande
Interface Siemens.Engineer‐ Interfaces pour blocs d'affichage R
ing.HmiUni‐
fied.UI.Parts.HmiFace‐
plateInterfaceCompos‐
tion
Conditions

Code de programme
Modifiez le code de programme suivant pour appeler les propriétés de l'instance de bloc
d'affichage :
HmiScreen screen = m_hmiSoftware.Screens[0];

HmiFaceplateContainer faceplate = screens[0].ScreenItems[0] as HmiFaceplateContainer;
//Get_Caption
string Caption = faceplate.Caption.Items[0].Text;
Console.WriteLine("Faceplate Caption: " + Caption);
//Get_WindowFlags
HmiWindowFlag WindowFlags = faceplate.WindowFlags;
Console.WriteLine("Faceplate WindowFlags: " + WindowFlags);
//Get_Icon
string Icon = faceplate.Icon;
Console.WriteLine("Faceplate Icon: " + Icon);
//Get_Top
int Top = faceplate.Top;
Console.WriteLine("Faceplate Top: " + Top);
//Get_Left
int Left = faceplate.Left;
Console.WriteLine("Faceplate Left: " + Left);
//Get_Width
uint Width = faceplate.Width;
Console.WriteLine("Faceplate Width: " + Width);
//Get_Height
uint Height = faceplate.Height;
Console.WriteLine("Faceplate Height: " + Height);
//Get_CurrentQuality
HmiQuality CurrentQuality = faceplate.CurrentQuality;
Console.WriteLine("Faceplate CurrentQuality: " + CurrentQuality);
//Get_RequireExplicitRelease
bool RequireExplicitRelease = faceplate.RequireExplicitRelease;
Console.WriteLine("Faceplate RequireExplicitRelease: " + RequireExplicitRelease);
//Get_Authorization
string Authorization = faceplate.Authorization;
Console.WriteLine("Faceplate Authorization: " + Authorization);
//Get_Name
string Name = faceplate.Name;
Console.WriteLine("Faceplate Name : " + Name);
//Get_Visible
bool Visible = faceplate.Visible;
Console.WriteLine("Faceplate Visible: " + Visible);
//Get_Enabled
bool Enabled = faceplate.Enabled;
Console.WriteLine("Faceplate Enabled: " + Enabled);
//Get_TabIndex
ushort TabIndex = faceplate.TabIndex;
Console.WriteLine("Faceplate TabIndex: " + TabIndex);

Modifiez le code de programme suivant pour paramétrer les propriétés de l'instance de bloc
d'affichage :
//Set_Caption:
faceplate.Caption.Items[0].Text = "testCaption";
//Set_WindowFlags
faceplate.WindowFlags = HmiWindowFlag.CanSize;
//Set_Icon
faceplate.Icon = “testCaption”;
//Set_Top
faceplate.Top = 50;
//Set_Left
faceplate.Left = 50;
//Set_Width
faceplate.Width = 50;
//Set_Height
faceplate.Height = 50;
//Set_RequireExplicitRelease
faceplate.RequireExplicitRelease = true;
//Set_Authorization
faceplate.Authorization = Authorization;
//Set_Name
faceplate.Name = “TestName”;
//Set_Visible
faceplate.Visible = true;
//Set_Enabled
faceplate.Enabled = true;
//Set_TabIndex
faceplate.TabIndex = 10;
Remarque
Get - Recoverable exception est déclenchée si le contrôle de cohérence concerné pour la
propriété indiquée échoue. Si les contrôles de cohérence sont absents pendant la définition de
propriétés de l'opération d'écriture, une Recoverable exception est déclenchée.
Voir aussi

Utilisation de la dynamisation et d'événements d'une instance de bloc d'affichage
Introduction
La dynamisation et les objets événements dans les propriétés de bloc d'affichage vous
permettent d'effectuer les actions suivantes en cas d'utilisation de TIA Portal Openness :
● Accéder à la dynamisation (liaisons de variables, animations, scripts locaux) pour les
instances de bloc d'affichage.
● Accéder aux événements d'instances de bloc d'affichage par les scripts et fonctions
système.
● Accéder aux événements propriétés d'une instance de bloc d'affichage.
Conditions
Code du programme : Accéder à la dynamisation des instances de bloc d'affichage

Pour obtenir une description détaillée de l'accès à la dynamisation pour les instances de bloc
d'affichage, référez-vous à Utilisation de la dynamisation pour les vues/objets graphiques
(Page 415).
Code du programme : Accéder aux événements d'instances de bloc d'affichage par les scripts et
fonctions système.
Pour une description détaillée de la manière d'accéder aux événements d'instances de bloc
d'affichage par des scripts et fonctions système, référez-vous à Utilisation de la dynamisation
et des événements pour les vues/objets graphiques via script (Page 412).
Code du programme : Accéder aux événements propriétés d'une instance de bloc d'affichage
Pour une description détaillée de la manière d'accéder aux événements propriétés d'une
instance de bloc d'affichage, référez-vous à Utilisation d'événements pour des vues/objets
graphiques et des propriétés (Page 409).
Voir aussi


Utilisation d'une dynamisation pour des vues/objets graphiques (Page 415)
Utilisation de la dynamisation et des événements pour les vues/objets graphiques via script
(Page 412)
Utilisation d'événements pour des vues/objets graphiques et des propriétés (Page 409)
7.18.9.6 Utilisation d'événements pour des vues/objets graphiques et des propriétés
Introduction
Lors de l'utilisation de TIA Portal Openness, les événements propriétés et les événements pour
des vues et des objets graphiques vous permettent d'exécuter les actions suivantes :
● Créer des événements propriétés
● Énumérer des événements propriétés
● Supprimer des événements propriétés
● Accéder aux propriétés d'événements
● Créer des événements pour des vues et des objets graphiques
● Énumérer des événements pour des vues et des objets graphiques
● Accéder aux propriétés d'événements pour des vues et des objets graphiques
● Supprimer des événements pour des vues et des objets graphiques
Conditions
● TIA Portal Openness est connectée à TIA Portal.
● Accès à un objet logiciel HMI-Unified
Code de programme
d'événements pour des vues/objets graphiques.

Créer des événements propriétés

Modifiez le code de programme suivant pour créer des événements propriétés :
HmiScreen screen = ((HmiSoftware)targetSW).Screens.Create("MyScreen");

HmiCircle hmiCircle = screen.ScreenItems.Create<HmiCircle>("MYCircle");
//Event Creation
PropertyEventHandler propertyEvent = hmiCircle.PropertyEventHandlers.Create("ToolTipText",
PropertyEventType.Change);
Énumérer des événements propriétés

Modifiez le code de programme suivant pour énumérer des événements propriétés :
HmiScreen screen = ((HmiSoftware)targetSW).Screens.Create("MyScreen");

HmiCircle hmiCircle = screen.ScreenItems.Create<HmiCircle>("MYCircle");
var hmiScreenPropeventDyn = screen.PropertyEventHandlers.Create(“Enabled”,
var enabledEvent = screen.PropertyEventHandlers.Find("Enabled", PropertyEventType.Change);
//Event Browse
Console.WriteLine("CountofEventActions"+ screen PropertyEventHandlers.Count.ToString());
Supprimer des événements propriétés

Modifiez le code de programme suivant pour supprimer des événements propriétés :

PropertyEventHandler propertyEvent =
((HmiSoftware)targetSW).Screens[0].ScreenItems[0].PropertyEventHandlers.Create("ToolTipTex
t", PropertyEventType.Change);
var changedEvent = screen.PropertyEventHandlers.Find(“ToolTipText”,
//Event Deletion
changedEvent.Delete();
Accéder aux propriétés d'événements

Modifiez le code de programme suivant pour appeler des propriétés d'un événement :
//Event Get
PropertyEventType eventType = propertyEvent.EventType;
string propertyName = propertyEvent.PropertyName;
IHmiScript hmiScript = propertyEvent.Script;
//Script Action in Event Get
bool hmiScriptEventAsync = hmiScript.Async;
string hmiScriptEventGlobal = hmiScript.GlobalDefinitionAreaScriptCode;
string hmiScriptEventCode = hmiScript.ScriptCode;
HmiValidationResult result = hmiScript.SyntaxCheck();

Créer des événements pour des vues et des objets graphiques

Modifiez le code de programme suivant pour créer l'événement dans la vue ou l'objet au niveau
de l'objet graphique avec le EventHandler :
var screenComp = ((HmiSoftware)targetSWTag).Screens;

HmiScreen screenOne = screenComp.Create("Screen2");
HmiScreenEventHandler screenHandler =
screenOne.EventHandlers.Create(HmiScreenEventType.Unloaded);
Énumérer des événements pour des vues et des objets graphiques

Modifiez le code de programme suivant pour énumérer des vues et des objets graphiques :
public EventHandler Find(string propertyName);

HmiScreenEventHandler screenHandlerSearched =
screenOne.EventHandlers.Find(HmiScreenEventType.Unloaded);
Accéder aux propriétés d'événements pour des vues et des objets graphiques
Modifiez le code de programme suivant pour appeler les propriétés pour des vues et des objets
graphiques :

Console.WriteLine(screenOne.Name + ".EventHandler.EventType - {0}",
screenHandler.EventType);
Console.WriteLine(screenOne.Name + ".EventHandler.Script.Async - {0}",
screenHandler.Script.Async);
Console.WriteLine(screenOne.Name + ".EventHandler.Script.GlobalDefinitionAreaScriptCode -
{0}", screenHandler.Script.GlobalDefinitionAreaScriptCode);
Console.WriteLine(screenOne.Name + ".EventHandler.Script.ScriptCode - {0}",
screenHandler.Script.ScriptCode);
Supprimer des événements pour des vues et des objets graphiques

Modifiez le code de programme suivant pour supprimer des vues et des objets graphiques :
public void Delete ()

HmiScreen hmiscreen = hmisoftware.Screens.Create(Guid.NewGuid().ToString());
var hmiscreenPropEventDyn = hmiscreen.PropertyEventHandlers.Create("Enabled",
var enabledevent = hmiscreen.PropertyEventHandlers.Find("Enabled",
enabledevent.Delete();

Remarque
Create - Recoverable exception est déclenchée quand les événements propriétés et les
événements pour vues et objets graphiques concernés ne sont pas pris en charge pour la
propriété indiquée. Si les contrôles de cohérence sont absents pendant la définition de
propriétés de l'opération d'écriture, une Recoverable exception est déclenchée.
Voir aussi
7.18.9.7 Utilisation de la dynamisation et des événements pour les vues/objets graphiques via
script
Introduction
Lors de l'utilisation de TIA Portal Openness, les scripts pour la configuration de la dynamisation
de propriétés et d'événements pour des vues/objets graphiques vous permettent d'effectuer
● Créer des dynamisations de script
● Énumérer des dynamisations de script
● Supprimer des dynamisations de script
● Accéder aux propriétés de dynamisations de script
● Accéder aux propriétés d'un déclenchement
● Vérifier la syntaxe
Conditions
● Il existe un accès à l'objet logiciel HMI-Unified
Code de programme
dynamisation de script pour des vues/objets graphiques.

Créer des dynamisations de script

Modifiez le code de programme suivant pour créer des dynamisations de script pour une
propriété :
public DynamizationBase Create<DynamizationBase>(string propertyName);

HmiScreen screen = m_hmisoftware.Screen[0];
DynamizationBaseComposition dyns = screen.Dynamizations;
ScriptDynamization scriptDynamic = dyns.Create<ScriptDynamization>("BackColor");
Énumérer des dynamisations de script

Modifiez le code de programme suivant pour énumérer la dynamisation de script d'une
propriété :
public DynamizationBase Find(string propertyName);

if (dyns is ScriptDynamization)
{
ScriptDynamization scriptDynamic = (ScriptDynamization)dyns.Find("BackColor");
}
Supprimer des dynamisations de script

Modifiez le code de programme suivant pour supprimer la dynamisation de script pour une
propriété :

if (dyns is ScriptDynamization)
ScriptDynamization scriptDynamic = (ScriptDynamization)dyns.Find("BackColor");
scriptDynamic.Delete();

Accéder aux propriétés de dynamisations de script

Modifiez le code de programme suivant pour appeler et définir les propriétés de la
dynamisation de script :

foreach (DynamizationBase dynamic in dyns)
{
if (dynamic.DynamizationType == DynamizationType.Script)
{
ScriptDynamization scriptDynamization = (ScriptDynamization)dynamic;
scriptDynamization.Async = true;
scriptDynamization.GlobalDefinitionAreaScriptCode = @"Add(parameter1,parameter2)";
scriptDynamization.ScriptCode = @"
var value;
let tag1 = Tags('Tag_1');
let tagValue1 = tag1.Read();
HMIRuntime.Trace('value of MyTag1: ' + tagValue1);
return value; ";
Trigger triggerObj = scriptDynamization.Trigger;
}
}
Accéder aux propriétés d'un déclenchement

Modifiez le code de programme suivant pour appeler et définir les propriétés d'un
déclenchement :

{
{
// Property write
scriptDynamization.Trigger.Type = TriggerType.CustomCycle;
scriptDynamization.Trigger.CustomDuration = "T500ms";
scriptDynamization.Trigger.Tags = new List<string>() { "Tag_1" };
// Property read
Console.WriteLine(scriptDynamization.Trigger.Type);
Console.WriteLine(scriptDynamization.Trigger.CustomDuration);
Console.WriteLine(scriptDynamization.Trigger.Tags);
}
}

Contrôle de syntaxe
Modifiez le code de programme suivant pour vérifier avec l'action de dynamisation de script
(méthode) SyntaxCheck la syntaxe du code du script ou du code d'un script global.

{
{
scriptDynamization.ScriptCode = @"
var value;let tag1 = Tags('Tag_1');
let tagValue1 = tag1.Read();
HMIRuntime.Trace('value of MyTag1: ' + tagValue1);
return value; ";
HmiValidationResult syntaxCkResult = scriptDynamization.SyntaxCheck();
IEnummerable<string> error = syntaxCkResult.Errors;
IEnumerable<string> warnings = syntaxCkResult.Warning;
}
}
Remarque
Create - Recoverable exception est déclenchée lorsque la dynamisation concernée pour la
propriété indiquée n'est pas prise en charge. Si les contrôles de cohérence sont absents
pendant la définition de propriétés de l'opération d'écriture, une Recoverable exception est
déclenchée.
Voir aussi
7.18.9.8 Utilisation d'une dynamisation pour des vues/objets graphiques
Introduction
Lors de l'utilisation de TIA Portal Openness, la fonction de dynamisation des vues et des objets
graphiques vous permet d'exécuter les actions suivantes :
● Créer une dynamisation pour une propriété
● Énumérer une dynamisation pour une propriété
● Supprimer une dynamisation pour une propriété
● Accéder à des propriétés communes de la dynamisation
● Accéder aux propriétés de la dynamisation de variables

● Accéder aux propriétés de la dynamisation du clignotement

● Accéder aux propriétés de la dynamisation de la liste des ressources
Remarque
Pour accéder à la dynamisation pour une propriété au niveau de l'objet Part, vous devez
accéder à l'objet Part correspondant du contrôle. Pour plus d'informations sur les Part,
voir Accéder aux propriétés d'une vue de courbes (Page 79).
Conditions
Code de programme
dynamisations pour des vues/objets graphiques.
Créer une dynamisation pour une propriété

Modifiez le code de programme suivant pour créer la dynamisation pour une propriété :

// Flashing dynamization
FlashingDynamization FlashingDyn = dyns.Create<FlashingDynamization>("BackColor");
// ResourceList dynamization
ResourceListDynamization ResListDyn = dyns.Create<ResourceListDynamization>("DisplayName");
// Tag dynamization
TagDynamization tagDyn = dyns.Create<TagDynamization>("Width");
Énumérer une dynamisation pour une propriété

Modifiez le code de programme suivant pour énumérer la dynamisation pour une propriété :

// Flashing dynamization
FlashingDynamization FlashDyn = (FlashingDynamization)dyns.Find("BackColor");
// ResourceList dynamization
ResourceListDynamization resourceDyn = (ResourceListDynamization)dyns.Find("DisplayName");
// Tag dynamization
TagDynamization tagDyn = (TagDynamization)dyns.Find("Width");

Supprimer une dynamisation pour une propriété

Modifiez le code de programme suivant pour supprimer la dynamisation d'une propriété :
public void Delete ()

DynamizationBase dynamization = dyns.Find("BackColor");
dynamization.Delete();
Accéder à des propriétés communes de la dynamisation

Modifiez le code de programme suivant pour appeler les propriétés communes de la
dynamisation :
HmiSoftware m_hmiSoftware = ..;

DynamizationBaseComposition screenDynamizations = m_hmiSoftware.Screens[0].Dynamizations;
DynamizationBase screenDynamization = screenDynamizations.Find("BackColor");
string propertyName = screenDynamization.PropertyName;
DynamizationType dynamizationType = screenDynamization.DynamizationType;
Accéder aux propriétés de la dynamisation de variables

dynamisation de variables :

TagDynamization tagDynamization = (TagDynamization)screen.Dynamizations.Find("Width");
foreach (DynamizationBase dynamization in screen.Dynamizations)
{
if (dynamization.DynamizationType == DynamizationType.Tag)
{
TagDynamization TagDynamization = (TagDynamization)dynamization;
TagDynamization.Tag = "HmiTagName";
TagDynamization.UseIndirectAddressing = true;
TagDynamization.ReadOnly = true;
}
}

Accéder aux propriétés de la dynamisation du clignotement

dynamisation du clignotement :

{
if (dynamization.DynamizationType == DynamizationType.Flashing)
{
FlashingDynamization flashingDynamization = (FlashingDynamization)dynamization;
flashingDynamization.AlternateColor = Color.Beige;
flashingDynamization.Color = Color.FromArgb(12, 22, 152, 200);
flashingDynamization.FlashingCondition = FlashingCondition.Always;
flashingDynamization.FlashingRate = FlashingRate.Medium;
}
}
Accéder aux propriétés de la dynamisation de la liste des ressources

dynamisation de la liste des ressources :

{
if (dynamization.DynamizationType == DynamizationType.ResourceList)
{
ResourceListDynamization resourceListDyn = (ResourceListDynamization)dynamization;
resourceListDyn.Tag = "Tag name";
resourceListDyn.ResourceList = "Resource list name";
}
}
Remarque
Create - Recoverable exception est déclenchée lorsque la dynamisation concernée pour la
propriété indiquée n'est pas prise en charge. Si les contrôles de cohérence sont absents
pendant la définition de propriétés de l'opération d'écriture, une Recoverable exception est
déclenchée.
Voir aussi
Accéder aux propriétés d'une vue de courbes (Page 393)

7.18.9.9 Vérifier la présence de la licence d'accès sur un appareil Unified
Introduction
Vous pouvez via l'interface TIA Openness vérifier l'existence d'une licence WinCC Unified pour
chaque application Openness client de sorte qu'une application client ne puisse contourner la
procédure d'octroi de licence à travers l'utilisation d'interfaces Openness.
Vous n'avez accès à un appareil IHM (Unified) et ses objets subordonnés (par ex. variables,
alarmes, vues, etc.) que si une licence IHM Unified est existante. S'il n'existe aucune licence
WinCC Unified, l'API Openness retourne une valeur nulle à chaque action au niveau de
l'appareil (par ex. créer, rechercher, supprimer).
Remarque
Une valeur nulle est fournie en retour pour une licence invalide de logiciel WinCC Unified
Conditions

Code du programme
Modifiez le code de programme suivant pour accéder à l'appareil ou aux systèmes partiels de
l'appareil lorsqu'il n'y a pas de licence ; une valeur nulle est retournée :
private static void ListDevices(Project project)

{
foreach (var device in project.Devices)
{
ListDeviceItem(device);
}
}
private static void ListDeviceItem(Device device)
{
Console.Write("HMI device - " + device.Name);
foreach (var item in device.DeviceItems)
{
Console.WriteLine("HMI device type - " + item.TypeIdentifier);
var softContainer = item.GetService<SoftwareContainer>();
if (softContainer != null)
{
var softTarget = softContainer.Software;
if (softTarget != null)
{
Console.WriteLine("HMI device software - " + softTarget.Name);
}
}
}
}
Remarque
Pendant l'accès au code du programme ci-dessus, la valeur de SoftTarget est nulle et aucun
accès aux systèmes partiels (alarmes, variables) n'est possible.

Modifiez le code de programme suivant pour accéder à l'appareil ou aux systèmes partiels de
l'appareil lorsqu'une licence est existante ; une valeur nulle est retournée :
private static void ListDevices(Project project)

{
foreach (var device in project.Devices)
{
ListDeviceItem(device);
}
}
private static void ListDeviceItem(Device device)
{
Console.Write("HMI device - " + device.Name);
foreach (var item in device.DeviceItems)
{
Console.WriteLine("HMI device type - " + item.TypeIdentifier);
var softContainer = item.GetService<SoftwareContainer>();
if (softContainer != null)
{
var softTarget = softContainer.Software;
}
if (softTarget != null)
{
Console.WriteLine("HMI device software - " + softTarget.Name);
}
}
}
}
Remarque
Pendant l'accès au code du programme ci-dessus, le SoftTarget contient des conteneurs
d'appareils et l'accès aux systèmes partiels (alarmes, variables) est possible.
Une valeur NULL retournée pour un conteneur d'appareils indique que la licence n'est pas
disponible. L'exception Recovarable ne prenant pas en charge des alertes d'exception
personnalisées, c'est NULL qui est utilisée comme valeur en retour.
Voir aussi

7.18.10 Accès aux hiérarchies dans le Common Plant Model
7.18.10.1 Utiliser la vue de l'installation
Introduction
Vous pouvez exécuter les actions suivantes dans la vue de l'installation lors de l'utilisation de
TIA Portal Openness :
● Créer une vue de l'installation
● Supprimer une vue de l'installation
● Renommer une vue de l'installation
Conditions
Code de programme
Modifiez le code de programme suivant pour créer une vue de l'installation :
PlantViewComposition plantViews = m_tiaPortalApp.Projects[0].PlantViews;

PlantView plantView = plantViews.Create("ABCManufacturingPlant");
Remarque
Vous ne pouvez créer qu'une seule vue de l'installation dans un projet.
Modifiez le code de programme suivant pour enlever ou supprimer une vue de l'installation :

PlantView plantView = plantViews.Find("ABCManufacturingPlant");
plantView.Delete();
Modifiez le code de programme suivant pour renommer une vue de l'installation en actualisant
la propriété 'Name' :

plantView.Name = "New_PlantView_Name";

Voir aussi
7.18.10.2 Utilisation de nœuds de vue de l'installation
Introduction
Vous pouvez exécuter les actions suivantes dans les nœuds de vue de l'installation lors de
l'utilisation de TIA Portal Openness :
● Créer un nœud de vue de l'installation
● Supprimer un nœud de vue de l'installation
● Renommer un nœud de vue de l'installation
Propriétés
Les propriétés suivantes sont prises en charge par un noeud de vue de l'installation avec TIA
Portal Openness :
Nom de la propriété Type de données Possibilité d'accès

HierarchyPath String R
PlantObject Siemens.Engineering.HmiUni‐ R
fied.Cpm.PlantObject
Name String R/W
PlantView String R
ViewPath String R
PlantViewNodes PlantViewNodeComposition R
Conditions
Code de programme
Modifiez le code de programme suivant pour créer un nœud de vue de l'installation :

PlantViewNodeComposition viewNodes = plantView.PlantViewNodes;
PlantViewNode mixingNode = viewNodes.Create("Mixing");

Modifiez le code de programme suivant pour créer un nœud de vue de l'installation sous un
autre nœud de vue :

PlantViewNode motorNode = mixingNode.Create("Motor");
Remarque
Vous pouvez créer autant de nœuds que vous voulez dans une vue de l'installation ou sous un
autre nœud de vue de l'installation.
Modifiez le code de programme suivant pour enlever ou supprimer un nœud de la vue de

l'installation :

PlantViewNode mixingNode = plantView.PlantViewNodes.Find("Mixing");
mixingNode.Delete();
Modifiez le code de programme suivant pour renommer un nœud de vue de l'installation en

actualisant la propriété 'Name' :

mixingNode.Name = "New_PlantViewNode_Name";
Voir aussi
7.18.10.3 Énumérer une vue de l'installation
Introduction
Avec TIA Portal Openness, vous pouvez énumérer la vue de l'installation existant dans un
projet défini dans TIA Portal.

Conditions
Code de programme
Modifiez le code de programme suivant pour énumérer toutes les vue de l'installation existant
dans le projet :

foreach (var item in plantViews)
{
// work with plant views (currently only 1 plant view can be created inside a project)
}
Modifiez le code de programme suivant pour rechercher une vue de l'installation dans une liste
de vues de l'installation à l'aide du nom :

de vues de l'installation à l'aide de l'indice :

PlantView plantView = plantViews[0];
de vues de l'installation à l'aide du nœud :

PlantViewNode plantViewNode = plantViews.FindPlantViewNode("ABCManufacturingPlan\Mixing
\Motor");
Modifiez le code de programme suivant pour rechercher un nœud de vue de l'installation dans
une liste nœuds de vues de l'installation à l'aide du nom :
PlantViewNodeComposition plantViewNodes =
m_tiaPortalApp.Projects[0].PlantViews[0].PlantViewNodes;
PlantViewNode plantViewNode = plantViewNodes.Find("Mixing");

Modifiez le code de programme suivant pour énumérer toutes les listes de nœuds qui existent
dans la vue de l'installation :

PlantViewNodeComposition nodes = plantView.PlantViewNodes;
foreach (var item in nodes)
{
// work with plant view nodes inside plant view
}
Modifiez le code de programme suivant pour énumérer tous les nœuds existant dans les vues
de l'installation disponibles à tous les niveaux hiérarchiques :

PlantViewNodeComposition subNodes = nodes[2].PlantViewNodes;
foreach (var item in subNodes)
{
// work with plant view nodes inside 2nd node within the plant view
}
Voir aussi
7.18.10.4 Utiliser la vue de l'installation et les appareils
Introduction
Vous pouvez exécuter les actions suivantes pour l'accès aux hiérarchies dans les vues de
l'installation et aux objets de l'installation lors de l'utilisation de TIA Portal Openness :
● Affecter l'appareil à une vue de l'installation
● Modifier l'appareil dans une vue de l'installation
● Supprimer l'appareil d'une vue de l'installation
Conditions

Code de programme
Modifiez le code de programme suivant pour affecter un appareil à la vue de l'installation en
définissant la propriété 'AssignedHmiDevice' :

plantView.AssignedHmiDevice = "HMI_RT_1";
Modifiez le code de programme suivant pour modifier un appareil dans la vue de l'installation
en définissant un nom d'appareil dans la propriété 'AssignedHmiDevice' :

Modifiez le code de programme suivant pour supprimer un appareil dans la vue de l'installation
en définissant un nom d'appareil vide dans la propriété 'AssignedHmiDevice' :

plantView.AssignedHmiDevice = string.Empty;
Remarque
Pour supprimer un appareil, utilisez uniquement string.empty. NULL ou espace (" ") est
considéré comme un nom d'appareil et un message d'erreur stipulant que l'appareil est
introuvable apparaît.
Voir aussi

7.18.11 Accès aux instances dans le Common Plant Model
7.18.11.1 Utilisation d'instances d'objet CPM
Introduction
Vous pouvez exécuter les actions suivantes pour l'accès à une instance CPM à l'aide du type
de CPM lors de l'utilisation de TIA Portal Openness :
● Créer des instances d'objet CPM
● Supprimer des instances d'objet CPM
● Renommer des instances d'objet CPM
Conditions
● Une installation est créée
Code de programme
Modifiez le code de programme suivant pour créer une instance d'objet CPM :
// Instance inside plant view

PlantViewNode node = nodes.Create("ObjectLevel1", "Plant_Object_Type_1");
//Instance inside plant view node
PlantViewNode mixerObject =
plantView.PlantViewNodes.Find("Mixing").PlantViewNodes.Create("IngredientMixer",
"Plant_Object_Type_1");
Modifiez le code de programme suivant pour enlever ou supprimer une instance d'objet CPM :

plantView.PlantViewNodes.Find("Mixing").PlantViewNodes.Find("IngredientMixer");
mixerObject.Delete();

Modifiez le code de programme suivant pour renommer une instance d'objet CPM en
actualisant la propriété 'Name' :

plantView.PlantViewNodes.Find("Mixing").PlantViewNodes.Find("IngredientMixer");
mixerObject.Name = "New_PlantViewNode_Name";
Voir aussi
7.18.11.2 Utilisation de nœuds de la vue de l'installation d'instances d'objet CPM
Introduction
Vous pouvez exécuter les actions suivantes pour l'accès aux nœuds dans la vue de
l'installation des instances d'objet CPM lors de l'utilisation de TIA Portal Openness :
● Créer un nœud de vue de l'installation
● Supprimer un nœud de vue de l'installation
● Renommer un nœud de vue de l'installation
Conditions
Code de programme
Modifiez le code de programme suivant pour créer un nœud de vue de l'installation dans une
instance d'objet CPM :

PlantViewNode mixerObject = plantView.PlantViewNodes.Create("ObjectLevel1",
PlantViewNode mixingNode = mixerObject.PlantViewNodes.Create("Mixing");

Remarque
Vous pouvez créer autant de nœuds de vue de l'installation que vous voulez dans un objet
CPM.
Modifiez le code de programme suivant pour créer une instance d'objet CPM dans un nœud de
vue de l'installation :

PlantViewNode mixingNode = plantView.PlantViewNodes.Create("Mixing");
PlantViewNode mixerObject = mixingNode.PlantViewNodes.Create("ObjectLevel1",
Remarque
Vous pouvez créer autant d'instances d'objet CPM que vous voulez dans un nœud de vue de
l'installation.
Modifiez le code de programme suivant pour enlever ou supprimer un nœud sous un nœud de
la vue de l'installation :

PlantViewNode mixerObject = plantView.PlantViewNodes.Find("ObjectLevel1");
PlantViewNode mixingNode = mixerObject.PlantViewNodes.Find("Mixing");
mixingNode.Delete();
Modifiez le code de programme suivant pour renommer un nœud dans la vue de l'installation
d'une instance d'objet CPM en actualisant la propriété 'Name' :

PlantViewNode mixerObject = plantView.PlantViewNodes.Find("ObjectLevel1",
PlantViewNode mixingNode = mixerObject.PlantViewNodes.Find("Mixing");
mixingNode.Name = "New_PlantViewNode_Name";
Voir aussi

7.18.11.3 Énumérer les variables de l'interface d'instances d'objet CPM
Introduction
Avec TIA Portal Openness vous pouvez énumérer les membres d'une instance d'objet CPM.
Conditions
Code de programme
Modifiez le code de programme suivant pour énumérer tous les membres de l'instance d'objet
CPM :

PlantViewNodeComposition plantViewNodes = plantView.PlantViewNodes;
PlantViewNode plantViewNode = plantViewNodes.Find("MixerObject_1");
PlantObject plantObject = plantViewNode.PlantObject;
PlantObjectInterfaceComposition interfaces = plantObject?. PlantObjectInterfaces;
Remarque
Dans l'exemple ci-dessus, l'opérateur ?. se réfère à la vérification du zéro.
Modifiez le code de programme suivant pour rechercher une variable d'interface dans la liste
des interfaces à l'aide du nom :

PlantViewNodeComposition plantNodes = plantView.PlantViewNodes;
PlantViewNode plantViewNode = plantNodes.Find("MixerObject_1");
PlantObjectInterface interface = plantObject. PlantObjectInterfaces.Find("Interface_1");

Modifiez le code de programme suivant pour rechercher une variable d'interface dans la liste
des interfaces à l'aide de l'indice :

PlantViewNodeComposition plantViewNodes = plantView.PlantViewNodes;
PlantViewNode plantViewNode = plantViewNodes.Find("MixerObject_1");
PlantObjectInterfaceComposition interfaces = plantObject.PlantObjectInterfaces;
PlantObjectInterface interface = interfaces[0];
Voir aussi
7.18.12 Accéder aux propriétés des interfaces/variables d'archive des instances d'objets
de l'installation
7.18.12.1 Accès et actualisation des propriétés des variables de l'interface des instances d'objets
de l'installation CPM
Introduction
TIA Portal Openness vous permet d'accéder aux propriétés des variables d'interface des
instances d'objets de l'installation CPM et de les actualiser.
Il est possible d'accéder aux propriétés des variables de l'interface des instances d'objets de
l'installation CPM suivantes :

Name System.String Nom de la variable d'in‐ R/W
terface
PlcTag System.String Variable API aux varia‐ R/W
bles d'interface
Connection System.String Couplage des varia‐ R/W
bles d'interface
PlcName System.String Nom API aux variables R
d'interface
AccessMode PlantObjectTagAccessMode Mode d'accès de la va‐ R
riable d'interface
DataType System.String Type d'objet de la va‐ R
riable d'interface
MaxLength System.Int Longueur de la varia‐ R
ble d'interface


HmiDataType System.Int Type de données IHM R
de la variable d'interfa‐
ce
AcquisitionMode PlantObjectTagAcquisitionMode Mode d'acquisition de R/W
la variable d'interface
AcquisitionCycle System.Int Cycle d'acquisition de R/W
la variable d'interface
Persistent System.Bool Rémanence de varia‐ R
bles internes de l'ins‐
tance d'objet CPM
Comment System.String Commentaire R/W
Members PlantObjectInterfaceMemberCom‐ Membre de la variable R
position d'interface
Remarque
Il n'est possible de configurer la propriété PLCTag & Connection qu'une fois que l'appareil IHM
a été affecté à une vue de l'installation.
Conditions
Code du programme
Modifiez le code de programme suivant pour accéder à toutes les propriétés des variables
d'interface :
// Instance inside plant view node

plantView.PlantViewNodes.Find("Mixing").PlantViewNodes.Create("IngredientMixer", "Mixer");
PlantObjectInterfaceComposition interfaceTags =
mixerObject.PlantObject.PlantObjectInterfaces;
PlantObjectInterface interfaceTag = interfaceTags.FirstOrDefault();
string name = interfaceTag.Name;
MultilingualText comment = interfaceTag.Comment

Modifiez le code de programme suivant pour actualiser certaines propriétés d'une variable de
l'interface, par ex. commentaire, variable API, coupleur, mode d'acquisition, cycle
d'acquisition :

interfaceTag.Name = "New_InterfaceTag_Name";
interfaceTag.Comment.Items[0].Text = "New_InterfaceTag_Comment";
interfaceTag.AcquisitionMode = PlantObjectTagAcquisitionMode.CyclicContinuous;
interfaceTag.AcquisitionCycle = "T12s";
interfaceTag.Connection = "Connection_1";
interfaceTag.PlcTag = "PLC_Tag_1";
Voir aussi
7.18.12.2 Accès et actualisation des propriétés de variables membre d'une variable d'interface
Introduction
TIA Portal Openness vous permet d'accéder aux propriétés des variables membre d'une
variable d'interface et de les actualiser.
Il est possible d'accéder aux propriétés des variables membre des variables d'interface
suivantes :

Name System.String Nom de la variable R
membre
DataType System.String Type d'objet de la va‐ R
riable membre
MaxLength System.Int Longueur de la varia‐ R
ble membre
HmiDataType System.String Type de données IHM R
de la variable membre
InitialMinValue PlantObjectTagLowerRange Valeur de plage infé‐ R/W
rieure
InitialMaxValue PlantObjectTagUpperRange Valeur de plage supéri‐ R/W
eure
InitialValue System.Object Valeur de début R/W
SubstituteValue PlantObjectTagSubstituteValue Valeur de remplace‐ R
ment


Comment MultilingualText Commentaire R/W
Members PlantObjectInterfaceMemberCom‐ Membre de la variable R
position Member
LoggingTags PlantObjectLoggingTagComposi‐ Variables d'archive de R
tion la variable Member
Conditions
Code du programme

PlantViewNodeComposition plantViewNodeComposition = plantView.PlantViewNodes;
PlantViewNode plantViewNode = plantViewNodeComposition[0];
PlantObjectInterfaceComposition tagComposition =
plantViewNode.PlantObject.PlantObjectInterfaces;
PlantObjectInterface interfaceTag = tagComposition[0];
PlantObjectInterfaceMemberComposition memberTags = interfaceTag.Members;
PlantObjectInterfaceMember memberTag = memberTags.FirstOrDefault();
//GetAttributes
List<string> listOfPropertyNames = new List<string>()
{
"Name"
};
var listOfPropertyValues = memberTag.GetAttributes(listOfPropertyNames);
//SetAttributes
IEnumerable<KeyValuePair<string, object>> propertyNameValuePairList = new
List<KeyValuePair<string, object>>()
{
new KeyValuePair<string, object>("Name", "MemberTag_1");
};
memberTag.SetAttributes(propertyNameValuePairList);

Modifiez le code de programme suivant pour accéder à toutes les propriétés de la variable
membre :

string name = memberTag.Name;
string comment = memberTag.Comment.Items[0].Text;
Modifiez le code de programme suivant pour actualiser les propriétés d'une variable membre
d'une instance d'objet CPM :

memberTag.Comment.Items[0].Text = "New_MemberTag_Comment";
memberTag.InitialValue = 2;
memberTag.InitialMinValue.Value = 2;
memberTag.InitialMinValue.ValueType = PlantObjectTagLimitValueType.Constant;
memberTag.InitialMaxValue.Value = 2;
memberTag.InitialMaxValue.ValueType = PlantObjectTagLimitValueType.Constant;
Modifiez le code de programme suivant pour accéder à toutes les variables d'archive d'une
variable membre d'une instance d'objet CPM :

PlantObjectLoggingTagComposition loggingTags = memberTag.LoggingTags;
PlantObjectLoggingTag loggingTag = loggingTags.FirstOrDefault();
Voir aussi

7.18.12.3 Accès et actualisation des propriétés des variables de journalisation d'une variable
membre
Introduction
Vous pouvez accéder avec TIA Portal Openness aux variables d'archive de variables Member
dans les instances d'objet d'installation CPM.
Il est possible d'accéder aux propriétés suivantes des variables d'archive de variables
membres dans les instances d'objet d'installation CPM :

AggregationDelay System.TimeSpan Valeur pour le retard d'agré‐ R
gation
AggregationMode PlantObjectLoggingTagAg‐ Valeur pour le mode d'agré‐ R
gregationMode gation
Cycle System.String Cycle d'archivage de la varia‐ R
ble d'archive
CycleFactor System.UInt32 Valeur du facteur de cycle R
d'archivage
DataLog　 System.String R
Source System.string Source de la variable d'archi‐ R
ve
TriggerMode PlantObjectLoggingTagTrig‐ Mode de déclenchement de R
gerMode la variable d'archive
TriggerTag System.String Valeur de la variable de dé‐ R
clenchement
TriggerTagBitNumber System.UInt32 Valeur de TriggerTagBitNum‐ R
ber
Name System.string Nom de la variable d'archive R
LogConfiguration System.String Archive de données de la va‐ R
riable d'archive
LoggingMode PlantObjectLoggingTagLog‐ Mode de journalisation de la R
gingMode variable d'archive
SmoothingMode PlantObjectLoggingTagS‐ Mode de lissage de la varia‐ R
moothingMode ble d'archive
SmoothingMinTime System.TimeSpan Durée minimale de la varia‐ R
ble d'archive
SmoothingMaxTime System.TimeSpan Durée maximale de la varia‐ R
ble d'archive
SmoothingDeltaValue System.Double Delta de la variable d'archive R
LimitScope PlantObjectLoggingTagLimit‐ Limitation de la portée de la R
Scope variable d'archive
HighLimit System.Object Valeur limite supérieure de la R
variables d'archive
LowLimit System. Object Valeur limite inférieure de la R
variable d'archive

Conditions
Code du programme
Modifiez le code de programme suivant pour accéder à toutes les propriétés des variables
d'archive :

PlantObjectInterfaceMemberComposition interfaceTags =
mixerObject.PlantObject.PlantObjectInterfaceMembers;
PlantObjectInterfaceMember interfaceTag = interfaceTags.FirstOrDefault();
PlantObjectLoggingTagComposition loggingTags = memberTag.LoggingTags;
PlantObjectLoggingTag loggingTag = loggingTags.FirstOrDefault();
string name = loggingTag.Name;
object lowLimit = loggingTag.LowLimit;
Remarque
Il n'est pas possible d'actualiser des propriétés de la classe PlantObjectLoggingTag
correspondant aux variables d'archive d'une instance d'objet CPM.
Voir aussi

7.19 Fonctions pour l'accès aux données d'un appareil API.
7.19.1 Déterminer le statut d'un API
Conditions requises
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
Utilisation
Vous pouvez déterminer l'état d'un API ou de tous les API au sein d'un projet.
TIA Portal Openness distingue les états suivants :
● Offline
● l'API est connecté ("la connexion est établie")
● En ligne
● l'API n'est pas connecté ("la connexion est coupée")
● Incompatible
● non accessible
● Protégé
Code du programme
Pour déterminer l'état d'un API, modifiez le code de programme suivant :
public static OnlineState GetOnlineState(DeviceItem deviceItem)

{
OnlineProvider onlineProvider = deviceItem.GetService<OnlineProvider>();
return onlineProvider.State;
}

Pour déterminer l'état de tous les API dans un projet, modifiez le code de programme suivant :
public static void DetermineOnlineStateOfAllProjectDevices(Project project)

{
{
{
if (onlineProvider != null)
{
OnlineState state = onlineProvider.State;
}
}
}
}
7.19.2 Accéder aux paramètres d'une liaison en ligne
Conditions requises
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
Utilisation
L'interface TIA Portal Openness API vous permet de définir les paramètres pour une liaison en
ligne :
● Enumérer les types de connexion disponibles avec un API
● Enumérer les interfaces disponibles avec un API
● Enumérer les emplacements affectés
● Enumérer les adresses disponibles des sous-réseaux et passerelles
● Définir les paramètres de liaison

Code de programme : déterminer les paramètres de liaison

Pour énumérer les modes de liaison, interfaces de PC et emplacements disponibles, modifiez
public static void EnumerateConnectionModesOfPLC(DeviceItem deviceItem)

{
if (onlineProvider == null)
{
return; // Only cpu device items can provide OnlineProvider service
}
// Accessing connection configuration object
ConnectionConfiguration configuration = onlineProvider.Configuration;
// Now access connection configuration members
foreach (ConfigurationMode mode in configuration.Modes)
{
Console.WriteLine("Mode name:{0}", mode.Name);
foreach (ConfigurationPcInterface pcInterface in mode.PcInterfaces)
{
Console.WriteLine("PcInterface name:{0}", pcInterface.Name);
Console.WriteLine("PcInterface number:{0}", pcInterface.Number);
foreach (ConfigurationTargetInterface targetInterface in
pcInterface.TargetInterfaces)
{
Console.WriteLine("TargetInterface:{0}", targetInterface.Name);
}
}
}
}
Vous pouvez aussi accéder à un type de connexion et une interface de PC par le nom :
public static ConfigurationTargetInterface

GetTargetInterfaceForOnlineConnection(OnlineProvider onlineProvider)
{
ConfigurationMode mode = configuration.Modes.Find("PN/IE");
ConfigurationPcInterface pcInterface = mode.PcInterfaces.Find("PLCSIM", 1);
ConfigurationTargetInterface slot = pcInterface.TargetInterfaces.Find("2 X3");
return slot;
}

Pour énumérer les adresses disponibles des sous-réseaux et passerelles sur une interface de
PC, modifiez le code de programme suivant :
public static void EnumeratingPCInterfaceSubnetsAndGateways(ConfigurationPcInterface

pcInterface)
{
foreach (ConfigurationSubnet subnet in pcInterface.Subnets)
{
Console.WriteLine("Subnet name:{0}", subnet.Name);
foreach (ConfigurationGateway 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 (ConfigurationAddress gatewayAddress in gateway.Addresses)
{
Console.WriteLine("Gateway Address:{0} has {1}", gatewayAddress.Name,
gatewayAddress.Address);
}
}
}
}
Vous pouvez également accéder aux sous-réseaux et passerelles par le nom ou l'adresse IP :
public static void AccessSubnetAndGatewayOfPCInterface(ConfigurationPcInterface

pcInterface)
{
ConfigurationSubnet subnet = pcInterface.Subnets.Find("PN/IE_1");
ConfigurationAddress subnetAddress = subnet.Addresses.Find("192.168.0.1");
ConfigurationGateway gateway = subnet.Gateways.Find("Gateway 1");
ConfigurationAddress gatewayAddress = gateway.Addresses.Find("192.168.0.2");
}
Code de programme : Définir les paramètres de liaison
Remarque
La définition des paramètres de liaison écrase tous les paramètres de liaison définis
auparavant. Si vous avez déjà défini les paramètres de liaison directement dans TIA Portal,
vous n'avez pas besoin d'appeler ApplyConfiguration. Si une liaison en ligne existe déjà
vers un API pendant l'appel de ApplyConfiguration, une exception sera déclenchée.

Pour définir les paramètres d'emplacement, modifiez le code de programme suivant :
public static void SetConnectionWithSlot(OnlineProvider onlineProvider)

{
ConfigurationMode mode = configuration.Modes.Find(@"PN/IE");
// or network pc interface that is connected to plc
ConfigurationTargetInterface slot = pcInterface.TargetInterfaces.Find("2 X3");
configuration.ApplyConfiguration(slot);
// After applying configuration, you can go online
onlineProvider.GoOnline();
}
Pour définir les paramètres d'adresse de passerelles, modifiez le code de programme suivant :
public static void SetConnectionWithGatewayAddress(OnlineProvider onlineProvider, string

subnetName, string gatewayAddressName)
{
ConfigurationSubnet subnet = pcInterface.Subnets.Find(subnetName);
ConfigurationAddress gatewayAddress = subnet.Addresses.Find(gatewayAddressName);
configuration.ApplyConfiguration(gatewayAddress);
}
Pour définir les paramètres d'adresse de sous-réseaux, modifiez le code de programme

suivant :
public static void SetConnectionWithSubnetAddress(OnlineProvider onlineProvider, string

subnetName)
{
ConfigurationSubnet subnet = pcInterface.Subnets.Find(subnetName);
ConfigurationAddressComposition addresses = subnet.Addresses;
configuration.ApplyConfiguration(addresses[0]);
}

7.19.3 Accès à l'empreinte pour une comparaison rapide des stations
Conditions
● L'application Openness est connectée à TIA Portal.
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
● L'API est hors ligne.
Application
TIA Portal Openness vous permet d'appeler FingerprintData pour différents aspects de la
configuration de l'appareil API afin d'établir une comparaison rapide entre les stations. Pour
cela, utilisez le service FingerprintDataProvider que vous pouvez appeler via un TIA Portal
défini. L'appel GetService renvoie normalement une instance de FingerprintDataProvider.
Sinon, la valeur zéro est renvoyée.
Code de programme : Appel de FingerprintDataProvider depuis TIA Portal
TiaPortal tia = new TiaPortal(TiaPortalMode.WithUserInterface);

FingerprintDataProvider fingerprintDataProvider =
tia.GetService<FingerprintDataProvider>();
if (fingerprintDataProvider != null)
{
...
}
Paramètres de la méthode FingerprintDataProvider

Pour appeler la FingerprintData d'un appareil, vous devez appeler la méthode
GetFingerprintData de FingerprintDataProvider.
Les attributs suivants sont pris en charge dans le FingerprintDataProvider :

configurationAddress Siemens.Engineering.Online.Configu‐ Adresse de l'appareil pour lequel vous
ration souhaitez appeler la FingerprintData.
onlineConfigurationDelegate Siemens.Engineering.Online Délégué appelé pour vérifier la configu‐
ration avant l'appel de la FingerprintDa‐
ta.

Adresse de configuration
Vous devez mettre à disposition un objet ConfigurationAddress pour GetFingerprintData.
L'objet adresse est utilisé pour établir une connexion à l'appareil pour lequel vous souhaitez
appeler la FingerprintData. L'objet ConfigurationAddress doit être créé dans la
ConnectionConfiguration du FingerprintDataProvider.
Vous pouvez par exemple utiliser le code suivant pour créer un objet adresse :
...
ConnectionConfiguration configuration = fingerprintDataProvider.Configuration;
ConfigurationMode configurationMode = configuration.Modes.Find("PN/IE");
ConfigurationPcInterface pcInterface = configurationMode.PcInterfaces.Find("Intel(R)
Ethernet Connection I217-LM", 1);
// Create an address. This "ConfigurationAddress" is used as parameter for getting the
fingerprintData
ConfigurationAddress fingerprintAddress = pcInterface.Addresses.Create("192.68.0.1");
...
La configuration contient une liste de Modes pris en charge. Vous devez sélectionner l'un des
Modes pour l'appel des empreintes. Le ConfigurationMode sélectionné contient une liste de
toutes les PCInterfaces locales prenant en charge le Mode sélectionné. Vous devez
sélectionner une interface. L'adresse souhaitée peut être créée dans la collection d'adresses
de la ConfigurationPcInterface sélectionnée.
Code de programme : Appeler une FingerprintData

Vous pouvez appeler la FingerprintData d'une station en appelant l'action GetFingerprintData.
Les paramètres suivants sont pris en charge :
Paramètres Description
ConfigurationAddress Adresse de l'appareil
OnlineConfigurationDelegate Rappel pour le traitement des inhibitions
...
OnlineConfigurationDelegate preConfigurationDelegate = PreConfigureFingerprint;
FingerprintDataResult result =
fingerprintDataProvider.GetFingerprintData(fingerprintAddress , preConfigurationDelegate);
// The fingerprints
FingerprintDataItemComposition allFingerprints = result.FingerprintDataItems;
foreach (FingerprintDataItem item in allFingerprints)
{
// do something with the fingerprint ...
}
internal void PreConfigureFingerprint(OnlineConfiguration onlineConfiguration)
{
...
}

Délégué pour la configuration en ligne

Les types possibles de configuration en ligne sont décrits ci-après :
Nom de configuration Description et propriétés

OnlineConfiguration ● Classe de base pour d'autres configurations
● OnlineConfiguration.Message: chaîne de caractères (pro‐
priété protégée en écriture contenant le message de con‐
figuration)
Comme cette classe de base est valable pour toutes les autres configurations, cet adaptateur
de propriétés est disponible dans toutes les configurations.
Le type de données de la configuration est expliqué ci-après.
Configuration Type de données Description et action

OnlineConfiguration OnlineReadAccessPassword Set password via la méthode SetPass‐
word(password:SecureString).
Saisir le mot de passe afin d'obtenir un
accès en lecture au module.
Une configuration non traitée pouvant empêcher l'accès à l'empreinte entraîne une
EngineeringDelegateInvocationException et annule l'action. Une
EngineeringDelegateInvocationException est émise dans le cas d'une exception non traitée
dans le délégué.
Exemple de mise en œuvre de PreConfigureFingerprint
private static void PreConfigureFingerprint(OnlineConfiguration onlineConfiguration)

{
OnlineReadAccessPassword readAccess = onlineConfiguration as OnlineReadAccessPassword;
if (readAccess != null)
{
string passWD = "passWD";
var password = new SecureString();
foreach (var c in passWD) password.AppendChar(c);
moduleReadAccessPassword.SetPassword(password);
return;
}
throw new NotSupportedException(); // Exception thrown in the delagate will cancel get
fingerprints
}
FingerprintDataResult
Le FingerprintDataResult renvoyé par l'action GetFingerprintData fournit une liste de toutes les
empreintes pour l'appareil.

Vous pouvez par exemple utiliser le code suivant pour analyser des éléments d'empreinte :
{
...
FingerprintDataResult result = dataProvider.GetFingerprintData(fingerprintAddress,
preConfigurationDelegate);
FingerprintDataItemComposition allFingerprints = result.FingerprintDataItems;
foreach (FingerprintDataItem item in allFingerprints)
{
string fingerprintDataIdentifier = item.FingerprintDataIdentifier;
string fingerprintDataValue = plcItem.FingerprintDataValue;
// Do something, e.g. store Identifier and Value in a file
}
}
Traitement d'erreur dans les empreintes Openness

Toutes les erreurs au sein des empreintes Openness sont affectées à
EngineeringTargetInvocationException en tant qu'exceptions personnalisées récupérables.
C'est pourquoi aucune erreur survenue dans une action Openness n'entraîne une panne de
TIA Portal.
La condition est que le client traite l'exception correspondante. Cela peut par exemple
s'effectuer comme dans le code suivant :
TiaPortal currentTIA = ...;

FingerprintDataProvider dataProviderFingerprints =
currentTIA.GetService<FingerprintDataProvider>();
OnlineConfigurationDelegate configurationDelegate = OnlineConfigurationFingerprintData;
try
{
// The used addr referes a PLC300.
FingerprintDataResult dataResult = dataProviderFingerprints.GetFingerprintData(addrObj,
configurationDelegate);
// Try to get a list of all FingerprintDataItems. But a PLC300 supports no fingerprints.
FingerprintDataItemComposition dataItems = dataResult.FingerprintDataItems;
foreach (FingerprintDataItem searchItem in dataItems)
{
string valueToCompareIdent = searchItem.FingerprintDataIdentifier;
string valueToCompareValue = searchItem.FingerprintDataValue;
DoAnything(valueToCompareIdent, valueToCompareValue);
}
}
catch (EngineeringTargetInvocationException targetException)
{
// In case of the not supported PLC this exception will be catched.
Console.WriteLine(targetException.Message);
}

Classes d'assistance
Deux classes sont nécessaires pour cet exemple : Vous pouvez utiliser le code de programme
suivant pour encapsuler les paires de données d'empreinte.
/// <summary>
/// Helperclass to handle a "Dictionary" as serializeable class object
/// </summary>
[Serializable]
public class FingerprintDataPairs : Dictionary<string, string>, ISerializable
{
public FingerprintDataPairs(){}
public FingerprintDataPairs(SerializationInfo si, StreamingContext context)
{
KeyValuePair<string, string>[] dataPair = si.GetValue("KeyValuePairs",
typeof(KeyValuePair<string, string>[])) as KeyValuePair<string, string>[];
if (dataPair != null)
foreach (KeyValuePair<string, string> pair in dataPair)
this.Add(pair.Key, pair.Value);
}
}

Vous pouvez utiliser l'exemple suivant pour traiter les données d'empreinte et établir une
comparaison :

/// <summary>
/// Helperclass for handle the fingerprint data and compare two datasets.
/// </summary> public class FingerprintDataCompare
{
internal FingerprintDataPairs m_FingerprintDataPairs;
internal FingerprintDataPairs FingerprintDataPairSet
{
get
{
if (m_FingerprintDataPairs == null) m_FingerprintDataPairs = new FingerprintDataPairs();
return m_FingerprintDataPairs;
}
set
{
m_FingerprintDataPairs = value;
}
}
internal bool CompareDataSets(FingerprintDataPairs dataSet1, FingerprintDataPairs dataSet2)
{
foreach (string key in dataSet1.Keys)
{
if (dataSet2[key] != dataSet1[key])
return false;
}
return true;
}
internal void SaveFingerprintDataItems(FingerprintDataPairs fingerprintDataPairSet, string
filename)
{
using (FileStream fs = new FileStream(filename, FileMode.Create))
{
BinaryFormatter formatter = new BinaryFormatter();
try
{
formatter.Serialize(fs, fingerprintDataPairSet);
}
catch (SerializationException e)
{
Console.WriteLine("Failed to write fingerprints. See: " + e.Message);
}
finally
{
fs.Close();
}
}
}
internal FingerprintDataPairs LoadFingerprintDataItems(string filename)
{
FingerprintDataPairs dataPair = null;
using(FileStream fs = new FileStream(filename, FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
try
{
dataPair = (FingerprintDataPairs)formatter.Deserialize(fs);

}
catch (System.Runtime.Serialization.SerializationException e)
{
Console.WriteLine("Failed to read fingerprints. See: " + e.Message);
}
finally
{
fs.Close();
}
}
return dataPair;
}
}
Comparer les empreintes

Pour établir une comparaison, vous pouvez utiliser le FingerprintDataResult.
...
// See chapter "FingerprintDataResult"
FingerprintDataResult fingerprintDataResult = dataProvider.GetFingerprintData(address,
preConfigurationDelegate);
...
Pour enregistrer les empreintes, vous pouvez utiliser les classes d'assistance :
string pathDat = "FingerprintDataOverview.dat";

// Create a fingerprint comparer and fill the dataitems with the result of
"GetFingerprintData".
FingerprintDataCompare fingerprintDataSet = new FingerprintDataCompare();
foreach (FingerprintDataItem item in fingerprintDataResult.FingerprintDataItems)
fingerprintDataSet.FingerprintDataPairSet.Add(item.FingerprintDataIdentifier,
item.FingerprintDataValue);
fingerprintDataSet.SaveFingerprintDataItems(fingerprintDataSet.FingerprintDataPairSet,
pathDat);

À l'aide des FingerprintDataItems enregistrés et d'un FingerprintDataResult actuel, il est

possible de comparer les empreintes :
...
string pathDat = "FingerprintDataOverview.dat";
FingerprintDataCompare fingerprintDataSet = new FingerprintDataCompare();
foreach (FingerprintDataItem item in fingerprintDataResult.FingerprintDataItems)
fingerprintDataSet.FingerprintDataPairSet.Add(item.FingerprintDataIdentifier,
item.FingerprintDataValue);
FingerprintDataPairs loadDataSet = new FingerprintDataPairs();
loadDataSet = fingerprintDataSet.LoadFingerprintDataItems(pathDat);
if (!fingerprintDataSet.CompareDataSets(loadDataSet,
fingerprintDataSet.FingerprintDataPairSet))
{
// Here is place to implement user actions.
}
7.19.4 Accès à CM DP comme esclave DP et zone de transfert
Conditions
Application
Lorsqu'un CM DP est enfiché, vous pouvez configurer avec TIA Portal Openness un ET200SP
PLC comme esclave DP. Il est aussi possible de créer, configurer et supprimer des zones de
transfert sur l'interface DP dans TIA Portal Openness Le maniement est similaire à celui des
zones de transfert de l'interface PN décrite sous Zones de transfert Openness pour coupleur
PnP.
Les attributs dynamiques suivants sont pris en charge sur l'interface DP de l'élément d'appareil :
Nom d'attribut Type de don‐ Accès Accessible en écriture

nées
DpUseForTestCommissionin‐ Boolean uniquement disponible r/w
gRouting si configuré comme es‐
clave DP
DpWatchdog Boolean uniquement disponible r/w
si configuré comme es‐
clave DP et affecté com‐
me maître DP

Code de programme : Créer des zones de transfert

Modifiez le code de programme suivant pour créer une zones de transfert sur l'interface DP :
NetworkInterface cpuItf = CpuInterface.GetService<NetworkInterface>();

// Create TransferAreas
TransferAreaComposition transferAreas = cpuItf.TransferAreas;
// Simple TranferArea
TransferArea transferAreaExample = transferAreas.Create("Example TA MS",
TransferAreaType.MS);
Paramètres des zones de transfert

Les paramètres suivants sont pris en charge dans les zones de transfert de la configuration
esclave DP :
Nom du paramètre Type de données Accès

Name string read/write
Direction enum read/write
Comment string read/write
LocalToPartnerLength Int32 read/write
PartnerToLocalLength Int32 read/write
LocalAddresses AddressComposition object read
PartnerAddresses AddressComposition object read
PositionNumber Int32 read
Type enum read
Code de programme : supprimer la zone de transfert

Modifiez le code de programme suivant de sorte à supprimer une zone de transfert pour la
configuration d'esclave DP :
TransferArea transferAreaExample = transferAreas.Create("Example TA MS",

TransferAreaType.MS);
transferAreaExample.Delete();
7.19.5 Commuter l'API du système R/H en ligne
Conditions
Voir Établissement d'une connexion à TIA Portal
Voir Ouverture d'un projet

Application
Avec le service RHOnlineProvider vous pouvez commuter en ligne l'API principal ou l'API de
réserve d'un système R/H.
Code de programme : Accéder au service RHOnlineProvider depuis un appareil

Modifiez le code de code suivant pour accéder à RHOnlineProvider :
Device device = project.Devices.Find("S7-1500R/H-System_1");

RHOnlineProvider rhOnlineProvider = device.GetService<RHOnlineProvider>();
Code de programme : Définir les paramètres de liaison

Avec l'objet ConnectionConfiguration , vous pouvez établir une liaison à l'appareil. L'accès est
possible via la propriété Configuration de RHOnlineProvider. Pour plus d'informations sur
l'établissement de la liaison, référez-vous à Accéder aux paramètres d'une liaison en ligne
Modifiez le code de programme suivant pour créer un type de liaison via le nom et accéder à
une interface PC :
ConnectionConfiguration connectionConfiguration = rhOnlineProvider.Configuration;

ConfigurationMode mode = connectionConfiguration.Modes.Find("PN/IE");
ConfigurationPcInterface pcInterface = mode.PcInterfaces.Find("Broadcom NetXtreme Gigabit
Ethernet", 1);
ConfigurationTargetInterface targetConfiguration = pcInterface.TargetInterfaces.Find("1
X1");
bool success = connectionConfiguration.ApplyConfiguration(targetConfiguration);
Remarque
Le système R/H est composé de deux API, une configuration de liaison individuelle est mise à
disposition.
Code de programme : Commuter le système R/H en ligne

Vous pouvez commuter en ligne l'API principal ou l'API de réserve. Si vous tentez de commuter
les deux en ligne simultanément, le système renvoie une exception
EngineeringTargetInvocationException .
Modifiez le code de programme suivant pour commuter l'API principal en ligne :
OnlineState onlineState = rhOnlineProvider.GoOnlineToPrimary();
Modifiez le code de programme suivant pour commuter l'API de réserve en ligne :
OnlineState onlineState = rhOnlineProvider.GoOnlineToBackup();

Remarque
Si vous commutez en ligne un API d'un système R/H, vous pouvez réutiliser un mot de passe
enregistré auparavant.
Code de programme : Déterminer l'état en ligne d'un système R/H

Avec les propriétés PrimaryState et BackupState de RHOnlineProvider, vous pouvez
déterminer l'état de liaison en ligne d'un API principal et d'un API de réserve séparément . Les
deux propriétés renvoient l'énumération OnlineState. Vous trouverez des informations sur la
manière de déterminer l'état en ligne d'un API sous Déterminer l'état d'un API
Modifiez le code de programme suivant pour déterminer l'état d'un API principal et d'un API de
réserve :
RHOnlineProvider rhOnlineProvider = ...;

OnlineState primaryState = rhOnlineProvider.PrimaryState;
OnlineState backupState = rhOnlineProvider.BackupState;
Code de programme : Commuter le système R/H hors ligne

Modifiez le code de programme suivant pour commuter un système R/H actuellement en ligne
en mode hors ligne par l'appel de la méthode RHOnlineProvider.GoOffline :
rhOnlineProvider.GoOffline();
7.19.6 Accéder à des conteneurs de logiciels via l'API principal d'un système R/H
Conditions
Application
Pour l'accès à un conteneur de logiciels, vous pouvez utiliser l'API principal d'un système R/H.
Par exemple, le système R/H met à disposition des conteneurs de logiciels pour un API
principal représenté comme PLC_1. Si vous tentez cependant d'accéder à un conteneur de
logiciels pour un API de réserve représenté comme PLC_2, le système renvoie la valeur zéro.
Les particularités d'un conteneur de logiciels et ses propriétés logicielles sont décrites sous
Accéder au logiciel cible.

Code de programme : accéder à des conteneurs de logiciels

Modifiez le code de programme suivant pour accéder à des conteneurs de logiciels via
l'appareil principal d'un système R/H :
foreach (DeviceItem deviceItem in rhDevice.DeviceItems)

{
if (deviceItem.Name == "PLC_1")
{
... //Work with softwareContainer
}
}
7.19.7 Charger l'API d'un système R/H
Conditions
Voir Établir une liaison à TIA Portal
Application
Avec l'application TIA Portal Openness, vous pouvez charger l'API principal ainsi que l'API de
réserve d'un système R/H. Vous pouvez charger aussi bien les composants matériels que les
composants logiciels du système. (vous trouverez des informations supplémentaires sous
Charger des composants matériels et logiciels dans l'API).
Code de programme : appeler RHDownloadProvider

Via RHDownloadProvider service , vous pouvez effectuer un chargement depuis un appareil
vers un système R/H.
Modifiez le code de programme suivant pour appeler RHDownloadProvider :
...
RHDownloadProvider rhDownloadProvider = device.GetService<RHDownloadProvider>();
...
Remarque
Un accès au service DownloadProvider n'est pas effectué en liaison avec des CPU
appartenant au système R/H.

Code de programme : Appel de IConfiguration

RHDownloadProvider met à disposition l'objet ConnectionConfiguration via la propriété
Configuration , à l'aide de laquelle la liaison à l'appareil est configurée.
Modifiez le code de programme suivant pour appeler l'objet IConfiguration via
ConnectionConfiguration sur RHDownloadProvider :
...
ConnectionConfiguration connectionConfiguration = rhDownloadProvider.Configuration;
Ethernet", 1);
IConfiguration targetConfiguration = pcInterface.TargetInterfaces.Find("1 X1");
...
Remarque
Les systèmes R/H sont composés de deux API. Seul un objet de configuration de liaison qui
peut être utilisé pour le chargement dans l'API principal et dans l'API de réserve est mis à
disposition.
Code de programme : Charger dans la CPU principale et la CPU de réserve

Modifiez le code de programme suivant pour effectuer un chargement dans l'API principal par
l'appel de RHDownloadProvider.DownloadToPrimary :
DownloadResult DownloadToPrimary(configuration, preDownloadConfigurationDelegate,

postDownloadConfigurationDelegate, downloadOptions);
Modifiez le code de programme suivant pour effectuer un chargement dans l'API de réserve par
l'appel de RHDownloadProvider.DownloadToBackup :
DownloadResult DownloadToBackup(configuration, preDownloadConfigurationDelegate,

postDownloadConfigurationDelegate, downloadOptions);

Paramètre de la méthode RHDownloadProvider

RHDownloadProvider.DownloadToPrimary et RHDownloadProvider.DownloadToBackup
acceptent les mêmes paramètres et renvoient le cas échéant un DownloadResult. Vous
trouverez des informations détaillées sur IConfiguration, DownloadConfigurationDelegate,
DownloadOptions et DownloadResult sous Charger des composants matériels et logiciels
dans l'API.
Nom de paramètre Type Description

configuration Siemens.Engineering.Connec‐ Configuration de la connexion à un ap‐
tion.IConfiguration pareil.
preDownloadConfigurationDelegate Siemens.Engineering.Download.Down‐ Délégué appelé pour vérifier la configu‐
loadConfigurationDelegate ration avant le chargement
postDownloadConfigurationDelegate Siemens.Engineering.Download.Down‐ Délégué appelé pour vérifier la configu‐
loadConfigurationDelegate ration après le chargement
downloadOptions Siemens.Engineering.Download.Down‐ Options de téléchargement
loadOptions
Selon l'état du système R/H, vous avez la possibilité d'exiger un arrêt du système pour la
procédure de chargement via DownloadConfigurations. Outre la configuration décrite sous

Charger des composants matériels et logiciels dans l'API, les types de données suivants sont
également ajoutés pour la prise en charge de RHDownload pour cette raison.
Configuration Type de données Action Description

DownloadSelection‐ StopHSystem Set CurrentSelection:StopH‐ Les modules sont arrêtés pour
Configuration SystemSelections. permettre le chargement dans
Valeurs d'énumération disponi‐ un appareil.
bles :
● NoAction (aucune action)
● StopHSystem (arrêt du sys‐
tème R/H)
StopHSystemOrModule Set CurrentSelection:StopH‐ Les modules sont arrêtés pour
SystemOrModuleSelections. permettre le chargement dans
Valeurs d'énumération disponi‐ un appareil.
bles :
● StopHSystem (arrêt du sys‐
tème R/H)
● StopModule (arrêt du mo‐
dule)
StartBackupModules Set CurrentSelection:StartBac‐ Démarrer les modules après le
kupModulesSelections. chargement dans l'appareil.
Valeurs d'énumération disponi‐
bles :
● SwitchToPrimaryCpu (com‐
muter sur la CPU principale)
● StartModule (démarrer le
module)
SwitchBackupToPrimary Set CurrentSelection:Switch‐ Démarrer les modules après le
BackupToPrimarySelections. chargement dans l'appareil.
Valeurs d'énumération disponi‐
bles :
● SwitchToPrimaryCpu (com‐
muter sur la CPU principale)

Code de programme : Gestion de la configuration du chargement dans des rappels

Modifiez le code de programme suivant dans des appels de DownloadToPrimary et
DownloadToBackup pendant le traitement des configurations dans des rappels :

Exemple d'appel de la méthode Download

static void Main(string[] args)
{
...
Project project = tiaPortal.Projects[0];
ConnectionConfiguration connectionConfiguration = rhDownloadProvider.Configuration;
Ethernet", 1);
IConfiguration targetConfiguration = pcInterface.TargetInterfaces.Find("1 X1");
// Download to primary
DownloadResult primaryDownloadResult =
rhDownloadProvider.DownloadToPrimary(targetConfiguration,
PreConfigureDownloadCallback,
PostConfigureDownloadCallback,
DownloadOptions.Hardware | DownloadOptions.Software);
WriteDownloadResults(primaryDownloadResult);
// Download to backup
DownloadResult backupDownloadResult =
rhDownloadProvider.DownloadToBackup(targetConfiguration,
PreConfigureDownloadCallback,
PostConfigureDownloadCallback,
DownloadOptions.Hardware | DownloadOptions.Software);
WriteDownloadResults(backupDownloadResult);
...
}
private static void PreConfigureDownloadCallback(DownloadConfiguration
downloadConfiguration)
{
StopHSystem stopHSystem = downloadConfiguration as StopHSystem;
if (stopHSystem != null)
{
stopHSystem.CurrentSelection = StopHSystemSelections.StopHSystem;
}
OverwriteTargetLanguages overwriteTargetLanguages = downloadConfiguration as
OverwriteTargetLanguages;
if (overwriteTargetLanguages != null)
{
overwriteTargetLanguages.Checked = true;
}
AlarmTextLibrariesDownload alarmTextLibraries = downloadConfiguration as
AlarmTextLibrariesDownload;
if (alarmTextLibraries != null)
{
alarmTextLibraries.CurrentSelection =
AlarmTextLibrariesDownloadSelections.ConsistentDownload;
return;
}
CheckBeforeDownload checkBeforeDownload = downloadConfiguration as CheckBeforeDownload;
if (checkBeforeDownload != null)
{
checkBeforeDownload.Checked = true;
return;


}
ConsistentBlocksDownload consistentBlocksDownload = downloadConfiguration as
ConsistentBlocksDownload;
if (consistentBlocksDownload != null)
{
consistentBlocksDownload.CurrentSelection =
ConsistentBlocksDownloadSelections.ConsistentDownload;
return;
}
OverwriteSystemData overwriteSystenData = downloadConfiguration as OverwriteSystemData;
if (overwriteSystenData != null)
{
overwriteSystenData.CurrentSelection = OverwriteSystemDataSelections.Overwrite;
return;
}
}
private static void PostConfigureDownloadCallback(DownloadConfiguration
downloadConfiguration)
{
StartModules startModules = downloadConfiguration as StartModules;
if (startModules != null)
{
startModules.CurrentSelection = StartModulesSelections.StartModule;
return;
}
}
private static void WriteDownloadResults(DownloadResult result)
{
}
private static void RecursivelyWriteMessages(DownloadResultMessageComposition messages,
string indent = "")
{
indent += "\t";
foreach (DownloadResultMessage message in messages)
{
Console.WriteLine(indent + "Message: " + message.Message);
}
}

7.19.8 Fonctions de chargement de données dans l'API
7.19.8.1 Chargement du système PC
Conditions
Application
Vous pouvez charger indépendamment la station PC Plus et la CPU logicielle. Pour charger la
configuration de la station PC Plus, vous devez appeler l'élément d'appareil stationmanager du
châssis de l'appareil et appeler le download provider comme service. La CPU logicielle aussi
doit être appelée comme élément d'appareil pour la même opération.
Code de programme : charger des composants logiciels et matériels

Vous pouvez charger sur un appareil des composants logiciels et matériels à l'aide du service
DownloadProvider qui peut être appelé via un DeviceItem indiqué. Si un DeviceItem
représente une cible pouvant être chargée, une instance de DownloadProvider est fournie en
retour en cas d'appel de GetService call. Sinon, la valeur zéro est renvoyée.
DeviceItem stationManager = dev.DeviceItems.First(p => p.PositionNumber ==

0).DeviceItems.First(a => a.PositionNumber == 125);
DownloadProvider downloadProviderStationManager =
stationManager.GetService<DownloadProvider>();
if (downloadProviderStationManager == null)
{
//no download is possible for PC-Station
}
DeviceItem swCpu = dev.DeviceItems.First(p => p.Name == "Software PLC_1");
DownloadProvider downloadProviderSwCpu = swCpu.GetService<DownloadProvider>();
Modifiez le code de programme suivant pour configurer des paramètres réseau :
ConnectionConfiguration connConfig = downloadProviderStationManager.Configuration;

ConfigurationMode configurationMode = connConfig.Modes.Find("PN/IE");
ConfigurationPcInterface pcInterface = configurationMode.PcInterfaces.Find("ASIX AX88179
USB 3.0 to Gigabit Ethernet Adapter", 1);
ConfigurationTargetInterface targetInterface = pcInterface.TargetInterfaces.Find("2 X2");
IConfiguration targetConfiguration = pcInterface.TargetInterfaces[0];
bool isConfigured = connConfig.ApplyConfiguration(targetInterface);
if (isConfigured)
...

Notez que lors d'un redémarrage du système cible après le chargement de la configuration de
la station PC Plus, la réaction standard d'Openness est Attente. Cela signifie que le flux de
code Openness est interrompu jusqu'à la fin du chargement du premier niveau (et après
redémarrage du système cible) ou jusqu'à ce que le délai soit dépassé ou qu'une erreur se
produise.
Si vous ne voulez pas attendre le redémarrage, vous pouvez choisir une option post-
chargement intitulée WaitOnReboot.
//Post Download Configuration Delegate

DownloadConfigurationDelegate postDownloadForPcStation = downloadConfiguration =>
{
WaitOnReboot waitOnReboot = downloadConfiguration as WaitOnReboot;
if (waitOnReboot != null)
{
//In case user does not want to wait...
waitOnReboot.CurrentSelection = WaitOnRebootSelections.NoAction;
//In case user wants to wait... This is the default option anyway...
//waitOnReboot.CurrentSelection = WaitOnRebootSelections.Wait;
return;
}
};

Vous devez toujours charger la CPU logicielle séparément, mais il faut s'assurer que la station
PC a d'abord été chargée.
DownloadResult downloadResult = null;

try
{
//WE FIRST DOWNLOAD PC-STATION
downloadResult = downloadProviderStationManager.Download(targetConfiguration,
preDownloadForPcStation, postDownloadForPcStation, DownloadOptions.Hardware);
if (DownloadResultState.Error != downloadResult.State)
{
Console.WriteLine("The download is successful for pc-station");
}
}
catch (EngineeringTargetInvocationException e)
{
Console.WriteLine("Exception Thrown, Message: " + e.Message.ToString());
}
downloadResult = null;
try
{
downloadResult = downloadProviderSwCpu.Download(targetConfiguration, preDownloadForSwCpu,
postDownloadForWinac, DownloadOptions.Hardware | DownloadOptions.Software);
if (DownloadResultState.Error != downloadResult.State)
{
Console.WriteLine("The download is successful for SW-CPU");
}
}
{
Console.WriteLine("Exception Thrown, Message: " + e.Message.ToString());
}
Le chargement de la CPU logicielle est similaire à celui d'un PC normal. Vous trouverez plus
d'informations sur le chargement d'une CPU logicielle sous texte hotspot (Page 466).
Remarque
Le chargement d'API activés F n'est actuellement pas pris en charge pour une CPU logicielle,
tout comme pour une CPU matérielle.
Une méthode de chargement déclenche aussi la compilation. Il est aussi possible de compiler
indépendamment un élément d'appareil, avec l'extrait de code suivant :
ICompilable compileServiceSwCpu = swCpu.GetService<ICompilable>();

ICompilable compileServiceStationManager = stationManager.GetService<ICompilable>();
CompilerResult compileResultStationManager = compileServiceStationManager.Compile();
CompilerResult compileResultSwCpu = compileServiceStationManager.Compile();
bool compileCheck = !compileResultStationManager.State.Equals(CompilerResultState.Error);
if (compileCheck != true)
{
...
}

Voir aussi
Charger des composants matériels et logiciels dans l'API (Page 466)
7.19.8.2 Charger des composants matériels et logiciels dans l'API
Conditions
Application
L'utilisateur d'Openness peut charger des composants logiciels et matériels dans l'API via
DownloadProvider (accès via le DeviceItem). Si un DeviceItem représente une cible pouvant
être chargée, une instance de DownloadProvider est fournie en retour en cas d'appel de
GetService. Sinon, le service fournit null en retour.
Code de programme : Appeler le service DownloadProvider depuis un élément d'appareil

DownloadProvider downloadProvider = deviceItem.GetService<DownloadProvider>();
if (downloadProvider != null)
{ ...
}
Paramètres de la méthode Download

Pour charger des données dans un API, l'utilisateur appelle la méthode Download de
DownloadProvider. La méthode Download comprend quatre paramètres : l'objet
IConfiguration, deux délégués et DownloadOptions (matériel, logiciel ou matériel et logiciel).

configuration Siemens.Engineering.Connec‐ Configuration de la connexion à un ap‐
tion.IConfiguration pareil.
preDownloadConfigurationDelegate Siemens.Engineering.Download.Down‐ Délégué à appeler pour le contrôle de la
loadConfigurationDelegate configuration avant la procédure de
chargement.


postDownloadConfigurationDelegate Siemens.Engineering.Download.Down‐ Délégué à appeler pour le contrôle de la
loadConfigurationDelegate configuration après la procédure de
chargement.
downloadOptions Siemens.Engineering.Download.Down‐ Options de chargement.
loadOptions
● La procédure de chargement Openness n'est prise en charge que si les configurations sont
réalisées correctement par l'utilisateur. Si la configuration n'est pas valide, une
EngineeringTargetInvocationException est émise et la procédure de chargement est
annulée. Les API activés avec sécurité ne sont pas pris en charge pour la procédure de
chargement.
● La compilation faisant partie de la procédure de chargement, il est recommandé d'exécuter
la compilation avant la procédure de chargement afin d'analyser les résultats de la
compilation.
● Openness ne prend en charge que l'option de chargement complet.
Paramètre 1 : IConfiguration
L'utilisateur doit indiquer l'objet IConfiguration comme premier paramètre de la méthode
Download. Il sert à établir une connexion à l'API spécifié. L'interface IConfiguration est mise en
œuvre par ConfigurationAddress et ConfigurationTargetInterface. Il est possible d'accéder aux
deux objets via l'instance ConnectionConfiguration. L'instance ConnectionConfiguration peut
être déterminée via la propriété DownloadProvider.Connection: ConnectionConfiguration ou
en option via OnlineProvider.Connection: ConnectionConfiguration.
La configuration de l'objet ConnectionConfiguration est décrite à la rubrique AUTOHOTSPOT.
...
DownloadProvider downloadProvider = null;
ConnectionConfiguration configuration = downloadProvider.Configuration;
IConfiguration targetConfiguration = pcInterface.TargetInterfaces[0];
...
Paramètres 2 et 3 : DownloadConfigurationDelegate
L'utilisateur d'Openness doit mettre à disposition deux mises en œuvre de
DownloadConfigurationDelegate(DownloadConfiguration downloadConfiguration) vides. Le
premier délégué est appelé pour les configurations avant la procédure de chargement et le
second une fois la procédure de chargement terminée. Les délégués sont appelés pour
chaque configuration pour laquelle une action de l'utilisateur est nécessaire. Pour plus
d'informations sur les rappels, référez-vous à Prise en charge de rappels (Page 477) Certaines
configurations ne comprennent qu'une seule information et ne nécessitent alors pas d'action
de l'utilisateur.
Les types possibles de configuration de chargement sont décrits ci-après.


DownloadConfiguration ● Classe de base pour toutes les configurations.
● Contient l'unique propriété DownloadConfiguration.Message : string (propriété protégée en
écriture contenant le message de configuration)
DownloadSelectionConfi‐ ● Classe de base pour toutes les configurations pouvant être sélectionnées.
guration ● Ne contient aucune autre propriété. Une sélection doit être mise à disposition dans toutes les
classes subordonnées dérivées de cette classe.
DownloadCheckConfigu‐ ● Classe de base pour toutes les configurations contrôlées ou non.
ration ● Contient l'unique propriété DownloadCheckConfiguration.Checked: bool<string> (propriété
accessible en lecture/écriture indiquant si la configuration est contrôlée ou non)
DownloadPasswordConfi‐ ● Classe de base pour toutes les configurations nécessitant un mot de passe pour la procé‐
guration dure de chargement.
● Contient une méthode unique de définition du mot de passe. DownloadPasswordConfigu‐
ration.SetPassword (password: SecureString) : void
Le type de données des configurations est expliqué ci-après.



DownloadSelection‐ StartModules Set CurrentSelection:StopModulesSelections. Les va‐
Configuration leurs d'énumération disponibles sont
NoAction (No action)
StartModule (Stop module)
Ces modules sont arrêtés pour un chargement dans un appareil.
StopModules Set CurrentSelection:StartModulesSelections. Valeurs
d'énumération disponibles :
StopAll (Stop all)
Ces modules sont démarrés une fois la procédure de chargement ter‐
minée.
AllBlocksDownload Set CurrentSelection:AllBlocksDownloadSelections.
Valeur d'énumération disponible :
DownloadAllBlocks (Download all blocks to the
device)
Charge le logiciel dans l'appareil.
OverwriteSystemData Set CurrentSelection:OverwriteSystemDataSelections.
Les valeurs d'énumération disponibles sont
Overwrite (Download to device)
Supprime et écrase les données système disponibles dans le lieu de
stockage cible.
ConsistentBlocksDown‐ Set
load CurrentSelection:ConsistentBlocksDownloadSelections
. Valeur d'énumération disponible :
ConsistentDownload (Consistent download)
Charge le logiciel dans l'appareil.
AlarmTextLibrariesDown‐ Set
load CurrentSelection:AlarmTextLibrariesDownloadSelectio
ns. Les valeurs d'énumération disponibles sont
ConsistentDownload (Consistent download)
Charge tous les textes d'alarme et toutes les listes de texte.
ProtectionLevelChanged Set CurrentSelection:ProtectionLevelChangedSelections. Les valeurs
d'énumération disponibles sont
NoChange (No change)
ContinueDownloading (Continue downloading to the
device)
La protection de la CPU est définie sur le prochain niveau plus bas.
ActiveTestCanBeAborted Set
CurrentSelection:ActiveTestCanBeAbortedSelections.
AcceptAll (Accept all)
Les fonctions de test et de mise en service actives sont annulées pen‐
dant la procédure de chargement dans l'appareil.


ResetModule Les valeurs d'énumération Set
CurrentSelection:ResetModuleSelections disponibles sont
DeleteAll (Delete all)
Réinitialise le module.
LoadIdentificationData Set
CurrentSelection:LoadIdentificationDataSelections.
LoadNothing (Load nothing)
LoadData (Load data)
LoadSelected (Load selected)
Charger les données d'identification dans les appareils PROFINET IO
et leurs modules.
DifferentTargetConfigura‐ Set
tion CurrentSelection:DifferentTargetConfigurationSelect
ions. Les valeurs d'énumération disponibles sont
Indique la différence entre le module configuré et le module cible (en
ligne).
InitializeMemory Set CurrentSelection:InitializeMemorySelections. Va‐
leurs d'énumération disponibles :
Ce type de données sert à l'initialisation de la mémoire.
ExpandDownload Set CurrentSelection: ExpandDownloadSelections. Va‐
Download (Download)}}
Le chargement doit être étendu au-delà de votre sélection.


DownloadCheckConfi‐ CheckBeforeDownload Propriété Set IsChecked:bool
guration Effectue un contrôle avant le chargement dans l'appareil.
UpgradeTargetDevice Propriété Set IsChecked:bool
Contrôle les différentes versions de projet dans l'appareil configuré et
dans l'appareil cible (en ligne).
OverWriteHMIData Propriété Set IsChecked:bool
Écrase les objets en ligne.
FitHMIComponents Propriété Set IsChecked:bool
Les composants avec une autre version sont installés sur l'appareil
cible.
TurnOffSequence Propriété Set IsChecked:bool
Désactive la séquence avant le chargement.
OverwriteTargetLangua‐ Propriété Set IsChecked:bool
ges Pour différencier les paramètres du projet et de la programmation de
l'API
DowngradeTargetDevice Propriété Set IsChecked:bool
Pour mentionner les différents formats de fichier dans des projets en
ligne et hors ligne.
DownloadPassword‐ ModuleReadAccessPass‐ Méthode Set password via
Configuration word SetPassword(password:SecureString)
Saisir le mot de passe afin d'obtenir un accès en lecture au module.
ModuleWriteAccessPass‐ Méthode Set password via
word SetPassword(password:SecureString)
Saisir le mot de passe afin d'obtenir un accès en écriture au module.
BlockBindingPassword Méthode Set password via
SetPassword(password:SecureString)
Méthode pour la configuration d'un mot de passe lié à un bloc.
IMPORTANT
Tenez compte du fait que les configurations de chargement sont semblables aux
configurations dans les dialogues avec aperçu du chargement et ressemblent aux résultats
de chargement si vous travaillez avec l'interface utilisateur de TIA Portal.
ATTENTION
L'utilisateur de l'API est responsable des mesures de sécurité pour la gestion des mots de
passe par code.
Une configuration non traitée pouvant empêcher la procédure de chargement entraîne une
EngineeringTargetInvocationException et annule la procédure de chargement. Une

EngineeringDelegateInvocationException est émise en cas d'exception non traitée dans le

délégué.
Exemple de mise en œuvre de PreDownloadDelegate :

private static void PreConfigureDownload(DownloadConfiguration downloadConfiguration)
{
StopModules stopModules = downloadConfiguration as StopModules;
if (stopModules != null)
{
stopModules.CurrentSelection = StopModulesSelections.StopAll; // This selection
will set PLC into "Stop" mode
return;
}
AlarmTextLibrariesDownload alarmTextLibraries = downloadConfiguration as
AlarmTextLibrariesDownload;
if (alarmTextLibraries != null)
{
alarmTextLibraries.CurrentSelection =
AlarmTextLibrariesDownloadSelections.ConsistentDownload;
return;
}
BlockBindingPassword blockBindingPassword = downloadConfiguration as
BlockBindingPassword;
if(blockBindingPassword != null)
{
SecureString password = ...; // Get Binding password from a secure location
blockBindingPassword.SetPassword(password);
return;
}
CheckBeforeDownload checkBeforeDownload = downloadConfiguration as
CheckBeforeDownload;
if (checkBeforeDownload != null)
{
checkBeforeDownload.Checked = true;
return;
}
ConsistentBlocksDownload consistentBlocksDownload = downloadConfiguration as
ConsistentBlocksDownload;
if (consistentBlocksDownload != null)
{
consistentBlocksDownload.CurrentSelection =
ConsistentBlocksDownloadSelections.ConsistentDownload;
return;
}
ModuleWriteAccessPassword moduleWriteAccessPassword = downloadConfiguration as
ModuleWriteAccessPassword;
if (moduleWriteAccessPassword != null)
{
SecureString password = ...; // Get PLC protection level password from a secure
location
moduleWriteAccessPassword.SetPassword(password);
return;
}
throw new NotSupportedException(); // Exception thrown in the delagate will cancel
download
}

Exemple de mise en œuvre de PostDownloadDelegate :

private static void PostConfigureDownload(DownloadConfiguration downloadConfiguration)
{
{
startModules.CurrentSelection = StartModulesSelections.StartModule; //
Sets PLC in "Run" mode
}
}
Paramètre 4 : DownloadOptions
L'utilisateur doit indiquer les options de chargement (marquées par enum) via
DownloadOptions. Ce paramètre détermine le type de procédure de chargement à exécuter,
par exemple matériel, logiciel ou matériel et logiciel.
[Flags]
public enum DownloadOptions {
None = 0, // Download nothing
Hardware, // Download hardware only
Software // Download software only
}
Si l'utilisateur souhaite charger le matériel et le logiciel dans l'appareil,

DownloadOptions.Hardware | DownloadOptions.Software doit être indiqué comme 4ème
paramètre de la méthode Download.

DownloadResult
Le DownloadResult obtenu par l'action Download fournit l'état des objets chargés en retour.

[STAThread]
static void Main()
{
...
DownloadProvider downloadProvider = ...;
IConfiguration targetConfiguration = ...;
DownloadConfigurationDelegate preDownloadDelegate = PreConfigureDownload;
DownloadConfigurationDelegate postDownloadDelegate = PostConfigureDownload;
DownloadResult result = downloadProvider.Download(targetConfiguration,
preDownloadDelegate, postDownloadDelegate, DownloadOptions.Hardware |
DownloadOptions.Software);
if (result.State == DownloadResultState.Error)
{
// Handle error state
}
WriteDownloadResults(result);
...
}
private static void PreConfigureDownload(DownloadConfiguration downloadConfiguration)
{
...
}
private static void PostConfigureDownload(DownloadConfiguration downloadConfiguration)
{
...
}
private void WriteDownloadResults(DownloadResult result)
{
}
private void RecursivelyWriteMessages(DownloadResultMessageComposition messages, string
indent = "")
{
indent += "\t";
foreach (DownloadResultMessage message in messages)
{
Console.WriteLine(indent + "Message: " + message.Message);
}
}

Modifiez le code suivant pour effectuer un chargement dans l'API par un appel de la
configuration correspondante :
private static void DownloadNCU(Device ncu, ConfigurationTargetInterface

configurationTargetInterface)
{
DownloadProvider downloadProvider = null;
foreach (var item in ncu.DeviceItems[0].DeviceItems)
{
downloadProvider = item.GetService<DownloadProvider>();
if (downloadProvider != null)
{
break;
}
}
downloadProvider.Configuration.ApplyConfiguration(configurationTargetInterface);
IConfiguration targetConfiguration = configurationTargetInterface;
downloadProvider.Download(targetConfiguration, preDownloadDelegate,
postDownloadDelegate, DownloadOptions.Hardware | DownloadOptions.Software);
}
7.19.8.3 Démarrage et arrêt d'un API
Conditions
Utilisation
En cas d'interactions avec TIA Portal via l'API Openness, il peut être nécessaire de changer le
mode de fonctionnement de l'automate. TIA Portal Openness offre la possibilité de modifier
l'état de fonctionnement de l'API soit sur Start, soit sur Stop.

Code du programme
Pour régler l'état de fonctionnement de l'API sur STOP, modifiez le code de programme suivant.
public void ConfigurePreDownload(DownloadConfiguration downloadConfiguration)

{
StopModules stopModules = downloadConfiguration as StopModules;
if (stopModules != null)
{
// Puts PLC in "Stop" mode
stopModules.CurrentSelection = StopModulesSelections.StopAll;
}
}
Pour régler l'état de fonctionnement de l'API sur START, modifiez le code de programme
suivant.
public void ConfigurePostDownload(DownloadConfiguration downloadConfiguration)

{
{
// Puts PLC in "Start" mode
startModules.CurrentSelection = StartModulesSelections.StartModule;
}
}
7.19.8.4 Prise en charge de rappels
Conditions
Utilisation
Au cours de leur exécution, certaines méthodes de l'API nécessitent une interaction avec le
code d'application défini par l'utilisateur. Les Delegates servent à gérer ces actions de rappel
dans le code d'application personnalisé. Vous devez mettre en œuvre une méthode avec une
signature compatible et la transmettre à l'action en tant que paramètre delegate. Le TIA Portal
appelle les méthodes mises en œuvre pour l'exécution.

Code de programme
// This delegate is declared in Siemens.Engineering.dll

public delegate void
Siemens.Engineering.Download.DownloadConfigurationDelegate(Siemens.Engineering.Download.Co
nfigurations.DownloadConfiguration configuration);
...
Exemple de code d'application personnalisé utilisant et mettant en œuvre delegate :
[STAThread]
static void Main()
{
...
DownloadProvider downloadProvider = ...;
IConfiguration targetConfiguration = ...;
DownloadResult result = downloadProvider.Download(targetConfiguration,
preDownloadDelegate, postDownloadDelegate, DownloadOptions.Hardware |
...
//This method will be called back by TIA Portal

private static void ConfigurePreDownload(DownloadConfiguration downloadConfiguration)
{
// Work with the parameter
}
//This method will be called back by TIA Portal

private static void ConfigurePostDownload(DownloadConfiguration downloadConfiguration)
{
// Work with the parameter
}
Remarque
L'attribut STAThread assure que les délégués (Delegates) sont appelés dans le thread
principal de l'exécution.

7.19.8.5 Protection de l'API par mot de passe
Conditions
Voir Ouverture d'un projet (Page 109)
Utilisation
Dans les interactions avec TIA Portal via Openness API, il peut être nécessaire de changer le
niveau de protection de l'automate. TIA Portal Openness offre la possibilité de protéger l'API
par un mot de passe. Le mot de passe peut être aussi bien paramétré pour des API en écriture
seule que lecture seule.
Code de programme
Pour les API en écriture seule, modifiez le code de programme suivant :

{
ModuleReadAccessPassword moduleReadAccessPassword = downloadConfiguration
asModuleReadAccessPassword;
if (moduleReadAccessPassword != null)
{
moduleReadAccessPassword.SetPassword(password); // enter the password to gain
full access
}
}
Pour les API en lecture seule, modifiez le code de programme suivant :

{
ModuleWriteAccessPassword moduleWriteAccessPassword = downloadConfigurationas
{
moduleWriteAccessPassword.SetPassword(password); // enter the password to gain full
access
}
}

ATTENTION
L'utilisateur de l'API est responsable des mesures de sécurité pour la gestion des mots de
passe par code.
7.19.8.6 Manipulation des mots de passe d'API liée aux blocs
Conditions
Utilisation
TIA Portal Openness prend en charge la liaison de données de mots de passe pour les
applications client. TIA Portal Openness donne au client un moyen de spécifier un mot de
passe lié au bloc. Par exemple, un mot de passe lié au bloc peut être configuré à la catégorie
DownloadPasswordConfiguration en faisant appel à la méthode SetPassword.
Remarque
Si vous souhaitez protéger la procédure de chargement avec un mot de passe, un mot de
passe doit être saisi à chaque appel de la fonction Download. Cela s'applique toujours, que
l'appareil soit configuré ou non. Après la saisie correcte du mot de passe pour une configuration
donnée, tous les appels suivants de SetPassword sont ignorés.

Code de programme

{
DownloadPasswordConfiguration downloadPasswordConfiguration = downloadConfiguration as
DownloadPasswordConfiguration;
if(downloadPasswordConfiguration != null &&
downloadPasswordConfiguration.Message.Contains("block_1"))
{
SecureString password = ...; // Get password from a secured location
downloadPasswordConfiguration.SetPassword(password);
}
}
7.19.9 Fonctions permettant l'accès au service API
7.19.9.1 Paramétrage des niveaux d'accès
Conditions
Application
TIA Portal Openness permet d'accéder, via le matériel PlcAccessLevelProvider sur la
Deviceitem CPU de l'appareil aux paramètres des niveaux d'accès.
Cette fonction fournit des actions pour la définition/la restauration du mot de passe et un attribut
modélisé pour définir/lire les paramètres des niveaux d'accès.
● Void SetPassword (accessLevelType PlcProtectionAccessLevel, mot de passe
SecureString )
● Void ResetPassword (accessLevelType PlcProtectionAccessLevel)
● Attribut PlcProtectionAccessLevel
De façon générale, les opérations dans Openness sont similaires à celles de l'IU TIA Portal.
● PlcProtectionAccessLevel peut toujours être lu et défini sur les API S7-1200/1500.
● Si, pour le niveau d'accès, un autre réglage que l'accès complet est défini (ou accès complet
y compris Fail-safe), un mot de passe doit être défini pour l'accès complet. Sinon, une erreur
de compilation se produit : "Le mot de passe ne doit pas être vide"

● Il n'est pas autorisé d'utiliser le même mot de passe pour différents niveaux d'accès.
● Seuls des mots de passe pour des niveaux d'accès supérieurs au niveau d'accès fixé
peuvent être définis/restaurés (si pour PlcProtectionAccessLevel, HMIAccess est
paramétré, un mot de passe peut être défini uniquement pour ReadAccess et FullAccess).
Exceptions possibles :
● EngineeringTargetInvocationException : "Un mot de passe identique existe déjà pour des
niveaux d'accès différents" – est retourné lorsque l'utilisateur essaie de définir le même mot
de passe pour des niveaux d'accès différents.
● EngineeringTargetInvocationException : "Impossible de définir le mot de passe pour le
niveau d'accès" – est retourné lorsque l'utilisateur essaie de définir un mot de passe pour un
niveau d'accès plus strict que celui sélectionné.
● EngineeringTargetInvocationException : "Le mot de passe ne doit pas être vide" – est
retourné lorsque l'utilisateur essaie de définir un mot de passe vide.
● EngineeringTargetInvocationException : "Niveau d'accès invalide" – est retourné lorsque
l'utilisateur essaie de définir un même mot de passe pour le niveau d'accès
FullAccessIncludingFailsafe sur des API qui ne sont pas de sécurité.
Niveau de protection
Dans Openness, le niveau d'accès est modélisé comme Enumeration avec le nom
PlcProtectionAccessLevel. Le nom des champs Enumeration est basé sur les entrées "Access
Level" pour les API S7-1200/1500.
Nom dans l'interface utilisa‐ Entrée d'énumération Valeur Remarques

teur TIA
- None 0 Pour l'initialisation de l'Enu‐
meration. Cette valeur ne
peut pas être définie par l'uti‐
lisateur Openness.
Accès complet (aucune pro‐ FullAccess 1
tection)
Accès en lecture ReadAccess 2
Accès IHM : HMIAccess 3
Aucun accès NoAccess 4
Accès complet y compris fail‐ FullAccessIncludingFailsafe 5 Disponible uniquement pour
safe (pas de protection) les API de sécurité.
Pour les API, un attribut EOM (attribut modélisé) avec le nom PlcProtectionAccessLevel , du
type PlcProtectionAccessLevel-Enumeration est disponible pour définir/appeler le niveau
d'accès.

Vous pouvez utiliser l'exemple de code suivant pour PlcProtectionAccessLevel pour "Aucun
accès" :
DeviceItem S71500PLC = ...;

PlcAccessLevelProvider myPlcAccessLevelProvider =
S71500PLC.GetService<PlcAccessLevelProvider>();
myPlcAccessLevelProvider.PlcProtectionAccessLevel = PlcProtectionAccessLevel.NoAccess;
Mot de passe
Le mot de passe est implémenté comme SecureString, pour des raisons de sécurité. Les mots
de passe pour les différents niveaux d'accès peuvent uniquement être définis/restaurés à l'aide
de l'action correspondante. La lecture des mots de passe n'est pas prise en charge.
myPlcAccessLevelProvider.SetPassword(PlcProtectionAccessLevel.ReadAccess,
someSecureString);
myPlcAccessLevelProvider.ResetPassword(PlcProtectionAccessLevel.ReadAccess);
Voir aussi
7.19.9.2 Accès à l'interface serveur OPC UA
Conditions
Application
Vous pouvez créer des objets d'interface de serveur et importer des fichiers XML qui
définissent l'interface serveur OPC UA pour l'API.
L'API TIA Portal Openness permet d'accéder via le service OpcUaProvider aux fonctionnalités
suivantes :
● Ajout d'un objet d'interface serveur OPC UA
● Énumération via l'interface serveur de l'API
● Importation d'un fichier d'interface serveur
● Exportation d'une interface serveur vers XML

● Activation/désactivation de l'interface serveur

● Suppression d'une interface serveur
Code de programme
À l'aide d'un service OpcProvider que vous pouvez acquérir via PlcSoftware, vous pouvez
interagir avec les interfaces serveur OPC UA.
PlcSoftware software = ....;

OpcUaProvider provider = software.GetService<OpcUaProvider>();
if (provider != null)
{
....
}
Pour permettre la navigation vers les interfaces serveur OPC UA, modifiez le code de
programme suivant :
PlcSoftware software = ....;

OpcUaProvider provider = software.GetService<OpcUaProvider>();
if (provider != null)
{
OpcUaCommunicationGroup commGroup = provider.CommunicationGroup;
ServerInterfaceGroup serverInterfaceGroup = commFolder.ServerInterfaceGroup;
ServerInterfaceComposition serverInterfaces = serverInterfaceGroup.ServerInterfaces;
}
Pour énumérer les éléments de la bibliothèque ServiceInterfaceComposition, modifiez le code

ServerInterfaceComposition serverInterfaces = ....;

foreach (ServerInterface serverInterface in serverInterfaces)
{
....;
}
Pour ajouter un objet d'interface serveur OPC UA, modifiez le code de programme suivant :

if (serverInterfaces != null)
{
ServerInterface serverInterface = serverInterfaces.Create(name);
}

Pour appeler et définir les propriétés d'un objet d'interface serveur OPC UA, modifiez le code

{
ServerInterface serverInterface = serverInterfaces.Create("New Interface");
serverInterface.Author = "James Cornett";
}
Pour définir le contenu d'un objet d'interface serveur basé sur un fichier XML, modifiez le code

{
ServerInterface serverInterface = serverInterfaces.Create(name);
if (serverInterface != null)
{
serverInterface.Import(new FileInfo(importFilePath));
}
}
Pour écrire le contenu d'un objet d'interface serveur dans un fichier XML, modifiez le code de
programme suivant :
String exportFilePath = Path.Combine(Directory.GetCurrentDirectory(),

"ExportInterface.xml"); 　
ServerInterface serverInterface = …;
serverInterface.Export(new FileInfo(exportFilePath));
Pour supprimer l'objet de la ServerInterfaceComposition dans laquelle il est contenu et annuler

l'affectation de l'objet, modifiez le code de programme suivant :
ServerInterface serverInterface = …;
serverInterface.Delete());
Voir aussi

7.19.9.3 Accéder au total de contrôle logiciel
Conditions
Application
Avec l'API Openness, vous pouvez accéder au total de contrôle logiciel d'une station API.
Code de programme
Pour l'accès, vous appelez l'instance PlcSoftware et vous chargez une instance de service de
PlcChecksumProvider.
PlcSoftware plc = …;
//get PlcSoftware instance
PlcChecksumProvider checksumProvider =
plc.GetService<PlcChecksumProvider>();
Si l'API ne prend pas en charge le calcul du total de contrôle, l'appel de GetService fournit un
retour nul.
Sur l'instance PlcChecksumProvider, le total de contrôle logiciel peut être atteint comme suit :
string softwareChecksum = checksumProvider.Software;
L'attribut logiciel est protégé en écriture et fournit un retour nul lorsque le programme n'est pas
compilé.
Voir aussi
7.19.9.4 Affecter une interface PC
Conditions

Application
Pour l'affectation d'interface, vous devez appeler le service PcInterfaceAssignment de
Siemens.HW.Features sur l'interface d'élément de l'appareil.
Si la station PC possède une version <= 2.0, les méthodes de ce service fournissent un retour
nul et l'affectation d'interface n'est pas possible pour les interfaces qui sont affectées
uniquement à la station PC ou uniquement à Windows ou à aucun des deux. Pour les interfaces
affectées à une CPU logicielle, cela est possible.
Remarque
Lors de l'échange CAx, la prise en charge de la station PC est très limitée. Seules les stations
PC avec version 1.0 et la valeur standard pour InterfaceAssignment sont prises en charge.
Cela est dû au fait que ces deux valeurs influencent la structure de l'appareil (c.-à-d. les
éléments montés, les lieux d'enfichage). Étant donné que les paramètres n'appartiennent pas
au fichier AutomationML, les valeurs ne sont pas définies lors de l'importation. En
conséquence, la structure de l'IPC ne convient pas et les autres modules ne peuvent pas être
enfichés.
Code de programme : Affectation d'interface

Pour l'affectation d'interface, modifiez et utilisez le code de programme suivant :
DeviceItem swCpu = ...;

DeviceItem myInterface = ...;
PcInterfaceAssignment provider = myInterface.GetService<PcInterfaceAssignment>();
//user has to give device item sw cpu in case he/she wants to assign to it. (in the future,
there could be multi sw-cpu cases)
provider.AssignInterface(PcInterfaceAssignmentMode.SoftwarePlc, swCpu);
...
provider.AssignInterface(PcInterfaceAssignmentMode.PcStation);
...
provider.AssignInterface(PcInterfaceAssignmentMode.None);
...
Pour appeler des informations sur le mode d'affectation d'une interface, modifiez et utilisez le

PcInterfaceAssignmentMode mode = provider.PcInterfaceAssignmentMode;
switch(mode)
{
case PcInterfaceAssignmentMode.None: Console.WriteLine("Assigned to none or windows-
only.");
break;
case PcInterfaceAssignmentMode.PcStation: Console.WriteLine("Assigned to pc-station.");
break;
case PcInterfaceAssignmentMode.SoftwarePlc: Console.WriteLine("Assigned to SoftwarePlc: "
+ provider.SoftwarePlc.Name);
break;
}

Code de programme : Configuration de ressources matérielles et extension IPC

Avec le code suivant, vous pouvez également sélectionner la propriété correcte 'Extension IPC
et ressource matérielle' via le service PcInterfaceAssignment :
DeviceItem myInterface = ...;

//this method returns a subset of IpcExpansion values which are available for the IPC that
the interface is plugged in. IEnumerable<string> ipcExpansionChoices =
provider.GetAvailableIPCExpansions ();
string myChoice;
foreach(var choice in ipcExpansionChoices)
{
//user must select the desired value depending on his/her configuration
if (choice.Contains("3yxx1")
{
myChoice = choice;
break;
}
}
provider.IpcExpansion = myChoice;
//after assigning IpcExpansion value, user may assign HardwareResource value using the
following enumeration. provider.HardwareResource = HardwareResource.X101;
//OR
//myInterface.SetAttribute("HardwareResource", HardwareResource.X101);
//myInterface.SetAttribute("IpcExpansion", mychoice);
Voir aussi
7.19.10 Charger le matériel, le logiciel et des fichiers dans l'appareil API
Conditions
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
Utilisation
L'utilisateur Openness peut charger une station dans un projet via StationUploadProvider
(auquel un accès est effectué depuis un project). Le chargement dans un DeviceGroup n'est
pas pris en charge Si un project est utilisé pour l'exécution d'une procédure de chargement, le
service renvoie une instance de StationUploadProvideren cas d'appel de GetService . Sinon,
la valeur zéro est renvoyée.

Code de programme : Appeler le service StationUploadProvider depuis un projet
Project myProject = ...;

StationUploadProvider uploadProviderForProject =
myProject.GetService<StationUploadProvider>();
if (uploadProviderForProject != null)
{
...
}
Paramètres de la méthode Upload

Pour exécuter le chargement dans un API, l'utilisateur appelle la méthode Upload
StationUpload du StationUploadProvider. . Les paramètre de cette méthode Upload sont
ConfigurationAddress et UploadConfigurationDelegte . Comme le logiciel, le matériel et des
fichiers sont chargés avec la méthode StationUpload, les UploadOptions sont facultatives.

configurationAddress Siemens.Engineering.Connection.Con‐ Adresse de l'appareil à charger
figurationAddress
uploadConfigurationDelegate Siemens.Engineering.Upload.Upload‐ Délégué appelé pour vérifier la configu‐
ConfigurationDelegate ration avant le chargement
uploadOptions Siemens.Engineering.Upload.Uploa‐ Options Upload
dOptions
Paramètre 1 : ConfigurationAddress
L'utilisateur doit indiquer l'objet ConfigurationAddress pour la méthode Upload. L'objet Adresse
permet d'établir une connexion à l'API spécifié dans lequel le chargement doit être effectué.
L'objet ConfigurationAddress doit être créé dans la ConnectionConfiguration du
StationUploadProvider. . La Configuration contient une liste de Modes pris en charge. Un des
Modes doit être sélectionné pour utilisation lors du chargement. Le ConfigurationMode
sélectionné contient une liste de toutes les PcInterfaces locales prenant en charge le Mode
sélectionné. L'une des interfaces doit être sélectionnée. L'adresse souhaitée peut être créée
dans la collection Address de la ConfigurationPcInterface sélectionnée.

Modifiez le code suivant pour créer un objet Adresse :
...
StationUploadProvider uploadProvider = null;
...
ConnectionConfiguration configuration = uploadProvider.Configuration;
//"Create an address. This "ConfigurationAddress" is used as parameter for upload."
ConfigurationAddress uploadAddress = pcInterface.Addresses.Create("192.68.0.1");
...
Chargement du projet
L'utilisateur peut démarrer le chargement de la station par l'appel de l'action StationUpload.
Les paramètres suivants sont obligatoires :
● ConfigurationAddress : L'adresse de l'appareil dans lequel le chargement doit être effectué
● UploadConfigurationDelegate : Le rappel pour le traitement d'inhibitions de chargement
...
StationUploadProvider uploadProvider = null;
Device uploadedObject = null;
...
UploadConfigurationDelegate preUploadDelegate = PreConfigureUpload;
UploadResult result = uploadProvider.StationUpload(uploadAddress, preUploadDelegate);
// The uploaded device
uploadedObject = result.UploadedStation;
if (uploadedObject == null)
{
...
}
internal void PreConfigureUpload(UploadConfiguration uploadConfiguration)
{
...
}
Paramètre2 : UploadConfigurationDelegate
L'utilisateur d'Openness doit mettre à disposition une implémentation de void
UploadConfigurationDelegate (UploadConfiguration uploadConfiguration). Le délégué est
appelé pour la configuration avant le chargement. Le délégué est appelé pour chaque
configuration pour laquelle une action de l'utilisateur est nécessaire. Pour plus d'informations
sur les rappels, référez-vous à AUTOHOTSPOT Certaines configurations ne comprennent
qu'une seule information et ne nécessitent alors pas d'action de l'utilisateur.

Les types possibles de configuration de chargement sont décrits ci-après :

UploadConfiguration ● Classe de base pour toutes les configurations. Elle contient des informations dans l'attribut
de message
● Contient l'unique propriété UploadConfiguration.Message : string (propriété protégée en
écriture contenant le message de configuration)
UploadPasswordConfigu‐ ● Dérivée de UploadConfiguration
ration ● Classe de base pour toutes les configurations requérant un mot de passe pour la procédure
de chargement.
● Contient une méthode unique de définition du mot de passe. UploadPasswordConfigura‐
tion.SetPassword (password: SecureString) : void - Définir le mot de passe
UploadSelectionConfigu‐ ● Classe dérivée de UploadConfiguration
ration ● Ne contient aucune autre propriété.
Le type de données des configurations est expliqué ci-après.

UploadPasswordConfi‐ ModuleReadAccessPass‐ Méthode Set password via
guration word SetPassword(password:SecureString)
Saisir le mot de passe afin d'obtenir un accès en lecture au module.
PasswordReadAccess Méthode Set password via
SetPassword(password:SecureString)
Saisir le mot de passe pour le chargement logiciel dans des API clas‐
siques afin d'obtenir un accès en lecture au module.
UploadSelectionConfi‐ UploadMissingProducts Set
guration CurrentSelection:UploadMissingProductsSelections Va‐
TryUpload (Consistent upload)
Indiquer une sélection pour le chargement.
La prise en charge d'un mot de passe de sécurité n'est pas nécessaire. Aucun mot de passe
n'est requis pour l'accès en lecture lors du chargement dans un API de sécurité.
Une configuration non traitée pouvant empêcher la procédure de chargement entraîne une
EngineeringTargetInvocationException et annule la procédure de chargement.
Une EngineeringDelegateInvocationException est émise dans le cas d'une exception non
traitée dans le délégué.

Exemple de mise en œuvre de PreUploadDelegate :

private static void PreConfigureUpload(UploadConfiguration UploadConfiguration)
{
ModuleReadAccessPassword moduleReadAccessPassword = UploadConfiguration as
ModuleReadAccessPassword;
if (moduleReadAccessPassword != null)
{
foreach (var c in passWD)
password.AppendChar(c);
moduleReadAccessPassword.SetPassword(password);
return;
}
ModuleWriteAccessPassword moduleWriteAccessPassword = UploadConfiguration as

{
foreach (var c in passWD)
password.AppendChar(c);
moduleWriteAccessPassword.SetPassword(password);
return;
}
...
throw new NotSupportedException(); // Exception thrown in the delagate will cancel upload
}
Paramètre3 : UploadOptions
L'utilisateur ne peut pas indiquer les options Upload. Les options Upload sont les suivantes :
"Matériel", "Logiciel", "Matériel et logiciel" ainsi que "Matériel, logiciel et fichiers".
UploadResult
Le résultat UploadResult renvoyé par l'action Upload fournit l'état des objets chargés en retour.
● UploadResult.Message: UploadResultMessageComposition - Composition de
UploadResultMessage
Les attributs suivants sont pris en charge :
Attributs Description
ErrorCount Valeur int des erreurs lors du chargement
State UploadResultState avec les valeurs suivantes : Success, Information, Warning et
Error

UploadedStation Une instance "Device" de la station chargée
WarningCount Nombre d'avertissements au chargement comme int
UploadResultMessage contient :
● UploadResultMessage.Messages : UploadResultMessageComposition - Composition de
UploadResultMessage
Les attributs suivants sont pris en charge :
DateTime System.DateTime de l'alarme créée.
ErrorCount Un compteur int pour des erreurs.
State UploadResultState avec les valeurs suivantes : Success, Information, Warning et
Error
WarningCount Nombre d'avertissements comme int
Exemple d'appel de la méthode Upload

internal bool UploadPLC()
{
...
UploadResult result = uploadProvider.StationUpload(uploadAddress, preUploadDelegate);
...
PrintAllMessages(result.Messages, 0);
...
}
internal void PrintAllMessages(UploadResultMessageComposition messages, int level)

{
if (messages == null)
return;
if (level == 0)
Console.WriteLine("\n");
foreach (UploadResultMessage message in messages)
{
string messageOut = message.Message.PadLeft(message.Message.Length + level, '\t') + "\n";
Console.WriteLine(messageOut);
if ((message.Messages != null) && (message.Messages.Count > 0))

PrintAllMessages(message.Messages, level+1);
}
}

7.19.11 Comparer le logiciel de l'API
Conditions
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
Utilisation
Pour déterminer la divergence entre les logiciels de deux appareils, vous disposez des
possibilités suivantes :
● Comparaison entre les logiciels de deux API configurés
● Comparaison entre le logiciel d'un API et la bibliothèque de projet
● Comparaison entre le logiciel d'un API et la bibliothèque globale
● Comparaison entre le logiciel d'un API et la copie maître d'un API
● Comparaison entre le logiciel d'un API configuré et le logiciel d'un API connecté à l'état "En
ligne"
Signature
Utilisez la méthode CompareTo ou CompareToOnline pour la comparaison.
public CompareResult CompareTo (ISoftwareCompareTarget compareTarget)

public CompareResult CompareToOnline ()
Valeur de retour/paramètre Fonction

CompareResult compareResult Fournit en retour le résultat de comparaison :
● FolderContentsDifferent : le contenu des dossiers
comparés diffère.
● FolderContentsIdentical : le contenu des dossiers
comparés est identique.
● ObjectsDifferent : le contenu des objets comparés
diffère.
● ObjectsIdentical : le contenu des objets comparés
est identique.
● LeftMissing : l'objet n'est pas compris dans l'objet à
partir duquel la comparaison a été lancée.
● RightMissing : l'objet n'est pas compris dans l'objet
auquel la comparaison s'applique.
● CompareIrrelevant: La comparaison de ces 2 objets
n'est pas pertinente.
● FolderContainsDifferencesOwnStateDifferen
t: le contenu du dossier présente une ou deux différen‐
ces, l'état du dossier diffère.
● FolderContentEqualOwnStateDifferent: Le con‐
tenu du dossier est identique, l'état du dossier diffère.
ISoftwareCompareTarget Liste d'objets comparables.
compareTarget
Code de programme
Pour afficher le résultat de la comparaison, modifiez le code de programme suivant :
private static void WriteResult(CompareResultElement compareResultElement, string indent)

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

Pour comparer les logiciels des appareils, modifiez le code de programme suivant :
private static void CompareTwoOfflinePlcs(PlcSoftware plcSoftware0, PlcSoftware

plcSoftware1)
{
if (plcSoftware0 != null && plcSoftware1 != null)
{
CompareResult compareResult = plcSoftware0.CompareTo(plcSoftware1);
WriteResult(compareResult.RootElement, string.Empty);
}
}
Pour comparer le logiciel d'un API avec la bibliothèque de projet, modifiez le code de
programme suivant :
private static void ComparePlcToProjectLibrary(Project project, PlcSoftware plcSoftware)

{
if (project != null && plcSoftware != null)
{
CompareResult compareResult = plcSoftware.CompareTo(project.ProjectLibrary);
}
}
Pour comparer le logiciel d'un API avec la bibliothèque globale, modifiez le code de programme
suivant :
private static void ComparePlcToGlobalLibrary(PlcSoftware plcSoftware, GlobalLibrary

globalLibrary)
{
if (plcSoftware != null && globalLibrary != null)
{
CompareResult compareResult = plcSoftware.CompareTo(globalLibrary);
WriteResult(compareResult.RootElement, String.Empty);
}
}
Pour comparer le logiciel d'un API avec une copie maître, modifiez le code de programme
suivant :
private static void ComparePlcToMasterCopy(Project project, PlcSoftware plcSoftware)

{
if (project != null && plcSoftware != null)
{
CompareResult compareResult =
plcSoftware.CompareTo(project.ProjectLibrary.MasterCopyFolder.MasterCopies[0]);
}
}

Pour comparer le logiciel d'un API avec le logiciel d'un API connecté, modifiez le code de
programme suivant :
private static void ComparePlcToOnlinePlc(PlcSoftware plcSoftware)

{
if (plcSoftware != null)
{
CompareResult compareResult = plcSoftware.CompareToOnline();
}
}
7.19.12 Comparer le matériel API
Conditions
Application
À l'aide de TIA Portal Openness, vous pouvez comparer le matériel de deux appareils API.
Signature
Utilisez la méthode CompareTo ou pour la comparaison des deux objets Matériel.
CompareResult CompareTo (IHardwareCompareTarget compareTarget);
Valeur/paramètre de retour Fonction

CompareResult compare result Fournir en retour le résultat de comparaison :
● FolderContainsDifferencesOwnStateDifferent : le conte‐
nu du dossier présente une ou deux différences, l'état du
dossier diffère.
● FolderContentEqualOwnStateDifferent : Le contenu du
dossier est identique, l'état du dossier diffère.
IHardwareCompareTarget compareTarget Cible de comparaison pour laquelle la comparaison matériel‐
le est réalisée. Doit être différent de zéro.
Si une tentative de comparaison de matériel est effectuée alors que le paramètre

compareTarget a la valeur zéro, une exception
Siemens.Enginnering.EngineeringTargetInvocationExceptions est déclenchée.

Programme
Modifiez le code de programme suivant pour afficher le résultat de la comparaison :
...
CompareResult compareResult = plc_1.CompareTo(plc_2);
CompareResultState resultState = compareResult.RootElement.ComparisonResult;
if (resultState == CompareResultState.FolderContainsDifferencesOwnStateDifferent)
{
// Folder contents have one or more differences, folder's own state is different:
// May occur if the plc has a different subordinate element, e.g., a local module, and
// the plc itself is different, e.g., in a parameter
}
else if (resultState == CompareResultState.FolderContentEqualOwnStateDifferent)
{
// Folder content is the same, folder's own state is different:
// May occur if a folder-style module, e.g., FM 351, has equal subordinate elements but
// the module itself is different, e.g., in a parameter
}
else if (resultState == CompareResultState.FolderContentsIdentical)
{
...
}
...
7.19.13 Etablir ou interrompre une liaison en ligne à l'API
Conditions requises
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
● Tous les appareils sont énumérés.
Voir AUTOHOTSPOT.
Utilisation
Vous pouvez établir la liaison en ligne à un API ou interrompre une liaison en ligne existante.

Code du programme
Pour établir ou interrompre la liaison en ligne à un API, modifiez le code de programme suivant :
public static void SetOnlineConnection(DeviceItem deviceItem)

{
if (onlineProvider == null) { return; }
// Go online
if (onlineProvider.Configuration.IsConfigured)
{
}
// Go offline
onlineProvider.GoOffline();
}
Vous pouvez également établir ou interrompre les liaisons en ligne à tous les API disponibles
dans un projet.
public static void SetOnlineConnectionForAllPLCs(Project project)

{
{
{
if (onlineProvider != null)
{
// Establish online connection to PLC:
// ...
// Disconnect online connection to PLC:

onlineProvider.GoOffline();
}
}
}
}
7.19.14 Affecter la langue du projet à l'API
Conditions

Application
À l'aide de TIA Portal Openness vous pouvez affecter des langues du projet au serveur Web
et afficher les langues d'un API S7-1500. Un attribut dynamique du type StructuredData est
nécessaire à cette fin.
Pour l'accès aux paramètres multilingues, le nouvel attribut dynamique MultilingualSupport du
type TableData a été ajouté. Cet attribut peut être réparti sur plusieurs lignes. Dans les lignes
individuelles, la langue du projet affectée est définie ou lue avec l'attribut dynamique
ProjectLanguage.
Code de programme
Modifiez le code de programme suivant pour affecter la langue du projet à l'API :
//To Set the Project Language

DeviceItem Plc = …;
Tabledata multilingualSupportTable = Plc.GetAttribute("MultilingualSupport");
StructuredDataComposition structuredDataComp = multilingualSupportTable.Rows; // This will
return a collection of Structured Data.
StrcuturedData firstRow= structuredDataComp[0]; //First row
Language activeGermanLanguage = activeLanguages.Find(CultureInfo.GetCultureInfo("de-DE"));
firstRow.SetAttribute("ProjectLanguage", activeGermanLanguage.Culture);
//To Get the Languages of device displayed
var assignedToGerman = firstRow.GetAttribute("DisplayLanguage");
7.19.15 Affecter des tables de visualisation et de forçage pour écran de serveur Web et
d'API
Conditions
Application
Avec TIA Portal Openness vous pouvez affecter au serveur Web des table de visualisation et
de forçage déjà créées. Pour les tables de visualisation et les tables de forçage, il s'agit d'un
logiciel qui peut être trouvé, créé et supprimé dans le conteneur logiciel. TIA Portal Openness
vous permet d'importer/exporter des tables de visualisation et de forçage. Pour exporter/
importer des tables de surveillance et de forçage, voir Exporter/importer des tables de
visualisation et de forçage permanent
Pour l'affectation des tables de visualisation et de forçage au serveur Web, le
serviceWatchAndForceTableAccessManager est utilisé sur le DeviceItem de l'API.

Ce service contient deux navigateurs pour les tables de visualisation et de forçage.

● WatchtableAccessRules {WatchtableAccessRuleComposition}
● ForcetableAccessRules {ForcetableAccessRuleComposition}
Le navigateur WatchTableAccessRules met à disposition la composition
WatchTableAccessRuleComposition qui comprend des objets du type
WatchTableAccessRule. La composition est vide par défaut. Pour les objets
WatchTableAccessRule , les actions "Rechercher" et "Créer" sont définies.
AccessRule pour WatchTable & ForceTable

● PlcWatchTable watchtable {get;} indique en retour la table de visualisation de l'objet logiciel.
Pour remplacer une table de visualisation affectée, l'utilisateur doit supprimer l'affectation
de la table actuelle (avec WatchTableAccessRule.Delete()) et ajouter une nouvelle table
(avec WatchTableAccessRule.Create()).
● WatchAndForceTableAccess access {get; set;} retourne ou définit le niveau d'accès du
serveur Web (c.-à-d. écriture ou lecture/écriture)
Nom dans la TIA UI Valeur Description enum dans Open‐

ness
- 0 None
Lecture 1 Read
lecture/écriture 2 Write
Des erreurs sont déclenchées dans les cas suivants :

● Lorsque le serveur Web n'a pas été activé (WebserverActivate == FALSE), une
EngineeringTargetInvocationException est déclenchée, dont les détails d'erreur informent
qu'une WatchTableAccessRule ne peut être ajoutée que si le serveur Web a été activé.
● Lorsque l'utilisateur tente d'ajouter une table de visualisation avec
WatchAndForceTableAccess.None une ConfigOpenessUserException est déclenchée,
dont les détails d'erreur informent que WatchAndForceTableAccess.None n'est pas
autorisé comme niveau d'accès.
Code de programme : Affecter les tables de visualisation et supprimer leur affectation

Pour rechercher une table de visualisation sur le serveur Web, modifiez le code de programme
suivant :
WatchAndForceTableAccessManager mngr =
deviceItem.GetService<WatchAndForceTableAccessManager>();
WatchTableAccessRuleComposition watchTableCmp = mngr.WatchTableAccesseRules;
WatchTableAccessRule accessRule1 = watchTableCmp.Find(watchTable1);
Remarque
Zéro est retourné lorsque la table de visualisation concernée n'est pas connectée au serveur
Web avec une WatchTableAccessRule

Modifiez le code de programme suivant pour créer sur le serveur Web une nouvelle table de
visualisation avec accès en lecture :
WatchTableAccessRuleComposition watchTableCmp = mngr.WatchTableAccesseRules;
watchTableCmp.Create(watchTable1, WatchAndForceTableAccess.Read);
Modifiez le code de programme suivant pour supprimer une WatchTableAccessRule et lever

l'affectation de la table de visualisation au serveur Web :
WatchTableAccessRule whatchtable= watchTableCmp.Find(watchTable1);

whatchtable.Delete();
Des erreurs sont déclenchées dans les cas suivants :

● Lorsque le serveur Web n'a pas été activé (WebserverActivate == FALSE), une
EngineeringTargetInvocationException est déclenchée, dont les détails d'erreur informent
qu'une WatchTableAccessRule ne peut être ajoutée que si le serveur Web a été activé
● Lorsqu'une WatchtableAccessRule est déjà présente pour cette table de visualisation, une
ConfigOpenessUserException est déclenchée, dont les détails d'erreur informent que la
table de visualisation est déjà présente.
● Lorsque vous tentez d'ajouter une table de visualisation avec
WatchAndForceTableAccess.None une ConfigOpenessUserException est déclenchée,
dont les détails d'erreur informent que WatchAndForceTableAccess.None n'est pas
autorisé comme niveau d'accès.
Code de programme : affecter au serveur Web une table de forçage

Pour rechercher une table de forçage sur le serveur Web, modifiez le code de programme
suivant :
ForceTableAccessRuleComposition forceTableCmp = mngr.ForceTableAccessRules;
ForceTableAccess forceTable = forceTableCmp.Find(forceTable1);
Modifiez le code de programme suivant pour créer une table de forçage API avec accès en
lecture :
ForceTableAccessRuleComposition forceTableCmp = mngr.ForceTableAccessRules;

forceTableCmp.Create(forceTable1, WatchAndForceTableAccess.Read);

Tables de visualisation et de forçage sur l'écran de l'API

Vous pouvez utiliser le même service Openness WatchAndForceTableAccessManager que
celui disponible sur l'affichage de sous-module (DeviceItem) du DeviceItem de l'API. Pour
l'affectation des tables de visualisation et de forçage à l'écran de l'API, la même fonction de
serveur Web que celle décrite ci-dessus est utilisée. À la différence du serveur Web, l'écran ne
peut pas être désactivé. Une validation similaire à WebserverActive n'est ici pas possible.
7.19.16 Accès au serveur Web et à la gestion des utilisateurs OPC UA
Conditions
Application
TIA Portal Openness vous permet d'accéder au serveur Web et au sous-module OPC UA des
API. Il est possible d'ajouter un utilisateur jusqu'au nombre maximal au serveur Web et au sous-
module OPC UA d'API. Cet utilisateur possède un nom d'utilisateur et du mot de passe.
Gestion des utilisateurs sur le serveur Web

Vous ne pouvez effectuer les opérations suivantes, comme p. ex. l'ajout d'un utilisateur, la
suppression d'un utilisateur et la définition du mot de passe sur le serveur Web pour tous les
appareils pris en charge que lorsque le serveur Web est activé sur le module.
Lorsque le serveur Web n'est pas activé une EngineeringTargetInvocationException est
déclenchée par l'ajout et la suppression d'utilisateurs et la définition du mot de passe. Les
opérations de lectures sont tout de même disponibles.
Le service WebServerUserManagement est uniquement disponible pour les Instances API des
appareils pris en charge. Pour tous les appareils non pris en charge, le service est nul.
WebServerUserManagement
{
Navigators WebServerUsers
{
WebServerUserComposition
}
}

Le service met à disposition un navigateur nommé WebServerUsers à l'aide duquel une

WebServerUserComposition peut être associée, qui gère les instances de WebServerUser.
WebServerUserComposition
{
WebServerUser Find(string username);
void Create(string username, WebserverUserPermissions permissions,SecureString password);
}
WebServerUser
{
string UserName{get;}
WebserverUserPermissions Permissions {get;set;}
void Delete();
void SetPassword(SecureString password);
}
Code de programme : Actions sur la WebServerUserComposition

Pour rechercher un utilisateur de serveur Web, modifiez le code de programme suivant :
WebServerUserComposition webServerUserComposition = WebServerUserManagement.WebServerUsers;

WebServerUser user1 = webServerUserComposition.Find("user1");
Modifiez le code de programme suivant pour créer un nouvel utilisateur serveur Web avec des
droits d'utilisateur serveur Web :

WebServerUser user1 = webServerUserComposition.Create("user1",
WebserverUserPermissions.ReadTagStatus, someSecureString);
Modifiez le code de programme suivant pour supprimer l'utilisateur de serveur Web :

user1.Delete();
Modifiez le code de programme suivant pour remplacer le mot de passe actuel par le nouveau :

user1.SetPassword(someSecureString);
Gestion des utilisateurs sur le serveur OPC UA

Vous ne pouvez effectuer les opérations suivantes, comme p. ex. l'ajout d'un utilisateur, la
suppression d'un utilisateur et la définition du mot de passe sur le serveur OPC UA pour tous
les appareils pris en charge que lorsque le serveur OPC UA et l'authentification sont activés.

Lorsque cette condition n'est pas remplie, l'opération déclenche une

EngineeringTargetInvocationException, dont les détails d'erreur informent que
l'authentification doit être activée.
Le service OpcUaUserManagement est disponible uniquement sur le sous-module OPC UA de
l'API. Le service est disponible pour tous les appareils pris en charge pour lesquels le sous-
module OPC UA est disponible pour l'élément d'appareil. Sinon, le service est retourné avec la
valeur nulle.
OpcUaUserManagement
{
Navigators OpcUaUsers
{
OpcUaUserComposition
}
}
Le service met à disposition un navigateur nomméOpcUaUsers à l'aide duquel une

OpcUaUserComposition peut être associée. La composition gère les instances de
OpcUaUser:
OpcUaUserComposition
{
OpcUaUser Find(string username);
void Create(string username, SecureString password);
}
OpcUaUser
{
string UserName{get;}
void Delete();
void SetPassword(SecureString password);
}
Code de programme : Actions sur la OpcUaUserComposition

Pour rechercher un OpcUaUser, modifiez le code de programme suivant :
OpcUaUserComposition opcUaUserComposition = opcUaUserManagement.OpcUaUsers;

OpcUaUser user1 = opcUaUserComposition.Find("user1");
Modifiez le code de programme suivant pour créer un nouvel OpcUaUser :

opcUaUserComposition.Create("user1", someSecureString);

Modifiez le code de programme suivant pour supprimer l'OpcUaUser :

OpcUaUser user = opcUaUserComposition.Find("user1");
user.Delete();
Modifiez et utilisez le code de programme suivant pour remplacer le mot de passe actuel par
un autre mis à disposition :

OpcUaUser user = opcUaUserComposition.Find("user1");
user.SetPassword(someSecureString);
7.19.17 Accès aux paramètres de domaine
Conditions
Introduction
TIA Portal Openness vous permet d'accéder à l'intégralité de la gestion de domaines. Les deux
nouveaux services suivants sont ajoutés à la classe Subnet pour permettre l'accès à la gestion
de domaine via TIA Portal Openness :
● Service MrpDomainOwner
● Service SyncDomainOwner
Code de programme : accéder à MrpDomainOwner

Le service MrpDomain fournit au navigateur du MrpDomain le contenu de la
MrpDomainComposition. La composition contient des objets du type "MrpDomain".
Subnet subnet = …;
MrpDomainOwner mrpDomainOwner = subnet.GetService<MrpDomainOwner>();
MrpDomainComposition mrpDomainComposition = mrpDomainOwner.MrpDomains;

Modifiez le code de programme suivant pour créer un nouveau domaine nommé

newMrpDomain :
int countOfMrpDomains = mrpDomainComposition.Count;

MrpDomain someMrpDomain = mrpDomainComposition.ElementAt(3);
MrpDomain firstMrpDomain = mrpDomainComposition.First();
MrpDomain byName = mrpDomainComposition.Find("DomainName");
// create a new domain
MrpDomain newMrpDomain = mrpDomainOwner.MrpDomains.Create("newMrpDomain");
Modifiez le code de programme suivant pour lire/écrire des valeurs d'attribut d'un domaine
MRP :
NetworkInterface toBeAdded = …;
newMrpDomain.SetAttribute("IsDefault", true);
newMrpDomain.SetAttribute("ManagerOutsideOfProjectActive", false);
var participants = firstMrpDomain.DomainParticipants;
int count = participants.Count;
participants.Add(toBeAdded);
foreach (NetworkInterface networkIf in participants)
{
// do something at the interface
}
newMrpDomain.Delete();
Code de programme : Accéder à SyncDomainOwner

Le service met à disposition les SyncDomains du navigateur qui contiennent les
SyncDomainComposition. Cette composition contient des objets du type SyncDomain.
Subnet subnet = …;
SyncDomainOwner syncDomainOwner = subnet.GetService<SyncDomainOwner>();
SyncDomainComposition syncDomainComposition = syncDomainOwner.SyncDomains;
Modifiez le code de programme suivant pour créer un nouveau SyncDomain avec un nom défini
int countOfSyncDomains = syncDomainComposition.Count;

SyncDomain someSyncDomain = syncDomainComposition.ElementAt(3);
SyncDomain firstSyncDomain = syncDomainComposition.First();
SyncDomain byName = syncDomainComposition.Find("DomainName");
// create a new domain
SyncDomain newSyncDomain = syncDomainOwner.SyncDomains.Create("newSyncDomain");

Modifiez le code de programme suivant pour lire/écrire la valeur d'attribut de SyncDomain :
NetworkInterface toBeAdded = …;
string convertedName = newSyncDomain.ConvertedName;
newSyncDomain.SetAttribute("IsDefault", true);
newSyncDomain.SetAttribute("HighPerformanceActive", true);
newSyncDomain.SetAttribute("FastForwardingActive", true);
var participants = firstSyncDomain.DomainParticipants;
int count = participants.Count;
participants.Add(toBeAdded);
foreach (NetworkInterface networkIf in participants)
{
// do something at the interface
}
newSyncDomain.Delete();
7.19.18 Définir un mot de passe d'écran
Conditions
Application
TIA Portal Openness vous permet de définir le mot de passe de protection de l'écran. La
méthode SetPassword(SecureString password) vous permet de définir le mot de passe de
protection de l'écran, le paramètre du mot de passe devant être un SecureString. Le mot de
passe de confirmation n'est pas nécessaire dans Openness et n'est donc pas disponible.
La fonction est disponible lorsque les conditions suivantes sont remplies :
● L'API dispose d'une instance "Écran".
● L'"Écran" prend en charge la fonction de protection par "Mot de passe". Dans certains cas,
p. ex. un automate logiciel, "Écran" est disponible, mais pas de protection par mot de passe.
Code de programme
Modifiez le code de programme suivant pour appeler l'élément d'appareil qui possède
l'instance de service. La propriété OwnedBy peut être utilisée à cette fin.
DisplayProtection displayProtection = plcDisplay.GetService<DisplayProtection>();

var displayDeviceItem = displayProtection.OwnedBy;

Modifiez le code de programme suivant pour définir le mot de passe de protection de l'écran :
displayProtection.SetPassword(someSecuredString);
//Sets the string someSecuredString as the CPU display protection password.
Remarque
Les contrôleurs logiciels disposent d'un sous-module écran, mais ne prennent pas en charge
la protection de l'écran. C'est pourquoi dans TIA Portal Openness la fonction SetPassword
n'est pas disponible sur le sous-module écran des contrôleurs logiciels.
7.19.19 Accessibilité
Conditions
Introduction
TIA Portal Openness vous permet de prendre en charge l'accessibilité IP. Dans TIA Portal
Openness, un nouvel attribut dynamique PlcAccessCommunicationModule est disponible
pour la CPU élément d'appareil. L'attribut appartient au type objet. Vous pouvez ainsi accéder
à l'objet CP que vous souhaitez sélectionner pour l'accessibilité IP et affecter l'objet au
PlcAccessCommunicationModule.
Lorsqu'une CP a déjà été sélectionnée, vous pouvez appeler l'objet CP en appelant la valeur
de PlcAccessCommunicationModule.
Code de programme
DeviceItem Plc = ...;

object communicationModule = Plc.GetAttribute("PlcAccessCommunicationModule");
// cP contains the object reference of a plugged CP
Plc.SetAttribute("PlcAccessCommunicationModule", cP);

7.19.20 Actualisation de la description du module
Conditions
Voir AUTOHOTSPOT
Application
Dans TIA Portal Openness, le service ModuleDescriptionUpdater est utilisé sur l'élément de
l'appareil pour mettre à jour la description de module actuelle à la dernière version du module.
Pour appeler l'élément d'appareil qui possède l'instance de service, vous pouvez utiliser la
propriété OwnedBy.
Avec l'attribut CanUpdate vous pouvez afficher si une nouvelle version ConfigObject pour ce
DeviceItem.

CanUpdate bool TRUE : Une nouvelle version est
disponible
FALSE : Il n'existe pas de nou‐
velle version
À l'aide de l'action UpdateModuleDescription ( ) vous pouvez actualiser la version

ConfigObject d'un Deviceitem.
Action Valeur en retour Description

UpdateModuleDescription True Le Deviceitem est à jour :
● Le DeviceItem a été actualisé avec succès
● Le DeviceItem était déjà actualisé
False Le Deviceitem n'est pas à jour :
● Le Deviceitem n'a pas pu être actualisé
Code de programme

var descriptionUpdater = deviceItem.GetService<ModuleDescriptionUpdater>();
if (descriptionUpdater != null)
{
if (descriptionUpdater.CanUpdate) //e.g is update module version possible
{
bool result = descriptionUpdater.UpdateModuleDescription();
.
.
}
}

7.19.21 Gérer le certificat
Conditions
Application
TIA Portal Openness vous permet de gérer des certificats. Cela comprend la création et
suppression de certificats, l'exportation et importation de certificats, l'affectation et suppression
de l'affectation de certificats, ainsi que l'appel d'ID de certificats.
Local Certificate Manager

Le service LocalCertificateManager est mis à disposition sur l'API du DeviceItem pour les
certificats d'appareil. Le LocalCertificateManager dispose d'un magasin local nommé
LocalCertificateStore pour les certificats. Les certificats pour l'API définie y sont stockés. Pour
appeler l'élément d'appareil qui possède l'instance de service, vous pouvez utiliser la propriété
OwnedBy.
DeviceItem Plc= ...;

// Get local certificate manager
var localCertificateManager = Plc.GetService<LocalCertificateManager>();
// Disable global certificate manager
localCertificateManager.EnableGlobalCertificatesStore = false;
// Get local certificate store
var localCertificateStore = localCertificateManager.LocalCertificateStore;
Gestion des certificats

Modifiez le code de programme suivant pour créer un certificat :
/ Create templates
var templateTls = localCertificateStore.GetCertificateTemplate(CertificateUsage.Tls);
var templateWebserver =
localCertificateStore.GetCertificateTemplate(CertificateUsage.WebServer);
var templateOpcUaServer =
localCertificateStore.GetCertificateTemplate(CertificateUsage.OpcUaServer);//
...
//Template handling and configuration is handled later
// Create certificates
var certificateTls = localCertificateStore.Certificates.Create(templateTls);
var certificateWeb = localCertificateStore.Certificates.Create(templateWebserver);
var certificateOpcUa = localCertificateStore.Certificates.Create(templateOpcUaServer);

Modifiez le code de programme suivant pour supprimer et exporter un certificat :
var exportPath = …;
// renew a certificatecertificate
Tls.Delete();
certificateTls = localCertificateStore.Certificates.Create(templateTlsNew);
certificateWeb.Export(new FileInfo(exportPath), CertificateExportFormat.Cer);
Modifiez le code de programme suivant pour affecter au serveur Web et au serveur OPC UA
des certificats avec des attributs dynamiques :
DeviceItem opcUaSubmodule = …;
//Find assigned certificates
var foundWebCertificate = Plc.GetAttribute("WebserverCertificate");
var foundOpcUaCertificate = opcUaSubmodule.GetAttribute("OpcUaServerCertificate");
//Assign certificatesPlc.SetAttribute("WebserverCertificate", certificateWeb);
opcUaSubmodule.SetAttribute("OpcUaServerCertificate", certificateOpcUa);
//Unassign certificatesPlc.SetAttribute("WebserverCertificate", null);
opcUaSubmodule.SetAttribute("OpcUaServerCertificate", null);
Modifiez le code de programme suivant pour importer des certificats dans le magasin de
certificats local pour un API :
var certificateWithoutPwd = …;
var certificateWithPwd = …;
//
…
// Import certificates
// Without password
var importedCertificate1 = certificates.Import(new FileInfo(certificateWithoutPwd));
//With password
var importedCertificate2 = certificates.Import(new FileInfo(certificateWithPwd), password);
Modifiez le code de programme suivant pour appeler l'ID de certificat :
var certificateId = importedCertificate2.Id;
Modifiez le code de programme suivant pour indiquer si un certificat dispose d'une clé privée.
La propriété booléenne HasPrivateKey peut être utilisée à cette fin dans l'objet de certificat.
if(importedCertificate2.HasPrivateKey)
{
//Do something
}

Modèle de certificat
Les modèles servent de base à la création de certificats. Les nouveaux certificats peuvent être
créés dans LocalCertificateStore avec l'action GetCertificateTemplate(CertificateUsage).
CertificateUsage est énuméré avec les valeurs possibles suivantes :
● Aucun (non pris en charge)
● Tls
● Serveur Web
● OpcUaServer
● OpcUaClient
● OpcUaClientServer
// Create template
var certTemplate = localCertificateStore.GetCertificateTemplate(CertificateUsage.Tls);
Toutes les propriétés d'un certificat peuvent être définies dans un modèle de certificat. Accès
en lecture et écriture au modèle de certificat :
● Signature : L'algorithme de signature appartient au type SignatureAlgorithm énuméré avec
les valeurs possibles suivantes :
– Aucun (non pris en charge)
– Sha1RSA
– Sha256RSA
certTemplate.Signature = SignatureAlgorithm.Sha1RSA;
● SubjectAlternativeNames : Il s'agit d'une composition qui comprend des objets du type

SubjectAlternativeName (IList de type <SubjectAlternativeName>). Un nouveau SAN peut
être créé avec l'action Create(SubjectAlternativeNameType, chaîne de caractères) Les
paramètres transmis sont du type (du type SubjectAlternativeNameType) et de la valeur (du
type String).
● SubjectAlternativeNameType
– Aucun (non pris en charge)
– Dns
– Email
– IP
– Uri

var san1 = certTemplate.SubjectAlternativeNames.Create(SubjectAlternativeNameType.Dns,

"127.0.0.1");
var san2 = certTemplate.SubjectAlternativeNames.Create(SubjectAlternativeNameType.IP,
"192.168.178.1");
var san3 = certTemplate.SubjectAlternativeNames.Create(SubjectAlternativeNameType.Email,
"test@prov.com");
var san4 = certTemplate.SubjectAlternativeNames.Create(SubjectAlternativeNameType.Uri,
"something");
san3.Delete();
● SubjectCommonName: string
string subjectCommonName = certTemplate.SubjectCommonName;

certTemplate.SubjectCommonName = "exampleSubjectCommonName";
Utilisation du type CertificateUsage
var usage = certTemplate.Usage;

certTemplate.Usage = CertificateUsage.OpcUaClientServer;
ValidFrom: type DateTime

ValidUntil: type DateTime
var validFrom = certTemplate.ValidFrom;

var validUntilDateTime = new DateTime(2080, 10, 10);
certTemplate.ValidUntil = validUntilDateTime;
7.19.22 Blocs
7.19.22.1 Interroger le groupe "Blocs de programme"
Conditions requises
● Un API est décelé dans le projet.

Code du programme
Pour interroger le groupe "Blocs de programme", modifiez le code de programme suivant :
private static void GetBlockGroupOfPLC(PlcSoftware plcsoftware)

//Retrieves the system group of a block
{
PlcBlockSystemGroup blockGroup = plcsoftware.BlockGroup;
}
7.19.22.2 Interroger un groupe système pour blocs système
Conditions requises
Code du programme :
Pour déterminer le groupe créé par le système pour les blocs système, modifiez le code de
programme suivant :
PlcSoftware plcSoftware = ...

foreach (PlcSystemBlockGroup systemGroup in plcSoftware.BlockGroup.SystemBlockGroups)
{
foreach (PlcSystemBlockGroup group in systemGroup.Groups)
{
PlcBlockComposition pbComposition = group.Blocks;
foreach (PlcBlock block in pbComposition)
{
//Ajoutez votre code ici
}
}
}
7.19.22.3 Enumérer les sous-groupes système
Conditions requises

Code du programme : Enumérer tous les sous-groupes système

Pour énumérer les sous-groupes système de tous les blocs système, modifiez le code de
programme suivant :
//Retrieves the system generated group for system blocks

private static void GetSystemgroupForSystemblocks(PlcSoftware plcSoftware)
{
PlcSystemBlockGroupComposition systemBlockGroups =
plcSoftware.BlockGroup.SystemBlockGroups;
if (systemBlockGroups.Count != 0)
{
PlcSystemBlockGroup sbSystemGroup = systemBlockGroups[0];
foreach (PlcSystemBlockGroup group in sbSystemGroup.Groups)
{
EnumerateSystemBlockGroups(group);
}
}
}
private static void EnumerateSystemBlockGroups(PlcSystemBlockGroup systemBlockGroup)
{
foreach (PlcSystemBlockGroup group in systemBlockGroup.Groups)
{
// recursion EnumerateSystemBlockGroups(group);
}
}
Code du programme : Accéder à un sous-groupe déterminé

Pour accéder à un sous-groupe déterminé, modifiez le code de programme suivant :
private static void AccessSbGroup(PlcSystemBlockGroup systemBlockGroup)

{
PlcSystemBlockGroup group1 = systemBlockGroup.Groups.Find("User group XYZ");
PlcSystemBlockGroup group2 = group1.Groups.Find("User group ZYX");
}
Voir aussi
Ajouter un fichier externe (Page 530)

7.19.22.4 Enumérer les groupes Blocs personnalisés
Conditions requises
Utilisation
Les sous-groupes compris sont considérés comme récurrents lors de l'énumération.
Code du programme : Enumérer tous les groupes

Pour énumérer les groupes Blocs personnalisés, modifiez le code de programme suivant :
//Enumerates all block user groups including sub groups

private static void EnumerateAllBlockGroupsAndSubgroups(PlcSoftware plcsoftware)
{
foreach (PlcBlockUserGroup blockUserGroup in plcsoftware.BlockGroup.Groups)
{
EnumerateBlockUserGroups(blockUserGroup);
}
}
private static void EnumerateBlockUserGroups(PlcBlockUserGroup blockUserGroup)

{
foreach (PlcBlockUserGroup subBlockUserGroup in blockUserGroup.Groups)
{
EnumerateBlockUserGroups(subBlockUserGroup);
// recursion
}
}
Code du programme : Accéder à un groupe

Pour accéder à un groupe de blocs personnalisé sélectionné, modifiez le code de programme
suivant :
//Gives individual access to a specific block user group

private static void AccessBlockusergroup(PlcSoftware plcsoftware)
{
PlcBlockUserGroupComposition userGroupComposition = plcsoftware.BlockGroup.Groups;
PlcBlockUserGroup plcBlockUserGroup = userGroupComposition.Find("MyUserfolder");
}

7.19.22.5 Enumérer tous les blocs
Conditions requises
Utilisation
Il est possible d'accéder de manière ciblée à un bloc de programme si son nom est connu.
Code du programme : Enumérer tous les blocs

Pour énumérer les blocs de tous les groupes Blocs, modifiez le code de programme suivant :
private static void EnumerateAllBlocks(PlcSoftware plcsoftware)

//Enumerates all blocks
{
foreach (PlcBlock block in plcsoftware.BlockGroup.Blocks)
{
// Do something...
}
}
Code du programme : Accéder à un bloc déterminé

Pour accéder à un bloc donné, modifiez le code de programme suivant :
private static void AccessASingleBlock(PlcSoftware plcsoftware)

//Gives individual access to a block
{
// The parameter specifies the name of the block
PlcBlock block = plcsoftware.BlockGroup.Blocks.Find("MyBlock");
}

7.19.22.6 Interroger les informations d'un bloc/type de données utilisateur
Conditions requises
Utilisation
La TIA Portal Openness API prend en charge l'interrogation des informations suivantes pour le
programme et les blocs de données et pour les types de données utilisateur :
● Horodatage au format UTC
L'horodatage fournit les informations suivantes :
– Quand le bloc a-t-il été compilé pour la dernière fois ?
– Quand le bloc a-t-il été modifié pour la dernière fois ?
● Attribut "Consistency"
L'attribut « Consistency" est mis sur "True" dans les cas suivants :
– Le bloc a été correctement compilé.
– Le bloc n'a pas été modifié depuis la compilation.
– Aucune modification ayant impliqué une nouvelle compilation n'a été apportée aux
objets externes.
● Langage de programmation utilisé (uniquement programme et de blocs de données)
● Numéro de bloc
● Nom de bloc
● Auteur du bloc
● Famille de bloc
● Titre du bloc
● Version du bloc
Pour plus d’informations, voir AUTOHOTSPOT.

Code du programme
Pour interroger les informations susmentionnées, modifiez le code de programme suivant :
private static void GetPlcBlockInformation(PlcSoftware plcSoftware)

{
PlcBlock plcBlock = plcSoftware.BlockGroup.Blocks.Find("MyBlock");
// Read information
DateTime compileDate = plcBlock.CompileDate;
DateTime modifiedDate = plcBlock.ModifiedDate;
bool isConsistent = plcBlock.IsConsistent;
int blockNumber = plcBlock.Number;
string blockName = plcBlock.Name;
ProgrammingLanguage programmingLanguage = plcBlock.ProgrammingLanguage;
string blockAuthor = plcBlock.HeaderAuthor;
string blockFamily = plcBlock.HeaderFamily;
string blockTitle = plcBlock.HeaderName;
System.Version blockVersion = plcBlock.HeaderVersion;
}
Voir aussi
7.19.22.7 Protéger un bloc et annuler la protection
Condition
Utilisation
Vous pouvez protéger un bloc par un mot de passe et annuler cette protection via la classe
PlcBlockProtectionProvider et le service PlcBlockProtectionProvider. Le service
PlcBlockProtectionProvider est disponible pour les blocs qui remplissent les conditions
suivantes :
● Le bloc peut recevoir une protection Know-How
● Le bloc est un bloc de code ou un bloc de données global DB
● Le bloc est pris en charge ou éditable dans l'API actuel
● Le bloc n'est pas protégé en écriture
● Le bloc n'a pas de protection Know-How
● Le bloc n'est pas en ligne

● Le bloc n'est pas une CPU-DB

● Le bloc n'utilise pas de langage de cryptage classique, ProDiag ou ProDiag-OB
● Le bloc n'est pas un bloc classique, importé et crypté
Si le bloc ne satisfait pas à toutes les conditions, alors la méthode GetService() génère un zéro
de référence.
Code de programme : Exécution des opérations de protection en Know-how

PlcBlock block = ...;

PlcBlockProtectionProvider protectionProvider =
block.GetService<PlcBlockProtectionProvider>();
if (protectionProvider != null)
{
... // perform know-how protection related operations here
}
Protéger un bloc
Avec la méthode Protect(), définissez un mot de passe pour protéger le bloc de programmation.
void Protect(SecureString password)
Une erreur se produit

● quand vous essayez de protéger un bloc déjà protégé : Une exception
EngineeringTargetInvocationException est déclenchée par un message stipulant que la
protection d'un objet protégé n'est pas possible.
● quand vous essayez de protéger un bloc par une chaîne de caractères vide faisant office de
mot de passe : Une exception EngineeringTargetInvocationException est déclenchée par
un message stipulant qu'un mot de passe n'a pas été indiqué.
● Si vous essayez de protéger un bloc de sécurité alors que le programme de sécurité
Failsafe est protégé par un mot de passe : Une exception
EngineeringTargetInvocationException est déclenchée.
● Si vous essayez de protéger un bloc de sécurité qui n'a pas fait l'objet d'un appel : Une
exception EngineeringTargetInvocationException est déclenchée.
Bloc non protégé

Annulez le mot de passe qui protège le bloc de programmation à l'aide de la méthode
Unprotect().
void Unprotect(SecureString password)


● quand vous essayez d'annuler la protection d'un bloc qui ne fait pas du tout l'objet d'une
protection : Une exception EngineeringTargetInvocationException est déclenchée par un
message stipulant que l'annulation de la protection d'un objet non protégé n'est pas
possible.
● quand vous essayez d'annuler la protection d'un bloc par un mot de mot de passe incorrect :
Une exception EngineeringTargetInvocationException est déclenchée par un message
stipulant qu'un mot de passe n'a pas été accepté.
Recherche de caractères non valides

Étant donné que vous avez la possibilité de protéger un bloc par des caractères quelconques,
y compris retour arrière, tabulation etc. en utilisant la méthode Protect(), l'annulation de la
protection dans TIA Portal n'est pas possible dans certains cas. Étant donné que les mots de
passe sont transmis sous la forme de SecureString, vous devez vérifier si le mot de passe
contient des caractères non valides. La méthode GetInvalidPasswordCharacters() permet
d'appeler une liste de caractères non valides.
SecureString CreatePasswordString(ProtectionProvider protectionProvider, IEnumerable<char>

contentCharacters)
{
IList<char> invalidCharacters = protectionProvider.GetInvalidPasswordCharacters();
SecureString password = new SecureString();
foreach(char ch in contentCharacters)
{
if (!invalidCharacters.Contains(ch))
{
password.AppendChar(ch);
}
else
{
// at least one of the content characters is not valid
// signal an error - e.g. throw an exception
...
}
}
return password;
}


● quand vous essayez d'annuler la protection d'un bloc qui ne fait pas du tout l'objet d'une
protection : Une exception EngineeringTargetInvocationException est déclenchée par un
message stipulant que l'annulation de la protection d'un objet non protégé n'est pas
possible.
● quand vous essayez d'annuler la protection d'un bloc par un mot de mot de passe incorrect :
Une exception EngineeringTargetInvocationException est déclenchée par un message
stipulant qu'un mot de passe n'a pas été accepté.
7.19.22.8 Supprimer un bloc
Conditions requises
Code du programme
Pour supprimer un bloc, modifiez le code de programme suivant :
//Runs through block group and deletes blocks

private static void DeleteBlocks(PlcSoftware plcsoftware)
{
PlcBlockSystemGroup group = plcsoftware.BlockGroup;
// or BlockUserGroup group = ...;
for (int i = group.Blocks.Count - 1; i >= 0; i--)
{
PlcBlock block = group.Blocks[i];
if (block != null)
{
block.Delete();
}
}
}
Voir aussi

7.19.22.9 Créer un groupe pour blocs
Conditions requises
Code du programme
Pour créer un groupe pour blocs, modifiez le code de programme suivant :
private static void CreateBlockGroup(PlcSoftware plcsoftware)

//Creates a block group
{
PlcBlockSystemGroup systemGroup = plcsoftware.BlockGroup;
PlcBlockUserGroupComposition groupComposition = systemGroup.Groups;
PlcBlockUserGroup myCreatedGroup = groupComposition.Create("MySubGroupName");
}
Voir aussi
7.19.22.10 Supprimer un groupe pour blocs
Conditions requises

Code du programme
Pour supprimer un groupe pour blocs, modifiez le code de programme suivant :
// Deletes user groups from PlcBlockSystemGroup or PlcBlockUserGroup

private static void DeleteBlockFolder(PlcSoftware plcSoftware)
{
PlcBlockUserGroup group = plcSoftware.BlockGroup.Groups.Find("myGroup");
//PlcBlockSystemGroup group = plcSoftware.BlockGroup;
PlcBlockUserGroupComposition subgroups = group.Groups;
PlcBlockUserGroup subgroup = subgroups.Find("myUserGroup");
if (subgroup != null)
{
subgroup.Delete();
}
}
Voir aussi
7.19.22.11 Accéder aux attributs de tous les blocs
Conditions
Utilisation
Vous pouvez définir les attributs valables pour tous les blocs à l'aide de la méthode
SetAttribute() et SetAttributes().
SetAttributes() peut être utilisé pour tous les types d'objets pour lesquels un attribut Openness
pouvant être écrit est disponible. Pour un élément d'entrée, il se comporte comme SetAttribute.
Vérification des paramètres :
● Des vérifications initiales sont effectuées, avant que le premier élément soit traité par
l'infrastructure PE globale : Les éléments d'entrée sont contrôlés pour vérifier que les noms
d'attributs sont identiques et valides et que les types de données correspondent. Un attribut
ne peut pas être défini deux fois par un SetAttributes.
● Une vérification séquentielle a lieu durant l'exécution de SetAttributes. L'ordre du traitement
correspond à l'ordre des éléments dans la liste d'entrée.
SetAttributes est traité dans une seule transaction. Si un attribut de la liste d'entrée ne peut pas
être défini, les valeurs des attributs restent inchangées. SetAttributes définit les attributs dans
le même ordre qu'ils sont présents dans la liste de paramètres. Les paramètres peuvent être
dépendants ou indépendants les uns des autres. Lorsqu'un paramètre est dépendant d'un

paramètre précédent dans la liste, ce paramètre est vérifié et évalué en fonction de la valeur
actuelle de l'autre attribut (pas en fonction de la valeur d'origine au moment de l'appel). Si
SetAttributes ne peut pas être exécuté, des détails sur l'erreur sont indiqués. Le message
d'erreur contient le nom du premier attribut qui n'a pas pu être défini, ainsi que sa valeur et la
raison de l'erreur.
Les exemples de code de programme sont basés sur les deux attributs AutoNumber et Number
qui utilisent SetAttribute() (voir Exporter des blocs (Page 896) pour tous les attributs valides
des blocs).
Code de programme : SetAttribute
...
PlcBlockGroup blockFolder = YourUtilities.GetFolder();
var block = blockFolder.Blocks.Find("Block_1");
if ((bool)block.GetAttribute(“AutoNumber”)==true)
{
block.SetAttribute("AutoNumber",false);
}
block.SetAttribute("Number",2);
...
Code de programme : SetAttributes
PlcBlock block = SelectBlock("MC-Servo");

if (block != null)
{
IList<KeyValuePair<string, object>> list = new List<KeyValuePair<string, object>>()
{
new KeyValuePair<string, object>("DataExchangeMode", OBDataExchangeMode.Synchronous),new
KeyValuePair<string, object>("SynchronousApplicationCycleTime", (float)69)
};
try
{
block.SetAttributes(list);
}
catch (EngineeringException e)
{
Console.WriteLine("Exception: " + e.Message);
}
}

7.19.22.12 Créer un FB ProDiag
Conditions
Utilisation
L'utilisateur d'Openness peut créer un ProDiag FB via l'action Create de la PLCBlock
composition avec les paramètres suivants.
1. Nom
2. Mémento de numérotation automatique
3. Numéro
– Lorsque "Mémento de numérotation automatique" est vrai, le numéro de bloc indiqué est
défini à condition qu'il soit libre. Sinon, un nouveau bloc est généré.
– Lorsque "Mémento de numérotation automatique" est faux, le bloc est défini avec le
numéro de bloc indiqué.
4. Langage de programmation
– Si l'utilisateur appelle l'action Create avec le langage de programmation ProDiag, un
nouveau FB est créé sans IDB .
– Si l'utilisateur appelle l'action Create avec un IDB de ProDiag, l'IDB est créé par ProDiag.
– Dans tous les autres cas non pris en charge, une exception récupérable est déclenchée.
Code de programme : Créer un FB ProDiag
...
PlcBlockGroup blockFolder = plc.BlockGroup;
PlcBlockComposition blockComposition = blockFolder.Blocks;
if (blockComposition != null)
{
string fbName = "ProDiag_Block";
bool isAutoNumber = true;
int number = 1;
var progLang = ProgrammingLanguage.ProDiag;
FB block = blockComposition.CreateFB(fbName, isAutoNumber, number, progLang);
string iDBName="ProDiag_IDB";
string instanceOfName = fbName;
InstanceDB iDbBlock = blockComposition.CreateInstanceDB(iDBName, isAutoNumber, number,
instanceOfName);
}
...

Voir aussi
Accéder aux surveillances et aux propriétés du FB ProDiag (Page 528)
7.19.22.13 Accéder aux surveillances et aux propriétés du FB ProDiag
Conditions
Accéder aux surveillances du FB utilisateur (User-FB)

L'utilisateur d'Openness peut accéder aux surveillances du FB avec l'extrait de code suivant.
Chaque FB a une liste de surveillance incluant des API Classic et Plus.
Code de programme : accéder aux surveillances du FB ProDiag
…
PlcBlock iDB = plc.BlockGroup.Blocks.Find("FB_Block_DB");
string fbName = iDB.GetAttribute("InstanceOfName").ToString();
FB fb = (FB)plc.BlockGroup.Blocks.Find(fbName);
if (fb.Supervisions.Count > 0)Console.WriteLine("Contains supervisions");
else
Console.WriteLine("Does not contains supervisions");
…
Accéder aux attributs du bloc FB

L'utilisateur d'Openness peut définir AssignedProDiagFB dans InstanceDB via l'attribut
AssignedProDiagFB (voir Exporter des blocs (Page 896)). L'utilisateur peut accéder aux
attributs avec la méthode GetAttribute(), GetAttributes() and SetAttribute(). L'utilisateur ne peut
pas utiliser la méthode SetAttributes() pour définir des attributs pour plus d'un attribut. TIA
Portal Openness déclenche une exception lors de l'utilisation de la méthode SetAttributes() .
Si l'attribut n'est pas pris en charge (dans le bloc indiqué), une exception utilisateur récupérable
est déclenchée. Si aucun bloc ProDiag affecté n'est défini, GetAttribute() fournit une chaîne de
caractères vide en retour.

Code de programme : appeler et définir le FB ProDiag affecté et l'IDB
...
PlcBlockGroup blockFolder = plc.BlockGroup;
PlcBlock instanceDB = blockFolder.Blocks.Find("IDB");
PlcBlock plcProdiag = blockFolder.Blocks.Find("block_Prodiag");
instanceDB.SetAttribute("AssignedProDiagFB", plcProdiag.Name);
var assignedProDiagFB = instanceDB.GetAttribute("AssignedProDiagFB");
...
Voir aussi
Créer un FB ProDiag (Page 527)
7.19.22.14 Lire des blocs fonctionnels ProDiag et des attributs
Conditions
● Vous avez ouvert un projet par le biais d'une application TIA Portal Openness.
Application
Vous pouvez utiliser TIA Portal Openness pour lire la version du bloc fonctionnel ProDiag et
d'autres valeurs d'attribut en liaison avec ProDiag. Avec GetAttribute ( ) et GetAttributes ( ) ,
vous pouvez lire les attributs disponibles spécifiques à une langue de blocs fonctionnels
ProDiag.
Attributs
Les attributs suivants sont pris en charge par les blocs fonctionnels ProDiag dans Openness :
Attributs Type
ProDiagVersion Version
InitialValueAcquisition Bool
UseCentralTimeStamp Bool
Voir aussi

7.19.22.15 Ajouter un fichier externe
Conditions requises
● Vous avez ouvert un projet par le biais d'une application TIA Portal Openness :
Utilisation
Vous pouvez ajouter un fichier externe à un API. Ce fichier externe est enregistré sous le
chemin défini dans le système de fichiers.
Les formats suivants sont pris en charge :
● LIST
● SCL
● DB
● UDT
Remarque
L'accès à des groupes dans le dossier "Fichiers sources externes" n'est pas pris en charge.
Une exception est déclenchée si vous indiquez une autre extension de fichier que *.AWL,
*.SCL, *.DB ou *.UDT .
Code de programme
Pour créer un fichier externe dans le dossier "Fichiers sources externes" à partir d'un bloc,
private static void CreateBlockFromFile(PlcSoftware plcSoftware)

// Creates a block from a AWL, SCL, DB or UDT file
{
PlcExternalSource externalSource =
plcSoftware.ExternalSourceGroup.ExternalSources.CreateFromFile("SomeBlockNameHere","SomePa
thHere");
}

7.19.22.16 Générer une source à partir d'un bloc
Conditions
Utilisation
L'interface TIA Portal Openness API prend en charge la génération de sources en UTF-8 à
partir de blocs LIST ou SCL, de blocs de données et de types de données API (types de
données utilisateur). Pour générer un fichier source d'un bloc, appelez la
méthode GenerateSource sur l'instance PlcExternalSourceSystemGroup.
L'étendue du fichier source généré dépend de l'option de génération de cette fonction :
● GenerateOptions.None
Générer la source uniquement à partir des blocs mis à disposition.
● GenerateOptions.WithDependencies
Générer la source y compris tous les objets dépendants.
L'interface Siemens.Engineering.SW.ExternalSources.IGenerateSource
indique qu'une source peut être générée.
Pour les blocs, seuls les langages de programmation LIST et SCL sont pris en charge. Des
exceptions sont lancées dans les cas suivants :
● Le langage de programmation n'est pas LIST ou SCL
● Un fichier du même nom existe déjà au lieu de sauvegarde cible.
Seule l'extension de fichier "*.udt" est prise en charge pour les types de données utilisateur.
Des exceptions sont lancées dans les cas suivants :
● L'extension de fichier pour blocs de données n'est pas "*.db"
● L'extension de fichier pour blocs LIST n'est pas "*.awl"
● L'extension de fichier pour blocs SCL n'est pas "*.scl"

Code de programme
Pour générer les fichiers sources à partir de blocs et de types, modifiez le code de programme
suivant :
//method declaration
...
PlcExternalSourceSystemGroup.GenerateSource
(IEnumerable<Siemens.Engineering.SW.ExternalSources.IGenerateSource>
plcBlocks, FileInfo sourceFile, GenerateOptions generateOptions);
...
//examples
...
var blocks = new List<PlcBlock>(){block1};
var fileInfo = new FileInfo(@"C:\temp\SomePathHere.scl");
PlcExternalSourceSystemGroup systemGroup = ...;
systemGroup.GenerateSource(blocks, fileInfo, GenerateOptions.WithDependencies);
// exports all blocks and with all their dependencies(e.g. called blocks, used DBs or UDTs)
// as ASCII text into the provided source file.
...
or
..
var types = new List<PlcType>(){udt1};
var fileInfo = new FileInfo(@"C:\temp\SomePathHere.udt");
PlcExternalSourceSystemGroup systemGroup = ...;
systemGroup.GenerateSource(types, fileInfo, GenerateOptions.WithDependencies );
// exports all data types and their used data types into the provided source file.
...
Voir aussi
7.19.22.17 Générer les blocs à partir de la source
Conditions requises

Utilisation
Vous pouvez générer des blocs à partir de tous les fichiers externes du groupe "Fichiers
sources externes". Seuls les fichiers externes au format ASCII sont pris en charge.
Remarque
L'accès à des groupes dans le dossier "Fichiers sources externes" n'est pas pris en charge.
Les blocs existants sont écrasés.
Si une erreur apparaît lors de l'appel, une Exception est déclenchée. Les 256 premiers
caractères de tout message d'erreur sont compris dans le message de l'Exception. Le projet
est remis à l'état de traitement où il se trouvait avant l'exécution de la
méthode GenerateBlocksFromSource.
Code du programme
Pour générer les blocs à partir de tous les fichiers externes du groupe "Fichiers sources
externes", modifiez le code de programme suivant.
// Creates a block from an external source file

PlcSoftware plcSoftware = ...;
foreach (PlcExternalSource plcExternalSource in
plcSoftware.ExternalSourceGroup.ExternalSources)
{
plcExternalSource.GenerateBlocksFromSource();
}
7.19.22.18 Génération à partir d'une source avec un format de source connu
Conditions

Application
Le générateur peut créer un objet (bloc/UDT), mais un élément interne rend le bloc/UDT non
compilable.
Éléments manquants ou invalides typiques qui rendent le bloc/type non compilable :
● Référence à un type non présent
● Utilisation d'un symbole manquant

Lors d'erreurs de génération dans l'implémentation actuelle de 'GenerateBlocksFromSource'

void GenerateBlocksFromSource():
● Une exception restaurable est retournée (en raison d'un échec de génération)
● Les messages d'erreur de la génération sont inclus dans le message de l'exception
● Le bloc/UDT généré est supprimé
En raison de la stabilité à long terme d'Openness, une nouvelle surcharge de
GenerateBlocksFromSource est disponible :
IList<IEngineeringObject> GenerateBlocksFromSource(GenerateBlockOptions option)
Lorsque ce nouveau 'GenerateBlocksFromSource' est appelé avec
GenerateBlockOptions.KeepOnError,
● Aucune exception restaurable n'est retournée (indépendamment des résultats de
génération)
● Aucune information sur les résultats de génération des blocs créés n'est livrée
● Une IList des IEngineeringObjects des blocs générés est fournie en retour (avec ou sans
erreur de génération)
Lorsque ce nouveau 'GenerateBlocksFromSource' a été appelé avec
GenerateBlockOptions.None et que la génération a été effectuée avec des erreurs,
● Une exception restaurable est retournée (en raison d'un échec de génération)
● Les messages d'erreur de la génération sont inclus dans le message de l'exception
● Le bloc/UDT généré est supprimé
– C'est le même comportement qu'avec l'implémentation actuelle.
Dans le cas d'une génération sans erreur
● Aucune exception n'est retournée
● Aucune information sur les résultats de génération des blocs créés n'est livrée
● Une IList des IEngineeringObjects des blocs générés est fournie en retour
– C'est le même comportement que lors de l'appel avec
GenerateBlockOptions.KeepOnError.

Code de programme
try
{
IList<IEngineeringObject> generatedObjects =
externalSource.GenerateBlocksFromSource(GenerateBlockOptions.KeepOnError);
foreach (IEngineeringObject engineeringObject in generatedObjects)
{
CompilerResult compilerResult = null;
string objectName = null;
if (engineeringObject is PlcBlock)
{
// handle case for PLcBlock
// e.g. retrieve the compiler result
PlcBlock block = (PlcBlock)engineeringObject;
objectName = block.Name;
compilerResult = block.Compile();
}
else if (engineeringObject is PlcType)
{
// handle case for PlcType
// e.g. retrieve the compiler result
PlcType plcType = (PlcType)engineeringObject;
objectName = plcType.Name;
compilerResult = plcType.Compile();
}
// handle the compiler result
if (compilerResult != null)
{
if (compilerResult.State == CompilerResultState.Error)
{
Console.WriteLine("Object '{0}' could not be compiled successfully!", objectName);
Console.WriteLine("Number of compiler errors: {0}", compilerResult.ErrorCount);
foreach (CompilerResultMessage compilerResultMessage in compilerResult.Messages)
{
Console.WriteLine(compilerResultMessage.Description);
}
}
else
{
Console.WriteLine("Object '{0}' could be compiled successfully.", objectName);
}
}
}
}
catch (RecoverableException exception)
{
// handle recoverable exception
Console.WriteLine(exception.Message);
}

Voir aussi
7.19.22.19 Supprimer un type de données utilisateur
Conditions requises
Code du programme
Pour supprimer un type utilisateur, modifiez le code de programme suivant :
private static void DeleteUserDataType(PlcSoftware plcSoftware)

{
PlcTypeSystemGroup typeGroup = plcSoftware.TypeGroup;
PlcTypeComposition dataTypes = typeGroup.Types;
PlcType dataType = dataTypes.Find("DataTypeName");
if (dataType != null)
{
dataType.Delete();
}
}
Voir aussi
7.19.22.20 Supprimer un fichier externe
Conditions requises
● Vous avez ouvert un projet par le biais d'une application TIA Portal Openness :

Code du programme
Pour supprimer un fichier externe dans le groupe "Fichiers sources externes", modifiez le code
Remarque
L'accès à des groupes dans "Fichiers sources externes" n'est pas pris en charge.
// Deletes an external source file

private static void DeleteExternalSource(PlcSoftware plcSoftware)
{
PlcExternalSource externalSource =
plcSoftware.ExternalSourceGroup.ExternalSources.Find("myExternalsource");
externalSource.Delete();
}
7.19.22.21 Démarrer un éditeur de bloc
Conditions requises
● L'instance du portail TIA est ouverte avec interface utilisateur.
Code du programme
Pour démarrer l'éditeur correspondant à une référence d'objet du type PlcBlock dans
l'instance de TIA Portal, modifiez le code de programme suivant :
//Opens a block in a block editor

private static void StartBlockEditor(PlcSoftware plcSoftware)
{
plcBlock.ShowInEditor();
}

Pour ouvrir l'éditeur correspondant à une référence d'objet du type PlcType dans l'instance de
TIA Portal, modifiez le code de programme suivant :
//Opens a udt in udt editor

private static void StartPlcTypEditor(PlcSoftware plcSoftware)
{
PlcTypeComposition types = plcSoftware.TypeGroup.Types;
PlcType udt = types.Find("my_udt");
udt.ShowInEditor();
}
Voir aussi
7.19.22.22 Modifier des blocs à l'aide des empreintes
Conditions
Application
TIA Portal Openness vous permet de reconnaître des modifications dans des blocs ou des
UDT. Pour cela, vous pouvez comparer les empreintes de l'objet. Une instance d'empreinte
comprend une FingerprintId, qui définit le type d'empreinte, ainsi qu'une valeur fingerprint sous
forme de chaîne de caractères. Toutes les fingerprints ne prennent en compte que les entrées
utilisateur, et aucun résultat de compilation ou autres modifications apportées par le système.
L'énumération FingerprintId répertorie tous les types d'empreintes pris en charge dans
Openness :
Valeur Description
Code Tient compte de toutes les modifications du code
dans la partie principale du bloc. Le résultat de la
compilation n'est pas pris en compte.
Interface Tient compte de toutes les modifications dans l'in‐
terface d'un bloc, y compris les valeurs initiales
d'un bloc de données.
Properties Tient compte des modifications des propriétés
d'un bloc, par ex. le nom et le numéro.
Comments Tient compte des modifications des commentaire
d'un bloc. Pour les blocs d'organisation (OB), l'em‐
preinte est également modifiée si la liste des lan‐
gues disponibles dans les réglages de la langue
du projet est modifiée.

Valeur Description
LibraryType Disponible si un bloc est connecté à un type de
bibliothèque.
Texts Avec V15 SP1, cette empreinte n'est disponible
que pour des blocs Graph.
Alarms Disponible si un bloc travaille avec la fonction
d'alarme.
Supervision Disponible si un bloc comprend une fonction de
surveillance.
TechnologyObject Disponible uniquement pour les blocs de données
d'objets technologiques.
Events Disponible uniquement pour les OB.
TextualInterface Disponible si le bloc est doté d'une interface tex‐
tuelle.
Vous avez besoin du FingerprintProvider pour appeler les empreintes d'un objet. Ce service
est disponible pour des blocs (FB, FC, OB et DB) et des UDT, mais pas pour les tables des
variables. Le FingerprintProvider calcule toutes les empreintes disponibles d'un objet et les
renvoie à chaque appel de GetFingerprints. Pour recevoir des empreintes correctes, le bloc ou
l'UDT doit être cohérent avant l'appel des empreintes. Faute de quoi une
RecoverableException est signalée. Si une empreinte est invalide après son calcul, une
RecoverableException est signalée.
Code de programme
Pour appeler l'instance d'empreinte, modifiez le code de programme suivant :
PlcBlock block = ...;

FingerprintProvider provider = block.GetService<FingerprintProvider>();
IList<Fingerprint> fingerprints = provider.GetFingerprints();
foreach(var fingerprint in fingerprints)
{
string fpValue = fingerprint.Value;
FingerprintId fpId = fingerprint.Id;
}
Voir aussi

7.19.22.23 Générer/supprimer des blocs pour des pages personnalisées
Conditions
Application
TIA Portal Openness vous permet de créer des pages personnalisées dans le serveur Web des
API : Les données des pages personnalisées sont enregistrées dans des blocs spéciaux
générés par le système de l'API. Vous pouvez aussi éditer et supprimer manuellement ces
blocs. SI vous modifiez néanmoins des données ou des propriétés dans ce bloc de données,
le serveur Web ne fonctionne par la suite plus de façon conforme.
Dans TIA Portal Openness, le nouveau service WebserverUserDefinedPages est ajouté à
l'API du DeviceItem. À l'aide de ce service, vous pouvez générer les blocs de données pour les
pages personnalisées : List<PLCBlock> GenerateBlocks(Arguments). Lors de l'appel de cette
fonction, les blocs de données correspondants sont générés et une liste des blocs de données
générés est retournée à l'utilisateur.
Il existe deux surcharges possibles de cette fonction :
● List<PLCBlock> WebserverUserDefinedPages.GenerateBlocks(WebDBGenerateOptions
GenerateOptions);
● List<PLCBlock> WebserverUserDefinedPages.GenerateBlocks(System.IO.DirectoryInfo
htmlDirectory, System.IO.FileInfo defaultHTMLPage, string applicationName,
WebDBGenerateOptionsGenerateOptions);

Les valeurs de paramètres pour le répertoire HTML, la page HTML et le nom d'application ne
sont pas enregistrées dans les données de projet. Les valeurs des attributs dynamiques
correspondants ne sont ainsi pas modifiées.
Paramètre Type de données Type Description

GenerateOptions WebDBGenerateOptions (enu‐ Mandatory Valeurs possibles :
meration) ● None - Lorsque des blocs
de données de pages per‐
sonnalisées ont déjà été
créés, aucune action n'est
exécutée et une exception
est déclenchée.
● Override - Lorsque des
blocs de données de pages
personnalisées ont déjà été
créés, ils sont supprimés et
les nouveaux bloc de don‐
nées sont générés.
htmlDirectory System.IO.DirectoryInfo Optional Indique le répertoire HTML in‐
dépendamment de la valeur de
l'attribut dynamique Webser‐
verHTMLDirectory.
defaultHTMLPage System.IO.FileInfo Optional Indique la page HTML par dé‐
faut indépendamment de la va‐
leur de l'attribut dynamique
WebserverDefaultHTMLPage.
applicationName string Optional Indique le nom d'application in‐
dépendamment de la valeur de
l'attribut dynamique Webserve‐
rApplicationName.
GenerateBlocks() déclenche une exception récupérable :

● Lorsque le serveur Web est désactivé (WebserverActive == False) - "Le serveur Web doit
être activé"
● Lorsque WebserverHTMLDirectory est vide ou que le chemin est invalide - "Le répertoire
HTML a un chemin invalide"
● Lorsque WebserverdefaultHTMLPage est vide ou que le chemin est invalide - "Le répertoire
HTML par défaut a un chemin invalide"
● Lorsque le WebserverHTMLDirectory est trop long - "Le répertoire HTML contient trop de
données"
● Le nom d'application est invalide - "Le nom d'application est invalide"
● Les contenus dynamiques sont invalides - "Contenu dynamique invalide"
● Le numéro du bloc de données de commande est invalide - "Le numéro du DB de
commande est invalide"
● Le numéro de départ du bloc de données est invalide - "Le numéro du DB est invalide"
● Les blocs existent déjà : Lorsque l'utilisateur tente de générer un bloc avec un nom déjà
présent - "Supprimez les blocs présents avant de générer de nouveaux blocs" (déclenché
uniquement si WebDBGenerateOptions.None a été utilisé)

Il n'y a pas de fonction spéciale pour la suppression de tous les blocs liés aux pages
personnalisées. Vous devez supprimer manuellement les blocs qui sont transmis en retour aux
pages par l'action "Générer" ou naviguer vers les blocs de données correspondants, comme
c'est déjà possible dans TIA Portal Openness.
Code de programme
Pour générer un bloc pour une page personnalisée, modifiez le code de programme suivant :

var WebserverUserDefinedPagesService = deviceItem.GetService<WebserverUserDefinedPages>();
List<PLCBlock> blocks =
WebserverUserDefinedPagesService.GenerateBlocks(WebDBGenerateOptions.None);
List<PLCBlock> blocks = WebserverUserDefinedPagesService.GenerateBlocks(htmlDirectory,
defaultHTMLPage, applicationName, WebDBGenerateOptions.Override);
Voir aussi
7.19.23 Objets technologiques
7.19.23.1 Vue d'ensemble des objets technologiques

TIA Portal Openness prend en charge une sélection de fonctions d'objets technologiques pour
des tâches définies, que vous pouvez appeler à l'aide de l'API Public à l'extérieur de TIA Portal.
Les chapitres suivants contiennent des exemples de code pouvant être adaptés à votre
programme Openness.
Fonctions
Les fonctions suivantes sont disponibles pour les objets technologiques :
● Interroger la composition des objets technologiques (Page 545)
● Créer un objet technologique (Page 546)
● Supprimer des objets technologiques (Page 547)
● Compiler un objet technologique (Page 548)
● Enumérer des objets technologiques (Page 549)
● Rechercher un objet technologique (Page 550)
● Enumérer les paramètres d'un objet technologique (Page 551)
● Rechercher les paramètres d'un objet technologique (Page 551)
● Lire les paramètres d'un objet technologique (Page 552)

● Ecrire les paramètre d'un objet technologique (Page 553)

● Exporter des objets technologiques (Page 918)
● Importer des objets technologiques (Page 920)
● Connecter à des composants matériels (Page 563)
Voir aussi
Bibliothèques standard (Page 45)
Possibilités d'utilisation (Page 38)
7.19.23.2 Vue d'ensemble des objets technologiques et des versions
Objets technologiques
Le tableau suivant indique les objets technologiques disponibles dans l'API Public.
CPU Technologie Objet technologique Version de l'objet Firmware de la

technologique CPU
S7-1200 Commande TO_PositioningAxis ≥ V6.0 ≥ V4.2
de mouve‐ TO_CommandTable
ment
Régulation PID_Compact V2.3 ≥ V4.2
PID PID_3Step V2.3
PID_Temp V1.1

CPU Technologie Objet technologique Version de l'objet Firmware de la

technologique CPU
S7-1500 Commande TO_SpeedAxis ≥ V3.0 ≥ V2.0
de mouve‐ TO_PositioningAxis
ment
TO_ExternalEncoder
TO_SynchronousAxis
TO_OutputCam
TO_CamTrack
TO_MeasuringInput
TO_Cam (S7-1500T)1)
TO_Kinematics (S7-1500T) ≥ V4.0 ≥ V2.6
TO_LeadingAxisProxy ≥ V5.0 ≥ V2.8
(S7-1500T)
Comptage et High_Speed_Counter ≥ V4.1 au choix
mesure SSI_Absolute_Encoder ≥ V3.1
Régulation PID_Compact ≥ V2.3 ≥ V2.0
PID PID_3Step V2.3
PID_Temp V1.1
CONT_C
CONT_S
TCONT_CP
TCONT_S
S7-300/400 Régulation CONT_C V1.1 Chaque
PID CONT_S
TCONT_CP
TCONT_S
TUN_EC2)
TUN_ES2)
PID_CP2) V2.0
PID_ES2)
EMC AXIS_REF V2.0
1) L'objet technologique ne prend pas en charge les fonctions Openness suivantes : écriture de
paramètres.
2) L'objet technologique ne prend pas en charge les fonctions Openness suivantes : énumération de
paramètres, recherche de paramètres, lecture de paramètres, écriture de paramètres.
Voir aussi
S7-1500 Motion Control (Page 563)
7.19.23.3 Vue d'ensemble des types de données

Les types de données des paramètres des objets technologiques dans TIA Portal sont affectés
à des types de données C#-dans l'API Public.

Types de données
Le tableau suivant indique l'affectation des types de données :
Format Type de données dans TIA Portail Type de données dans C#

Nombres binaires Bool bool
BBool bool
Byte byte
Word ushort
DWord uint
LWord ulong
Nombres entiers SInt sbyte
Int short
Dint int
LInt long
USInt byte
UInt ushort
UDint uint
ULInt ulong
Nombres à virgule flottante Real float
LReal double
Time double
Chaînes de caractères Char char
WChar char
String string
WString string
Types de données matériel HW_* ushort
Block_* ushort
* réservation pour les extensions du type d'appareil dans le projet TIA Portal.
7.19.23.4 Interroger la composition des objets technologiques
Conditions requises
● L'application Openness est connectée au portail TIA.
VoirEtablissement d'une connexion au portail TIA (Page 79)
● Un API est déterminé dans le projet.
Voir Interroger PLC Target et HMI Target (Page 185)

Code du programme
Pour obtenir tous les objets technologiques d'un API, modifiez le code du programme suivant :
// Retrieves all technology objects of a PLC

private static void GetTechnologicalObjectsOfPLC(PlcSoftware plcSoftware)
{
TechnologicalInstanceDBGroup technologicalObjectGroup =
plcSoftware.TechnologicalObjectGroup;
TechnologicalInstanceDBComposition technologicalObjects =
technologicalObjectGroup.TechnologicalObjects;
}
Voir aussi
7.19.23.5 Créer un objet technologique
Conditions requises
● L'application Openness est liée avec leTIA Portal .
Utilisation
Seuls les objets technologiques qui sont listés au paragraphe Vue d'ensemble des objets
technologiques et des versions (Page 543) peuvent être créés. Pour les objets technologiques
non pris en charge ou les paramètres invalides, une exception est signalée. Voir
aussi Traitement des exceptions (Page 765).

Code du programme
Pour ajouter un objet technologique depuis un API précédent, modifiez le code du programme
suivant :
// Create a technology object and add to technology object composition

private static void CreateTechnologicalObject(PlcSoftware plcSoftware)
{
plcSoftware.TechnologicalObjectGroup.TechnologicalObjects;
string nameOfTO = "PID_Compact_1"; // How the technology object should be named

string typeOfTO = "PID_Compact"; // How the technology object type is called, e.g. in
// "Add new technology object"-dialog
Version versionOfTO = new Version("2.3"); // Version of technology object
TechnologicalInstanceDB technologicalObject = technologicalObjects.Create(nameOfTO,
typeOfTO, versionOfTO);
}
Les valeurs et les combinaisons de nom, type et version des objets technologiques peuvent
être trouvées au paragraphe Vue d'ensemble des objets technologiques et des versions
(Page 543).
Voir aussi
7.19.23.6 Supprimer des objets technologiques
Conditions requises
● L'objet technologique est présent.
Voir Rechercher un objet technologique (Page 550)

Code du programme
Pour supprimer un objet technologique, modifiez le code du programme suivant :
// Delete a technology object from DB composition and from PLC

private static void DeleteTechnologicalObject(TechnologicalInstanceDB technologicalObject)
{
technologicalObject.Delete();
}
Voir aussi
7.19.23.7 Compiler un objet technologique
Conditions requises
● L'application Openness est liée à TIA Portal.
Voir Créer un objet technologique (Page 546)
Code du programme Compilation d'un objet technologique

Pour compiler un objet technologique, modifiez le code du programme suivant :
// Compile a single technology object

private static void CompileSingleTechnologicalObject(TechnologicalInstanceDB
technologicalObject)
{
ICompilable singleCompile = technologicalObject.GetService<ICompilable>();
CompilerResult compileResult = singleCompile.Compile();
}

Code du programme Compilation d'un groupe d'objets technologiques

Pour compiler un groupe d'objets technologiques, modifiez le code du programme suivant :
// Compile technology object group

private static void CompileTechnologicalObjectGroup(PlcSoftware plcSoftware)
{
TechnologicalInstanceDBGroup technologicalObjectGroup =
plcSoftware.TechnologicalObjectGroup;
ICompilable groupCompile = technologicalObjectGroup.GetService<ICompilable>();
CompilerResult compileResult = groupCompile.Compile();
}
Résultats de la compilation
Les résultats de la compilation d'objets technologiques sont enregistrés de façon récurrente.
Vous trouverez un exemple du traitement récurrent des résultats de compilation au paragraphe
"Compiler le projet (Page 133)".
Remarque
Autres paramètres
Les données importées sont étendues après la compilation. Par exemple, vous pouvez utiliser
Openness pour élaborer des objets technologiques pour la commande du mouvement avec
différentes versions. Après la compilation d'objets technologiques, les versions de commande
du mouvement d'autres objets technologiques sont adaptées à celles du dernier objet
technologique élaboré.
Voir aussi
7.19.23.8 Enumérer des objets technologiques
Conditions requises
Vous pouvez énumérer les objets technologiques de premier niveau tels que "TO_Axis" et
"TO_Cam". Pour les objets technologiques de niveau inférieur tels que "TO_OutputCam"
voir Créer et trouver TO_OutputCam, TO_CamTrack et TO_MeasuringInput (Page 563).

Code du programme
Pour énumérer des objets technologiques, modifiez le code du programme suivant :
// Enumerate all technology objects

private static void EnumerateTechnologicalObjects(PlcSoftware plcSoftware)
{
foreach (TechnologicalInstanceDB technologicalObject in technologicalObjects)
{
// Do something ...
}
}
Voir aussi
7.19.23.9 Rechercher un objet technologique
Conditions requises
Code du programme
Pour rechercher un objet technologique spécifique, modifiez le code du programme suivant.
// Find a specific technology object by its name

private static void FindTechnologicalObject(PlcSoftware plcSoftware)
{
string nameOfTO = "PID_Compact_1";
TechnologicalInstanceDB technologicalObject = technologicalObjects.Find(nameOfTO);
}
Voir aussi

7.19.23.10 Enumérer les paramètres d'un objet technologique
Conditions requises
● Un objet technologique est présent.
Voir Créer un objet technologique (Page 546) ou Rechercher les paramètres d'un objet
technologique (Page 551)
● L'objet technologique (Page 543) prend en charge cette fonction.
Code du programme
Pour énumérer les paramètres d'un objet technologique, modifiez le code du programme
suivant :
// Enumerate parameters of a technology object

private static void EnumerateParameters(PlcSoftware plcSoftware)
{
TechnologicalInstanceDB technologicalObject =
plcSoftware.TechnologicalObjectGroup.TechnologicalObjects.Find(nameOfTO);
foreach (TechnologicalParameter parameter in technologicalObject.Parameters)

{
// Do something ...
}
}
Voir aussi
Rechercher un objet technologique (Page 550)
7.19.23.11 Rechercher les paramètres d'un objet technologique
Conditions requises


Code du programme
Pour rechercher les paramètres d'un objet technologique, modifiez le code du programme
suivant :
// Find parameters of a technology object

private static void FindParameterOfTechnologicalObject(PlcSoftware plcSoftware)
{
string nameOfParameter = "Config.InputUpperLimit";

TechnologicalParameter parameter =
technologicalObject.Parameters.Find(nameOfParameter);
}
Paramètres de différents objets technologiques

Paramètres de SIMATIC S7-1200 Motion Control (Page 555)
Paramètres de la régulation PID (Page 585)
Paramètres de comptage (Page 586)
Paramètres d'Easy Motion Control (Page 587)
Voir aussi
7.19.23.12 Lire les paramètres d'un objet technologique
Conditions requises


Code du programme
Pour lire les paramètres d'un objet technologique défini, modifiez le code du programme
suivant :
// Read parameters of a technology object

private static void ReadParameterOfTechnologicalObject(PlcSoftware plcSoftware)
{

// Read from parameter

string name = parameter.Name;
object value = parameter.Value;
}
Voir aussi
7.19.23.13 Ecrire les paramètre d'un objet technologique
Conditions requises

Exception
Une EngineeringException est signalée lorsque :
● vous définissez une nouvelle valeur pour un paramètre qui ne possède pas d'accès en
écriture.
● une nouvelle valeur pour un paramètre est d'un type non pris en charge.
Code du programme
Pour écrire un paramètre d'un objet technologique spécifique, modifiez le code du programme
suivant :
// Write parameters of a technology object

private static void WriteParameterOfTechnologicalObject(PlcSoftware plcSoftware)
{

// Write to parameter if the value is writable

object value = 3.0;
parameter.Value = value;
}
Paramètres des différents objets technologiques

Paramètres de la régulation PID (Page 585)
Paramètres de comptage (Page 586)
Paramètres d'Easy Motion Control (Page 587)
Voir aussi

7.19.23.14 S7-1200 Motion Control
Modifier la version d'Openness Engineering Library

Tant que vous utilisez "Openness\PublicAPI\V14 SP1\Siemens.Engineering.dll" avec TIA
Portal V15, votre application Openness actuelle fonctionne normalement.
Lorsque vous passez à "Openness\PublicAPI\V15\Siemens.Engineering.dll" avec TIA Portal
V15, vous devez adapter tous les accès aux variables ARRAY pour S7-1200 Motion Control.
Les variables de type ARRAY pour TO_PositioningAxis concernées sont énumérées dans les
tableaux suivants :
Accès à Openness < V15 Accès à Openness ≥ V15

_Sensor.Sensor[1].<toutes les variables> _Sensor[1].<toutes les variables>
ControlPanel.Input.Command.Command[1].<tou‐ ControlPanel.Input.Command[1].<toutes les varia‐
tes les variables> bles>
ControlPanel.Output.Command.Com‐ ControlPanel.Output.Command[1].<toutes les va‐
mand[1].<toutes les variables> riables>
Internal.Internal[n].<toutes les variables> Internal[n].<toutes les variables>
Sensor.Sensor[1].<toutes les variables> Sensor[1].<toutes les variables>
StatusSensor.StatusSensor[1].<toutes les varia‐ StatusSensor[1].<toutes les variables>
bles>
Les variables de type ARRAY pour TO_CommandTable concernées sont énumérées dans les
tableaux suivants :
Accès à Openness < V15 Accès à Openness ≥ V15

Command.Command[n].<toutes les variables> Command[n].<toutes les variables>
Connecter des sorties PTO
Conditions
Voir Établir une connexion à TIA Portal (Page 79).
● Un API S7-1200 avec des sorties PTO a été créé dans le projet.
Voir Élaborer un objet technologique (Page 546).

Code du programme
Pour connecter une sortie PTO pour le "TO_PositioningAxis", modifiez le code du programme
suivant :
//An instance of the technology object axis is already available in the program before 　
private static void ConnectingDrive(TechnologicalInstanceDB technologicalObject)
{
//Set axis to PTO mode
technologicalObject.Parameters.Find("Actor.Type").Value = 2;
//Set PTO-Output
technologicalObject.Parameters.Find("_Actor.Interface.PTO").Value = 0; // select
Pulse_1
// 0 = Pulse_1
// 1 = Pulse_2
// 2 = Pulse_3
// 3 = Pulse_4
}
Connecter des PROFIdrives avec l'adresse matérielle
Conditions
● Une CPU S7-1200 est créée dans le projet.
● Un PROFIdrive est disponible dans le projet et connecté à la CPU S7-1200.
Voir Créer un objet technologique (Page 546).

Code du programme
Modifiez le code de programme suivant pour connecter un PROFIdrive à l'objet technologique
"TO_PositioningAxis" à l'aide d'une adresse matérielle.
private static void ConnectingDrive(TechnologicalInstanceDB technologicalObject)
{
//Set axis to PROFIdrive mode
//Set axis to drive mode

technologicalObject.Parameters.Find("_Actor.Interface.DataConnection").Value = 0;
//Set connection to address of drive. The output will be set automatically.

technologicalObject.Parameters.Find("_Actor.Interface.ProfiDriveIn").Value = "%I68.0";
technologicalObject.Parameters.Find("Sensor[1].Interface.Number").Value = 1;
// 1 = Encoder1, 2 = Encoder2;
}
Connecter un codeur pour PROFIdrives à l'adresse matérielle
Conditions

● Un PROFIdrive est disponible dans le projet et connecté à la CPU S7-1200.

Code du programme
Modifiez le code de programme suivant pour connecter un codeur à l'adresse matérielle avec
l'objet technologique "TO_PositioningAxis" :
//An instance of the technology object axis is already available in the program before
private static void ConnectingEncoder(TechnologicalInstanceDB technologicalObject)
{
//Set the encoder mode

technologicalObject.Parameters.Find("_Sensor[1].Interface.EncoderConnection").Value =
7;
//Set axis to use PROFINET encoder

technologicalObject.Parameters.Find("_Sensor[1].Interface.DataConnection").Value = 0;
//Set connection to address of drive. The output will be set automatically.

technologicalObject.Parameters.Find("_Sensor[1].Interface.ProfiDriveIn").Value =
"%I68.0";
}
Connecter des entraînements analogiques à l'adresse matérielle
Conditions

● Un entraînement analogique est disponible dans le projet et connecté à la CPU S7-1200.

Code du programme
Modifiez le code de programme suivant pour connecter un entraînement analogique à
l'adresse matérielle avec l'objet technologique "TO_PositioningAxis" :
{
//Set axis to analog drive mode
//Set axis to drive mode

//Set connection to analog address of drive

technologicalObject.Parameters.Find("_Actor.Interface.Analog").Value = "%QW64";
}
Connecter les codeurs pour les entraînements analogiques à l'adresse matérielle
Conditions
● Un entraînement analogique est disponible dans le projet et connecté à la CPU S7-1200.

Code du programme
Modifiez le code de programme suivant pour connecter un codeur à l'adresse matérielle avec
l'objet technologique "TO_PositioningAxis" :
//Connecting by High Speed Counter mode
{
//Set encoder for high-speed counter mode

4;
technologicalObject.Parameters.Find("_Sensor[1].Interface.HSC.Name").Value = "HSC_1";
}
//Connecting by PROFINET/PROFIBUS telegram
private static void ConnectingEncoder(TechnologicalInstanceDB
{
//Set encoder for PROFINET/PROFIBUS mode
7;
technologicalObject.Parameters.Find("_Sensor[1].Interface.DataConnection").Value =
"Encoder";
technologicalObject.Parameters.Find("_Sensor[1].Interface.ProfiDriveIn").Value =
"%I68.0";
}
Connecter des entraînements à un bloc de données
Conditions


● Un bloc de données est disponible dans le projet et réglé sur "Non optimisé".
Avec un type d'axe PROFIdrive, le bloc de données contient une variable de ce type, par
exemple PD_TEL3.
Avec un entraînement analogique, le bloc de données contient une variable du type de
données Mot.
Code du programme
Modifiez le code de programme suivant pour connecter un PROFIdrive à un bloc de données
avec l'objet technologique "TO_PositioningAxis".
private static void ConfigureDrivewithDataBlock(TechnologicalInstanceDB
{
//Set axis to data block mode

//Set the tag in the data block

technologicalObject.Parameters.Find("_Actor.Interface.DataBlock").Value =
"Data_block_1.Member_of_type_PD_TEL3";
}
Code du programme
Modifiez le code de programme suivant pour connecter un entraînement analogique à un bloc
de données avec l'objet technologique "TO_PositioningAxis" :
//Connecting an analog drive with data block.
private static void ConfigureDrivewithDataBlock(TechnologicalInstanceDB
{
//Set axis to analog mode
//Set the tag in the data block

technologicalObject.Parameters.Find("_Actor.Interface.Analog").Value =
"Data_block_1.Static_1";
}

Connecter un codeur à un bloc de données
Conditions

● Un bloc de données est disponible dans le projet et réglé sur "Non optimisé".
Avec PROFIdrive, le bloc de données contient une variable de ce type, par exemple
PD_TEL3.
Code du programme
Modifiez le code de programme suivant pour connecter un codeur à un bloc de données :
private static void ConfigureEncoderwithDataBlock(TechnologicalInstanceDB
{
//Set axis to PROFIdrive mode depending by axis type. 1 = PROFIdrive, 0 = Analog Drive.
//Set the encoder mode

7;
//Set axis to data block mode

technologicalObject.Parameters.Find("_Sensor[1].Interface.DataConnection").Value = 1;
//Set the tag in the data block. For PD_TEL3 and PD_TEL4 "Encoder1" or "Encoder2".
technologicalObject.Parameters.Find("_Sensor[1].Interface.DataBlock").Value =
"Data_block_1.Member_of_Type_PD_TEL3";
}

Paramètres pour TO_PositioningAxis et TO_CommandTable

Pour une liste contenant toutes les variables disponibles, voir la description fonctionnelle
SIMATIC STEP 7 S7-1200 Motion Control sur Internet (https://support.industry.siemens.com/
cs/ww/fr/view/109754206)
Remarque
Dans TIA Portal, la colonne "Nom dans Openness" se trouve dans la vue des paramètres de
la configuration de l'objet technologique.
Créer et trouver TO_OutputCam, TO_CamTrack et TO_MeasuringInput
Conditions
● Un objet technologique du type TO_PositioningAxis, TO_SynchronousAxis ou
TO_ExternalEncoder est créé dans le projet.
Application
Les objets technologiques Came, Piste de came et Palpeur de mesure sont connectés à l'un
des objets technologiques Axe de positionnement, Axe synchrone ou Codeur externe. Pour
accéder aux objets technologiques Came, Piste de came ou Palpeur de mesure, utilisez le
service OutputCamMeasuringInputContainer.

Code du programme : Créer et trouver les objets technologiques Came, Piste de came et Palpeur de
mesure
Modifiez le code de programme suivant pour créer ou trouver l'objet technologique Came, Piste
de came ou Palpeur de mesure.
/*An instance of the technology object under which the TO_OutputCam, TO_CamTrack or
TO_MeasuringInput should be created is already available in the program before*/
private static void CreateFind_OutputcamCamtrackMeasuringinput(TechnologicalInstanceDB
technologyObject)
{
//Retrieve service OutputCamMeasuringInputContainer
OutputCamMeasuringInputContainer container =
technologyObject.GetService<OutputCamMeasuringInputContainer>();
//Get access to TO_OutputCam / TO_CamTrack container
TechnologicalInstanceDBComposition outputcamCamtrackContainer = container.OutputCams;
//Find technology object TO_OutputCam or TO_CamTrack

TechnologicalInstanceDB outputCam = outputcamCamtrackContainer.Find("OutputCamName");
TechnologicalInstanceDB camTrack = outputcamCamtrackContainer.Find("CamTrackName");
//Create new technology object TO_OutputCam or TO_CamTrack

TechnologicalInstanceDB newOutputCam =
outputcamCamtrackContainer.Create("NewOutputCamName", "TO_OutputCam",
new Version(3, 0));
TechnologicalInstanceDB newCamTrack =
outputcamCamtrackContainer.Create("NewCamTrackName", "TO_CamTrack", new Version(3, 0));
//Get access to TO_MeasuringInput container

TechnologicalInstanceDBComposition measuringInputContainer = container.MeasuringInputs;
//Find technology object TO_MeasuringInput

TechnologicalInstanceDB measuringInput =
measuringInputContainer.Find("MeasuringInputName");
//Create new technology object TO_MeasuringInput

TechnologicalInstanceDB newMeasuringInput =
measuringInputContainer.Create("NewMeasuringInput", "TO_MeasuringInput",
new Version(3, 0));
}

Vous élaborez les objets technologiques S7-1500 OutputCam, CamTrack et MeasuringInput

en tant que copie maîtresse de Siemens.Engineering.Library.MasterCopies.MasterCopy.
/*An instance of the technology object under which the TO_OutputCam, TO_CamTrack or
TO_MeasuringInput should be created is already available in the program before*/
// sourceMasterCopy contains master copy object output cam
private static void CreateFind_OutputcamCamtrackMeasuringinput(TechnologicalInstanceDB
technologyObject, MasterCopy sourceMasterCopy)
{
TechnologicalInstanceDB result = container.OutputCams.CreateFrom(sourceMasterCopy);
Paramètres de S7-1500 Motion Control

La plupart des paramètres des objets technologiques S7-1500 Motion Control sont
représentés directement sur des variables de bloc de données mais il existe également
quelques autres paramètres qui ne le sont pas.
Paramètres directement représentés sur les variables de bloc de données de l'objet technologique :
Vous avez accès à toutes les variables de bloc de données de l'objet technologique
généralement décrites sauf :
● Variables protégées en écriture
● Variables du type de données VREF
● Variables avec la structure "InternalToTrace"
● Variables avec la structure "ControlPanel"
Vous pouvez trouver dans les annexes suivantes des informations supplémentaires sur les
paramètres représentés directement :
● Description fonctionnelle SIMATIC S7-1500 Motion Control :
https://support.industry.siemens.com/cs/ww/fr/view/109749262 (https://
support.industry.siemens.com/cs/ww/fr/view/109749262)
● Description fonctionnelle SIMATIC S7-1500T Motion Control :
● Description fonctionnelle SIMATIC S7-1500T Fonctions cinématiques :
Certains paramètres technologiques assignés aux variables de bloc de données protégées en
écriture peuvent être écrits dans PublicAPI. Les valeurs autorisées sont les mêmes que pour

les variables de bloc de données subordonnées. Les paramètres concernés sont énumérés
dans les tableaux suivants :
Nom dans Openness Type de don‐ TO_SpeedAxis TO_Positionin‐ TO_Synchro‐ TO_ExternalEn‐

nées gAxis nousAxis coder
Actor.Type int X X X -
Actor.Interface.EnableDri‐ bool X X X -
veOutput
Actor.Interface.DriveRea‐ bool X X X -
dyInput
VirtualAxis.Mode uint X X X -
Sensor[n].Existent 1)
bool - X X -
Sensor[n].Interface.Number1) uint - X X -
Sensor[n].Type 1)
int - X X -
Sensor.Interface.Number uint - - - X
Sensor.Type int - - - X
Nom dans Openness Type de don‐ TO_OutputCam TO_MeasuringInput TO_Kinematics2)

nées
Interface. int X - -
Parameter.MeasuringInput‐ int - X -
Type
Kinematics.TypeOfKinema‐ int - - X
tics
MotionQueue.MaxNumbe‐ int - - X
rOfCommands
1) CPU S7-1500 : n=1 ; CPU S7-1500T : 1≤n≤4

2) CPU S7-1500T

Paramètres qui ne sont pas directement représentés sur les variables de bloc de données de l'objet
technologique :
Les paramètres supplémentaires suivants qui ne sont pas directement représentés sur les
variables de bloc de données sont disponibles pour les objets technologiques S7-1500 Motion
Control :
Nom dans Openness Nom dans la Valeur pos‐ Type de don‐ TO_SpeedA‐ TO_Positionin‐ TO_Externa‐
vue de fonction sible nées dans xis gAxis lEncoder
Openness TO_Synchro‐
nousAxis
_Properties.Motion‐ Type d'axe ou 0 : Linéaire int - X X
Type "unité techni‐ 1 : Rotatif
que de la posi‐
tion"
_Properties.UseHigh‐ Utiliser la va‐ True, False bool - X X
ResolutionPosition‐ leur de posi‐
Values tionnement
avec une hau‐
te résolution
_CrossPlcSynchro‐ Activer le cal‐ True, False bool - X X
nousOperation. cul de la durée
ActivateLocalLea‐ de retard
dingValueDelayTime‐
Calculation
_Units.LengthUnit Unités de posi‐ Voir la variable uint - X X
tion Units.Leng‐
thUnit3)
_Units.VelocityUnit Unités de vi‐ Voir la variable uint X X X
tesse Units.Veloci‐
tyUnit3)
_Units.TorqueUnit Unités de cou‐ Voir la variable uint X X -
ple Units.Tor‐
queUnit3)
_Units.ForceUnit Unités de force Voir la variable uint - X -
Units.ForceU‐
nit3)
_Actor.DataAdaptio‐ Appliquer au‐ Vrai, faux bool X X -
nOffline tomatique‐
ment ...
_Actor.Interface.Tele‐ Télégramme Numéro de té‐ uint X X -
gram d'entraîne‐ légramme4)
ment
_Actor.Interface.Ena‐ Adresse pour Objet PublicA‐ SW.Tags.PlcT X X -
bleDriveOutputAd‐ la sortie Vali‐ PI ag
dress dation d'entraî‐
nement
_Actor.Interface.Dri‐ Adresse pour Objet PublicA‐ SW.Tags.PlcT X X -
veReadyInputAd‐ l'entrée Valida‐ PI ag
dress tion d'entraîne‐
ment
_Sensor[n].Interfa‐ Télégramme Numéro de té‐ uint - X -
ce.Telegram5) de codeur légramme4)

Nom dans Openness Nom dans la Valeur pos‐ Type de don‐ TO_SpeedA‐ TO_Positionin‐ TO_Externa‐
vue de fonction sible nées dans xis gAxis lEncoder
Openness TO_Synchro‐
nousAxis
_Sensor[n].Active‐ Entrée TOR Objet PublicA‐ SW.Tags.PlcT - X -
Homing.DigitalInpu‐ PI ag
tAddress5)
_Sensor[n].Passive‐ Entrée TOR Objet PublicA‐ SW.Tags.PlcT - X -
tAddress5)
_PositionLi‐ Adresse du fin Objet PublicA‐ SW.Tags.PlcT - X -
mits_HW.MinSwit‐ de course ma‐ PI ag
chAddress tériel négatif
_PositionLi‐ Adresse du fin Objet PublicA‐ SW.Tags.PlcT - X -
mits_HW.MaxSwit‐ de course ma‐ PI ag
chAddress tériel positif
_Sensor[n].DataA‐ Appliquer au‐ Vrai, faux bool - X -
daptionOffline1) tomatique‐
ment ...
_Sensor.DataAdap‐ Appliquer au‐ Vrai, faux bool - - X
tionOffline tomatique‐
ment ...
_Sensor.Interface.Te‐ Télégramme Numéro de té‐ uint - - X
legram de codeur légramme4)
_Sensor.Passive‐ Entrée TOR Objet PublicA‐ SW.Tags.PlcT - - X
tAddress
_CrossPlcSynchro‐ Synchronisme Objet PublicA‐ SW.Tags.PlcT - X X
nousOperation.Inter‐ réparti PI ag
face[1]. AddressOut
Le paramètre supplémentaire suivant est disponible pour les objets technologiques Came,
Piste de came et Palpeur de mesure :
Nom dans Openness Nom dans la vue de fonction Valeur possible Type de données
_AssociatedObject Axe ou codeur externe affecté Objet PublicAPI SW.TechnologicalObjects.Tech‐
nologicalInstanceDB
Pour l'objet technologique Cinématique, les paramètres supplémentaires suivants sont

disponibles (S7-1500T) :
_KinematicsAxis[1...4] Axes 1 - 3, axe d'orientation Axe pouvant être con‐ SW.TechnologicalObjects.Tech‐
necté aux objets TO_Ki‐ nologicalInstanceDB
nematics
_Units.LengthUnit Unité de mesure > position Voir la variable uint
Units.LengthUnit3)
_Units.LengthVelocityUnit Unité de mesure > vitesse Voir la variable uint
Units.LengthVelocityU‐
nit3)
_Units.AngleUnit Unité de mesure > angle Voir la variable UnitsAn‐ uint
gleUnit3)

_Units.AngleVelocityUnit Unité de mesure > vitesse an‐ Voir la variable Units.An‐ uint
gulaire gleVelocityUnit3)
_X_Minimum Minimum x -1.00E+12 .. +1.00E+12 double
_X_Maximum Maximum x -1.00E+12 .. +1.00E+12 double
_Y_Minimum Minimum y -1.00E+12 .. +1.00E+12 double
_Y_Maximum Maximum y -1.00E+12 .. +1.00E+12 double
_Z_Minimum Minimum z -1.00E+12 .. +1.00E+12 double
_Z_Maximum Maximum z -1.00E+12 .. +1.00E+12 double
_A3_Maximum Maximum A3 -1.00E+12 .. +1.00E+12 double
Pour l'objet technologique TO_LeadingAxisProxy, le paramètre supplémentaire suivant est

disponible :
_Interface.AddressIn Plage de transfert Objet PublicA‐ SW.Tags.PlcTag
PI
3) Les valeurs possibles sont décrites dans le chapitre Variable Units (TO) de la description
fonctionnelle S7-1500 Motion Control
4) Les valeurs possibles sont décrites dans le chapitre Télégrammes PROFIdrive de la
description fonctionnelle S7-1500 Motion Control
5) CPU S7-1500 : n=1 ; CPU S7-1500T : 1≤n≤4
Code du programme : Variables de bloc de données directement représentées

Pour accéder aux paramètres représentés directement, modifiez le code de programme
suivant :
//An instance of the technology object is already available in the program before
private static void ReadWriteDataBlockTag(TechnologicalInstanceDB technologyObject)
{
//Read value from data block tag "ReferenceSpeed"
double value =
(double)technologyObject.Parameters.Find("Actor.DriveParameter.ReferenceSpeed").Value;
//Write data block tag "ReferenceSpeed"

technologyObject.Parameters.Find("Actor.DriveParameter.ReferenceSpeed").Value = 3000.0;
}

Code du programme : Autres paramètres

Pour accéder aux autres paramètres, modifiez le code de programme suivant :
//An instance of the technology object is already available in the program before
private static void ReadWriteAdditionalParameter(TechnologicalInstanceDB technologyObject)
{
//Read additional parameter "_Properties.MotionType"
uint value = (uint)technologyObject.Parameters.Find("_Properties.MotionType").Value;
//Write additional parameter "_Properties.MotionType"

technologyObject.Parameters.Find("_Properties.MotionType").Value = 1;
}
Informations supplémentaires
Pour plus d'informations, voir :
● Description fonctionnelle SIMATIC S7-1500 Motion Control :
● Description fonctionnelle SIMATIC S7-1500T Motion Control :
● Description fonctionnelle SIMATIC S7-1500T Fonctions cinématiques :
Connecter des entraînements
Conditions
Vous devez utiliser les adresses de bits pour une connexion d'objet technologique. Les
adresses d'octet ne peuvent pas être utilisées.
● Un objet technologique du type TO_SpeedAxis, TO_PositioningAxis ou
TO_SynchronousAxis est créé dans le projet.
● Un entraînement est créé dans le projet.

Application
Pour connecter un axe à un entraînement, il est nécessaire d'indiquer plusieurs valeurs
ensemble au cours d'un seul appel. Le type du Public API
AxisEncoderHardwareConnectionInterface offre les méthodes suivantes pour connecter ou
couper les interfaces d'actionneur ou de capteur :
Méthode Description
void Connect(HW.DeviceItem moduleInOut) Connecte aux adresses d'entrée et de sortie d'un module
void Connect(HW.DeviceItem moduleIn, HW.DeviceItem mo‐ Connecte aux adresses d'entrée et de sortie de modules cou‐
duleOut) pés
duleOut, ConnectOption connectOption) pés en indiquant une ConnectOption supplémentaire
void Connect(HW.Channel channel) Connecte à une voie
void Connect(int addressIn, int addressOut, ConnectOption Connecte des adresses binaires directement
connectOption)
void Connect(string pathToDBMember) Connecte à une variable de bloc de données
void Connect(SW.Tags.PlcTag outputTag) Connecte à une variable CPU
void Disconnect() Coupe une connexion existante
Remarque
Connexion automatique
Notez que s'applique ici le même comportement que dans l'interface utilisateur. Les parties
sont toujours connectées automatiquement lorsque l'interface d'actionneur est connectée via
l'une des méthodes de connexion suivantes et que le télégramme contient une partie capteur
ou télégramme 750.
Vous pouvez utiliser les attributs en lecture seule suivants pour déterminer comment l'objet
technologique est connecté. Les valeurs de connexion correspondantes sont réglées
uniquement si une connexion spécifique de ce type existe.

IsConnected bool TRUE : L'interface est connectée
FALSE : L'interface n'est pas connectée
InputOutputModule HW.DeviceItem Module connecté qui contient des adresses d'entrée et de sortie
InputModule HW.DeviceItem Module connecté qui contient des adresses d'entrée
La valeur est également réglée si une connexion à un module contenant
des adresses d'entrée et de sortie existe.
OutputModule HW.DeviceItem Module connecté qui contient des adresses de sortie
InputAddress int Adresse d'entrée logique de l'objet connecté ; par exemple : 256.
OutputAddress int Adresse de sortie logique de l'objet connecté ; par exemple : 256.


ConnectOption ConnectOption Valeur de la ConnectOption paramétrée lors de l'établissement de la con‐
nexion :
● Paramètre par défaut
Seuls les modules détectés comme partenaires de liaison valides peu‐
vent être sélectionnés.
● AllowAllModules
Correspond à la sélection de "Afficher tous les modules" dans l'inter‐
face utilisateur.
Channel HW.Channel Voie connectée
PathToDBMember string Variable de bloc de données de l'objet technologique connectée
OutputTag SW.Tags.PlcTag Variable CPU connectée (connexion analogique)
SensorIndexInActor‐ int Partie capteur connectée dans le télégramme d'activation
Telegram Cet attribut n'est pertinent que pour les interfaces de capteur.
0 : Le codeur n'est pas connecté
1 : Le codeur est connecté à la première interface de capteur dans le
télégramme
2 : Le codeur est connecté à la seconde interface de capteur dans le
télégramme
La valeur de l'interface d'actionneur est toujours 0.
Remarque
Accès à l'interface de capteur
Pour accéder à l'interface de capteur, vous pouvez utiliser SensorInterface[m] avec 0≤m≤3.

Code du programme : void Connect(HW.DeviceItem moduleInOut)

Modifiez le code de programme suivant pour connecter un module mixte contenant des
adresses d'entrée et de sortie.
//An instance of technology object and device item is already available in the program
before
private static void UseServiceAxisHardwareConnectionProvider(TechnologicalInstanceDB
technologyObject, DeviceItem devItem)
{
//Retrieve service AxisHardwareConnectionProvider
AxisHardwareConnectionProvider connectionProvider =
technologyObject.GetService<AxisHardwareConnectionProvider>();
//Connect ActorInterface with DeviceItem

connectionProvider.ActorInterface.Connect(devItem);
//Connect first SensorInterface with DeviceItem

connectionProvider.SensorInterface[0].Connect(devItem);
//Check ConnectionState of ActorInterface

bool actorInterfaceConnectionState = connectionProvider.ActorInterface.IsConnected;
//Check ConnectionState of first SensorInterface

bool sensorInterfaceConnectionState =
connectionProvider.SensorInterface[0].IsConnected;
}
Connecter le télégramme 750
Conditions
● Un objet technologique du type TO_SpeedAxis, TO_PositioningAxis ou
TO_SynchronousAxis V4.0 est créé dans le projet.
● Un entraînement, qui prend en charge le télégramme 750, est créé dans le projet.

Application
Lorsque le télégramme 750 est ajouté après la connexion de l'entraînement et de l'axe, le
télégramme 750 doit être connecté séparément. EnableTorqueData est automatiquement mis
sur TRUE . Le type du Public API TorqueHardwareConnectionInterface offre les méthodes
suivantes pour connecter ou couper le télégramme 750.
void Connect(HW.DeviceItem moduleInOut) Connecte aux adresses d'entrée et de sortie d'un
module
void Connect(HW.DeviceItem moduleIn, HW.De‐ Connecte aux adresses d'entrée et de sortie de
viceItem moduleOut) modules coupés
void Connect(HW.DeviceItem moduleIn, HW.De‐ Connecte aux adresses d'entrée et de sortie de

viceItem moduleOut, ConnectOption connectOp‐ modules coupés en indiquant une ConnectOption
tion) supplémentaire
void Connect(int addressIn, int addressOut, Con‐ Connecte des adresses binaires directement
nectOption connectOption)
TorqueHardwareConnectionInterface peut être appelée via l'attribut TorqueInterface sur le

type AxisHardwareConnectionProvider. Si la connexion avec le télégramme 750 n'est pas
prise en charge, la valeur de l'attribut est "nulle".
En cas de connexion de l'entraînement par variables de bloc de données, vous ne pouvez pas
connecter le télégramme 750 à l'aide du module. Vous pouvez utiliser les attributs en lecture
seule suivants pour déterminer comment l'objet technologique est connecté. Les valeurs de
connexion correspondantes sont réglées uniquement si une connexion spécifique de ce type
existe.

IsConnected bool TRUE: l'interface est connectée
FALSE: l'interface n'est pas connectée
InputOutput‐ HW.DeviceItem Module connecté qui contient des adresses d'en‐
Module trée et de sortie
InputModule HW.DeviceItem Module connecté qui contient des adresses d'en‐
trée
La valeur est également réglée si une connexion à
un module contenant des adresses d'entrée et de
sortie existe.
OutputModu‐ HW.DeviceItem Module connecté qui contient des adresses de
le sortie
La valeur est également réglée si une connexion à
un module contenant des adresses d'entrée et de
sortie existe.
InputAddress int Adresse d'entrée logique de l'objet connecté ; par
exemple : 256.
OutputAd‐ int Adresse de sortie logique de l'objet connecté ; par
dress exemple : 256.


ConnectOp‐ ConnectOption Valeur de la ConnectOption paramétrée lors de
tion l'établissement de la connexion :
● Standard
Seuls les modules détectés comme partenai‐
res de connexion valides peuvent être sélec‐
tionnés.
● AllowAllModules
Correspond à la sélection de "Afficher tous les
modules" dans l'interface utilisateur.
PathToDB‐ string Variable de bloc de données objet technologique
Member connectée
Code du programme : connexion du télégramme 750

Modifiez le code de programme suivant pour connecter un module mixte contenant des
adresses d'entrée et de sortie :
before
private static void ConnectTorqueInterface(TechnologicalInstanceDB technologyObject,
DeviceItem devItem)
{
//Retrieve service AxisHardwareConnectionProvider
AxisHardwareConnectionProvider connectionProvider =
technologyObject.GetService<AxisHardwareConnectionProvider>();
//Connect TorqueInterface with DeviceItem
connectionProvider.TorqueInterface.Connect(devItem);
}
Connecter un codeur
Conditions
● Un objet technologique du type TO_ExternalEncoder est créé dans le projet.
● Un objet fournissant le télégramme PROFIdrive 81 ou 83 est défini dans le projet.

Application
Pour connecter un objet technologique Codeur externe au matériel du codeur, il est nécessaire
d'indiquer plusieurs valeurs ensemble au cours d'un seul appel. Le type du Public API
AxisEncoderHardwareConnectionInterface offre les méthodes suivantes pour connecter ou
couper l'interface de capteur.
void Connect(HW.DeviceItem moduleInOut) Connecte aux adresses d'entrée et de sortie d'un module
duleOut) pés
duleOut, ConnectOption connectOption) pés en indiquant une ConnectOption supplémentaire
void Connect(int addressIn, int addressOut, ConnectOption Connecte des adresses binaires directement
connectOption)
void Connect(SW.Tags.PlcTag outputTag) Non pertinent pour la connexion de codeurs
technologique est connecté. Les valeurs de connexion correspondantes sont réglées
uniquement si une connexion spécifique de ce type existe.

IsConnected bool TRUE : L'interface est connectée
FALSE : L'interface n'est pas connectée
InputOutputModule HW.DeviceItem Module connecté qui contient des adresses d'entrée et de sortie
OutputModule HW.DeviceItem Module connecté qui contient des adresses de sortie
InputAddress int L'adresse d'entrée logique de l'objet connecté est par exemple 256.
OutputAddress int L'adresse de sortie logique de l'objet connecté est par exemple 256.
ConnectOption ConnectOption Valeur de la ConnectOption paramétrée lors de l'établissement de la con‐
nexion :
● Default
Seuls les modules détectés comme partenaires de liaison valides peu‐
vent être sélectionnés.
● AllowAllModules
Correspond à la sélection de "Afficher tous les modules" dans l'inter‐
face utilisateur.
PathToDBMember string Variable de bloc de données connectée


OutputTag SW.Tags.PlcTag Non pertinent pour la connexion de codeurs
SensorIndexInActor‐ int Télégramme de capteur connecté
Telegram Cet attribut n'est pertinent que pour les interfaces de capteur.
0 : Le codeur n'est pas connecté
1 : Le codeur est connecté à la première interface de capteur dans le
télégramme
2 : Le codeur est connecté à la seconde interface de capteur dans le
télégramme
La valeur de l'interface d'actionneur est toujours 0.
Code du programme : Connecter un codeur

Modifiez le code de programme suivant pour connecter un objet technologique Codeur
externe :
before
private static void UseServiceEncoderHardwareConnectionProvider(TechnologicalInstanceDB
technologyObject, DeviceItem devItem)
{
//Retrieve service EncoderHardwareConnectionProvider
EncoderHardwareConnectionProvider connectionProvider =
technologyObject.GetService<EncoderHardwareConnectionProvider>();
//Connect SensorInterface with DeviceItem

connectionProvider.SensorInterface.Connect(devItem);
//Check ConnectionState of SensorInterface

bool sensorInterfaceConnectionState = connectionProvider.SensorInterface.IsConnected;
}
Connecter une came et une piste de came au matériel
Conditions
● Un objet technologique du type TO_OutputCam ou TO_CamTrack est créé dans le projet.
● Un module de sorties TOR est créé dans le projet, par exemple TM Timer DIDQ.

Application
Pour connecter un objet technologique Came ou Piste de came à une sortie TOR, il est
nécessaire d'indiquer plusieurs valeurs ensemble au cours d'un seul appel. Le type du Public
API OutputCamHardwareConnectionProvider offre les méthodes suivantes pour connecter ou
void Connect(SW.Tags.PlcTag outputTag) Connecte à une variable CPU
void Connect(int address) Connecte des adresses binaires directement
technologique est connecté :

IsConnected bool TRUE : l'objet technologique est connecté
FALSE : l'objet technologique n'est pas connecté
OutputTag SW.Tags.PlcTag Variable CPU connectée
OutputAddress int L'adresse de sortie logique de l'objet connecté est par exemple 256.
Code du programme : connecter l'objet technologique Came ou Piste de came

Modifiez le code de programme suivant pour connecter un objet technologique Came ou Piste
de came :
//An instance of technology object and channel item is already available in the program
before
private static void UseServiceOutputCamHardwareConnectionProvider(TechnologicalInstanceDB
technologyObject, Channel channel)
{
//Retrieve service OutputCamHardwareConnectionProvider
OutputCamHardwareConnectionProvider connectionProvider =
technologyObject.GetService<OutputCamHardwareConnectionProvider>();
//Connect technology object with Channel

connectionProvider.Connect(channel);
//Check ConnectionState of technology object

bool connectionState = connectionProvider.IsConnected;
}

Connecter le palpeur de mesure avec le matériel
Conditions
● Un objet technologique du type TO_MeasuringInput est créé dans le projet.
● Un module d'entrées TOR est créé dans l'entraînement ou dans le projet, par exemple TM
Timer DIDQ.
Application
Pour connecter un objet technologique Palpeur de mesure à une entrée TOR, il est nécessaire
MeasuringInputHardwareConnectionProvider offre les méthodes suivantes pour connecter ou
void Connect(HW.DeviceItem moduleIn, int channelIndex) Connecte à un module et définit un indice de canal de sup‐
plémentaire
void Connect(int address) Connecte des adresses binaires directement
● Pour les voies TM, les adresses de bits peuvent être cal‐
culées à l'aide de la formule
bit_address = module_start_address * 8 + channel_index.
● Pour le télégramme 39x, la formule associée est
bit_address = module_start_address * 8 + 24 + num‐
ber_of_measuringinput_in_telegram.
technologique est connecté :

IsConnected bool TRUE : l'objet technologique est connecté
FALSE : l'objet technologique n'est pas connecté
ChannelIndex int Indice du canal connecté concernant le module d'entrées
InputAddress int L'adresse d'entrée logique de l'objet connecté est par exemple 256.

Code du programme : connecter l'objet technologique Palpeur de mesure

Modifiez le code de programme suivant pour connecter un objet technologique Palpeur de
mesure :
//An instance of technology object and channel item is already available in the program
before
private static void
UseServiceMeasuringInputHardwareConnectionProvider(TechnologicalInstanceDB
technologyObject, Channel channel)
{
//Retrieve service MeasuringInputHardwareConnectionProvider
MeasuringInputHardwareConnectionProvider connectionProvider =
technologyObject.GetService<MeasuringInputHardwareConnectionProvider>();
//Connect technology object with Channel

connectionProvider.Connect(channel);
//Check ConnectionState of technology object

bool connectionState = connectionProvider.IsConnected;
}
Connecter un axe synchrone à des valeurs pilote
Conditions
● Un objet technologique du type TO_PositioningAxis, TO_SynchronousAxis,
TO_ExternalEncoder ou TO_LeadingAxisProxy en tant qu'axe pilote est créé dans le projet.
● Un objet technologique du type TO_SynchronousAxis en tant qu'axe asservi est créé dans
le projet.

Application
Pour connecter un objet technologique Axe synchrone à des valeurs pilote, il est nécessaire
SynchronousAxisMasterValues offre les méthodes suivantes pour connecter ou couper des
valeurs pilote. Les valeurs pilote peuvent être connectées en tant que couplages par valeur de
consigne (CPU S7-1500, CPU S7-1500T) ou en tant que couplages par valeur réelle (CPU
S7-1500T). Toutes les méthodes et tous les attributs sont pertinents pour les deux méthodes
de couplage.
int IndexOf (TechnologicalInstanceDB element) Renvoie l'indice correspondant d'une valeur pilote
bool Contains (TechnologicalInstanceDB element) TRUE : le conteneur contient la valeur pilote
FALSE : le conteneur ne contient pas la valeur pilote
IEnumerator GetEnumerator <TechnologicalInstanceDB>() Sert à la prise en charge de chaque itération
void Add (TechnologicalInstanceDB element) Connecte l'axe asservi à une valeur pilote
bool Remove (TechnologicalInstanceDB element) Sépare l'axe asservi de la valeur pilote
TRUE : la connexion a été coupée avec succès
FALSE : impossible de couper la connexion
Vous pouvez utiliser les attributs en lecture seule suivants :

Count int Nombre de valeurs pilote
IsReadonly bool TRUE : le conteneur est protégé en écriture
FALSE : le conteneur n'est pas protégé en écriture
Parent IEngineeringObject Renvoie les valeurs de niveau supérieur du conteneur.
Dans ce cas, la valeur de niveau supérieur est le service SynchronousA‐
xisMasterValues.
this [ id ] { get; } TechnologicalInstan‐ Accès basé sur des indices aux valeurs pilote
ceDB
Vous pouvez utiliser les attributs suivants pour connecter un axe synchrone à une valeur pilote :

SetPointCoupling SW.TechnologicalObjects.TechnologicalInstan‐ L'attribut reçoit un conteneur de l'axe pilote con‐
ceDBAssociation necté à un couplage de la valeur de consigne.
ActualValueCoupling SW.TechnologicalObjects.TechnologicalInstan‐ L'attribut reçoit un conteneur de l'axe pilote con‐
ceDBAssociation necté à un couplage de la valeur réelle.
DelayedCoupling SW.TechnologicalObjects.TechnologicalInstan‐ L'attribut contient toutes les valeurs maîtresses

ceDBAssociation couplées par des valeurs différées.

Code du programme : Connecter l'axe synchrone à une valeur pilote

Modifiez le code de programme suivant pour connecter un axe synchrone à une valeur pilote :
//An instance of leading axis and following axis is already available in the program before
private static void UseServiceSynchronousAxisMasterValues(TechnologicalInstanceDB
masterTechnologyObject, TechnologicalInstanceDB synchronousTechnologyObject)
{
//Retrieve service SynchronousAxisMasterValues
SynchronousAxisMasterValues masterValues =
synchronousTechnologyObject.GetService<SynchronousAxisMasterValues>();
//Connect following axis and leading axis with setpoint coupling

masterValues.SetPointCoupling.Add(masterTechnologyObject);
//Get container of connected leading axis with setpoint coupling

TechnologicalInstanceDBAssociation setPointMasterValues =
masterValues.SetPointCoupling;
//Remove connected leading axis with setpoint coupling

masterValues.SetPointCoupling.Remove(masterTechnologyObject);
//Connect following axis and leading axis with actual value coupling
masterValues.ActualValueCoupling.Add(masterTechnologyObject);
//Get container of connected leading axis with actual value coupling

TechnologicalInstanceDBAssociation actualValueMasterValues =
masterValues.ActualValueCoupling;
//Remove connected leading axis with actual value coupling

masterValues.ActualValueCoupling.Remove(masterTechnologyObject);
}
Connecter la cinématique avec valeurs pilotes pour le suivi de convoyeurs
Conditions
Voir "Établir une connexion à TIA Portal".
Voir "Ouverture d'un projet".
● Un APIS7-1500 est créé dans le projet.
● Un objet technologique du type TO_PositioningAxis, TO_SynchronousAxis ou
TO_ExternalEncoder en tant qu'axe pilote est créé dans le projet.
● Un objet technologique du type TO_Kinematics en tant qu'axe asservi est créé dans le
projet.

Utilisation
Pour configurer les valeurs pilotes du suivi de bande, utilisez le service
SW.TechnologicalObjects.Motion.ConveyorTrackingLeadingValues pour la cinématique TO ≥
V5.0.
int IndexOf (TechnologicalInstanceDB element) Renvoie l'indice correspondant d'une valeur pilote
bool Contains (TechnologicalInstanceDB element) TRUE: Le conteneur contient la valeur pilote
FALSE: Le conteneur ne contient pas la valeur pi‐
lote
IEnumerator GetEnumerator <TechnologicalIns‐ Sert à la prise en charge de chaque itération
tanceDB>()
void Add (TechnologicalInstanceDB element) Connecte l'axe asservi à une valeur pilote
bool Remove (TechnologicalInstanceDB element) Sépare l'axe asservi de la valeur pilote
TRUE: La connexion a été coupée avec succès
FALSE: La connexion n'a pas pu être coupée
Vous pouvez utiliser les attributs protégés en écriture suivants :

Count int Nombre de valeurs pilotes
IsReadonly bool TRUE: Le conteneur est protégé en écriture
FALSE: Le conteneur n'est pas protégé en écriture
Parent IEngineeringOb‐ Renvoie les valeurs de niveau supérieur du conteneur.
ject Dans ce cas, la valeur de niveau supérieur est le service
SynchronousAxisMasterValues.
this [ id ] { get; } TechnologicalIns‐ Accès basé sur des indices aux valeurs pilotes
tanceDB
Vous pouvez utiliser les attributs suivants pour connecter un axe cinématique à une valeur
pilote :

SetPointCoupling SW.TechnologicalObjects.Technologi‐ L'attribut reçoit un conteneur de l'axe pi‐
calInstanceDBAssociation lote connecté à un couplage de la valeur
de consigne.
ActualValueCoupl‐ SW.TechnologicalObjects.Technologi‐ L'attribut reçoit un conteneur de l'axe pi‐
ing calInstanceDBAssociation lote connecté à un couplage de la valeur
réelle.
DelayedCoupling SW.TechnologicalObjects.Technologi‐ L'attribut contient toutes les valeurs maî‐

calInstanceDBAssociation tresses couplées par des valeurs diffé‐
rées.
Connecter l'axe de suivi de bande de la cinématique à une valeur pilote

Un exemple de connexion est inclus dans le sujet Connecter un axe synchrone à des valeurs
pilote (Page 580).

Exporter et importer l'objet technologique Cam (S7-1500T)
Conditions
Application
Pour exporter ou importer les données d'un objet technologique Cam, vous devez indiquer le
format et le séparateur souhaité. Le type du Public API CamDataSupport offre les méthodes
suivantes que vous pouvez utiliser pour exporter les données de l'objet technologique Cam :
Vous trouverez plus d'informations sur le format d'exportation des cames dans la description
fonctionnelle S7-1500 / S7-1500T pour les fonctions synchrones, au chapitre Importation/
exportation de cames.
void SaveCamDataBinary(System.IO.FileInfo destinationFi‐ Exporte les données au format binaire dans un fichier cible.
le)
void SaveCamDataPointList(System.IO.FileInfo destination‐ Exporte les données au format "PointList" dans un fichier ci‐
File, CamDataFormatSeparator separator, int samplePoints) ble.
void SaveCamData(System.IO.FileInfo destinationFile, Cam‐ Exporte les données dans un fichier cible. Vous pouvez choi‐
DataFormat format, CamDataFormatSeparator separator) sir "MCD", "SCOUT" ou "Pointlist" comme format de données
et "Tabulation" ou "Virgule" comme séparateur.
Si vous choisissez "PointList", 360 points d'interpolation sont
exportés.
void LoadCamData(System.IO.FileInfo sourceFile, CamDa‐ Importe les données Cam au format "MCD", "SCOUT" ou
taFormatSeparator separator) "PointList" dans le projet.
void LoadCamDataBinary(System.IO.FileInfo sourceFile) Importe les données Cam d'un fichier binaire dans le projet.
Vous pouvez utiliser les attributs suivants :

separator CamDataFormatSepa‐ Valeurs autorisées
rator ● Tabulation
● Virgule
samplePoints int Nombre de points d'interpolation à exporter.
format CamDataFormat Valeurs autorisées
● MCD
● SCOUT
● PointList


destinationFile System.IO.FileInfo Nom du fichier cible. Doit être différent de zéro. Les droits d'accès néces‐
saires doivent être attribués et le support de stockage doit disposer de
suffisamment d'espace mémoire. Les fichiers existants sont écrasés.
sourceFile System.IO.FileInfo Nom du fichier source. Doit être différent de zéro. Les droits d'accès né‐
cessaires doivent être attribués. Le contenu doit exister dans le format
indiqué.
Code du programme : Exporter les données Cam

Modifiez le code de programme suivant pour exporter des données Cam :
//An instance of technology object is already available in the program before

private static void ExportCamData(TechnologicalInstanceDB technologyObject,
System.IO.FileInfo destinationFile)
{
//Retrieve service CamDataSupport
CamDataSupport camData = technologyObject.GetService<CamDataSupport>();
//Save cam data in MCD format, using the separator Tab

camData.SaveCamData(destinationFile, CamDataFormat.MCD, CamDataFormatSeparator.Tab);
}
Code du programme : Importer les données Cam

Modifiez le code de programme suivant pour importer des données Cam :
//An instance of technology object is already available in the program before

private static void ImportCamData(TechnologicalInstanceDB technologyObject,
System.IO.FileInfo sourceFile)
{
//Retrieve service CamDataSupport
CamDataSupport camData = technologyObject.GetService<CamDataSupport>();
//Load cam data from source file, using the separator Tab
camData.LoadCamData(sourceFile, CamDataFormatSeparator.Tab);
}
7.19.23.16 Régulation PID
Paramètres de PID_Compact, PID_3Step, PID_Temp, CONT_C, CONT_S, TCONT_CP et TCONT_S

Vous trouverez une liste de tous les paramètres disponibles dans l'information produit
"Paramètres des objets technologiques dans TIA Portal Openness" sur Internet (https://
support.industry.siemens.com/cs/ww/fr/view/109744932).

Les propriétés suivantes sont affichées pour chaque paramètre :

● Nom dans la configuration (TIA Portal)
● Nom dans Openness
● Type de données dans Openness
● Accès standard
● Plage de valeurs
Remarque
Dans TIA Portal, vous trouverez dans la vue de paramètre de la configuration d'objet
technologique la colonne "Name in Openness".
Pour plus d'informations...

Pour plus d'informations, reportez-vous à la description fonctionnelle SIMATIC S7-1200/
S7-1500 PID control sur Internet (https://support.industry.siemens.com/cs/ww/fr/view/
108210036).
7.19.23.17 Comptage
Paramètres pour High_Speed_Counter et SSI_Absolute_Encoder

● Accès standard

Pour plus d'informations, reportez-vous à la description fonctionnelle SIMATIC S7-1500, ET
200MP, ET 200SP Comptage, mesure et mesure de déplacement sur Internet (http://
support.automation.siemens.com/WW/view/fr/59709820).

7.19.23.18 Easy Motion Control
Paramètres pour AXIS_REF

● Accès standard
Remarque
Dans TIA Portal, vous trouverez dans la vue de paramètre de la configuration d'objet
technologique la colonne "Name in Openness".

Vous trouverez plus d'informations sur Easy Motion Control dans les informations système de
STEP 7 (TIA Portal).
7.19.24 Variables et tables de variables
7.19.24.1 Démarrage de l'éditeur de variables API
Conditions requises
● L'instance du portail TIA est ouverte avec interface utilisateur.

Code du programme
Pour démarrer l'éditeur correspondant à une référence d'objet du type PlcTagTable dans
l'instance de TIA Portal, modifiez le code de programme suivant :
//Ouvre la table des variables dans l'éditeur "Tags"

private static void OpenTagtableInEditor(PlcSoftware plcSoftware)
{
PlcTagTable plcTagTable = plcSoftware.TagTableGroup.TagTables.Find("MyTagTable");
plcTagTable.ShowInEditor();
}
Voir aussi
7.19.24.2 Interroger un groupe système pour variables API
Conditions requises
● Une instance PlcSoftware a été appelée par un élément d'appareil API.
Code du programme
Pour interroger un groupe système pour variables API, modifiez le code de programme suivant :
//Retrieves the plc tag table group from a plc

private PlcTagTableSystemGroup GetControllerTagfolder(PlcSoftware plcSoftware)
{
PlcTagTableSystemGroup plcTagTableSystemGroup = plcSoftware.TagTableGroup;
return plcTagTableSystemGroup;
}

7.19.24.3 Créer une table des variables API
Conditions
Code de programme
Pour créer la table des variables API, modifiez le code de programme suivant : Une nouvelle
table des variables API est créée avec le nom indiqué dans la combinaison.
PlcTagTable myTable = plc.TagTableGroup.TagTables.Create("myTable");
Voir aussi
Interroger PLC Target et HMI Target (Page 185)
7.19.24.4 Enumérer les groupes personnalisés pour variables API
Conditions requises
Utilisation
Les sous-dossiers compris sont considérés comme récurrents lors de l'énumération.

Code du programme : Enumérer les groupes personnalisés pour variables API

Pour énumérer les groupes personnalisés pour variables API, modifiez le code de programme
suivant :
//Enumerates all plc tag table user groups including subgroups

private static void EnumeratePlcTagTableUserGroups(PlcSoftware plcSoftware)
{
foreach (PlcTagTableUserGroup plcTagTableUsergroup in plcSoftware.TagTableGroup.Groups)
{
EnumerateTagTableUserGroups(plcTagTableUsergroup);
}
}
private static void EnumerateTagTableUserGroups(PlcTagTableUserGroup tagTableUsergroup)
{
foreach (PlcTagTableUserGroup plcTagTableUsergroup in tagTableUsergroup.Groups)
{
EnumerateTagTableUserGroups(plcTagTableUsergroup);
// recursion
}
}
Code du programme : Accéder à un groupe personnalisé

Pour accéder à un groupe personnalisé pour variables API, modifiez le code de programme
suivant :
//Gives individual access to a specific plc tag table user folder

private static void AccessPlcTagTableUserGroupWithFind(PlcSoftware plcSoftware, string
folderToFind)
{
PlcTagTableUserGroupComposition plcTagTableUserGroupComposition =
plcSoftware.TagTableGroup.Groups;
PlcTagTableUserGroup controllerTagUserFolder =
plcTagTableUserGroupComposition.Find(folderToFind);
// The parameter specifies the name of the user folder
}
7.19.24.5 Créer les groupes personnalisés pour variables API
Conditions requises

Utilisation
L'interface TIA Portal Openness API prend en charge la création d'un groupe personnalisé
pour variables API.
Code du programme
Pour créer un groupe personnalisé pour variables API, modifiez le code de programme suivant :
//Creates a plc tag table user group

private static void CreatePlcTagTableUserGroup(PlcSoftware plcSoftware)
{
PlcTagTableSystemGroup systemGroup = plcSoftware.TagTableGroup;
PlcTagTableUserGroupComposition groupComposition = systemGroup.Groups;
PlcTagTableUserGroup myCreatedGroup = groupComposition.Create("MySubGroupName");
// Optional;
// create a subgroup
PlcTagTableUserGroup mySubCreatedGroup =
myCreatedGroup.Groups.Create("MySubSubGroupName");
}
7.19.24.6 Supprimer les groupes personnalisés pour variables API
Conditions requises
Utilisation
L'interface TIA Portal Openness API prend en charge la suppression d'un groupe personnalisé
spécifique pour tables de variables API.
Code du programme
Pour supprimer un groupe personnalisé déterminé pour tables de variables API, modifiez le
private static void DeletePlcTagTableUserGroup(PlcSoftware plcSoftware)

{
PlcTagTableUserGroup group = plcSoftware.TagTableGroup.Groups.Find("MySubGroupName");
if (group != null)
{
group.Delete();
}
}

7.19.24.7 Enumérer des tables de variables API dans un dossier
Conditions requises
Code du programme : Enumérer des tables de variables API

Pour énumérer toutes les tables de variables API contenues dans les groupes système ou
groupes personnalisés, modifiez le code de programme suivant :
//Enumerates all plc tag tables in a specific system group or and user group
private static void EnumerateAllPlcTagTablesInFolder(PlcSoftware plcSoftware)
{
PlcTagTableComposition tagTables = plcSoftware.TagTableGroup.TagTables;
// alternatively, PlcTagTableComposition tagTables =
plcSoftware.TagTableGroup.Groups.Find("UserGroup XYZ").TagTables;
foreach (PlcTagTable tagTable in tagTables)
{
// add code here
}
}
Code du programme : Accéder à une table de variables API

Pour accéder à la table de variables API de votre choix, modifiez le code de programme
suivant :
//Gives individual access to a specific Plc tag table

private static void AccessToPlcTagTableWithFind(PlcSoftware plcSoftware)
{
PlcTagTableComposition tagTables = plcSoftware.TagTableGroup.TagTables;
// alternatively, PlcTagTableComposition tagTables =
plcSoftware.TagTableGroup.Groups.Find("UserGroup XYZ").TagTables;
PlcTagTable controllerTagTable = tagTables.Find("Tag table XYZ");
// The parameter specifies the name of the tag table
}

7.19.24.8 Interroger les informations d'une table de variables API
Conditions
Utilisation
Les tables de variables API vous permettent d'accéder à des constantes utilisateur, des
constantes système et des variables. Le nombre de compositions de variables d'une table des
variables correspond au nombre de variables d'une table des variables. La table PLCTagTable
comprend les navigateurs, attributs et actions suivants.
Vous avez accès aux attributs suivants dans la table des variables API.　
Nom Type Type

IsDefault Bool Protégé en écriture
ModifiedTime DateTime Protégé en écriture
Nom String Protégé en écriture
La table des variables API comprend les actions indiquées ci-après.
Nom Type de valeur en retour Description

Delete Vide Supprime l'instance. Déclenche
une exception si IsDefault est
vrai.
Exporter Vide Exporte SIMATIC ML d'une table
des variables API.
ShowInEditor Vide Affiche la table des variables
dans l'éditeur de table des varia‐
bles API.

Code de programme
Pour interroger les informations d'une table de variables API, modifiez le code de programme
suivant :
private static void AccessPlcConstantsUsingFind(PlcTagTable tagTable)

{
PlcUserConstantComposition plcUserConstants = tagTable.UserConstants;
PlcUserConstant plcUserConstant = plcUserConstants.Find("Constant XYZ");
//PlcSystemConstantComposition plcSystemConstants = tagTable.SystemConstants;
//PlcSystemConstant plcSystemConstant = plcSystemConstants.Find("Constant XYZ");
}
private static void EnumeratePlcTags(PlcTagTable tagTable)
{
PlcTagComposition plcTags = tagTable.Tags;
foreach (PlcTag plcTag in plcTags)
{
string name = plcTag.Name; string typeName = plcTag.DataTypeName;
string logicalAddress = plcTag.LogicalAddress;
}
}
private static void EnumeratePlcTagsUsingFind(PlcTagTable tagTable)
{
PlcTagComposition plcTags = tagTable.Tags;
PlcTag plcTag = plcTags.Find("Constant XYZ");
}
7.19.24.9 Lire la date et l'heure de la dernière modification d'une table de variables API
Conditions requises
Utilisation
Le format de l'horodatage est l'UTC.

Code du programme
Pour lire l'horodatage d'une table de variables API déterminée, modifiez le code de programme
suivant :
//Reads Time-Stamp of a plc Tag Table

private static void GetLastModificationDateOfTagtable(PlcSoftware plcSoftware)
{
PlcTagTable plcTagTable = plcSoftware.TagTableGroup.TagTables.Find("MyTagTable");
DateTime modifiedTagTableTimeStamp = plcTagTable.ModifiedTimeStamp;
}
7.19.24.10 Supprimer la table des variables API dans un groupe
Conditions requises
Code du programme
Pour supprimer une table des variables déterminée dans un groupe, modifiez le code de
programme suivant :
//Deletes a PlcTagTable of a group

private static void DeletePlcTagTableInAGroup(PlcSoftware plcSoftware)
{
PlcTagTableSystemGroup group = plcSoftware.TagTableGroup;
PlcTagTable tagtable = group.TagTables.Find("MyTagTable");
if (tagtable!= null)
{
tagtable.Delete();
}
}
7.19.24.11 Enumérer des variables API
Conditions requises

Code de programme : énumérer des variables API dans des tables de variables
Pour énumérer toutes les variables API contenues dans une table des variables, modifiez le
//Enumerates all plc tags in a specific tag table

private static void EnumerateAllPlcTagsInTagTable(PlcSoftware plcSoftware)
{
PlcTagTable tagTable = plcSoftware.TagTableGroup.TagTables.Find("Tagtable XYZ");
foreach (PlcTag tag in tagTable.Tags)
{
// add code here
}
}
7.19.24.12 Accéder à des variables API
Conditions
Utilisation
Le type PlcTagComposition représente un ensemble de variables API.
Code de programme : accéder à une variable API précise

Pour accéder à la variable API de votre choix, modifiez le code de programme suivant : Vous
avez accès aux attributs suivants :
● Nom (accès en lecture seule)
● Nom du type de données
● Adresse logique
● Commentaire
● ExternalAccessible
● ExternalVisible
● ExternalWritable

//Gives individual access to a specific plc tag

private static void AccessPlcTag(PlcTagTable tagTable)
{
PlcTag tag = tagTable.Tags.Find("Tag XYZ");
// The parameter specifies the name of the tag
}
Code de programme : créer des variables

private static void CreateTagInPLCTagtable(PlcSoftware plcsoftware)

// Create a tag in a tag table with default attributes
{
PlcTagTable table = plcsoftware.TagTableGroup.TagTables.Find("myTagTable");
PlcTagComposition tagComposition = table.Tags;
PlcTag tag = tagComposition.Create(tagName);
}
private static void CreateTagInPLCTagtable(PlcSoftware plcsoftware)

// Create a tag of data type bool and logical address not set
{
string dataType = "Bool";
string logicalAddress ="";
PlcTag tag = tagComposition.Create(tagName, dataType, logicalAddress);
}
Code de programme : supprimer des variables

private static void DeleteTagFromPLCTagtable(PlcSoftware plcsoftware)

// Deletes a single tag of a tag table
{
PlcTag tag = tagComposition.Find(tagName);
if (tag != null)
{
tag.Delete();
}
}

7.19.24.13 Accéder à des constantes API
Conditions
Utilisation
Le type PlcUserConstantComposition représente un ensemble de constantes utilisateur
API. Vous avez accès aux attributs suivants :
● Nom du type de données
● Valeur
Le type PlcSystemConstantComposition représente un ensemble de constantes
système API. Vous avez accès aux attributs suivants :
● Nom du type de données (accès en lecture seule)
● Valeur (accès en lecture seule)
Code de programme : créer des constantes utilisateur

private static void CreateUserConstantInPLCTagtable(PlcSoftware plcsoftware)

// Create a user consrant in a tag table
{
string constantName = "MyConstant";
PlcUserConstantComposition userConstantComposition = table.UserConstants;
PlcUserComnstant userConstant = userConstantComposition.Create(constantName);
}

Code de programme : supprimer des constantes utilisateur

private static void DeleteUserConstantFromPLCTagtable(PlcSoftware plcsoftware)

// Deletes a single user constant of a tag table
{
PlcUserConstantComposition userConstantComposition = table.UserConstants;
PlcUserConstant userConstant = userConstantComposition.Find("MyConstant");
if (userConstant != null)
{
userConstant.Delete();
}
}
Code de programme : accéder à des constantes système

//Gives individual access to a specific system constant

private static void AccessSystemConstant(PlcTagTable tagTable)
{
PlcTag systemConstant = tagTable.SystemConstants.Find("Constant XYZ");
// The parameter specifies the name of the tag
}
Voir aussi
Créer les groupes personnalisés pour variables API (Page 590)
Supprimer les groupes personnalisés pour variables API (Page 591)
Supprimer la table des variables API dans un groupe (Page 595)
Accéder à des variables API (Page 596)
Démarrage de l'éditeur de variables API (Page 587)
Lire la date et l'heure de la dernière modification d'une table de variables API (Page 594)

7.19.25 Fonctions pour unités logicielles
7.19.25.1 Utilisation d'unités logicielles
Conditions
Application
Les unités sont des composants importants de la programmation de l'API et se trouvent dans
le PlcSoftware.
Le unit provider est appelé via GetService depuis le PlcSoftware et la PlcUnitComposition peut
à son tour être appelée depuis ce dernier.
Lors de l'utilisation de TIA Portal Openness, les unités vous permettent d'exécuter les actions
suivantes :
● Créer des unités
● Supprimer des unités
● Renommer des unités
Code de programme : Créer des unités

Modifiez le code de programme suivant pour créer des unités :
PlcUnitProvider provider = m_Target.GetService<PlcUnitProvider>();

PlcUnitComposition unitComposition = provider.UnitGroup.Units;
//Creating Unit
PlcUnit unit1 = unitComposition.Create("Unit1");
Si vous saisissez mal le nom, par exemple avec une espace au début ou avec un caractère non
valide, ou si le nom est trop long, un message d'erreur est émis. Une Recoverable Exception
est déclenchée avec le message de d'erreur suivant : "La valeur de l'attribut 'nom' contient un
caractère invalide à la position 0."
try
{
}
{
}

Si vous essayez de créer une unité avec un nom qui est déjà utilisé, un message d'erreur est
émis. Une Recoverable Exception est déclenchée avec le message de d'erreur suivant :
"L'unité avec le nom 'Unité1' existe déjà."

...
...
try
{
}
catch (EngineeringTargetInvocationException　e)
{
}
Code de programme : Supprimer des unités

Modifiez le code de programme suivant pour supprimer des unités :
unitProvider.UnitGroup.Units.Find("Unit_2").Delete();
Une NullReferenceException est émise lorsque la méthode Find( ) de l'exemple ci-dessus ne

fournit aucune référence à une unité.
Code de programme : Renommer des unités

Vous pouvez définir les attributs de plusieurs façons. La définition peut s'effectuer par
l'affectation d'une valeur ou via l'appel de SetAttribute ou SetAttributes. La propriété Name peut
être validée par GetAttribute ou GetAttributes. Pour pouvoir utiliser SetAttribute ou
GetAttribute, l'objet doit d'abord être transmis à IEngineeringObject.
Modifiez le code de programme suivant pour renommer des unités :
//Set Value
unit1.Name = "Unit1_new";
//Using SetAttributes():
var attrList = new List<KeyValuePair<string, object>>()
{
new KeyValuePair<string, object>("Name", "Unit1_new")
};
unit1.SetAttributes(attrList);
//Using SetAttribute()
IEngineeringObject unit = (IEngineeringObject)unit2;
unit.SetAttribute("Name", "Unit2_new");
Si vous saisissez mal le nom, par exemple avec une espace au début ou avec un caractère non
valide, un message d'erreur est émis. Une Recoverable Exception est déclenchée avec le

message de d'erreur suivant : "La valeur de l'attribut 'nom' contient un caractère invalide à la
position 0."
PlcUnit unit1 = unitComposition.Create("Unit_1");

try　　　　　　　　　　　　　　　　　　　　　　　
{
unit1.Name = "Unit_1";　　　　　　　　　　　　　　　　　　　　　　
}　　　　　　　　　　　　　　　　　　　　　　
{
Console.WriteLine(e.Message);　　　　　　　　　　　　　　　　　　　　　　
}
Si vous essayez de renommer une unité avec un nom qui est déjà utilisé, un message d'erreur
est émis. Une Recoverable Exception est déclenchée avec le message de d'erreur suivant : "La
propriété 'Nom' a une valeur non valide." 'Unité1'. Une unité logicielle avec le même nom existe
déjà."

PlcUnit unit2 = unitComposition.Create("Unit_2");
try
{
}
catch (EngineeringTargetInvocationException　e)
{
}
Voir aussi
7.19.25.2 Accéder à des unités logicielles
Conditions
● L'application TIA Openness est connectée à TIA Portal.
Application
TIA Portal Openness vous permet d'accéder aux unités. Les unités sont des composants
importants de la programmation de l'API. Les unités sont prises en charge uniquement par
certains API. C'est pourquoi les unités ne sont pas structurées de manière statique dans le
modèle d'objet afin qu'elles ne puissent être trouvées directement dans le conteneur logiciel
API (PLC-Softwarecontainer).

L'accès aux unités est toutefois possible à l'aide du PlcUnitProvider . Le fournisseur est
disponible dans le logiciel API via GetService( ) , comme indiqué dans l'exemple de code de
programme suivant :
Le PlcUnitProvider permet l'accès via le UnitGroup navigator au PlcUnitSystemGroup qui
contient la PlcUnitComposition avec les possibilités spécifiques de la composition générale
(itération, recherche, création, importation etc. concernant les PlcUnits).
La représentation de l'unité (PlcUnit) contient les propriétés spécifiques propres de l'unité
comme attributs Openness.
Vous pouvez accéder aux attributs et méthodes suivants pour les propriétés d'unités
Openness :
Nom d'attribut Type

Author String
Name String
Nom de la méthode Type de valeur en retour

Export void
Delete void
GetAttributes IList<object>
SetAttributes void
Sous la PlcUnit, vous pouvez parcourir les objets suivants les uns après les autres :
● Commentaire : MultilingualText
● le BlockGroup (PlcBlockSystemGroup)
– unit.BlockGroup
● TagTableGroup (PlcTagTableSystemGroup)
– unit.TagTableGroup
● TypeGroup (PlcTypeSystemGroup)
– unit.TypeGroup
Code de programme : Accéder à des unités
PlcSoftware plcTarget = GetControllerTargetByPLCName(Session.OpnsProject.Devices, PLCName);

PlcUnitProvider unitProvider = plcTarget.GetService<PlcUnitProvider>();
PlcUnit unit = unitProvider.UnitGroup.Units.Find("Unit_2");
Voir aussi

7.19.25.3 Accéder à des objets sur lesquels sont basés des unités logicielles
Conditions
Application
TIA Portal Openness vous permet d'accéder :
● de façon récurrente au groupe système "Blocs de programme", aux groupes et blocs qu'il
contient
● de façon récurrente au groupe système "Types de données API", aux groupes et types de
données qu'il contient
● de façon récurrente au groupe système "Variables API", aux groupes et tables des variables
qu'il contient
Code de programme : Accéder aux blocs de programme et aux groupes de blocs

Pour accéder au bloc de programme sous l'unité API actuelle, modifiez le code de programme
suivant en appelant l'ensemble des blocs de programme et en réalisant une itération dans les
blocs contenus :
PlcBlockComposition blockComposition = m_PlcUnit.BlockGroup.Blocks;

foreach (PlcBlock block in blockComposition)
{
…
//usage of block
…
}
Pour accéder au groupe de blocs de programme sous l'unité API actuelle, modifiez le code de
programme suivant en appelant l'ensemble des groupes de blocs de programme et en réalisant
une itération dans les groupes contenus :
PlcBlockUserGroupComposition usergroupComposition = m_PlcUnit.BlockGroup.Groups;

foreach (PlcBlockUserGroup group in usergroupComposition)
{
PlcBlockComposition blockComposition = group.Blocks;
foreach (PlcBlock block in blockComposition)
{
…
//usage of the block
…
}
}

Code de programme : Accéder aux types de données API et aux groupes de types de données
Pour accéder aux types de données API sous l'unité API actuelle, modifiez le code de
programme suivant en appelant l'ensemble des types de données API et en réalisant une
itération dans les types de données contenus :
PlcTypeComposition typeComposition = m_PlcUnit.TypeGroup.Types;

foreach (PlcType type in typeComposition)
{
…
// usage of the type
…
}
Pour accéder au groupe de types de données API sous l'unité API actuelle, modifiez le code
de programme suivant en appelant l'ensemble des types de données API et en réalisant une
itération dans les groupes contenus :
PlcTypeUserGroupComposition usergroupComposition = m_PlcUnit.TypeGroup.Groups;

foreach (PlcTypeUserGroup group in usergroupComposition)
{
PlcTypeCompostion typeComposition = group.Types;
foreach (PlcType type in typeComposition)
{
…
// usage of the type
…
}
}
Code de programme : Accéder aux tables des variables API et aux groupes de tables des variables
Pour accéder aux tables des variables API sous l'unité API actuelle, modifiez le code de
programme suivant en appelant l'ensemble des tables des variables API et en réalisant une
itération dans les tables des variables contenues :
PlcTagTableComposition tagtableComposition = m_PlcUnit.TagTableGroup.TagTables;

foreach (PlcTagTable type in tagtableComposition)
{
…
// usage of the tag table
…
}

Pour accéder aux groupes de tables des variables API sous l'unité API actuelle, modifiez le
code de programme suivant en appelant l'ensemble des groupes de tables des variables API
et en réalisant une itération dans les groupes contenus :
PlcTagTableUserGroupComposition usergroupComposition = m_PlcUnit.TagTableGroup.Groups;

foreach (PlcTagTableUserGroup group in usergroupComposition)
{
PlcTagTableComposition tagtableComposition = group.TagTables;
foreach (PlcTagTable type in tagtableComposition)
{
…
// usage of the tag table
…
}
}
Voir aussi
7.19.25.4 Accéder relations aux relations existantes d'une unité
Conditions
Application
TIA Portal Openness vous permet d'accéder aux relations existantes d'une unité et de lire les
propriétés de celles-ci.
Les attributs suivants sont pris en charge par la relation d'unité dans Openness :
Nom d'attribut Type Description

RelationType UnitRelationType Type de relation
RelatedObject String Contient le nom de l'élément ac‐
cessible.
Les valeurs ENUM suivantes sont disponibles pour l'attribut RelationType :

● Unité logicielle
● Non-Unit DB
● TO DB

Code du programme : Accéder aux relations

Vous pouvez appeler les relations, les types de relation et les noms des objets associés de
plusieurs façons.
Modifiez le code de programme suivant pour appeler la composition d'une relation :
PlcSoftware plcTarget = GetControllerTargetByPLCName(Session.OpnsProject.Devices,　

PLCName);
PlcUnitProvider provider = plcTarget.GetService<PlcUnitProvider>();
//assuming existing units
m_PlcUnit = provider.UnitGroup.Units[0];
PlcUnitRelationComposition unitRelations = m_PlcUnit.Relations;
Modifiez le code de programme suivant pour appeler les relations par l'indexeur :

m_PlcUnit = provider.UnitGroup.Units[0]; //assuming existing units
PlcUnitRelation unitRelation = m_PlcUnit.Relations[1];
Modifiez le code de programme suivant pour appeler les relations par itération :
PlcSoftware　plcTarget = GetControllerTargetByPLCName(Session.OpnsProject.Devices,PLCName);
PlcUnitProvider　provider = plcTarget.GetService<PlcUnitProvider>();
PlcUnitRelationComposition unitRelations = m_PlcUnit.Relations;
foreach (PlcUnitRelation relation in unitRelations)
{
// using ‘relation’
}
Modifiez le code de programme suivant pour appeler le type de relation d'une unité via l'attribut
RelationType :
PlcSoftware　plcTarget　=　
GetControllerTargetByPLCName(Session.OpnsProject.Devices,PLCName);
PlcUnitProvider　provider　=　plcTarget.GetService<PlcUnitProvider>();
UnitRelationType unitRelationType = m_PlcUnit.Relations[2].RelationType;
Modifiez le code de programme suivant pour appeler le nom de l'objet associé à une unité via
l'attribut RelatedObject :
PlcSoftware plcTarget = GetControllerTargetByPLCName(Session.OpnsProject.Devices,PLCName);

string unitRelatedObjectName = m_PlcUnit.Relations[1].RelatedObject;

Modifiez le code de programme suivant pour rechercher une relation à l'aide de "Rechercher"
avec le nom de l'élément accessible (RelatedObject) :

PlcUnitRelation relation = m_PlcUnit.Relations.Find(unitRelatedObjectName);
Voir aussi
7.19.25.5 Actualiser les propriétés d'unités logicielles
Conditions
Application
TIA Portal Openness vous permet d'actualiser les propriétés d'unités telles que auteur et
commentaire.
Code de programme : Actualiser la propriété "Author" de l'unité

Modifiez le code de programme suivant pour actualiser la propriété "Author" de l'unité.
//Set value
string　newAuthor = "Z012345";
unit1.Author = newAuthor;
//Using SetAttributes()
string newAuthor = "Z012345";
var attrList = new List<KeyValuePair<string,　object>>()
{
new KeyValuePair<string, object>("Author", newAuthor)
};
unit1.SetAttributes(attrList));
//Using SetAttribute()
string newAuthor = "Z012345";
IEngineeringObject unit = (IEngineeringObject)unit2;
unit.SetAttribute("Author", newAuthor);

Message d'erreur
Si vous saisissez mal une valeur, par exemple avec une espace au début ou avec un caractère
non valide, un message d'erreur est émis. Une Recoverable Exception est déclenchée avec le
message de d'erreur suivant : "La valeur de l'attribut 'Author' contient un caractère invalide à la
position 0."
PlcUnit unit1 = unitComposition.Create("Unit1");　　　　　　　　　　　　　　　　　　　　　　　

try
{　　　　
unit1.Author = " Author";
}
{　　　
}
Code de programme : Actualiser la propriété "Comment" de l'unité

La propriété 'Comment' de l'unité ne peut pas être définie ou appelée directement car il s'agit
ici d'un MultilingualText. Mais vous pouvez actualiser la propriété "Text" du commentaire. Le
Comment.Item contient les différentes cultures ("cultures") du projet TIA. Il peut être défini via
l'affectation de valeurs. Les langues du projet sont indexées dans la Comment.Item
composition, la première langue par défaut du projet étant indiquée par 0. Si plusieurs langues
sont indiquées, vous pouvez parcourir la liste. Sinon, si la culture n'existe pas, une
//Setting the default first culture comment Item text:

unit1.Comment.Items[0].Text = "new Comment";
//Setting other culture comment Item Text:
unit1.Comment.Items[1].Text = "neuro Kommentar";
Message d'erreur
Si vous essayez d'utiliser SetAttribute, SetAttributes, GetAttribute, GetAttributes. , une
EngineeringNotSupportedException est émise avec le message d'erreur suivant : "Le
commentaire n'est pas pris en charge par le type 'Siemens.Engineering.SW.Units.PlcUnit'."
try
{
((IEngineeringObject)unit1).SetAttribute("Comment", "new comments");
}
catch (EngineeringNotSupportedException e)
{
}

Si vous essayez de créer une relation à une culture inexistante, un message d'erreur est émis.
Une EngineeringTargetInvocationException est déclenchée avec le message de d'erreur
suivant : "L'argument 'index' (3) se trouve en dehors de la plage de valeurs admissibles."
try
{
unit1.Comment.Items[3].Text = "new Comment";
}
{
Console.WriteLine(e.Message)
}
Voir aussi
7.19.25.6 Publier un objet d'une unité logicielle
Conditions
Application
Avec TIA Portal Openness, vous pouvez appeler ou paramétrer l'attribut "Access" d'objets sur
lesquels sont basées des unités, afin de pouvoir influencer leur accessibilité entre des unités.
Les objets suivants sont pris en charge dans les unités Openness :
● Blocs de programme et blocs de données – sauf les OB
● Types API
La valeur possible suivante de l'attribut Access est représentée comme énumération
UnitAccessType:
● Publié
● Non publié

Remarque
L'attribut "Access" est disponible uniquement dans des objets sous une unité. S'il n'est donc
pas appelé ou paramétré avec les objets correspondant à PlcUnit, une
EnginneringNotSupportedException est déclenchée. En cas de valeur incorrecte (par ex. des
valeurs d'énumération non valides), une EngineeringTargetInvocationException est
déclenchée.
Code de programme : configurer l'attribut d'accès de blocs API
//Getting attribute value with GetAttribute

...
PlcBlock block = m_PlcUnit.BlockGroup.Find("FB_1");
UnitAccessType currentAccessValue = (UnitAccessType)block.GetAttribute("Access");
...
//Getting attribute value with GetAttributes
...
PlcBlock block = m_PlcUnit.BlockGroup.Block.Find("FB_1");
List<string> attrList = new List<string>();
{
"Access"
};
IList<object> getAttributeValues = block.GetAttributes(attrList));
…
//Setting attribute value with SetAttribute
…
PlcBlock block = m_PlcUnit.BlockGroup.Blocks.Find("FB_1");
UnitAccessType newAccessValue = UnitAccessType.Published;
block.SetAttribute("Access", newAccessValue);
…
//Setting attribute value with SetAttributes
…
PlcBlock block = m_PlcUnit.BlockGroup.Blocks.Find("FB_1");
IList attrList = new List<KeyValuePair<string, object>>()
{
new KeyValuePair<string, object>("Access", newAccessValue),
};
block.SetAttributes(attrList);
…

Code de programme : configurer l'attribut d'accès de blocs API
//Getting attribute value with GetAttribute

…
PlcType type = m_PlcUnit.TypeGroup.Types.Find("UDT_1");
UnitAccessType currentAccessValue = (UnitAccessType)type.GetAttribute("Access");
…
//Getting attribute value with GetAttributes
…
List<string> attrList = new　List<string>()
{
"Access"
};
IList<object> getAttributeValues = type.GetAttributes(attrList));
…
//Setting attribute value with SetAttribute
…
type.SetAttribute("Access", newAccessValue);
…
//Setting attribute value with SetAttributes
…
IList attrList = new List<KeyValuePair<string, object>>()
{
new KeyValuePair<string, object>("Access", newAccessValue),
};
type.SetAttributes(attrList));
…
Voir aussi
7.19.25.7 Ajouter des sources externes dans des unités
Conditions

Application
Avec TIA Portal Openness, vous pouvez ajouter une source externe sous une unité logicielle.
Vous pouvez ajouter des fichiers source comme .SCL, .DB, .UDT sous des unités.
Avec l'API Openness, vous pouvez exécuter les tâches suivantes sous des unités logicielles
avec ExternalSourceGroup :
● Ajouter ExternalSourceGroup sous des unités
● Générer des blocs/types de données utilisateur sous des unités logicielles depuis une
source externe
● Exporter la source depuis des blocs/types de données utilisateur sous des unités
Code de programme : Ajouter ExternalSourceGroup

Modifiez le code de programme suivant pour ajouter une source externe sous une unité
logicielle :
PlcUnitProvider unitProvider = controllerTarget.GetService<PlcUnitProvider>();

PlcUnit newUnit = unitProvider.UnitGroup.Units.Create("Unit_1");
PlcExternalSource unitExternalSource =
newUnit.ExternalSourceGroup.ExternalSources.CreateFromFile(externalSourceFilename,
GetFilePath(externalSourceFilename));
Code de programme : Générer des blocs/types de données utilisateur à partir de la source

Modifiez le code de programme suivant pour générer des blocs/types de données utilisateur
avec des types de valeur en retour vides depuis une source externe sous une unité logicielle :
unitExternalSource.GenerateBlocksFromSource();
Modifiez le code de programme suivant pour générer des blocs/types de données utilisateur
avec un recueil de blocs appelés depuis une source externe sous une unité logicielle :
// Blocks/UDTs gets generated only if there are no compilation errors

IList<IEngineeringObject> generatedBlocksUnderUnitList =
unitExternalSource.GenerateBlocksFromSource(GenerateBlockOption.None);
// Blocks/UDTs will be generated regardless of any compilation errors
IList<IEngineeringObject> generatedBlocksUnderUnitList =
unitExternalSource.GenerateBlocksFromSource(GenerateBlockOption.KeepOnError);

Code de programme : exporter la source à partir de blocs/types de données utilisateur

Modifiez le code de programme suivant pour générer une source à partir de blocs sous une
unité logicielle :
// For blocks
PlcBlock unitPlcBlock = newUnit.BlockGroup.Blocks.Find(generatedBlockName);
// Generate source from blocks with dependencies
newUnit.ExternalSourceGroup.GenerateSource(new[] { unitPlcBlock }, new
FileInfo(outputFileGeneratedPath), GenerateOptions.WithDependencies);
// Generate source from blocks without dependencies
newUnit.ExternalSourceGroup.GenerateSource(new[] { unitPlcBlock }, new
FileInfo(outputFileGeneratedPath), GenerateOptions.None);
Modifiez le code de programme suivant pour générer une source à partir de types de données
utilisateur sous une unité logicielle :
// For UDTs
PlcType unitPlcUdt = newUnit.TypeGroup.Types.Find(generatedUdtName);
//Generate source from UDTs with dependencies
newUnit.ExternalSourceGroup.GenerateSource(new[] { unitPlcUdt }, new
FileInfo(outputFileGeneratedPath), GenerateOptions.WithDependencies);
//Generate source from UDTs without dependencies
newUnit.ExternalSourceGroup.GenerateSource(new[] { unitPlcUdt }, new
FileInfo(outputFileGeneratedPath), GenerateOptions.None);
Code de programme : Énumérer un groupe de fichiers source externe

Modifiez le code de programme suivant pour énumérer la composition du groupe de fichiers
source externe sous l'unité actuelle :
PlcUnitProvider unitProvider = controllerTarget.GetService<PlcUnitProvider>();

PlcUnit newUnit = unitProvider.UnitGroup.Units.Find(textBoxAddNewUnit.Text);
PlcExternalSourceComposition unitExtSrcComposition =
newUnit.ExternalSourceGroup.ExternalSources;
foreach (PlcExternalSource unitExtSrc in unitExtSrcComposition)
{
unitExtSrc.GenerateBlocksFromSource(GenerateBlockOption.None);
}

7.19.25.8 Unités comme copies maîtres
Conditions
● Une unité est créée.
Voir Utilisation d'unités logicielles (Page 600)
Application
Avec TIA Portal Openness, vous pouvez copier des unités sous forme de copie maître dans la
bibliothèque du projet ou dans la bibliothèque globale.
Lors de l'utilisation de TIA Portal Openness, les unités comme copie maître vous permettent
● Générer une unité comme copie maître dans la bibliothèque du projet à partir d'unités
logicielles
● Générer une unité comme copie maître dans la bibliothèque globale à partir d'unités
logicielles
● Créer une nouvelle unité à partir d'une copie maître dans la bibliothèque du projet contenue
dans les unités logicielles dans la NP
● Créer une nouvelle unité à partir d'une copie maître dans la bibliothèque globale contenue
dans les unités logicielles dans la NP
Code du programme
Modifiez le code de programme suivant pour générer une nouvelle unité comme copie maître
dans la bibliothèque du projet à partir d'unités logicielles à l'aide de MasterCopyComposition.
PlcUnitProvider m_UnitProvider = plc.GetService<PlcUnitProvider>();

PlcUnitComposition m_UnitComposition = m_UnitProvider.UnitGroup.Units;
PlcUnit m_SoftwareUnit1 = unitComposition.Create("Unit_1");//Assuming existing units
IMasterCopySource m_UnitAsMasterCopy = (IMasterCopySource)m_SoftwareUnit1;//Assuming that
m_SoftwareUnit1 is present in the PLC
m_ProjectLibrary.MasterCopyFolder.MasterCopies.Create(m_UnitAsMasterCopy);

Modifiez le code de programme suivant pour générer une unité comme copie maître dans la
bibliothèque globale à partir d'unités logicielles.
...
IMasterCopySource m_UnitAsMasterCopy = (IMasterCopySource)m_SoftwareUnit1;//Assuming that
m_SoftwareUnit1 is present in the PLC
m_TiaPortal.GlobalLibraries.Open(libfile, OpenMode.ReadWrite);
GlobalLibrary m_GlobalLibrary = m_TiaPortal.GlobalLibraries[0];
m_GlobalLibrary.MasterCopyFolder.MasterCopies.Create(m_UnitAsMasterCopy)
...
Si vous essayez de créer une nouvelle unité dans une bibliothèque globale protégée en
écriture, un message d'erreur apparaît. Une Recoverable Exception avec le message
"Impossible d'écrire dans une bibliothèque protégée en écriture" est déclenchée.
m_TiaPortal.GlobalLibraries.Open(libfile, OpenMode.ReadOnly);
try
{
m_GlobalLibrary.MasterCopyFolder.MasterCopies.Create(m_UnitAsMasterCopy);
}
catch (Exception e)
{
}
Modifiez le code de programme suivant pour créer une nouvelle unité à partir d'une copie
maître dans la bibliothèque du projet contenue dans les unités logicielles dans la NP.
...
ProjectLibrary m_ProjectLibrary = project.ProjectLibrary;
PlcUnitProvider m_UnitProvider = plc.GetService<PlcUnitProvider>();
PlcUnitComposition m_UnitComposition = m_UnitProvider.UnitGroup.Units;
...
MasterCopy mc_Unit_2 = m_ProjectLibrary.MasterCopyFolder.MasterCopies.Find("Unit_2");
m_UnitComposition.CreateFrom(mc_Unit_2);//Recreate a Unit from Project Library to
SoftwareUnits folder
Modifiez le code de programme suivant pour créer une nouvelle unité à partir d'une copie
maître dans la bibliothèque globale contenue dans les unités logicielles dans la NP.
...
...
mc_Unit_2 = m_GlobalLibrary.MasterCopyFolder.MasterCopies.Find("Unit_2");
m_UnitComposition.CreateFrom(mc_Unit_2);//Recreate a unit from Global Library to
SoftwareUnits folder

Voir aussi
Utilisation d'unités logicielles (Page 600)
7.19.25.9 Actualiser les relations existantes et créer/supprimer des relations
Conditions
Application
À l'aide de TIA Portal Openness vous pouvez modifier les relations des unités API et ainsi
piloter l'accessibilité des objets dans d'autres unités API ou hors des Unités API.
TIA Portal Openness vous permet d'effectuer les types de modifications suivants :
● Créer de nouvelles relations
● Supprimer les relations présentes
● Modifier les relations présentes
Code de programme : Créer de nouvelles relations

Vous pouvez créer une nouvelle relation, en indiquant le type de relation et le nom de l'objet
associé.
private PlcUnitRelation m_SoftwareUnitRelation;

private PlcUnitRelation m_NonUnitDBRelation;
private PlcUnitRelation m_TODBRelation;
...
PlcUnitProvider plcUnitProvider = plcTarget.GetService<PlcUnitProvider>();
m_PlcUnit = plcUnitProvider.UnitGroup.Units[0]; //assuming existing units
Modifiez le code de programme suivant pour créer une nouvelle relation avec laquelle vous
accédez à un objet dans une autre unité API :
...
//assuming Plc unit "Unit_2" is already existing in the Plc
m_SoftwareUnitRelation = m_PlcUnit.Relations.Create("Unit_2",
UnitRelationType.SoftwareUnit);
...

accédez à un bloc de données API hors des unités API :
...
//assuming Plc data block "Data_block_1" is already existing in the Plc
m_NonUnitDBRelation = m_PlcUnit.Relations.Create("Data_block_1",
UnitRelationType.NonUnitDB);
...
accédez à un objet technologique hors des unités API :
...
//assuming Technological object "SpeedAxis_1" is already existing in the Plc
m_TODBRelation = m_PlcUnit.Relations.Create("SpeedAxis_1", UnitRelationType.TODB);
...
Scénarios d'erreurs possibles lors de la création d'une nouvelle relation :

accédez à un objet associé non présent :
...
//assuming Plc unit "NonExistingUnit" is not existing in the Plc yet
m_SoftwareUnitRelation = m_PlcUnit.Relations.Create("NonExistingUnit", UnitRelationType.
SoftwareUnit);
...
Remarque
Dans le code de programme ci-dessus, la relation est créée et aucune exception n'est
déclenchée.
Modifiez le code de programme suivant pour créer une nouvelle relation, en indiquant un nom
de l'objet associé qui ne correspond pas aux règles de dénomination TIA :
...
m_SoftwareUnitRelation = m_PlcUnit.Relations.Create(" Unit_2",
...
Remarque
Dans le code de programme ci-dessus, la relation n'est pas créée et une exception récupérable
est déclenchée en raison d'espaces vides en tête.

Modifiez le code de programme suivant pour créer une nouvelle relation de l'unité avec elle-
même :
...
//assuming m_PlcUnit is assigned to Plc unit "Unit_1"
...
Modifiez le code de programme suivant pour créer une nouvelle relation qui est une copie d'une
relation existante avec le même type de relation et le même objet associé :
...
//assuming a relation with the same relation type and related object is already existing
...
Modifiez le code de programme suivant pour créer une nouvelle relation, en indiquant une
chaîne vide pour le nom de l'objet associé :
...
m_SoftwareUnitRelation = m_PlcUnit.Relations.Create(string.Empty,
...
Remarque
Dans toutes les sections de code de programme ci-dessus avec des scénarios d'erreur, la
relation n'est pas créée et une exception récupérable est déclenchée.
Code de programme : Supprimer les relations présentes

associé.
private PlcUnitRelation m_SoftwareUnitRelation;

private PlcUnitRelation m_NonUnitDBRelation;
private PlcUnitRelation m_TODBRelation;
...
m_PlcUnit = plcUnitProvider.UnitGroup.Units[0]; //assuming existing units
m_PlcUnit2 = plcUnitProvider.UnitGroup.Units[1]; //assuming existing units
m_NonUnitDBRelation = m_PlcUnit.Relations.Create("DB_Global", UnitRelationType.NonUnitDB);
m_TODBRelation = m_PlcUnit.Relations.Create("Axis_TO", UnitRelationType.TODB);

Vous pouvez supprimer les relations de plusieurs façons.

Modifiez le code de programme suivant pour supprimer directement la relation à laquelle
l'indexeur accède :
...
m_PlcUnit.Relations[0].Delete();
...
Modifiez le code de programme suivant pour supprimer directement la relation :
...
m_SoftwareUnitRelation.Delete();
...
Code de programme : Modifier les relations présentes

Vous pouvez modifier les relations de plusieurs façons.
associé.
private PlcUnitRelation　m_Relation;
m_PlcUnit = plcUnitProvider.UnitGroup.Units[0];
m_PlcUnit2 = plcUnitProvider.UnitGroup.Units[1];
m_Relation = m_PlcUnit.Relations.Create("Unit_2", UnitRelationType.SoftwareUnit);
...
Modifiez le code de programme suivant pour actualiser le nom de l'objet associé, en indiquant
directement une nouvelle valeur pour l'attribut RelatedObject :
...
m_Relation.RelatedObject = "Unit_3";
...
Modifiez le code de programme suivant pour actualiser le nom de l'objet associé, en affectant
une nouvelle valeur pour l'attribut RelatedObject via SetAttributes :
...
m_Relation.SetAttribute("RelatedObject", "Unit_4");
...

Modifiez le code de programme suivant pour actualiser le nom de l'objet associé, en affectant
une nouvelle valeur pour l'attribut RelatedObject via SetAttributes :
...
IList attrList = new List<KeyValuePair<string, object>>();
{
new KeyValuePair<string, object("RelatedObject", "Unit_4")
};
m_Relation.SetAttributes(attrList);
...
Scénarios d'erreur possibles lors de la modification de relations présentes

Modifiez le code de programme suivant pour actualiser une relation de telle sorte qu'elle
accède à un objet associé non présent :
...
//assuming Plc unit "NonExistingUnit" is not existing in the Plc yet
m_Relation.RelatedObject = "NonExistingUnit";
...
Remarque
Avec le code de programme ci-dessus, la relation est modifiée et aucune exception n'est
déclenchée.
Modifiez le code de programme suivant pour actualiser une relation, en indiquant un nom de
l'objet associé qui ne correspond pas aux règles de dénomination TIA :
...
m_Relation.RelatedObject = " Unit_2";
...
Modifiez le code de programme suivant pour actualiser une relation de telle sorte qu'elle
accède à elle-même :
...
//assuming m_Relation is defined under Plc unit "Unit_1"
...
Remarque
Avec le code de programme ci-dessus, la relation n'est pas modifiée et une exception
récupérable est déclenchée en raison d'espaces vides en tête.

7.20 Fonctions de l'interface de gestion des versions (VCI)
Modifiez le code de programme suivant pour actualiser une relation de telle sorte qu'une copie
d'une relation existante avec le même type de relation et le même objet associé est générée :
...
//assuming a relation with the same relation type and related object is already existing
...
Modifiez le code de programme suivant pour actualiser une relation, en indiquant une chaîne
vide pour le nom de l'objet associé :
...
m_Relation.RelatedObject = string.Empty;
...
Remarque
Dans toutes les sections de code de programme ci-dessus, la relation n'est pas modifiée et une
exception récupérable est déclenchée.
Voir aussi
7.20.1 Accès au groupe système VCI dans le projet
Conditions
Application
TIA Portal Openness vous permet depuis le projet d'accéder au groupe système VCI en
appelant une VersionControlInterface comme service depuis le projet. VersionControlInterface
même est toujours un service et renvoie un objet non nul.

Code de programme
Modifiez le code de programme suivant pour appeler le groupe système dans l'espace de
travail depuis VersionControlInterface :
Siemens.Engineering.Project project = tiaPortal.Projects[0];

Siemens.Engineering.VersionControl.VersionControlInterface versionControlInterface =
project.GetService<VersionControlInterface>();
Siemens.Engineering.VersionControl.WorkspaceSystemGroup workspaceSystemGroup =
versionControlInterface.WorkspaceGroup;;
Voir aussi
7.20.2 Énumérer des groupes d'utilisateurs dans un groupe VCI
Conditions
Code de programme
Modifiez le code de programme suivant pour énumérer tous les groupes d'utilisateurs dans un
espace de travail VCI dans d'autres groupes de l'espace de travail VCI :
WorkspaceUserGroupComposition userGroupComposition = workspaceGroup.Groups;

foreach (Siemens.Engineering.VersionControl.WorkspaceUserGroup workspaceUserGroup in
userGroupComposition)
{
//...
}
Modifiez le code de programme suivant pour accéder à un groupe d'utilisateurs particulier dans
d'autres groupes de l'espace de travail VCI :
Siemens.Engineering.VersionControl.WorkspaceUserGroup workspaceUserGroup =
workspaceGroup.Groups.Find("Some Group Name");

Voir aussi
7.20.3 Créer un groupe d'utilisateurs dans un groupe VCI
Conditions
Application
TIA Portal Openness vous permet de créer un groupe d'utilisateurs correspondant à l'espace
de travail dans un groupe de l'espace de travail.
Code de programme
Modifiez le code de programme suivant pour créer un groupe d'utilisateurs Workspace :
VersionControlInterface versionControlInterface =
WorkspaceSystemGroup workspaceGroupComposition =
versionControlInterface.WorkspaceGroup.Groups;
WorkspaceUserGroup result = workspaceGroupComposition.Create("NewWorkspaceUserGroup");
Remarque
Pour pouvoir créer un nouveau groupe d'utilisateurs correspondant à un espace de travail à
l'aide du nom, le nom indiqué doit être valide et il ne doit pas être déjà utilisé dans un autre
groupe d'utilisateurs d'espace de travail.
Voir aussi

7.20.4 Actualiser les propriétés d'un groupe VCI
Conditions
Application
TIA Portal Openness vous permet d'actualiser les propriétés des groupes d'utilisateurs
Workspace.
La propriété suivante est disponible pour actualisation dans un groupe d'utilisateurs
Workspace :
Nom de la propriété Type de valeur en retour Description Possibilité d'accès

Name System.String Nom du groupe d'utilisa‐ lecture/écriture
teurs Workspace.
Code de programme
Modifiez le code de programme suivant pour actualiser le nom du groupe d'utilisateurs dans
l'espace de travail :
var workspaceUserGroup = ...;

workspaceUserGroup.Name = "New_Group_Name";
Voir aussi
7.20.5 Supprimer un groupe d'utilisateurs VCI
Conditions

Application
Avec TIA Portal Openness vous pouvez supprimer des groupes d'utilisateurs Workspace. Lors
de la suppression d'un groupe d'utilisateurs Workspace, tous les autres objets qui y sont
contenus sont également supprimés. En font partie également les autres groupes d'utilisateurs
d'espace de travail et les espaces de travail VCI.
Code de programme
Modifiez le code de programme suivant pour supprimer un groupe d'utilisateurs Workspace :
WorkspaceUserGroup workspaceUserGroup = ...;

workspaceUserGroup.Delete();
Voir aussi
7.20.6 Énumérer des Workspaces VCI dans un groupe VCI
Conditions
Code de programme
Modifiez le code de programme suivant pour énumérer tous les Workspaces VCI dans un
groupe VCI :
WorkspaceComposition workspaceComposition = workspaceSystemGroup.Workspaces;

foreach (Siemens.Engineering.VersionControl.Workspace workspace in workspaceComposition)
{
//...
}
Modifiez le code de programme suivant pour trouver un espace de travail précis à l'aide du
nom :
Siemens.Engineering.VersionControl.Workspace workspace =
workspaceUserGroup.Workspaces.Find("SomeWorkspaceName");

Voir aussi
7.20.7 Créer un espace de travail VCI dans un groupe VCI
Conditions
Application
TIA Portal Openness vous permet de créer un espace de travail dans un groupe d'utilisateurs
de l'espace de travail.
Vous pouvez créer un Siemens.Engineering.VersionControl.Workspace avec l'action de
création suivante :
Siemens.Engineering.VersionControl.WorkspaceComposition.Create(strin
g name)
Code de programme
Modifiez le code de programme suivant pour créer un espace de travail :
VersionControlInterface versionControlInterface =
WorkspaceComposition workspaceComposition =
versionControlInterface.WorkspaceGroup.Workspaces;
Workspace result = workspaceComposition.Create("NewWorkspace");
Remarque
Pour pouvoir créer un nouvel espace de travail à l'aide du nom, le nom indiqué doit être valide
et il ne doit pas être déjà utilisé dans un autre groupe d'utilisateurs dans l'espace de travail.
Voir aussi

7.20.8 Actualiser les propriétés d'un espace de travail VCI
Conditions
Application
TIA Portal Openness vous permet d'actualiser les propriétés d'un espace de travail VCI.
Les propriétés suivantes sont disponibles pour actualisation dans un espace de travail :

Name System.String Nom de l'espace de tra‐ lecture/écriture
vail.
RootPath System.IO.DirectoryIn‐ Chemin d'accès à l'es‐ lecture/écriture
fo pace de travail configu‐
ré.
Code de programme : Actualiser l'attribut "Nom"

Modifiez le code de programme suivant pour actualiser le propriété "Name" dans l'espace de
travail :
var workspace = ...;

workspace.Name = "New_Workspace_Name";
Code de programme : Actualiser l'attribut "Roothpath"

Modifiez le code de programme suivant pour configurer le chemin d'accès à l'espace de travail
en indication de répertoire incluant le répertoire racine : si cette valeur est mise à zéro, la
configuration du chemin d'accès racine est annulée.

workspace.RootPath = new DirectoryInfo(@"D:\Project_WS");
Modifiez le code de programme suivant pour annuler la configuration d'un espace de travail :

workspace.RootPath = null;

Voir aussi
7.20.9 Supprimer un espace de travail VCI
Conditions
Application
TIA Portal Openness vous permet de supprimer un espace de travail. Lors de la suppression
d'un espace de travail, toutes les affectations correspondantes sont également supprimées.
Code de programme
Modifiez le code de programme suivant pour supprimer un espace de travail :
Workspace workspace = ...;

workspace.Delete();
Voir aussi
7.20.10 Énumérer les mappages d'un espace de travail VCI dans un VCI
Conditions

Code de programme
Modifiez le code de programme suivant pour énumérer tous les mappages entre l'espace de
travail VCI et un espace de travail :

WorkspaceMappingComposition mappings = workspace.Mappings;
foreach (Siemens.Engineering.VersionControl.WorkspaceMapping workspaceMapping in mappings)
{
//...
}
Modifiez le code de programme suivant pour accéder à un mappage déterminé entre l'espace
de travail et l'objet d'ingénierie spécifique :

IEngineeringObject versionControlSupportedEngineeringObject = ...;
Siemens.Engineering.VersionControl.WorkspaceMapping workspaceMapping =
workspace.Mappings.Find(versionControlSupportedEngineeringObject);
Voir aussi
7.20.11 Créer un mappage entre l'espace de travail et un espace de travail VCI
Conditions
Application
TIA Portal Openness vous permet de créer un mappage entre un espace de travail et l'espace
de travail VCI.
Vous pouvez créer un Siemens.Engineering.VersionControl.WorkspaceMapping avec la
signature suivante d'une action de création :
Siemens.Engineering.VersionControl.WorkspaceMappingComposition.Creat
e(string relativeWorkspacePath, IEngineeringObject
linkedProjectObject)

Code de programme
Modifiez le code de programme suivant pour créer un mappage d'espace de travail :

var plcBlock = ...;
var result = workspace.Mappings.Create(@"\TestCopy\Block_1.xml", plcBlock);
Une exception récupérable est déclenchée dans les cas suivants :

● L'objet associé n'est pas un objet VCI valide pris en charge.
● L'objet associé est déjà affecté.
● Le chemin relatif contient des caractères de fichier invalides.
● Le chemin relatif contient la navigation vers le dossier de niveau supérieur.
Voir aussi
7.20.12 Actualiser les mappages dans l'espace de travail VCI
Conditions
Application
TIA Openness Portal vous permet d'actualiser les propriétés d'un mappage dans l'espace de
travail VCI.
Les propriétés du mappage de l'espace de travail suivantes sont disponibles :

RelativeWorkspacePath System.String Le chemin relatif pour la repré‐ lecture/écriture
sentation des objets associés
dans la gestion de code source.
LinkedProjectObject IEngineeringObject L'objet d'ingénierie compatible lecture
VCI qui est associé au fichier
dans la gestion de code source.

Code de programme
Modifiez le code de programme suivant pour actualiser le chemin relatif du mappage de
l'espace de travail :
var workspaceMapping = ...;

workspaceMapping.RelativeWorkspacePath = @"\Test\NewBlock_1.xml";
Voir aussi
7.20.13 Supprimer le mappage entre espace de travail et VCI
Conditions
Principe
TIA Portal Openness vous permet de supprimer un mappage entre espace de travail et VCI.
Code de programme
Modifiez le code de programme suivant pour supprimer un mappage entre espace de travail et
VCI :
WorkspaceMapping workspaceMapping = ...;

workspaceMapping.Delete();
Voir aussi

7.20.14 Synchroniser le mappage d'espace de travail
Principe
Application
TIA Portal Openness vous permet d'afficher l'état d'une affectation de Workspace.
Code de programme : Actualiser l'état de synchronisation d'objets individuels

Pour afficher, actualiser ou synchroniser des objets individuels, vous devez d'abord appeler le
Siemens.Engineering.VersionControl.WorkspaceMapping.IndividualObjectSynchronizationSt
atus d'une affectation de Workspace.
Il est recommandé d'effectuer une vérification à zéro avant l'appel des actions du service de
synchronisation pour les objets, car il n'est pas certain que l'affectation existante prenne en
charge la synchronisation des objets.
var individualObjectSynchronizationStatus =
workpaceMapping.GetService<IndividualObjectSynchronizationStatus>();
if(individualObjectSynchronizationStatus != null);
{
//GetStatus()...
//UpdateStatus()..
//Synchronize()..
}
Code de programme : Lecture de l'état

Vous pouvez afficher l'état de synchronisation d'un objet à l'aide de l'action suivante :
Siemens.Engineering.VersionControl.IndividualObjectSynchronizationStatus.GetStatus().
L'action retourne Siemens.Engineering.VersionControl.IndividualObjectCompareResult.
L'objet IndividualObjectCompareResult informe sur l'état de synchronisation actuel.
public class IndividualObjectCompareResult

{
CompareState CompareState { get; }
IndividualObjectCompareDetails {get; }
}
Avec l'énumération de mémentos IndividualObjectCompareDetails , vous êtes informé de la

partie de l'affectation du Workspace modifiée (ou encore que les deux parties ont été
modifiées). Cette valeur est None, lorsque le

CompareState est Equal. Lorsque la valeur pour CompareState est "différent", cette
énumération peut avoir la valeur ProjectObjectChanged ou WorkspaceFileChanged ou
ProjectObjectChanged ou bien
WorkspaceFileChanged.
[Flags]public enum IndividualObjectCompareDetails

{
None = 0,
ProjectObjectChanged = 1,
WorkspaceFileChanged = 2
}
L'énumération CompareState informe sur les modifications d'un objet.
public enum CompareState

{
Equal,
Unequal,
WorkspaceFileMissing,
Unknown
}
Modifiez le code de programme suivant pour appeler l'état d'une affectation du Workspace :

if(individualObjectSynchronizationStatus != null)
{
var compareResult = individualObjectSynchronizationStatus.GetStatus();
//when compareState is unequal
{
if(compareResult.CompareState == CompareState.Unequal)
{
if(compareResult.IndividualObjectCompareDetails ==
IndividualObjectCompareDetails.WorkspaceFileChanged)
{
//Workspace file has changed
}
elseif(compareResult.IndividualObjectCompareDetails ==
(IndividualObjectCompareDetails.ProjectObjectChanged |
IndividualObjectCompareDetails.WorkspaceFileChanged))
{
//Both project object and workspace file has changed
}
}
}

Code de programme : Actualiser l'état de synchronisation

Vous pouvez contraindre le système à effectuer une comparaison en temps réel entre l'objet de
projet actuellement associé et le fichier Workspace. La comparaison peut avoir pour effet que
l'état de synchronisation peut être modifié à l'état système actuel et peut par ailleurs servir à
définir l'état d'une affectation associée depuis peu (mais non synchronisée), sans pour autant
modifier l'objet de projet ou le fichier Workspace.
Modifiez le code de programme suivant pour actualiser l'état d'une affectation du Workspace :

if(individualObjectSynchronizationStatus != Null)
{
individualObjectSynchronizationStatus.UpdateStatus();
}
Code de programme : Synchroniser le Workspace

Vous pouvez contraindre le système à effectuer une comparaison en temps réel entre l'objet de
projet actuellement associé et le fichier Workspace. La comparaison peut avoir pour effet que
l'état de synchronisation peut être modifié à l'état système actuel et peut par ailleurs servir à
définir l'état d'une affectation associée depuis peu (mais non synchronisée), sans pour autant
modifier l'objet de projet ou le fichier Workspace.
L'énumération SynchronizationMode informe le système de la direction dans laquelle il doit
effectuer la synchronisation.
public enum SynchronizationMode

{
ProjectToWorkspace,
WorkspaceToProject
}
Cette action donne au système l'instruction d'effectuer la synchronisation de l'objet de projet

associé à l'objet de données Workspace associé dans le sens opposé.
Modifiez le code de programme suivant pour synchroniser un espace de travail :

if(individualObjectSynchronizationStatus != null)
{
individualObjectSynchronizationStatus.Synchronize(SynchronizationMode.ProjectToWorkspace);
}

7.21 Fonctions sur OPC
Voir aussi
7.21.1 Configuration du protocole de communication sécurisé pour le serveur OPC-UA
Conditions
Introduction
Avec l'application TIA Portal Openness, vous pouvez configurer le serveur OPC-UA avec la
stratégie de sécurité Basic256Sha256. La stratégie de sécurité Basic256Sha256 doit être
ajoutée dans les paramètres Runtime. RDP doit compiler les propriétés dans le fichier de
configuration xml.
Les valeurs par défaut sont Enabled, Sign, ainsi que Sign and Encrypt.
Dans le fichier XML <Projet>\OPC\uaserver\OPCUaServerWinCCPro.xml. vous devez définir
la stratégie de sécurité, ainsi que les stratégies de sécurité selon la configuration d'appareil du
système d'ingénierie.

Voir aussi

7.21.2 Définir la stratégie de sécurité pour OPC UA
Conditions
Ouverture d'un projet (Page 109)
● Le serveur OPC UA est activé
Application
Avec l'application TIA Portal Openness, vous pouvez définir la stratégie de sécurité dans OPC
UA. Vous pouvez implémenter la stratégie de sécurité sous la forme d'un attribut dynamique de
type énumération : OpcUaSecurityPolicies. La directive de sécurité n'est disponible dans TIA
Portal Openness que si le serveur OPC UA est activé. Si le serveur OPC-UA est désactivé, une
EngineeringNotSupportedException est déclenchée en cas de tentative d'accès à la stratégie
de sécurité en raison d'un autre attribut non disponible.
Le tableau suivant montre les valeurs possibles pour des stratégies de sécurité :
Nom dans l'interface uti‐ Entrée d'énumération Valeur Remarques

lisateur TIA
- NoneSelected 0 Correspond à l'interface
utilisateur TIA si aucune
case à cocher n'est ac‐
tivée.
No security OpcUaSecurityPolicies‐ 1
None
Basic128Rsa15 - Sign OpcUaSecurityPoli‐ 2
cies128RSAS
Basic128Rsa15 - Sign OpcUaSecurityPoli‐ 4
& Encrypt cies128RSASE
Basic256 - Sign OpcUaSecurityPoli‐ 8
cies256S
Basic256 - Sign & En‐ OpcUaSecurityPoli‐ 16
crypt cies256SE
Basic256Sha256 - Sign OpcUaSecurityPoli‐ 32
cies256SHAS
Basic256Sha256 - Sign OpcUaSecurityPoli‐ 64
& Encrypt cies256SHASE

7.22 SiVArc Openness
Code de programme
Modifiez le code de programme suivant pour définir la directive de sécurité dans OPC UA avec
TIA Portal Openness :
DeviceItem UpcUaSubmodule= ...;

object SecurityPolicies = UpcUaSubmodule.GetAttribute("OpcUaSecurityPolicies");
if(SecurityPolicies | OpcUaSecurityPolicies.OpcUaSecurityPolicies256S ==
OpcUaSecurityPolicies.OpcUaSecurityPolicies256S)
{
//Do something
}
UpcUaSubmodule.SetAttribute("OpcUaSecurityPolicies",
OpcUaSecurityPolicies.OpcUaSecurityPolicies256S |
OpcUaSecurityPolicies.OpcUaSecurityPolicies256SHASE);
Voir aussi
7.22.1 Introduction
Introduction
Avec l'application TIA Portal Openness, vous pouvez instancier SiVArc. Il vous faut une
application Client pour accéder à TIA Portal et lancer les services SiVArc via la fonction
Openness. Pour plus d'informations sur la configuration et l'accès à Openness, référez-vous
au manuel de l'utilisateur de TIA Portal.

Configuration de l'application
Pour configurer une application Client, procédez comme suit :
1. Créez une application console. Ajoutez une référence à l'API publique
(Siemens.Engineering.dll), disponible sous _deployed\TIAPV15SP1_11010001\PublicAPI
\V15.1\ 936 Siemens.Engineerin.dll ou via les fichiers binaires installés sous PublicAPI
\V15.1\ 937 Siemens.Engineerin.dll.
2. Ajoutez des détails de configuration au fichier de configuration. Pour plus d'informations sur
les détails de configuration et l'accès à l'API publique, référez-vous au wiki TIA Openness.
3. Pour accéder au service SiVArc, utilisez l'API suivante :
using (TiaPortal tia = new
TiaPortal(TiaPortaMode.WithUserInterface))
{
Project myProject = tia.Projects.Open(new FileInfo(@"C:\Users
\z003exve\Documents\Automation\Project_Demo\Project_Demo.ap15));
//Si SiVArc n'est pas installé, l'utilisateur ne peut pas accéder
au service SiVArc (erreur de compilation)
Sivarc sivarc =myproject?.GetService<Sivarc>():
if (sivarc !=null)
{
}
}
7.22.2 Propriétés de service SiVArc
Propriétés de service SiVArc

Le tableau suivant présente les propriétés et les méthodes prises en charge pour SiVArc :
Nom de la pro‐ Description Type de données

priété
AlarmRules Ancrage pour tous les objets d'alarme AlarmRulesBrowsable
ScreenRules Ancrage pour tous les objets de la règle de vue ScreenRulesBrowsable
TextlistRules Ancrage pour tous les objets de la règle des lis‐ TextlistRulesBrowsable
tes de textes
TagRules Ancrage pour tous les objets de la règle de va‐ TagRulesBrowsable
riables
CopyRules Ancrage pour tous les objets de la règle de copie CopyRulesBrowsable
Alarm Rules Énumération de toutes les règles d'alarme direc‐ AlarmRuleComposition
tes de premier niveau
Groups Énumération de tous les groupes de règles AlarmRuleGroupComposition
d'alarme directs de premier niveau
ScreenRules Énumération de toutes les règles de vue directes ScreenRuleComposition
de premier niveau
ScreenRules‐ Énumération de tous les groupes de règles de ScreenRuleGroupComposition
Groups vue directs de premier niveau

Nom de la pro‐ Description Type de données

priété
TextlistRules Énumération de toutes les règles de listes de TextlistRuleComposition
textes directes de premier niveau
TextlistGroups Énumération de tous les groupes de règles de TextlistRuleGroupComposition
listes de textes directs de premier niveau
TagRules Énumération de toutes les règles de variables TagRuleComposition
directes de premier niveau
TagRulesGroups Énumération de tous les groupes de règles de TagRuleGroupComposition
variables directs de premier niveau
CopyRules Énumération de toutes les règles de copie direc‐ CopyRuleComposition
tes de premier niveau
CopyRules‐ Énumération de tous les groupes de règles de CopyRuleGroupComposition
Groups copie directs de premier niveau
Le tableau suivant présente la composition d'AlarmRule et d'AlarmRuleGroup. Le principe est

identique pour les autres objets SiVArc.
Nom de la méthode Paramètre Description Type de données

Find Chaine de caractères – Recherche la règle AlarmRule
nom de la règle d'alar‐ d'alarme/le groupe de
me/ du groupe de règles règles d'alarme dans la
collection des règles
d'alarme/groupes
d'alarme
CreateFrom MasterCopy – Copie Copie la copie maître AlarmRule
maître des règles d'alar‐ des règles d'alarme/
me/du groupe de règles groupes de règles
d'alarme d'alarme de la bibliothè‐
que dans le projet et uti‐
lise l'option standard
pour le remplacement
CreateFrom MasterCopy – Copie Copie la copie maître AlarmRule
maître des règles d'alar‐ des règles d'alarme/du
me/du groupe de règles groupe de règles d'alar‐
d'alarme, CreateOp‐ me de la bibliothèque
tions – renommer/ dans le projet et utilise
remplacer l'option pour la création

7.22.3 Copie de règles ou de groupes de règles de la bibliothèque
Conditions
● Démarrez l'application Openness TIA Portal. Pour plus d'informations sur les liaisons,
référez-vous au manuel de l'utilisateur de TIA Portal.
● Il existe un projet TIA Portal avec éditeur de règles de vue, des groupes de règles de vue
et une copie maitre.
Cas 1 : copie de règles/groupes de règles de la copie maitre dans l'éditeur de règles de vue
À partir de la bibliothèque globale "CreateFrom", il est possible de copier des règles et

groupes de règles dans l'éditeur de règles SiVArc. Si l'opération est un succès, la fonction API
renvoie les ScreenRule/ScreenRuleGroup. Le code suivant montre comment copier les règles
ou les groupes de règles de la copie maitre dans l'éditeur SiVArc.
Par défaut, le comportement est "Remplacer".

Cas 2 : si vous copiez des règles/groupes de règles de la copie maitre, ceux-ci peuvent être
renommés ou remplacés sur la base du deuxième paramètre défini.
Si les règles/groupes de règles de la copie maitre existent déjà dans l'éditeur SiVArc et que
vous essayez de les copier, ils sont renommés. L'API "CreateOptions" crée les règles/groupes
de règles dans l'éditeur SiVArc s'ils n'existent pas et remplace ceux déjà présents. Si
l'opération est un succès, la fonction API renomme les ScreenRule/ScreenRuleGroup. Le
Code-Snippet suivant montre le remplacement des règles/groupes de règles :

7.22.4 Recherche de règles de vue ou de groupes de règles de vue
Conditions
● L'application TIA Portal Openness est connectée à TIA Portal. Pour plus d'informations sur
les liaisons, référez-vous au manuel de l'utilisateur de TIA Portal.
● Il existe un projet TIA Portal avec des règles de vue et des groupes de règles de vue.
Recherche de règles de vue dans des groupes de vue

Cas 1 : recherche de règles de vue dans l'éditeur de règles de vue
Avec l'API sivarc.ScreenRules.Rules vous pouvez rechercher les règles disponibles
dans l'éditeur de règles de vue SiVArc comme indiqué ci-après :

Cas 2 : recherche de groupes de règles de vue dans l'éditeur de règles de vue.

Avec l'API sivarc.ScreenRules.Groups vous pouvez rechercher les règles et groupes de
règles disponibles dans l'éditeur de règles de vue SiVArc comme indiqué ci-après :
7.22.5 Suppression de règles et de groupes de règles
Conditions
● L'application TIA Portal Openness est connectée à TIA Portal. Pour plus d'informations sur
les liaisons, référez-vous au manuel de l'utilisateur de TIA Portal.
● Il existe un projet TIA Portal avec des règles de vue et des groupes de règles de vue.
Suppression de règles et de groupes de règles

Pour supprimer une règle ou un groupe de règles, utilisez l'API suivante :
sivarc.ScreenRules.Rules.Find("Screen rule_1").Delete();
ScreenRules est un ancrage pour tous les objets de la règle de vue. Pour la suppression, il
est nécessaire de rechercher la règle dans l'éditeur de règles. Pour plus d'informations sur la
recherche d'une règle de vue, référez-vous au paragraphe "Recherche de règles de vue ou de
groupes de règles de vue".
Pour supprimer des vues dans un groupe de vues, utilisez l'API suivante :
sivarc.ScreenRules.Rules.Find("Screen rule group_1").Delete();

7.22.6 Configuration UMAC pour Openness
Informations utiles sur UMAC

Pour accéder à UMAC via Openness, assurez-vous que vous disposez des données de
connexion UMAC et des droits d'accès requis. Si vous n'êtes pas un utilisateur UMAC valide,
l'application renvoie la valeur NULL pour tous les objets de règle d'ancrage SiVArc. Pour plus
d'informations sur UMAC, référez-vous à la rubrique "UMAC" du manuel de l'utilisateur SiVArc.
7.22.7 Génération SiVArc
Conditions
● Démarrez l'application Openness TIA Portal. Pour plus d'informations sur les liaisons,
référez-vous au manuel de l'utilisateur de TIA Portal.
● Il existe un projet TIA Portal relié à un appareil IHM et l'API est configuré.
Remarques importantes
● Assurez-vous que la licence SiVArc est installée sur votre PC, sinon une exception sera
signalée pendant la génération - "Licence SiVArc manquante ; une licence SiVArc est
obligatoire pour la modification des données".
● Assurez-vous d'utiliser un nom d'appareil valide, sinon une exception sera signalée
- "Appareil IHM 'nom de l'appareil' introuvable".
● Assurez-vous d'utiliser un nom d'API valide, sinon une exception sera signalée - "Appareil
API 'nom de l'API' introuvable".
● Assurez-vous d'utiliser le nom d'un appareil pris en charge, sinon une exception sera
signalée - "Appareil IHM 'nom de l'appareil' non pris en charge".
● Assurez-vous d'utiliser le nom d'un API pris en charge, sinon une exception sera signalée
- "Appareil API 'nom de l'API' non pris en charge".
● Assurez-vous que vous transmettez un paramètre GenerationOption valide. À défaut de
transmission d'un paramètre, la génération SiVArc s'exécute et utilise par défaut les
réglages du projet TIA Portal.
● Assurez-vous d'utiliser un nom d'API valide qui n'a pas déjà été utilisé pour une génération
précédente, sinon le système se fige.
Options de génération - Enum (mémento)

SiVArc prend en charge des options Enum et vous pouvez transmettre dans l'API Generate
une combinaison de deux valeurs. Le tableau suivant présente les options Enum :

SN Valeurs Description
1 None Pas de sélection, la génération reprend les paramètres par défaut
2 AllTags Toutes les variables sont générées
3 UsedHmi‐ Seules les variables pertinentes (utilisées) sont générées

Tags
Si l'option FullGeneration n'est pas sélectionnée, SiVArc décide en interne,
4 FullGenera‐ sur la base de la configuration, s'il convient d'exécuter une génération com‐
tion plète ou des modifications.
Si vous transmettez le paramètre FullGeneration, SiVArc exécute une
génération complète forcée.
Pour générer SiVArc, utilisez l'API suivante :

sivarc.Generate("HMI_1", new List<string> {PLC_1},
GenerateOptions.AllTags | GenerateOptions. FullGeneration);
SiVArcGenerationResult et SivarcFeedbackMessage
Si la génération SiVArc s'est effectuée avec succès, un accès aux propriétés suivantes est
effectué :
● IsGenerationSuccessful - Informe de la réussite de la génération SiVArc.
● WarningCount - Nombre total d'avertissements après la génération SiVArc
● ErrorCount - Nombre total d'erreurs après la génération SiVArc
● Messages - Composition de la réponse
Pour générer le résultat SiVArc, utilisez l'API suivante :

7.23 Openness pour CP 1604/CP 1616/CP 1626
Si la génération SiVArc s'est effectuée avec succès, un accès aux réponses suivantes est
effectué :
● Path : texte d'en-tête de la réponse (les messages d'en-tête ont toujours une zone de
description non renseignée)
● DateTime : date et heure de la réponse
● MessageType : type de réponse
● Description : description/contenu de la réponse (uniquement si le chemin d'accès est vide,
pour s'assurer qu'il ne s'agit pas d'un message d'en-tête)
● WarningCount : nombre d'avertissements pour un message d'en-tête
● ErrorCount : nombre d'erreurs pour un message d'en-tête
● Messages: composition de la réponse (SivarcFeedbackMessage)
Le Code-Snippet suivant permet d'afficher les réponses récursives :
Généralités
Avec l'application TIA Portal Openness, vous pouvez configurer les zones de transfert et les
règles d'affectation des zones de transfert. Ceci est valable pour les processeurs de
communication CP 1604/CP 1616 à partir de V2.8 (et, selon le numéro de référence,
également à partir de V2.7) ainsi que CP 1626 à partir de V1.1.

Conditions
Voir "Établissement d'une connexion à TIA Portal".
Voir "Ouvrir un projet".
● Tous les appareils doivent être mis "hors ligne" avant la compilation.
Configuration de zones de transfert
Créer des zones de transfert

Pour créer par exemple une zone de transfert de type "CD" pour un CP 1604, utilisez le code
NetworkInterface cpItf = CP
1604Interface.GetService<NetworkInterface>();
// Créer des zones de transfert
TransferAreaComposition transferAreas = cpItf.TransferAreas;
// Zone de transfert simple de type Entrée

TransferArea transferAreaInput =
transferAreas.Create("Input CD", TransferAreaType.CD);
name Indique le nom de la zone de transfert à créer.
type Indique le type de la zone de transfert à créer. Les types suivants sont possibles :
TransferAreaType.CD Appareil de commande pour échange de données
TransferAreaType.F_PS Echange de données PROFIsafe
TransferAreaType.TM Affectation du module de transfert
Remarque : Il n'est pas possible de modifier le type ultérieurement.
Définir les attributs des zones de transfert

Pour définir les attributs d'une zone de transfert, modifiez par ex. le code de programme
suivant :
transferAreaTm.LocalToPartnerLength = 8;
transferAreaTm.Direction = TransferAreaDirection.LocalToPartner;
string name = transferAreaTm.Name
Certains attributs doivent être définis ou interrogés, mais tous les attributs peuvent être définis
ou interrogés avec les appels généraux "GetAttribute()" ou "SetAttribute()". Utilisez p. ex. le
const string myIndividualComment = "MyIndividualComment";

transferAreaTm.SetAttribute("Comment", myIndividualComment);
Int32 updateTime = transferAreaTm.GetAttribute("TransferUpdateTime")
Name (chaîne de caractères) Indique le nom de la zone de transfert.
Sens Indique le sens dans lequel les données de la zone de transfert sont transmises. Les sens
suivants sont possibles :
TransferAreaDirection.LocalTo‐ Les données de la zone de transfert sont transmises
Partner du périphérique IO à l'automate de niveau supérieur.
TransferAreaDirection.partnerTo‐ Les données de la zone de transfert sont transmises
Local de l'automate de niveau supérieur au périphérique IO.
TransferAreaDirection.bidirectional Les données de la zone de transfert peuvent être
transmises entre l'automate de niveau supérieur et le
périphérique IO dans les deux sens.
L'attribut "LocalToPartnerLength" permet d'indiquer la
longueur des données de la zone de transfert transmi‐
ses du périphérique IO à l'automate de niveau supéri‐
eur. L'attribut "PartnerToLocalLength" permet de défi‐
nir le volume de données pouvant être transmises de
l'automate de niveau supérieur au périphérique IO.
Comment (chaîne de caractè‐ Champ de texte pour un commentaire sur la zone de transfert.
res)
LocalToPartnerLength Indique la longueur des données de la zone de transfert transmises du périphérique IO à
l'automate de niveau supérieur.
PartnerToLocalLength Indique la longueur des données de la zone de transfert transmises de l'automate de niveau
supérieur au périphérique IO.
LocalAdresses Indique les adresses d'entrée et de sortie de la zone de transfert dans l'appareil local.
PartnerAdresses Indique les adresses d'entrée et de sortie de la zone de transfert dans l'automate de niveau
supérieur.
TransferUpdateTime(Int32) Indique la période d'actualisation de la zone de transfert. Défini ou interrogé uniquement
pour une zone de transfert du type "TransferAreaType.TM".
PositionNumber Indique le nombre de sous-modules virtuels de cette zone de transfert.
Type Indique le type de la zone de transfert, avec protection en écriture.
TransferAreaMappingRules Indique le tableau de routage de la zone de routage, avec protection en écriture.
Supprimer des zones de transfert

Utilisez le code de programme suivant pour supprimer des zones de transfert :
transferAreaInput.Delete();
Itération via des zones de transfert

Utilisez le code de programme suivant pour l'itération de zones de transfert :
TransferAreaComposition transferAreas = cpItf.TransferAreas;
foreach (TransferArea transferArea in transferAreas)
{

transferArea.Delete();
}
Configuration du routage d'E/S
Créer des routes d'E/S

Utilisez le code de programme suivant pour créer des routes d'E/S :
// Créer transfertAreaMappingRule
TransferAreaMappingRuleComposition routingTable
= transferArea.TransferAreaMappingRules;
// Créer une nouvelle route d'E/S

TransferAreaMappingRule route1 =
routingTable.Create();
Définir les attributs de routes d'E/S

Les attributs suivants peuvent être définis pour le routage d'E/S :
Décalage Décalage indiqué en bits dans la zone de routage auquel les données doivent être affectées. La longueur
du décalage selon la définition par les attributs "Begin" et "End".
Cible Indique le module ou le sous-module du périphérique IO contenant les données à affecter à la configuration
du périphérique IO, c'est-à-dire une zone de transfert de type "TM".
IoType L'attribut "IoType" ne peut être modifié que dans une zone de transfert de type "Input". En outre, un module
mixte pour cette zone de transfert doit être configuré comme "Cible". Vous pouvez tout d'abord spécifier si
les données des entrées (IoType.Input) doivent être lues ou si les données des sorties (IoType.Output)
doivent être lues/relues.
Begin Indique le début des données à lire avec l'attribut "Target".
End Indique la fin des données à lire avec l'attribut "Target".
Supprimer des routes d'E/S

Utilisez le code de programme suivant pour supprimer des routes d'E/S :
transferAreaMappingRule.Delete();
Itération via un routage d'E/S

Utilisez le code de programme suivant pour une itération via routage d'E/S :
TransferAreaMappingRuleComposition routingTable =
transferArea.TransferAreaMappingRules;
foreach (TransferAreaMappingRule route in routingTable)
{

7.24 Zones de transfert Openness pour coupleur PN/PN
route.Delete();
}
Conditions
● Tous les appareils doivent être mis "hors ligne" avant la compilation.
Introduction
L'application TIA Portal Openness vous permet d'ajouter des modules/sous-modules et de
supprimer ou parcourir des zones de transfert pour coupleur PN/PN.
Configuration de zones de transfert
Créer des zones de transfert

Pour créer par exemple un module au prochain numéro de position libre, utilisez le code de
programme suivant :
NetworkInterface coupler_Itf = deviceItem.GetService<NetworkInterface>();

TransferAreaComposition transferAreas = coupler_Itf.TransferAreas;
// Create a transfer area of type input at next free positionnumber
TransferArea transferAreaInput = transferAreas.Create("Input", TransferAreaType.IN);
Remarque
Il est impossible de créer un sous-module sans numéro de position.
Pour créer par exemple un module à un numéro de position et un sous-module au prochain

numéro de position de sous-module libre, utilisez le code de programme suivant :
// Create a transfer area of type input at positionnumber 5

TransferArea transferAreaInput = transferAreas.Create("Input", TransferAreaType.IN, 5);

Type Indique le type de la zone de transfert à créer. Les types suivants sont possibles :
TransferAreaType.None Valeur par défaut
TransferAreaType.IN Entrée de la zone de transfert
TransferAreaType.OUT Sortie de la zone de transfert
TransferAreaType.MSI Entrée commune de la zone de transfert
(MSI)
TransferAreaType.MSO Sortie commune de la zone de transfert
(MSO)
TransferAreaType.MSO_LOCAL Sortie locale commune de la zone de
transfert (MSO_LOCAL)
TransferAreaType.RE‐ Zone de transfert pour Record Data
CORD_WRITE_STO Write, jusqu'à huit enregistrements sont
mis en mémoire tampon
TransferAreaType.RE‐ La zone de transfert pour Record Data
CORD_WRITE_PUB Write écrase l'enregistrement précédent
CORD_READ_STO Write lit l'enregistrement le plus ancien
dans le tampon
CORD_READ_PUB Write lit le dernier enregistrement écrit
TransferAreaType.MSI_MSO Entrée commune de la zone de transfert
(MSI)/Sortie commune de la zone de
transfert (MSO)
TransferAreaType.IN_OUT Entrée de la zone de transfert/sortie de
la zone de transfert
TransferAreaType.LOCAL_RE‐ Zone de transfert pour le couplage local
CORD_STO d'enregistrements, jusqu'à huit enregis‐
trements sont mis en mémoire tampon
TransferAreaType.LOCAL_RE‐ Zone de transfert pour le couplage local
CORD_PUB d'enregistrements, l'enregistrement pré‐
cédent est écrasé
TransferAreaType.SUB_MSI Copier la zone de transfert pour l'entrée
commune (MSI)
TransferAreaType.SUB_MSO Copier la zone de transfert pour la sortie
commune (MSO)
TransferAreaType.SUB_LOCAL_RE‐ Zone de transfert pour Record Data
CORD_STO_READ Read pour la lecture de l'enregistrement
le plus ancien dans le tampon
TransferAreaType.SUB_LOCAL_RE‐ Zone de transfert pour Record Data
CORD_PUB_READ Read pour la lecture du dernier enregis‐
trement écrit
TransferAreaType.PROFISA‐ Zone de transfert avec entrée de 12 oc‐
FE_IN12_OUT6 tets et sortie de 6 octets
TransferAreaType.PROFISA‐ Zone de transfert avec entrée de 6 oc‐
FE_IN6_OUT12 tets et sortie de 12 octets

Définir les attributs des zones de transfert

Pour définir les attributs d'une zone de transfert, modifiez par ex. le code de programme
suivant :
// Change input length　

CouplerTransf.LocalToPartnerLength = 5;　
// Change output length　
CouplerTransf.PartnerToLocalLength = 5;　
// Change name　
CouplerTransf.Name = "Testname";
Certains attributs doivent être définis ou interrogés, mais tous les attributs peuvent être définis
ou interrogés avec les appels généraux "TransferArea.GetAttribute()" ou "SetAttribute()".
Utilisez par ex. le code de programme suivant :
// Set Comment of Transferarea

string myIndividualComment = "MyIndividualComment";
CouplerTransf.SetAttribute("Comment", myIndividualComment);
// Get positionNumber of Transferarea
Int32 positionNumber = (Int32)CouplerTransf.GetAttribute("PositionNumber");
Name (string) Indique le nom de la zone de transfert.
Direction Indique le sens dans lequel les données de la zone de transfert sont transmises. Les sens
suivants sont possibles :
TransferAreaDirection.Lo‐ Les données de la zone de transfert sont transmises du périphé‐
calTo‐ Partner rique IO à l'automate de niveau supérieur.
TransferAreaDirection.part‐ Les données de la zone de transfert sont transmises de l'auto‐
nerTo‐ Local mate de niveau supérieur au périphérique IO.
TransferAreaDirection.bidi‐ Les données de la zone de transfert peuvent être transmises
rectional entre l'automate de niveau supérieur et le périphérique IO dans
les deux sens. L'attribut "LocalToPartnerLength" permet d'indi‐
quer la longueur des données de la zone de transfert transmises
du périphérique IO à l'automate de niveau supérieur. L'attribut
"PartnerToLocal‐ Length" permet de définir le volume de don‐
nées pouvant être transmises de l'automate de niveau supérieur
au périphérique IO.
Comment (string) Champ de texte pour un commentaire sur la zone de transfert
LocalToPartnerLength Indique la longueur des données d'entrée de la zone de transfert
PartnerToLocalLength Indique la longueur des données de sortie de la zone de transfert.
PositionNumber Indique le numéro d'emplacement de la zone de transfert.
ExtendedPositionNumber Indique le numéro de sous-emplacement de la zone de transfert
Type Indique le type de la zone de transfert
SharedDeviceAccessConfi‐ Commande l'accès à l'API
gured
UpdateAlarm Indique l'alarme de mise à jour de la zone de transfert.
RecordIndex Définit le numéro d'enregistrement que vous utilisez pour l'écriture de l'enregistrement

7.25 Modules/sous-modules Openness virtuels pour ET 200SP PN HF
Supprimer des zones de transfert

Utilisez le code de programme suivant pour supprimer des zones de transfert :
TransferArea TransferAreaInput = transferAreas.Create("Input", TransferAreaType.IN);

TransferAreaInput.Delete();
Rechercher des zones de transfert

Pour appeler la zone de transfert avec le numéro de position et un numéro de position étendu,
utilisez le code de programme suivant :
// Find a transfer area with Positionnumber and ExtendedPositionNumber

TransferArea transferAreaFind = transferAreas.Find(4, 3);
Remarque
Le numéro de position étendu n'est requis que pour les zones de transfert avec plusieurs sous-
modules comme MSI.
Pour appeler la première zone de transfert avec ce numéro de position, utilisez le code de
programme suivant :
// Find a transfer area with Positionnumber　

TransferArea transferAreaFind = transferAreas.Find(5);
Remarque
Si l'un de ces attributs n'est pas disponible, une exception est déclenchée.
Conditions
Introduction
TIA Portal Openness vous permet d'ajouter et de supprimer des modules/sous-modules
virtuels pour ET 200 SP PN HF.

Les propriétés suivantes sont prises en charge avec les modules virtuels :
Nom de la propriété Type de données EomAtomVa‐ Description EomAtom

lue
SharedDeviceAccessConfigured Boolean
Name String
PositionNumber Int32
VirtualType UInt64 1 MsoLocal
AddSubModules Int64
Les propriétés suivantes sont prises en charge avec les sous-modules virtuels :
Propriété Type de données EomAtomValue Description EomAtom

SharedDeviceAccessConfi‐ Boolean
gured
Comment String
PositionNumber Int32
Name String
ActivateDataStatus Boolean
InputAddressLength Int64
OutputAddressLength Int64
VirtualSubType UInt64 1 MsoLocal
2 MsoSub
Code de programme : Créer et supprimer un module virtuel

Modifiez le code de programme suivant pour ajouter un nouveau module :
string Type = "OrderNumber:6ES7 155-6AU30-0CN0/V4.2";

Device ET200SP = newProject.Devices.CreateWithItem(Type, "ET200SP",
"ET200SP");
DeviceItem Rack = ET200SP.DeviceItems.First();
string TypeIdentifier = "OrderNumber:ET200SP.Virtual.Module";
string Name = "VirtualIO_1";
int PositionNumber = 100;
DeviceItem VIM = Rack.PlugNew(TypeIdentifier, Name, PositionNumber);
Modifiez le code de programme suivant pour supprimer un module :
DeviceItem Rack = ET200SP.DeviceItems.First();

string TypeIdentifier = "OrderNumber:ET200SP.Virtual.Module";
string Name = "VirtualIO_1";
int PositionNumber = 100;
DeviceItem VIM = Rack.PlugNew(TypeIdentifier, Name, PositionNumber);
VIM.Delete();

7.26 Fonctions pour SINUMERIK
Code de programme : Créer et supprimer un sous-module virtuel

Modifiez le code de programme suivant pour créer des sous-modules virtuels Openness :
VIM1.SetAttribute("AddSubModules", (Int64)1);
VIM2.SetAttribute("AddSubModules", (Int64)2);
Remarque
Pour ajouter un sous-module, vous devez mettre la propriété de module "AddSubModules" sur
le nombre de sous-modules ajoutés. Si vous essayez d'ajouter plus de sous-modules que le
nombre autorisé, une exception est déclenchée.
Modifiez le code de programme suivant pour supprimer un sous-module :
SubModule3.Delete();
Remarque
Vous ne pouvez pas supprimer les deux premiers sous-modules.
7.26.1 Introduction
TIA Portal-Openness permet d'automatiser l'ingénierie de vos programmes que vous piloterez
via TIA Portal.
Vous trouverez dans cette aide des informations et des exemples de code pour ce programme
que vous créez. Il est également possible de créer et utiliser des programmes pour l'application
TIA Portal "SINUMERIK".
Informations complémentaires
Avant de compiler un programme unique pour SINUMERIK à partir des exemples de codes
énumérés ci-dessous, prendre connaissances des informations générales sur Openness,
présentes dans cette aide sous les mots clés suivants :
● Conditions pour TIA Portal Openness
● Installation de TIA Portal Openness
● Accès à TIA Portal
● Modèle d'objet TIA Portal Openness
● Étapes de programmation

7.26.2 Identifiant - Identification des composants

Chaque composant SINUMERIK possède un numéro univoque, appelé Identifiant
(TypeIdentifier) . Cet identifiant peut être utilisé dans le code du programme Openness pour
identifier et nommer un composant de façon univoque. Par exemple, l'identifiant pour
SINUMERIK 840D sl NCU 710.3 PN correspond à "N° d'article : 6FC5 371-0AA30-0Axx/Vy.z".
L'identifiant est visible lors de la création d'un appareil dans la boîte de dialogue "Ajouter nouvel
appareil", ainsi que dans le tableau de vue d'ensemble des appareils.
L'identifiant peut être copié dans l'application Openness.
L'identifiant est attendu dans Openness en tant que paramètre actuel lors de l'appel d'une
méthode, par exemple de la méthode CreateWithItem().
Activer l'affichage du TypeIdentifier dans SINUMERIK

1. Dans la vue du projet, sélectionner le menu "Outils > Réglages".
La zone de configuration "Réglages" s'ouvre.
2. Dans la navigation secondaire, sélectionner l'entrée "Configuration matérielle".
3. Activer l'option "Activer l'affichage du TypeIdentifier pour les appareils et les modules".
L'affichage du TypeIdentifier est maintenant actif.
7.26.3 Notions de base
Vue d'ensemble
Les appareils SINUMERIK suivants peuvent être créés dans TIA Portal Openness :
● NCU
● Module NX
● ADI4
Pour créer les appareils SINUMERIK, utiliser la méthode CreateWithItem() de la
Devices Collection.
Remarque
Tous les sous-composants intégrés d'une NCU SINUMERIK tels qu'AP, NCK, CP, HMI et
SINAMICS Integrated sont créés automatiquement et imbriqués au même niveau.
Particularités lors de la création des appareils SINUMERIK

Les noms des châssis correspondent aux types de NCU et sont protégés en écriture dans
l'interface utilisateur. Les désignations des châssis doivent également être utilisées dans TIA
Portal Openness.

Utiliser les noms standard de châssis ci-dessous lors de la création d'un appareil au moyen
d'un identifiant d'élément d'appareil avec la méthode Device CreateWithItem :
SINUMERIK NCU Noms standard de châssis

SINUMERIK 840D sl NCU 710.3 PN NCU 710.3 PN
SINUMERIK 840D sl NCU 730.3 PN /319 NCU 730.3 PN /319
Remarque
Les noms de paramètre peuvent être omis. Lorsque le nom est "Null" ou "String.Empty", le nom
standard est utilisé.
Les paramètres suivants peuvent être utilisés avec la méthode CreateWithItem() :

● default name, p.
ex. :
project.Devices.CreateWithItem("OrderNumber:6FC5 371-0AA30-0AAB/
V4.8", "NCU 710.3 PN", "TestDevice");
● null, p.
ex. :
V4.8", null, "TestDevice");
● string.Empty, p.
ex. :
V4.8", string.Empty, "TestDevice");
Plus d'informations sur les paramètres d'appel de la méthode CreateWithItem(), voir
chapitre "Création d'un appareil".
Le tableau suivant présente la correspondance des appareils et de leurs identifiants :
SINUMERIK NCU Identifiant

SINUMERIK 840D sl NCU 710.3 PN N° d'article : 6FC5 371-0AA30-0Axx/Vy.z
SINUMERIK 840D sl NCU 730.3 PN /319 N° d'article : 6FC5 373-0AA31-0Axx/Vy.z
Il est possible d'utiliser des caractères génériques dans l'identifiant lors de la création des
appareils SINUMERIK. Les caractères génériques doivent être remplacés ultérieurement par
des caractères spécifiques à l'appareil. Exemple : en saisissant "OrderNumber:6FC5
372-0AA30-0AA0/V4.8", une SINUMERIK 840D sl NCU 720.3 PN avec la version de firmware
FW4.8 est créée.

Classification de l'élément de l'appareil

Chaque appareil ou élément de l'appareil possède des attributs obligatoires qui sont lus et
écrits. Plus d'informations concernant les attributs pris en charge par Openness, voir chapitre
"Fonctions sur les éléments de l'appareil".
Les attributs de classification des éléments de l'appareil sont protégés en écriture et ne sont
pas affichés dans l'interface utilisateur de TIA Portal.
Les attributs de classification ont la valeur "DeviceItemClassification" :
Valeur de l'attribut de classification Description

DeviceItemClassifications.None (0) Aucune classification.
DeviceItemClassifications.CPU (1) L'élément de l'appareil est une CPU.
DeviceItemClassifications.HM (2) L'élément de l'appareil est un module de tête.
Lorsque la valeur de cet élément de l'appareil est interrogée via l'AP intégré, la valeur "CPU (1)"
est retournée pour un appareil SINUMERIK.
Dans le modèle d'objets d'Openness, les composants suivants ont la fonction de modules de
tête :
● SINAMICS Integrated
● Module NX
● ADI4
Dans tous les autres cas, la valeur de l'attribut de classification
"DeviceItemClassification" est "None" (0).
Trouver des éléments de l'appareil avec la propriété "Module de tête"

Les exemples suivants illustrent comment trouver les éléments de l'appareil ayant la propriété
"Module de tête" avant de configurer un télégramme par exemple.
Cette propriété n'est accessible qu'en lecture. Elle ne peut pas être spécifiée pour un élément
de l'appareil.

{
{
if (deviceItem.Classification == DeviceItemClassifications.HM)
{
var driveObjectContainer = deviceItem.GetService<DriveObjectContainer>();
// do something
}
}
}

L'exemple de code ci-dessous peut également être utilisé pour trouver un AP indépendamment
de la réalisation concrète (AP SINUMERIK, AP SIMATIC, AP logiciel intégrés au PC) sur la
base de la propriété "CPU" :
Trouver des AP
{
DeviceItem rack = device.DeviceItem[0]; //additional necessary step in SINUMERIK side
foreach (DeviceItem deviceItem in rack.DeviceItems)
{
if (deviceItem.Classification == DeviceItemClassifications.CPU)
{
var softwareContainer = deviceItem.GetService<SoftwareContainer>();
// do something
}
}
}
Voir aussi
Création d'un module NX (Page 668)
Créer une NCU (Page 667)

7.26.4 Modèle d'objet
Vue d'ensemble
Le diagramme ci-dessous donne une description des objets sous "Device" dans SINUMERIK
840D sl :
'HYLFH
5DFN'HYLFH,WHP
&3'HYLFH,WHP
31,(,QWHUIDFH'HYLFH,WHP
31,(3RUW'HYLFH,WHP
+0,'HYLFH,WHP
1&.'HYLFH,WHP
3/&'HYLFH,WHP
'3,QWHUIDFH'HYLFH,WHP
31,(3RUW'HYLFH,WHP
31,(3RUW'HYLFH,WHP
03,'3,QWHUIDFH'HYLFH,WHP
'3,QWHJUDWHG,QWHUIDFH'HYLFH,WHP
6,1$0,&6,QWHJUDWHG3UR[\'HYLFH,WHP
Le diagramme ci-dessous donne une description des objets sous "Device" dans SINUMERIK
NX 10.3/15.3 :
'HYLFH
5DFN'HYLFH,WHP
+HDGPRGXOH'HYLFH,WHP
'ULYH2EMHFW&RQWDLQHU6HUYLFH

Le diagramme ci-dessous donne une description des objets sous "Device" dans ADI4 :
'HYLFH
5DFN'HYLFH,WHP
$[LVVHSDUDWRU'HYLFH,WHP
%ODQNPRGXOH'HYLFH,WHP
','HYLFH,WHP
'2'HYLFH,WHP
'ULYH'HYLFH,WHP
'ULYH'HYLFH,WHP
'ULYH'HYLFH,WHP
'ULYH'HYLFH,WHP
(QFRGHU'HYLFH,WHP
(QFRGHU'HYLFH,WHP
(QFRGHU'HYLFH,WHP
(QFRGHU'HYLFH,WHP
Plus d'informations sur les modèles d'objet Openness TIA Portal, voir "TIA Portal Openness
API".

7.26.5 Référence
7.26.5.1 DriveObject
DriveObject
La classe DriveObject permet d'accéder à l'objet entraînement. L'objet entraînement
permet, par ex., d'accéder à ce télégramme.
Namespace : Siemens.Engineering.MC.Drives
Assembly : Siemens.Engineering.MC.Drives
dans Siemens.Engineering.dll
Le tableau suivant décrit les propriétés de la classe :
Nom Type de données Mode Accès Description

d'accès
Telegram TelegramCompos read - Renvoie une liste des télégrammes
s ition disponibles de l'objet entraînement.
Cette liste peut être modifiée avec la
classe TelegramComposition.
Parent IEngineeringOb read - Renvoie la référence à la classe de
ject niveau supérieur
(DriveObjectContainer)).
Le tableau suivant décrit les méthodes de la classe :
Nom Description
GetAttribute Accède en lecture à un attribut d'un objet entraînement
SetAttribute Accède en écriture à un attribut d'un objet entraînement
GetEnumerator Permet l'itération sur l'ensemble des éléments présents
7.26.5.2 DriveObjectContainer
DriveObjectContainer
Le DriveObjectContainer est un service de l'objet entraînement (DeviceItem) de
l'appareil actuel (Device).

Le tableau suivant décrit les navigateurs du DriveObjectContainer :
Nom Type de données Mode d'ac‐ Accès Description

cès
DriveObj DriveObjectCompo read - Renvoie une liste des objets entraî‐
ects sition nement disponibles. Les objets en‐
traînement permettent d'accéder
aux paramètres d'entraînement et
aux télégrammes.
Parent IEngineeringObje read - Renvoie la référence à la classe de
ct niveau supérieur (DeviceItem).
7.26.5.3 DriveObjectComposition
DriveObjectComposition
La classe DriveObjectComposition permet d'accéder aux télégrammes disponibles d'un
objet entraînement.
Assembly : Siemens.Engineering.MC.Drives in Siemens.Engineering.dll

cès
IndexOf int32 read - Renvoie l'indice dans l'en‐
semble des éléments pour
l'instance demandée.
Contains bool read - Détermine si l'instance spéci‐
fiée est présente dans l'en‐
semble des éléments.
TRUE: Le conteneur contient
l'instance
FALSE: Le conteneur ne con‐
tient pas l'instance
GetEnumerator IEnumerator<Dr read - Permet l'itération sur l'ensem‐
iveObject> ble des éléments présents
7.26.5.4 AddressComposition
AddressComposition
La classe AddressComposition représente l'adresse d'un télégramme.


d'accès
IoType enum: AddressIo read - Renvoie des informations sur le
Type type de l'adresse.
Context enum: read Accès pos‐ Renvoie des informations sur le
AddressContext sible uni‐ contexte de l'adresse.
quement
via
GetAttri
bute
ou
SetAttri
bute
StartAddres Int32 read/ - Renvoie ou détermine l'adresse
s write de début du télégramme.
Length Int32 read - Renvoie la longueur du télégram‐
me.
IndexOf int32 read - Renvoie l'indice dans l'ensemble
des éléments pour l'instance de‐
mandée.
Contains bool read - Détermine si l'instance spécifiée
est présente dans l'ensemble des
éléments.
TRUE: Le conteneur contient l'ins‐
tance
FALSE: Le conteneur ne contient
pas l'instance
GetEnumerat IEnumerator<DriveO read - Permet l'itération sur l'ensemble
or bject> des éléments présents
Remarque
Pour renaviguer vers le télégramme via Address.Parent, appeler à la place du
Namespace Siemens.Engineering.MC.Drives.Telegram le
Namespace Siemens.Engineering.MC.DriveConfiguration.Telegram.
Pour plus d'informations sur les bibliothèques TIA Portal Openness, voir "Bibliothèques
standard".
Voir aussi
AddressIoType (Page 666)
AddressContext (Page 666)

7.26.5.5 AddressContext
AddressContext
Enum AddressContext contient des informations sur le contexte de l'adresse.
Le tableau suivant décrit les entrées Enum :
Nom Description
AddressContext.None Un contexte a été trouvé pour l'adresse
AddressContext.Device Le contexte est une adresse d'appareil
AddressContext.Head Le contexte est une adresse de tête
standard".
7.26.5.6 AddressIoType
AddressIoType
Enum AddressIoType contient des informations sur le type de l'adresse.
Nom Description
AddressIoType.None Le type d'IO ne peut pas être utilisé
AddressIoType.Input Le type est une adresse d'entrée
AddressIoType.Output Le type est une adresse de sortie
AddressIoType.Diagnosis Le type est une adresse de diagnostic
AddressIoType.Substitute Le type est une adresse de remplacement
standard".

7.26.6 Exemple de code
7.26.6.1 Généralités
Les exemples de code suivants décrivent la procédure de base pour différents cas
d'application. Le code n'est pas nécessairement complet et compilable.
7.26.6.2 Réalisation de la mise en route dans SINUMERIK

● Connecter l'application TIA Portal Openness à TIA Portal.
● Ouvrir le projet.
L'exemple suivant montre comment déterminer quelle version de SINUMERIK Toolbox est
installée.
Déterminer la version de SINUMERIK Toolbox

if (tiaProcess.InstalledSoftware.Any(sw => sw.Name.Equals("SINUMERK Toolbox") &&
sw.Version.Equals("V16")))
{
Console.WriteLine("SINUMERIK Toolbox is available");
}
// "V16" is the current SINUMERIK version started at December 2019.
7.26.6.3 Créer une NCU

La méthode CreateWithItem() de la Devices Collection permet de créer une NCU
SINUMERIK. Les NCU SINUMERIK sont spécifiées à l'aide des paramètres de la méthode. Le
format des paramètres est décrit ci-après.
Créer une NCU

Format des paramètres pour les NCU SINUMERIK :
CreateWithItem(@"OrderNumber:mlfb/
FirmwareVersion/","NameOfTheDevice",positionNumber)
Le paramètre positionNumber est optionnel.
L'exemple suivant montre la création d'une commande SINUMERIK 840D sl NCU 720.3 PN.
Création d'une SINUMERIK 840D sl NCU 720.3 PN

Project tiaproject= portal.Projects.Open("..."); //The path of the project
Device NCUDevice = tiaproject.Devices.CreateWithItem("@OrderNumber:6FC5

372-0AA30-0AA0/4.8/", "NCU 720.3 PN", string.Empty, "TestDevice");

7.26.6.4 Création d'un module NX

La méthode Device CreateWithItem permet de créer un module NX. Le module NX est
ensuite connecté à une NCU.
Les identifiants suivants sont utilisés pour les modules NX SINUMERIK :
Module NX SINUMERIK Identifiant

SINUMERIK NX10.3 OrderNumber:6SL3 040-1NC00-0Axx/Vy.z
SINUMERIK NX15.3 OrderNumber:6SL3 040-1NB00-0Axx/Vy.z
L'exemple suivant illustre la création d'un module NX SINUMERIK.
Création d'un module NX

project.Devices.CreateWithItem("OrderNumber:6SL3040-1NC00-0AA0/
V5.1", "MyNXDevice", "TestDevice");
Compatibilité des versions

La version de firmware du module NX doit être identique à la version de firmware de SINAMICS
Integrated et doit être compatible avec la version de firmware de la NCU.
Une version de firmware NX différente de celle de SINAMICS Integrated ne peut pas être
affectée via Openness.
Le tableau suivant présente les compatibilités de version pour 840D :
NCU-Firmware (840D sl) Firmware SINAMICS Integrated / NX

V4.5 V4.5
V4.7 V4.7
V4.8 V5.1
V4.91 V5.2
V4.92
V4.93
7.26.6.5 Connexion du module NX avec une NCU
Connexion du module NX avec une NCU

Pour connecter un module NX à une NCU avec le type de sous-réseau
"ProfibusIntegrated", le service "NetworkInterface" doit être chargé avec le module
de tête de NX.

L'exemple suivant illustre le chargement du service "NetworkInterface".
Chargement du service NetworkInterface

{
{
{
var networkInterface = deviceItem.GetService<NetworkInterface>();
// do something
}
}
}
L'exemple suivant illustre la connexion d'un module NX à une NCU avec

"ProfibusIntegrated" :
Connexion du module NX à une NCU avec ProfibusIntegrated

Subnet pbiSubnet = ...;
Node node = networkInterface.Nodes.FirstOrDefault();
node.ConnectToSubnet(pbiSubnet);
L'adresse DP est affectée au NX fixe dans Openness par le port DRIVE-CLiQ. Chaque
étiquette de port dispose d'une adresse DP Integrated fixe.
L'adresse DP doit être affectée au NX avant la connexion à la NCU.
7.26.6.6 Création d'archives
Création d'archives pour la mise en service de série

TIA Portal Openness permet de créer et d'exporter des archives SINUMERIK, p. ex. pour
simplifier la mise en service de série.
Remarque
Pendant la création des archives, l'AP doit se trouver en mode hors ligne. Le mode Safety ne
doit pas être actif.
Les archives SINUMERIK sont créées via la propriété de projet TIA Portal HwUtilities avec
le service SinumerikArchiveProvider.

L'exemple suivant montre comment appeler le service SinumerikArchiveProvider :
Appeler SinumerikArchiveProvider
SinumerikArchiveProvider archiveProvider =
project.HwUtilities.Find("SinumerikArchiveProvider") as
SinumerikArchiveProvider;
if (archiveProvider != null)
{
// Work with the provider
}
L'exemple suivant montre comment créer une archive AP contenant les informations sur le
matériel et tous les blocs de données :
Créer une archive AP

...
Siemens.Engineering.HW.DeviceItem plc = ...;
try {
// The file extension is required
string archivePath = string.Format(@"D:\some_path\{0}.dsf", plc.Name);
// Comment and author arguments are optional

archiveProvider.Archive(plc, new FileInfo(archivePath),
SinumerikArchivationMode.HardwareAndAllProgramBlocks[, "Comment", "Author
name"]);
}
catch (EngineeringTargetInvocationException ex)
{
// Handle archive failure
}

L'exemple suivant montre comment mettre à jour des composantes logicielles d'une archive
AP déjà créée :
Mettre à jour des composantes d'archive

...
Siemens.Engineering.HW.DeviceItem plc_1 = ...;
Siemens.Engineering.HW.DeviceItem plc_1_copy = ...;
try {
string archivePath = @"D:\some_path\SinumerikArchive.dsf";
// Create a Sinumerik archive with HardwareAndAllProgramBlocks

archiveProvider.Export(plc_1, new FileInfo(archivePath),
SinumerikArchivationMode.HardwareAndAllProgramBlocks);
// Update the software part in the previously created archive using

UpdateProgramBlocksOfArchive method
archiveProvider.UpdateProgramBlocksOfArchive(plc_1_copy, new
FileInfo(archivePath));
}
catch (EngineeringException ex)
{
// Handle export failure
}
7.26.6.7 Activation de Safety Integrated
Activation de Safety Integrated

TIA Portal Openness permet d'activer Safety Integrated (AP de sécurité) dans les propriétés de
la NCU.
Remarque
Incidences sur la configuration des télégrammes
Le mode Safety Integrated utilisé a des incidences sur la configuration des télégrammes, étant
donné que le mode Safety Integrated plus (AP de sécurité) utilise d'autres télégrammes que
ceux utilisés lorsque le mode Safety Integrated est inactif.
Les télégrammes ajoutés ou modifiés sont toutefois conservés dès lors qu'ils sont compatibles
avec le mode Safety Integrated nouvellement sélectionné.
Après le changement de mode, s'assurer le cas échéant que les adaptations éventuelles sont
encore présentes dans la configuration des télégrammes.
Safety Integrated (AP de sécurité) est activé et désactivé avec le service

SafetyModeProvider.
Remarque
Lorsque Safety Integrated (AP de sécurité) est activé ou désactivé, l'AP doit se trouver en
mode hors ligne.

7.27 Fonctions pour SINUMERIK ONE
L'exemple suivant montre comment appeler le service SafetyModeProvider :
Appeler SafetyModeProvider
...
Siemens.Engineering.HW.Device ncu = ...;
try
{
SafetyModeProvider provider = ncu.GetService<SafetyModeProvider>();
//Perform the safety mode change:
provider.SetSafetyMode(SafetyMode.DbSI);
}
catch( (EngineeringException ex) )
{
// Handle safety mode change failure
}
L'exemple suivant montre comment appeler le réglage Safety Integrated actuel sur l'appareil :
Appeler le réglage Safety de l'appareil

...
try
{
//Query the safety mode:
SafetyMode safetyMode = provider.CurrentMode;
}
{
// Handle any failure
}
7.27.1 Introduction
via TIA Portal.
que vous créez. Il est également possible de créer et utiliser des programmes pour l'application
TIA Portal "SINUMERIK".

Informations complémentaires
Avant de compiler un programme unique pour SINUMERIK à partir des exemples de codes
énumérés ci-dessous, prendre connaissances des informations générales sur Openness,
présentes dans cette aide sous les mots clés suivants :
7.27.2 Identification de l'identifiant des composants

Chaque composant SINUMERIK possède un numéro univoque, appelé Identifiant
(TypeIdentifier) . Cet identifiant peut être utilisé dans le code du programme Openness pour
identifier et nommer un composant de façon univoque. Par exemple, l'identifiant pour
SINUMERIK ONE NCU 1750 correspond à "N° d'article : 6FC5 317-5AA00-0Axx/Vy.z".
L'identifiant est visible lors de la création d'un appareil dans la boîte de dialogue "Ajouter nouvel
appareil", ainsi que dans le tableau de vue d'ensemble des appareils.
L'identifiant peut être copié dans l'application Openness.
L'identifiant est attendu dans Openness en tant que paramètre actuel lors de l'appel d'une
méthode, par exemple de la méthode CreateWithItem().
Activer l'affichage du TypeIdentifier dans SINUMERIK

1. Dans la vue du projet, sélectionner le menu "Outils > Réglages".
La zone de configuration "Réglages" s'ouvre.
2. Dans la navigation secondaire, sélectionner l'entrée "Configuration matérielle".
3. Activer l'option "Activer l'affichage du TypeIdentifier pour les appareils et les modules".
7.27.3 Notions de base

Les appareils SINUMERIK suivants peuvent être créés dans TIA Portal avec Openness :
● NCU
● Module NX
● PPU

Pour créer les appareils SINUMERIK, la méthode CreateWithItem() de la collection

Devices est utilisée.
Remarque
Tous les sous-composants intégrés d'une NCU SINUMERIK tels qu'AP, NCK, CP, HMI et
SINAMICS Integrated sont créés automatiquement et imbriqués au même niveau.
Particularités lors de la création des appareils SINUMERIK

Les noms des châssis correspondent aux types de NCU et sont protégés en écriture dans
l'interface utilisateur. Les désignations des châssis doivent également être utilisées dans TIA
Portal Openness. Utiliser les noms standard de châssis ci-dessous lors de la création d'un
appareil au moyen d'un identifiant d'élément d'appareil avec la méthode :Device
CreateWithItem
Appareil SINUMERIK Noms standard de châssis

SINUMERIK ONE NCU 1750 NCU 1750
SINUMERIK ONE NCU 1760 NCU 1760
SINUMERIK ONE PPU 1740 PPU 1740
Remarque
Les noms de paramètre peuvent être omis. Lorsque le nom est "null" ou "String.Empty", le nom
standard est utilisé.
Les paramètres suivants peuvent être utilisés avec la méthode CreateWithItem() :

● default name, p. ex. project.Devices.CreateWithItem("OrderNumber:6FC5
317-5AA00-0AA0/V6.13", "NCU 1750", "TestDevice");
● null, p. ex. project.Devices.CreateWithItem("OrderNumber:6FC5
317-5AA00-0AA0/V6.13", null, "TestDevice");
● string.Empty, p. ex. project.Devices.CreateWithItem("OrderNumber:6FC5
317-5AA00-0AA0/V6.13", string.Empty, "TestDevice");
Plus d'informations sur les paramètres d'appel de la méthode CreateWithItem(), voir
chapitre "Création d'un appareil".
Le tableau suivant présente la correspondance des appareils et de leurs identifiants :
Appareil SINUMERIK Identifiant

SINUMERIK ONE NCU 1750 N° d'article : 6FC5 317-5AA00-0Axx/Vy.z
SINUMERIK ONE NCU 1760 N° d'article : 6FC5 317-6AA00-0Axx/Vy.z
SINUMERIK ONE PPU 1740 N° d'article : 6FC5 317-4AA00-1xxx/Vy.z
Il est possible d'utiliser des caractères génériques dans l'identifiant lors de la création des
appareils SINUMERIK. Les caractères génériques doivent être remplacés ultérieurement par
des caractères spécifiques à l'appareil.

Classification de l'élément de l'appareil

Chaque appareil ou élément de l'appareil possède des attributs obligatoires qui sont lus et
écrits. Plus d'informations concernant les attributs pris en charge par Openness, voir chapitre
"Fonctions sur les éléments de l'appareil".
Les attributs de classification des éléments de l'appareil sont protégés en écriture et ne sont
pas affichés dans l'interface utilisateur de TIA Portal.
Les attributs de classification ont la valeur "DeviceItemClassification" :
Valeur de l'attribut de classification Description

DeviceItemClassifications.None (0) Aucune classification.
DeviceItemClassifications.CPU (1) L'élément de l'appareil est une CPU.
DeviceItemClassifications.HM (2) L'élément de l'appareil est un module de tête.
Lorsque la valeur de cet élément de l'appareil est interrogée via l'AP intégré, la valeur "CPU (1)"
est retournée pour un appareil SINUMERIK.
Dans le modèle d'objets d'Openness, les composants suivants ont la fonction de module de
tête :
● SINAMICS Integrated
● Module NX
Dans tous les autres cas, la valeur de l'attribut de classification "DeviceItemClassification" est
"None" (0).

Les exemples suivants illustrent comment trouver les éléments de l'appareil ayant la propriété
"Module de tête" avant de configurer un télégramme par exemple.
Cette propriété n'est accessible qu'en lecture. Elle ne peut pas être spécifiée pour un élément
de l'appareil.
Trouver Sinamics Integrated / NX avec la propriété "Module de tête"

{
{
{
// do something
}
}
}

L'exemple de code ci-dessous peut également être utilisé pour trouver un AP indépendamment
de la réalisation concrète (AP SINUMERIK, AP SIMATIC, AP logiciel intégrés au PC) sur la
base de la propriété "CPU" :
Trouver des AP
Device ncuDevice = ...
DeviceItem plc = GetPlc(ncuDevice.DeviceItems);
...
DeviceItem GetPlc(DeviceItemComposition deviceItems)
{
if (deviceItems.Count == 0)
{
return null;
}
foreach (var deviceItem in deviceItems)
{
if (deviceItem.Classification == DeviceItemClassifications.CPU)
return deviceItem;
DeviceItem plc = GetPlc(deviceItem.DeviceItems);

if (plc != null)
return plc;
}
return null;
} 　
Voir aussi
Créer une NCU (Page 695)
Création d'un module NX (Page 695)

7.27.4 Modèle d'objet
Vue d'ensemble
Le diagramme ci-dessous donne une description des objets sous "Device" dans
SINUMERIK ONE :
'HYLFH
5DFN'HYLFH,WHP
6,1$0,&6,QWHJUDWHG3UR[\'HYLFH,WHP
3/&'HYLFH,WHP
&DUGUHDGHUZULWHU'HYLFH,WHP
23&8$'HYLFH,WHP
31,(3RUW'HYLFH,WHP
31,(3RUW'HYLFH,WHP
31,(3RUW'HYLFH,WHP
'3,QWHUIDFH'HYLFH,WHP
1&.'HYLFH,WHP
'3,QWHJUDWHG,QWHUIDFH'HYLFH,WHP
&3'HYLFH,WHP
31,(3RUW'HYLFH,WHP
31,(3RUW'HYLFH,WHP
31,(3RUW'HYLFH,WHP
+0,'HYLFH,WHP
Pour plus d'informations sur le modèle d'objet Openness TIA Portal, voir "TIA Portal Openness
API".

Namespaces disponibles pour la configuration des télégrammes

Les Namespaces suivants sont valides dans SINUMERIK Openness pour les interfaces de
configuration des télégrammes :
Namespace Assembly
Siemens.Engineering.MC.Drive Siemens.Engineering.MC.DriveConfiguration
Configuration (Page 679) dans Siemens.Engineering.dll
Siemens.Engineering.MC.Drive Siemens.Engineering.MC.Drives
s (Page 685) dans Siemens.Engineering.dll
Remarque
Le Namespace Siemens.Engineering.MC.DriveConfiguration met à disposition des
fonctions supplémentaires, comme la création et la suppression d'objets entraînement ou la
modification de leur ordre.
À long terme, le Namespace Siemens.Engineering.MC.DriveConfiguration est
conservé. Toutefois, pour des raisons de compatibilité, le
Namespace Siemens.Engineering.MC.Drives continuera à être pris en charge dans les
prochaines versions Openness.
Le diagramme ci-dessous donne une description des objets sous "Device" dans le Namespace
Siemens.Engineering.MC.Drives dans SINUMERIK NX 10.3/15.3 :
'HYLFH
5DFN'HYLFH,WHP
'ULYH2EMHFW&RQWDLQHU6HUYLFH
Le diagramme ci-dessous donne une description des objets sous "Device" dans les
Namespaces Siemens.Engineering.MC.Drives et
Siemens.Engineering.MC.DriveConfiguration dans SINUMERIK NX 10.3/15.3 :
'HYLFH
5DFN'HYLFH,WHP
'ULYH2EMHFW&ROOHFWLRQ6HUYLFH

7.27.5 Référence
7.27.5.1 Namespace Siemens.Engineering.MC.DriveConfiguration
DriveObject
DriveObject
Namespace : Siemens.Engineering.MC.DriveConfiguration
Assembly : Siemens.Engineering.MC.DriveConfiguration

d'accès
Telegram TelegramComposi read - Renvoie une liste des télégrammes
s tion disponibles de l'objet entraînement.
Parent IEngineeringObj read - Renvoie la référence à la classe de
ect niveau supérieur
(DriveObjectCollection
et DriveObjectContainer).
Category read - Renvoie la référence à la classe de
niveau supérieur
(DriveObjectCategory).
Name read - Renvoie le nom de l'objet entraîne‐
ment.
Nom Description
GetAttributes Accède en lecture à tous les attributs d'un objet entraînement
GetAttributeInfos Accède en lecture aux informations sur les attributs d'un objet entraînement
SetAttributes Accède en écriture à tous les attributs d'un objet entraînement
Delete Supprime l'instance d'objet entraînement au cours de laquelle "Delete" est
appelé

DriveObjectCollection
Le DriveObjectCollection est un service de l'objet entraînement (DeviceItem) de
Le tableau suivant décrit les navigateurs de DriveObjectCollection :

cès
aux télégrammes.
Nom Description
GetAttribute Accède en lecture à un attribut de DriveObjectCollection
GetAttributes Accède en lecture à tous les attributs de DriveObjectCollection
GetAttributeInfos Accède en lecture aux informations sur les attributs
de DriveObjectCollection
SetAttribute Accède en écriture à un attribut de DriveObjectCollection
SetAttributes Accède en écriture à tous les attributs de DriveObjectCollection
objet entraînement et contient tous les objets entraînement d'une NCU ou d'un module NX.


d'accès
Parent IEngineeringObject read - Renvoie la référence à la
classe
de niveau supérieur
(DriveObjectContainer)
.
Count read -
IsReadOnly read -
Nom Description
Contains Détermine si l'instance spécifiée est présente dans l'ensemble des éléments.
TRUE : Le conteneur contient l'instance. FALSE : Le conteneur ne contient
pas l'instance
IndexOf Renvoie l'indice dans l'ensemble des éléments pour l'instance demandée.
Create Crée une classe DriveObjectComposition
Find Recherche une classe DriveObjectComposition
DriveObjectCategory
DriveObjectCategory
L'Enum DriveObjectCategory contient des catégories prédéfinies d'objets entraînement.
Un accès en lecture à DriveObjectCategory est possible.
Le tableau suivant contient les catégories prédéfinies d'objets entraînement :
Objets entraînement pris en charge DriveObjectCategory

dans SINUMERIK
SinumerikDriveAxis SERVO, ENC, HLA, TM41
SinumerikControlUnit CU_I, CU_NX_CX
SinumerikInfeed A_INF, B_INF, S_INF

TelegramComposition
TelegramComposition
La classe TelegramComposition permet d'accéder aux télégrammes d'un objet
entraînement (DriveObject (Page 679)). La structure d'un télégramme peut être lue via la
classe Telegram (Page 683).
Toute modification apportée aux objets télégramme (p. ex. changement du télégramme Safety)
peut entraîner la suppression de l'objet télégramme correspondant et la création d'un nouvel
objet télégramme dans TelegramComposition. Dans ce cas, parcourir de nouveau
TelegramComposition pour retrouver le nouvel objet télégramme (Page 683) après la
modification.
Lorsque le type d'objet entraînement en question ne prend en charge aucun télégramme, la
valeur renvoyée de TelegramComposition est vide.

d'accès
Parent IEngineeringObject read - Renvoie la référence à la
classe
de niveau supérieur
(DriveObject).
Count read -
IsReadOnly read -
Nom Description
Create(enum TelegramId Id) Crée un télégramme, le type de télégramme cor‐
respond à l'ID.
int IndexOf(TelegramType) Renvoie l'indice dans l'ensemble des éléments
pour l'instance demandée.
bool Contains Détermine si l'instance spécifiée est présente
dans l'ensemble des éléments.
TRUE: Le conteneur contient l'instance
FALSE: Le conteneur ne contient pas l'instance
Contains Détermine si l'instance spécifiée est présente
dans l'ensemble des éléments. TRUE : Le conte‐
neur contient l'instance. FALSE : Le conteneur ne
contient pas l'instance
IEnumerator GetEnumerator IEnumerator<DriveObject> permet l'itéra‐
tion sur l'ensemble des éléments présents

Telegram
Telegram
La classe Telegram permet d'accéder à la structure d'un télégramme d'un objet entraînement.
Nom Type de don‐ Mode d'accès Ac‐ Description

nées cès
Id Int32 read - Renvoie l'ID du télégramme.
Type enum:Tele‐ read - Renvoie le type du télégramme sous la
gramType forme Enum TelegramType.
(Page 684)
Addresses AddressCom‐ read - Renvoie une AdressComposition
position (Pa‐ avec des informations sur l'adresse.
ge 692)
Nom Description
GetSize(AddressIoType (Pa‐ Renvoie la taille des entrées ou des sorties du télégramme.
ge 693))
CanChangeSize(AddressIoType (Pa‐ Renvoie true si la taille du télégramme peut être modifiée
ge 693), Int32, bool) comme elle a été paramétrée. Les télégrammes standard
peuvent uniquement être agrandis.
La conservation de l'adresse de télégramme actuelle est pri‐
se en compte si l'option est paramétrée avec true.
CanSetSize (AddressIoType (Pa‐ Renvoie true si la taille du télégramme peut être modifiée
ge 693) Int32, bool) comme elle a été paramétrée.
SetSize Accède en écriture à la taille du télégramme
Delete Supprime l'instance de télégramme au cours de laquelle
"Delete" est appelé
GetAttribute Accède en lecture à un attribut de télégramme
GetAttributes Accède en lecture à tous les attributs de télégramme
GetAttributeInfos Accède en lecture aux informations relatives aux attributs de
télégramme
SetAttribute Accède en écriture à un attribut de télégramme
SetAttributes Accède en écriture à tous les attributs de télégramme

Propriétés des télégrammes Safety

Le tableau suivant décrit les Propriétés additionnelles de la classe "Telegram" du type
"SafetyTelegram" :
Nom Type de Mode Accès Description

données d'accès
Failsafe_FSourceAddress UInt32 read Dynami‐ Adresse source PROFIsafe
que
Failsafe_FDestinationAddress UInt32 read/ Dynami‐ Adresse cible PROFIsafe
write que
Failsafe_FIODBNumber UInt32 read/ Dynami‐ Numéro DB Safety, accès en écriture uni‐
write que quement possible lorsque la valeur "1" est
affectée à la propriété
"Failsafe_ManualAssignmentFIODB
Number"
Failsafe_FIODBName string read Dynami‐ Nom DB Safety
que
Failsafe_ManualAssignmentFIODBNu bool read/ Dynami‐ Réglage pour l'affectation manuelle de la
mber write que propriété "Failsafe_FIODBNumber"
Failsafe_FMonitoringtime UInt32 read/ Dynami‐ Délai de timeout Safety, accès en écriture
write que uniquement possible lorsque la propriété
"Failsafe_ManualAssignmentFMoni
toringtime" contient la valeur "true"
Failsafe_ManualAssignmentFMonito bool read/ Dynami‐ Réglage pour l'affectation manuelle de la
ringtime write que propriété
"Failsafe_FMonitoringtime"
L'accès aux autres propriétés s'effectue avec GetAttribute et SetAttribute p. ex.

GetAttribute("Failsafe_FSourceAddress"). La valeur de retour attendue est du type
Uint32.
TelegramType
TelegramType
Enum TelegramType contient des types de télégrammes prédéfinis.
Nom Description
MainTelegram Télégramme principal : p. ex. télégramme 136
SupplementaryTelegram Télégramme additionnel : p. ex. télégramme 701
AdditionalTelegram Extension : télégramme libre
SafetyTelegram Télégramme Safety : p. ex. télégramme 903

Remarque
Le télégramme de couple (TorqueTelegram) n'est pas pris en charge bien qu'il soit
disponible dans l'AP TIA Portal Openness dans le contexte de SINUMERIK.
TelegramId
TelegramId
L'Enum TelegramId contient les numéros de télégramme pertinents pour la communication
entre l'AP et l'entraînement. Les ID sont définis à l'aide de la norme PROFIdrive.
7.27.5.2 Namespace Siemens.Engineering.MC.Drives
DriveObject
DriveObject

d'accès
Telegram TelegramCompos read - Renvoie une liste des télégrammes
s ition disponibles de l'objet entraînement.
Parent IEngineeringOb read - Renvoie la référence à la classe de
ject niveau supérieur
(DriveObjectContainer)).

Nom Description
Voir aussi
TelegramComposition (Page 687)

cès
aux télégrammes.
Le DriveObjectCollection est un service de l'objet entraînement (DeviceItem) de

Le tableau suivant décrit les navigateurs de DriveObjectCollection :

cès
aux télégrammes.
objet entraînement.

cès
IndexOf int32 read - Renvoie l'indice dans l'en‐
semble des éléments pour
l'instance demandée.
Contains bool read - Détermine si l'instance spéci‐
fiée est présente dans l'en‐
semble des éléments.
TRUE: Le conteneur contient
l'instance
FALSE: Le conteneur ne con‐
tient pas l'instance
GetEnumerator IEnumerator<Dr read - Permet l'itération sur l'ensem‐
iveObject> ble des éléments présents
TelegramComposition
TelegramComposition
entraînement (DriveObject (Page 685)). La structure d'un télégramme peut être lue via la
classe Telegram (Page 689).

Toute modification apportée aux objets télégramme (p. ex. changement du télégramme Safety)
peut entraîner la suppression de l'objet télégramme correspondant et la création d'un nouvel
objet télégramme dans TelegramComposition. Dans ce cas, parcourir de nouveau
TelegramComposition pour retrouver le nouvel objet télégramme (Page 689) après la
modification.
Nom Description
CanInsertAdditionalTelegram(Int32, Renvoie true si une extension peut être géné‐
Int32) rée conformément aux tailles paramétrées (tail‐
les d'entrée et de sortie).
InsertAdditionalTelegram(Int32, Int32) Génère, pour l'objet entraînement, une exten‐
sion conformément aux tailles paramétrées et
renvoie true si l'extension a pu être insérée.
En cas d'erreur,
une
EngineeringTargetInvocationExcepti
on est générée.
CanInsertSupplementaryTelegram(Int32) Renvoie true si un télégramme supplémentai‐
re peut être généré conformément au numéro
de télégramme paramétré.
InsertSupplementaryTelegram(Int32) Crée le télégramme additionnel avec le numéro
de télégramme paramétré et renvoie true, si le
télégramme a pu être ajouté.
En cas d'erreur,
une
on est générée.
CanInsertSafetyTelegram(Int32) Renvoie true lorsqu'un télégramme Safety
peut être créé en fonction du numéro de télé‐
gramme paramétré.
InsertSafetyTelegram(Int32) Crée le télégramme additionnel avec le numéro
de télégramme paramétré et renvoie true, si le
télégramme a pu être ajouté.
En cas d'erreur,
une
on est générée.
EraseTelegram(TelegramType) Renvoie true si le télégramme paramétré a pu
être supprimé.
Les télégrammes standard ne peuvent pas être
supprimés.
En cas d'erreur,
une
on est générée.

Nom Description
Find(TelegramType) Renvoie l'objet Telegram (Page 689) s'il a pu
être trouvé via le type de télégramme paramétré.
null si le télégramme n'est pas trouvé.
Exemple
Telegram telegram =
telegrams.Find(TelegramType.MainTe
legram);
int IndexOf(TelegramType) Renvoie l'indice dans l'ensemble des éléments
pour l'instance demandée.
Parent Renvoie la référence à la classe de niveau su‐
périeur (DriveObject).
bool Contains Détermine si l'instance spécifiée est présente
dans l'ensemble des éléments.
TRUE: Le conteneur contient l'instance
FALSE: Le conteneur ne contient pas l'instance
IEnumerator GetEnumerator IEnumerator<DriveObject> permet l'itéra‐
tion sur l'ensemble des éléments présents
Telegram
Telegram
Nom Type de don‐ Mode d'accès Ac‐ Description

nées cès
TelegramNumbe Int32 read - Renvoie le numéro du télégramme prin‐
r cipal ou définit ce numéro.
Un télégramme libre porte le numéro
999.
Type enum:Tele‐ read - Renvoie le type du télégramme sous la
gramType forme Enum TelegramType.
(Page 691)
Addresses AddressCom‐ read - Renvoie une AdressComposition
position (Pa‐ avec des informations sur l'adresse.
ge 692)

Nom Description
CanChangeTelegram(Int32) Renvoie true si le télégramme peut être modifié dans le type
standard paramétré.
GetSize(AddressIoType (Pa‐ Renvoie la taille des entrées ou des sorties du télégramme.
ge 693))
ChangeSize(AddressIoType (Pa‐ Renvoie true si la taille du télégramme a pu être modifiée
ge 693), Int32, bool) comme elle a été paramétrée.
Propriétés des télégrammes Safety

Le tableau suivant décrit les Propriétés additionnelles de la classe "Telegram" du type
"SafetyTelegram" :

don‐ d'accès
nées
Failsafe_FSourceAddress UInt32 read Accès possible uni‐ Adresse source
quement PROFIsafe
via
GetAttribute
ou SetAttribute
Failsafe_FDestinationAddre UInt32 read/ Accès possible uni‐ Adresse cible PROFI‐
ss write quement safe
via
GetAttribute
ou SetAttribute
Failsafe_FIODBNumber UInt32 read/ Accès possible uni‐ Numéro DB Safety,
write quement accès en écriture uni‐
via quement possible
GetAttribute lorsque la valeur "1"
ou SetAttribute est affectée à la pro‐
priété
"Failsafe_Manual
AssignmentFIODB
Number"
Failsafe_FIODBName string read Accès possible uni‐ Nom DB Safety
quement
via
GetAttribute
ou SetAttribute


don‐ d'accès
nées
Failsafe_ManualAssignmentF bool read/ Accès possible uni‐ Réglage pour l'affec‐
IODBNumber write quement tation manuelle de la
via propriété
GetAttribute "Failsafe_FIODBN
ou SetAttribute umber"
Failsafe_FMonitoringtime UInt32 read/ Accès possible uni‐ Délai de timeout Sa‐
write quement fety, accès en écritu‐
via re uniquement pos‐
GetAttribute sible lorsque la pro‐
ou SetAttribute priété
"Failsafe_Manual
AssignmentFMoni
toringtime" con‐
tient la valeur "true"
Failsafe_ManualAssignmentF bool read/ Accès possible uni‐ Réglage pour l'affec‐
Monitoringtime write quement tation manuelle de la
via propriété
GetAttribute "Failsafe_FMonit
ou SetAttribute oringtime"
L'accès aux autres propriétés s'effectue avec GetAttribute et SetAttribute p. ex.

GetAttribute("Failsafe_FSourceAddress"). La valeur de retour attendue est du type
Uint32.
TelegramType
TelegramType
Nom Description
MainTelegram Télégramme principal : p. ex. télégramme 136
SupplementaryTelegram Télégramme additionnel : p. ex. télégramme 701
AdditionalTelegram Extension : télégramme libre
SafetyTelegram Télégramme Safety : p. ex. télégramme 903
Remarque
Le télégramme de couple (TorqueTelegram) n'est pas pris en charge bien qu'il soit
disponible dans l'AP TIA Portal Openness dans le contexte de SINUMERIK.

AddressComposition
AddressComposition

d'accès
IoType enum: AddressIo read - Renvoie des informations sur le
Type type de l'adresse.
Context enum: read Accès pos‐ Renvoie des informations sur le
AddressContext sible uni‐ contexte de l'adresse.
quement
via
GetAttri
bute
ou
SetAttri
bute
StartAddres Int32 read/ - Renvoie ou détermine l'adresse
s write de début du télégramme.
Length Int32 read - Renvoie la longueur du télégram‐
me.
IndexOf int32 read - Renvoie l'indice dans l'ensemble
des éléments pour l'instance de‐
mandée.
Contains bool read - Détermine si l'instance spécifiée
est présente dans l'ensemble des
éléments.
TRUE: Le conteneur contient l'ins‐
tance
FALSE: Le conteneur ne contient
pas l'instance
GetEnumerat IEnumerator<DriveO read - Permet l'itération sur l'ensemble
or bject> des éléments présents
Remarque
Pour renaviguer vers le télégramme via Address.Parent, appeler à la place du
Namespace Siemens.Engineering.MC.Drives.Telegram le
Namespace Siemens.Engineering.MC.DriveConfiguration.Telegram.
standard".

Voir aussi
AddressIoType (Page 693)
AddressContext (Page 693)
AddressContext
AddressContext
Nom Description
standard".
AddressIoType
AddressIoType
Nom Description
standard".

7.27.5.3 ArchiveProvider
ArchiveProvider
La classe ArchiveProvider sert à générer les archives AP.
Namespace : Siemens.Engineering.HW.Utilities
Assembly : Siemens.Engineering.HW.Utilities
Le tableau suivant décrit les méthodes de la classe ArchiveProvider :
Nom Paramètres Descrip‐

tion
Archive DeviceItem plc Crée une
FileInfo path archive
AP
Siemens.Engineering.MC.Sinumerik.SinumerikA
rchivationMode
String comment (en option)
String author (en option)
Remarque
Si Safety est activé, aucune archive ne peut être créée avec Openness.
7.27.6 Exemple de code
7.27.6.2 Réalisation de la mise en route dans SINUMERIK

● Connecter l'application TIA Portal Openness à TIA Portal.
● Ouvrir le projet.
L'exemple suivant montre comment déterminer quelle version de SINUMERIK Toolbox est
installée.



if (tiaProcess.InstalledSoftware.Any(sw => sw.Name.Equals("SINUMERK Toolbox") &&
sw.Version.Equals("V16")))
{
Console.WriteLine("SINUMERIK Toolbox is available");
}
// "V16" is the current SINUMERIK version started at December 2019.
7.27.6.3 Créer une NCU

La méthode CreateWithItem() de la Devices Collection permet de créer une NCU
SINUMERIK. Les NCU SINUMERIK sont spécifiées à l'aide des paramètres de la méthode. Le
format des paramètres est décrit ci-après.
Créer une NCU

Format des paramètres pour les NCU SINUMERIK :
CreateWithItem(@"OrderNumber:mlfb/FirmwareVersion/",
"StandardSubrackName", "NameOfTheDevice")
L'exemple suivant montre la création d'une commande SINUMERIK ONE NCU 1750.
Créer une SINUMERIK ONE NCU 1750

Device NCUDevice = tiaproject.Devices.CreateWithItem("@OrderNumber:6FC5

317-5AA00-0AA0/6.13/", "NCU 1750", "TestDevice");
7.27.6.4 Création d'un module NX

La méthode Device CreateWithItem permet de créer un module NX. Le module NX est
ensuite connecté à une NCU.
Les identifiants suivants sont utilisés pour les modules NX SINUMERIK :
Module NX SINUMERIK Identifiant

SINUMERIK NX10.3 OrderNumber:6SL3 040-1NC00-0Axx/Vy.z
SINUMERIK NX15.3 OrderNumber:6SL3 040-1NB00-0Axx/Vy.z
L'exemple suivant illustre la création d'un module NX SINUMERIK.
Créer un module NX
project.Devices.CreateWithItem("OrderNumber:6SL3040-1NC00-0AA0/
V5.2", "MyNXDevice", "TestDevice");
Compatibilité des versions

La version de firmware du module NX doit être identique à la version de firmware de SINAMICS
Integrated et doit être compatible avec la version de firmware de la NCU.

Une version de firmware NX différente de celle de SINAMICS Integrated ne peut pas être
affectée via Openness.
Le tableau suivant présente les compatibilités de version pour SINUMERIK ONE :
Firmware NCU (SINUMERIK ONE) Firmware SINAMICS Integrated / NX

V6.13 V5.2
7.27.6.5 Connexion du module NX avec une NCU
Connexion du module NX avec une NCU

Pour connecter un module NX à une NCU avec le type de sous-réseau
"ProfibusIntegrated", le service "NetworkInterface" doit être chargé avec le module
de tête de NX.
L'exemple suivant illustre le chargement du service "NetworkInterface".
Chargement du service NetworkInterface

{
{
{
var networkInterface = deviceItem.GetService<NetworkInterface>();
// do something
}
}
}
L'exemple suivant illustre la connexion d'un module NX à une NCU avec

"ProfibusIntegrated" :
Connexion du module NX à une NCU avec ProfibusIntegrated

Subnet pbiSubnet = ...;
Node node = networkInterface.Nodes.FirstOrDefault();
node.ConnectToSubnet(pbiSubnet);
L'adresse DP est affectée au NX fixe dans Openness par le port DRIVE-CLiQ. Chaque
étiquette de port dispose d'une adresse DP Integrated fixe.
L'adresse DP doit être affectée au NX avant la connexion à la NCU.
7.27.6.6 Accès aux événements du NCK
Événements du NCK
Le module NCK est un DeviceItem selon le modèle d'objet SINUMERIK (Page 677).

Les attributs suivants du module NCK permettent d'accéder aux événements du NCK et de
configurer les événements du NCK dans TIA Portal Openness :
Nom Type de données Mode Description

d'accès
Boolean r/w Activation/désactivation de
HardwareInterruptNckToPlcSignalExch l'événement
angeActive
String r/w Nom d'événement
HardwareInterruptNckToPlcSignalExch
angeEventName
r/w L'OB affecté à l'événement
HardwareInterruptNckToPlcSignalExch Siemens.Engineering.SW
angeInterrupt .Blocks.OB
Int32 r/w Priorité des événements
HardwareInterruptNckToPlcSignalExch
angePriority
Tous les événements du NCK sont déclenchés via HardwareInterrupt (OB d'alarme de
process). Les OB d'alarme de process interrompent l'exécution cyclique du programme en
raison d'un événement matériel.
L'exemple suivant montre comment déterminer le nom d'événement pour le module NCK :
Déterminer le nom d'événement pour le module NCK

DeviceItem nck = ...;
string eventName =
(string)nck.GetAttribute("HardwareInterruptNckToPlcSignalExchangeEventName");
L'exemple suivant montre comment définir le HardwareInterrupt :
Définir le HardwareInterrupt
... DeviceItem nck = ...;
OB ob40 = ... try
{
nck.SetAttribute("HardwareInterruptNckToPlcSignalExchangeInterrupt", ob40);
}
{
// Handle setting failure
}

7.27.6.7 Création d'archives
Création d'archives pour la mise en service de série

TIA Portal Openness permet de créer et d'exporter des archives SINUMERIK, p. ex. pour
simplifier la mise en service de série.
Remarque
Pendant la création des archives, l'AP doit se trouver en mode hors ligne. Le mode Safety ne
doit pas être actif.
Les archives SINUMERIK sont créées via la propriété de projet TIA Portal HwUtilities avec
le service SinumerikArchiveProvider.
L'exemple suivant montre comment appeler le service SinumerikArchiveProvider :
Appeler SinumerikArchiveProvider
SinumerikArchiveProvider archiveProvider =
project.HwUtilities.Find("SinumerikArchiveProvider") as SinumerikArchiveProvider;
if (archiveProvider != null)
{
// Work with the provider
}
L'exemple suivant montre comment créer une archive AP contenant les informations sur le
matériel et tous les blocs de données :
Créer une archive AP

...
Siemens.Engineering.HW.DeviceItem plc = ...;
try {
string archivePath = string.Format(@"D:\some_path\{0}.dsf", plc.Name);
// Comment and author arguments are optional

archiveProvider.Archive(plc, new FileInfo(archivePath),
SinumerikArchivationMode.HardwareAndAllProgramBlocks[, "Comment", "Author name"]);
}
catch (EngineeringTargetInvocationException ex)
{
// Handle archive failure
}

L'exemple suivant montre comment mettre à jour des composantes logicielles d'une archive
AP déjà créée :
Mettre à jour des composantes d'archive

...
Siemens.Engineering.HW.DeviceItem plc_1 = ...;
Siemens.Engineering.HW.DeviceItem plc_1_copy = ...;
try {
string archivePath = @"D:\some_path\SinumerikArchive.dsf";
// Create a Sinumerik archive with HardwareAndAllProgramBlocks

archiveProvider.Export(plc_1, new FileInfo(archivePath),
SinumerikArchivationMode.HardwareAndAllProgramBlocks);
// Update the software part in the previously created archive using

UpdateProgramBlocksOfArchive method
archiveProvider.UpdateProgramBlocksOfArchive(plc_1_copy, new FileInfo(archivePath));
}
catch (EngineeringException ex)
{
// Handle export failure
}
7.27.6.8 Activation de Safety Integrated
Activation de Safety Integrated

TIA Portal Openness permet d'activer Safety Integrated (AP de sécurité) dans les propriétés de
la NCU.
Remarque
Incidences sur la configuration des télégrammes
Le mode Safety Integrated utilisé a des incidences sur la configuration des télégrammes, étant
donné que le mode Safety Integrated plus (AP de sécurité) utilise d'autres télégrammes que
ceux utilisés lorsque le mode Safety Integrated est inactif.
Les télégrammes ajoutés ou modifiés sont toutefois conservés dès lors qu'ils sont compatibles
avec le mode Safety Integrated nouvellement sélectionné.
Après le changement de mode, s'assurer le cas échéant que les adaptations éventuelles sont
encore présentes dans la configuration des télégrammes.
Safety Integrated (AP de sécurité) est activé et désactivé avec le service

SafetyModeProvider.
Remarque
Lorsque Safety Integrated (AP de sécurité) est activé ou désactivé, l'AP doit se trouver en
mode hors ligne.

L'exemple suivant montre comment appeler le service SafetyModeProvider :
Appeler SafetyModeProvider
...
try
{
//Perform the safety mode change:
provider.SetSafetyMode(SafetyMode.DbSI);
}
{
// Handle safety mode change failure
}
L'exemple suivant montre comment appeler le réglage Safety Integrated actuel sur l'appareil :
Appeler le réglage Safety de l'appareil

...
try
{
//Query the safety mode:
SafetyMode safetyMode = provider.CurrentMode;
}
{
// Handle any failure
}
7.27.6.9 Exemples de Namespace Siemens.Engineering.MC.DriveConfiguration
Préparation des télégrammes

La communication de l'entraînement d'une NCU SINUMERIK s'effectue, à l'aide de
télégrammes, via le sous-composant SINAMICS Integrated et, le cas échéant, via des modules
NX connectés en plus.
Remarque
La NCU SINUMERIK et un SINAMICS Integrated se situent sur le même niveau dans le modèle
d'objet TIA Portal Openness et apparaissent comme deux appareils distincts sous
"DeviceComposition".
Utiliser "DriveObjectCollection" pour configurer un télégramme.

"DriveObjectCollection" est un service de l'objet entraînement (élément de l'appareil) du
module de tête actuel (élément de l'appareil).

Pour démarrer le service "DriveObjectCollection", naviguer vers SINAMICS Integrated

ou vers le module de tête du module NX. La hiérarchie des appareils et éléments de l'appareil
est identique pour SINAMICS Integrated et le modules NX.
L'exemple suivant montre comment trouver le service "DriveObjectCollection" avec la
propriété "Module de tête" :
Trouver DriveObjectCollection avec un module de tête

{
{
{
var driveObjectCollection = deviceItem.GetService<DriveObjectCollection>();
// do something
}
}
}
La NCU SINUMERIK contient un objet proxy SINAMICS Integrated avec des références à
SINAMICS Integrated.
Pour accéder à un appareil SINAMICS Integrated ou un module NX, naviguer depuis la NCU
SINUMERIK via le NCK vers l'interface DP Integrated. Déterminer ensuite le système maître
PROFIBUS et naviguer vers l'esclave connecté.
Insertion et suppression de télégrammes

L'exemple suivant montre comment insérer un télégramme. Pour l'accès, un objet
entraînement est nécessaire.
Les ID permettent de faire la distinction entre les types de télégramme.
Insérer un télégramme et accéder aux attributs de télégramme

using Siemens.Engineering.MC.DriveConfiguration;


TelegramComposition telegrams = drvObj.Telegrams;
//Create telegram
const int tgrmId = 136;
drvObj.Telegrams.CreateTelegram(tgrmId);
//Create safety telegram

drvObj.Telegrams.CreateTelegram(tgrmId);
// Get and set safety telegram attributes

uint watchDogTime =
(uint)safetyTgrm.GetAttribute("Failsafe_FMonitoringtime");
safetyTgrm.SetAttribute("Failsafe_FMonitoringtime", 300);
const int newSafetyTelegramNumber= 902;

if (safetyTgrm.CanChangeTelegram(newSafetyTelegramId)) {
safetyTgrm.TelegramId = newSafetyTelegramId; }
L'exemple suivant montre comment supprimer un télégramme.
Supprimer un télégramme
//Delete telegram
drvObj.Telegrams.DeleteTelegram(tgrmId);
Insertion et suppression des télégrammes Safety

L'exemple suivant montre comment insérer un télégramme Safety. Pour l'accès, un objet
Insérer un télégramme Safety et accéder aux attributs de télégramme



//Add safety telegram

drvObj.Telegrams.Create(tgrmId);

uint Failsafe_FDestinationAddress =
(uint)safetyTelegram.GetAttribute("Failsafe_FDestinationAddress");
uint Failsafe_FSourceAddress =
(uint)safetyTelegram.GetAttribute("Failsafe_FSourceAddress");
uint Failsafe_FIODBNumber = (uint)safetyTelegram.GetAttribute("Failsafe_FIODBNumber");
string Failsafe_FIODBName = safetyTelegram.GetAttribute("Failsafe_FIODBName").ToString();
uint Failsafe_FMonitoringtime =
(uint)safetyTelegram.GetAttribute("Failsafe_FMonitoringtime");
uint Failsafe_ManualAssignmentFIODBNumber =
(uint)safetyTelegram.GetAttribute("Failsafe_ManualAssignmentFIODBNumber");
bool Failsafe_ManualAssignmentFMonitoringtime =
(bool)safetyTelegram.GetAttribute("Failsafe_ManualAssignmentFMonitoringtime");
// Set safety telegram attributes

safetyTelegram.SetAttribute("Failsafe_ManualAssignmentFIODBNumber", 1);
safetyTelegram.SetAttribute("Failsafe_ManualAssignmentFMonitoringtime", true);
safetyTelegram.SetAttribute("Failsafe_FIODBNumber", 40000);
safetyTelegram.SetAttribute("Failsafe_FMonitoringtime", 200);
safetyTelegram.SetAttribute("Failsafe_FDestinationAddress", 15);
const int newSafetyTelegramId= 900;

if (safetyTgrm.CanChangeTelegram(newSafetyTelegramId)) {
safetyTgrm.TelegramId = newSafetyTelegramId; }
L'exemple suivant montre comment supprimer un télégramme Safety.
Supprimer un télégramme Safety

//Remove Safety telegram
drvObj.Telegrams.DeleteTelegram(TelegramType.SafetyTelegram);
Extension de télégrammes
L'exemple suivant montre comment insérer une extension et modifier la taille d'un télégramme
standard. Pour l'accès, un objet entraînement est nécessaire.
Insérer une extension et modifier la taille d'un télégramme standard



Telegram telegram = telegrams.Find(TelegramType.MainTelegram);
Console.WriteLine("The Cu has the telegram: " + telegram.TelegramId);

Console.WriteLine("The Setpoint channel-specific size of the telegram is: "
+ telegram.GetOutputSize());
foreach (var address in telegram.Addresses)

{
if (address.IoType == AddressIoType.Output)
{
Console.WriteLine("The Setpoint channel-specific IO start address of
the telegram on the connected PLC is: " + address.StartAddress);
}
else if(address.IoType == AddressIoType.Input)
{
Console.WriteLine("The Actual value channel-specific IO start address
of the telegram on the connected PLC is: " + address.StartAddress);
}
}
// Create an additional telegram

if (drvObj.Telegrams.CreateAdditionalTelegram(2,4))
{
drvObj.Telegrams.CreateAdditionalTelegram(2,4);
}
// Add a 3 word extension to the main telegram

Telegram mainTelegram == drvObj.Telegrams.Find(TelegramType.MainTelegram);
Int32 newSize = mainTelegram.GetSize(AddressIoType.Input) + 3;
if (mainTelegram.CanChangeSize(AddressIoType.Input, newSize, true))
{
mainTelegram.ChangeSize(AddressIoType.Input, newSize, true)
}
7.27.6.10 Exemples de Namespace Siemens.Engineering.MC.Drives
Préparation des télégrammes

La communication de l'entraînement d'une NCU SINUMERIK s'effectue, à l'aide de
télégrammes, via le sous-composant SINAMICS Integrated et, le cas échéant, via des modules
NX connectés en plus.
Remarque
La NCU SINUMERIK et un SINAMICS Integrated se situent sur le même niveau dans le modèle
d'objet TIA Portal Openness et apparaissent comme deux appareils distincts sous
"DeviceComposition".
Utiliser "DriveObjectContainer" pour configurer un télégramme.

"DriveObjectContainer" est un service de l'objet entraînement (élément de l'appareil) du
module de tête actuel (élément de l'appareil).

Pour démarrer le service "DriveObjectContainer", naviguer vers SINAMICS Integrated ou

vers le module de tête du module NX. La hiérarchie des appareils et éléments de l'appareil est
identique pour SINAMICS Integrated et le modules NX.
L'exemple suivant montre comment trouver le service "DriveObjectContainer" avec la
propriété "Module de tête" :
Trouver DriveObjectContainer avec un module de tête

{
{
{
// do something
}
}
}
La NCU SINUMERIK contient un objet proxy SINAMICS Integrated avec des références à
SINAMICS Integrated.
Pour accéder à un appareil SINAMICS Integrated ou un module NX, naviguer depuis la NCU
SINUMERIK via le NCK vers l'interface DP Integrated. Déterminer ensuite le système maître
PROFIBUS et naviguer vers l'esclave connecté.
Insertion et suppression de télégrammes

L'exemple suivant montre comment insérer un télégramme. Pour l'accès, un objet

using Siemens.Engineering.MC.Drives;


//Add telegram
const int tgrmNumber = 136;
drvObj.Telegrams.InsertTelegram(tgrmNumber);
//Find telegram
Telegram telegram = drvObj.Telegrams.Find(TelegramType.MainTelegram);
/Add safety telegram

drvObj.Telegrams.InsertSafetyTelegram(tgrmNumber);
//Find safety telegram

Telegram safetyTgrm = drvObj.Telegrams.Find(TelegramType.SafetyTelegram);

uint watchDogTime =
(uint)safetyTgrm.GetAttribute("Failsafe_FMonitoringtime");

if (safetyTgrm.CanChangeTelegram(newSafetyTelegramNumber)) {
safetyTgrm.TelegramNumber = newSafetyTelegramNumber; }
//Add supplementary telegram

drvObj.Telegrams.InsertSupplementaryTelegram(tgrmNumber);
Telegram telegram =
drvObj.Telegrams.Find(TelegramType.SupplementaryTelegram);
L'exemple suivant montre comment supprimer un télégramme.
Supprimer un télégramme
//Remove safety telegram
drvObj.Telegrams.EraseTelegram(TelegramType.SafetyTelegram);
//Remove supplementary telegram

drvObj.Telegrams.EraseTelegram(TelegramType.SupplementaryTelegram);
Remarque
Un télégramme principal (MainTelegram) peut être modifié, mais pas supprimé.

Travailler avec des télégrammes Safety

L'exemple suivant montre comment insérer un télégramme Safety. Pour l'accès, un objet




uint Failsafe_FDestinationAddress =
(uint)safetyTelegram.GetAttribute("Failsafe_FDestinationAddress");
uint Failsafe_FSourceAddress =
(uint)safetyTelegram.GetAttribute("Failsafe_FSourceAddress");
uint Failsafe_FIODBNumber = (uint)safetyTelegram.GetAttribute("Failsafe_FIODBNumber");
string Failsafe_FIODBName = safetyTelegram.GetAttribute("Failsafe_FIODBName").ToString();
uint Failsafe_FMonitoringtime =
(uint)safetyTelegram.GetAttribute("Failsafe_FMonitoringtime");
uint Failsafe_ManualAssignmentFIODBNumber =
(uint)safetyTelegram.GetAttribute("Failsafe_ManualAssignmentFIODBNumber");
bool Failsafe_ManualAssignmentFMonitoringtime =
(bool)safetyTelegram.GetAttribute("Failsafe_ManualAssignmentFMonitoringtime");
// Set safety telegram attributes

safetyTelegram.SetAttribute("Failsafe_ManualAssignmentFIODBNumber", 1);
safetyTelegram.SetAttribute("Failsafe_ManualAssignmentFMonitoringtime", true);
safetyTelegram.SetAttribute("Failsafe_FIODBNumber", 40000);
safetyTelegram.SetAttribute("Failsafe_FMonitoringtime", 200);
safetyTelegram.SetAttribute("Failsafe_FDestinationAddress", 15);

if (safetyTgrm.CanChangeTelegram(newSafetyTelegramNumber)) {
safetyTgrm.TelegramNumber = newSafetyTelegramNumber; }
L'exemple suivant montre comment supprimer un télégramme Safety.
Supprimer un télégramme Safety

Extension de télégrammes


7.28 Fonctions pour Startdrive

Console.WriteLine("The Cu has the telegram: " + telegram.TelegramNumber);


{
{
Console.WriteLine("The Setpoint channel-specific IO start address of
the telegram on the connected PLC is: " + address.StartAddress);
}
{
Console.WriteLine("The Actual value channel-specific IO start address
of the telegram on the connected PLC is: " + address.StartAddress);
}
}
// Add an additional telegram

if (drvObj.Telegrams.CanInsertAdditionalTelegram(2,4))
{
drvObj.Telegrams.InsertAdditionalTelegram(2,4);
}

{
}
7.28.1 Introduction
via TIA Portal.
que vous créez. Vous pouvez également créer et utiliser des programmes pour l'application
TIA Portal "Startdrive".

Avant de créer votre propre programme à partir des exemples de code répertoriés ci-après
pour Startdrive, prenez connaissance des informations globales sur Openness qui sont
disponibles sous les mots-clés suivants dans cette aide :
7.28.2 TypeIdentifier - Identifiant des composants

Chaque variante d'un composant Startdrive possède un numéro univoque, appelé
TypeIdentifier . Dans le code du programme Openness, vous pouvez utiliser le TypeIdentifier
afin d'identifier et de nommer un composant de manière univoque.
Dans Startdrive, l'affichage du TypeIdentifier est facultatif et désactivé par défaut.
Activer l'affichage du TypeIdentifier dans Startdrive

1. Dans la vue du projet Startdrive, sélectionnez le menu "Outils > Paramètres".
La zone de configuration "Paramètres" s'ouvre.
2. Dans la navigation secondaire, sélectionnez l'entrée "Configuration matérielle".
3. Activez l'option "Activer l'affichage du TypeIdentifier pour les appareils et les modules".
Lire le TypeIdentifier dans Startdrive

Le TypeIdentifier peut être lu aux emplacements suivants dans un projet Startdrive avec
l'affichage activé :
● Pour tous les composants (dans la fenêtre d'inspection) :
● Pour les Control Units (lors de la création d'un groupe d'entraînement)
Pour lire le TypeIdentifier d'un composant dans la fenêtre d'inspection, procédez comme suit :
1. Dans la vue des appareils du projet Startdrive, double-cliquez sur le composant souhaité.
La fenêtre d'inspection s'ouvre. La variante active du composant est affichée dans la liste.
2. Le TypeIdentifier correspondant est indiqué dans la colonne située tout à droite.
Exemple : OrderNumber:6SL3131-7TE23-6Axx
Copiez ce TypeIdentifier dans votre application Openness.

Pour lire le TypeIdentifier d'une Control Unit dans la fenêtre d'inspection, procédez comme
suit :
1. Dans la navigation du projet Startdrive, double-cliquez sur "Ajouter nouvel appareil".
La boîte de dialogue de même nom s'ouvre.
2. Sélectionnez le module de régulation souhaité dans la liste.
Le TypeIdentifier est maintenant affiché à droite dans la vue de détail (sous le numéro
d'article et le numéro de firmware) pour la Control Unit correspondante.
Exemple : OrderNumber:6SL3040-1MA01-0Axx/V5.2/S120
3. Copiez ce TypeIdentifier dans votre application Openness.
7.28.3 Références
7.28.3.1 AddressComposition
AddressComposition
Le tableau suivant décrit la syntaxe de la classe :
public sealed class AddressComposition
Nom Type de données Description

IoType AddressIoType (Pa‐ Renvoie des informations sur le type de l'adresse.
ge 711)
Context AddressContext Renvoie des informations sur le contexte de l'adresse.
(Page 711)
StartAddress Int32 Renvoie l'adresse de début du télégramme ou définit cette
adresse.
Length Int32 Renvoie la longueur du télégramme.
Voir aussi
TelegramType (Page 724)

7.28.3.2 AddressContext
AddressContext
public enum AddressContext
Nom Description
7.28.3.3 AddressIoType
AddressIoType
public enum AddressIoType
Nom Description

7.28.3.4 ConfigurationEntry
ConfigurationEntry
La classe ConfigurationEntry sert à l'enregistrement des données de paramétrage, qui
peuvent être déterminées d'après les ConfigurationEntryCompositions d'une
configuration de moteur ou de codeur.

EnumValueList IDictionary<it, Renvoie une liste des valeurs possibles du paramètre
string> enum.
MaxValue object Valeur maximale de ConfigurationEntry.
MinValue object Valeur minimale de ConfigurationEntry.
Name string Nom de ConfigurationEntry.
Number int Représentation numérique du nom
de ConfigurationEntry.
Description string Description de ConfigurationEntry.
Parent IEngineeringObjec Élément parent Engineering Object Model de cet objet.
t
Unit string Unité de ConfigurationEntry.
Value object Valeur de ConfigurationEntry.
7.28.3.5 DriveDomainFunctions
DriveDomainFunctions
La classe DriveDomainFunctions sert à la restauration des réglages d'usine ou à la
sauvegarde du contenu de la RAM vers la ROM.
Elle ne peut être appliquée qu'à un objet OnlineDriveFunctionInterface.
Pour les entraînements G120, il est possible d'accéder à l'objet DriveDomainFunctions
uniquement lorsque le Power Module est câblé avec l'appareil. Sinon, null ou une exception est
renvoyé.
Nom Description
PerformFactoryReset Cette méthode permet la restauration des réglages d'usine.
PerformRAMtoROMCopyAllDriveObject Les données de tous les objets entraînement sont écrites de la RAM sur la
carte mémoire/le disque dur.

Parent IEngineeringObject Élément parent Engineering Object Model de cet objet.

7.28.3.6 DriveObject
DriveObject
La classe DriveObject permet l'accès à l'objet entraînement. L'objet entraînement permet
par ex. d'accéder aux paramètres d'entraînement ou au télégramme.
public sealed class DriveObject

Parameters DriveParameter‐ Renvoie une liste des paramètres disponibles de l'objet en‐
Composition (Pa‐ traînement.
ge 716)
Telegrams TelegramCompo‐ Renvoie une liste des télégrammes disponibles de l'objet
sition (Page 723) entraînement.
La liste peut être modifiée avec la
Voir aussi
Déterminer un objet entraînement (Page 728)
7.28.3.7 DriveObjectActivation
DriveObjectActivation
La classe DriveObjectActivation sert à l'activation des modules ou à la détermination de
l'état du module. Elle peut être appliquée à DriveObjectFunctions
de DriveFunctionInterface ou OnlineDriveFunctionInterface.
Nom Description
ChangeActivationState(DriveObjectAc Modifie l'état d'activation de l'objet entraînement. Renvoie false lorsque
tivationState) l'opération ne peut pas être achevée.
Valeurs d'état possibles :
● Deactivate
● Activate
● DeactivateAndNotPresent


ActivationState DriveObjectActivation Renvoie la valeur d'état actuelle.
State
IsActive Boolean Renvoie true lorsque l'objet entraînement est actif.
7.28.3.8 DriveObjectContainer

DriveObjects DriveObjectCom‐ Renvoie une liste des objets entraînement disponibles. Les
position (Pa‐ objets entraînement permettent d'accéder aux paramètres
ge 716) d'entraînement et aux télégrammes.
7.28.3.9 DriveObjectTypeHandler
DriveObjectTypeHandler
La classe DriveObjectTypeHandler sert à la commutation du type d'objet entraînement
pour chaque objet entraînement et à la détermination du type d'objet entraînement ainsi que de
tous les types d'objet entraînement possibles de l'objet entraînement actuel. Elle ne peut être
appliquée qu'à DriveFunctionInterface.
Nom Description
ChangeDriveObjectType((target)Drive Modifie le type actuel de l'objet entraînement sur un nouveau type sélec‐
ObjectType) tionnable.
Renvoie false lorsque l'opération ne peut pas être achevée.

PossibleDriveObjectTypes DriveObjectTypeCompos L'utilisation de targetDriveObjectType aboutit à
ition une exception sur l'objet entraînement actuel.
CurrentDriveObjectType DriveObjectType Affiche le type d'objet entraînement actuellement affec‐
té.

7.28.3.10 DriveParameter
DriveParameter
La classe DriveParameter permet l'accès à un paramètre d'entraînement. Tous les
paramètres de l'entraînement ne sont pas accessibles via Openness.
public sealed class DriveParameter

ArrayIndex Int32 Renvoie l'indice d'un paramètre de tableau.
Plage de valeurs : 0-7FFF
Pour les paramètres sans tableau, l'indice est -1
Exemple
p108[4].15
par.ArrayIndex donne 4
ArrayLength Int32 Renvoie le nombre d'éléments du tableau.
Pour les paramètres sans tableau, la valeur est 0
Bits DriveParameter‐ Renvoie un objet DriveParameter pour un bit du paramè‐
Composition (Pa‐ tre.
ge 716) Il est ainsi possible de lire, par exemple, la valeur ou le nom
d'un paramètre de bit.
Exemple
DriveParameter param133 =
cu.Parameters.Find(133, 0);
DriveParameter param133Bit1 =
param133.Bits[1];
String paramName = param133Bit1.Name;
EnumValueList IDictionary enum.
Par ex. <1, [1] Quick commissioning>
null si le paramètre n'est pas de type Enum.
MaxValue Object Renvoie la valeur maximale pour l'unité actuellement sélec‐
tionnée.
MinValue Object Renvoie la valeur minimale pour l'unité actuellement sélec‐
tionnée.
Name string Renvoie le nom du paramètre. Par ex. "p108[0].2"
ParameterText string Renvoie le texte de la description succinte du paramètre.


Number Int32 Renvoie le numéro du paramètre.
Exemple
p108[0].2
La valeur de retour est 108
Unit string Renvoie l'unité du paramètre sous forme de texte.
Value Object Renvoie la valeur hors ligne/en ligne du paramètre ou écrit
une valeur pour le paramètre.
En cas d'erreur d'écriture,
une EngineeringTargetInvocationException est
déclenchée.
Exemples
● P2080Bit6.Value = 0;
● P2080Bit6.Value =
cu.Parameters.Find("r19");
Source FCOM
Le paramètre d'une source FCOM ne peut qu'être lu
Puits de signal FCOM
Les valeurs possibles sont 0, 1 ou un
objet DriveParameter.
Un objet DriveParameter est renvoyé lorsque le puits de
signal FCOM est lié à un autre paramètre.
Voir aussi l'exemple Lire et écrire des paramètres FCOM
(Page 729).
Voir aussi
Lire et écrire des paramètres (Page 745)
7.28.3.11 DriveParameterComposition
DriveParameterComposition
La classe DriveParameterComposition permet d'accéder aux paramètres de
l'entraînement. Tous les paramètres de l'entraînement ne sont pas accessibles via Openness.
public sealed class DriveParameterComposition

Nom Description
Find(string) Renvoie l'objet DriveParameter (Page 715) recherché via le
nom.
null si le paramètre n'est pas trouvé
Exemple
Find("P108[1]");
Find(UInt16, Int32) Renvoie l'objet DriveParameter (Page 715) recherché via
l'indice de paramètre et de tableau.
null si le paramètre n'est pas trouvé
Exemples
● cu.Find(108, 1);
● cu.Find(51, -1);
WriteParameters(IEnumerable<s Écrit les valeurs dans les paramètres.
tring>, IEnumerable<string>, Avec le réglage ignoreErrors = true, le système tente,
bool) en cas d'erreur, d'écrire toutes les valeurs, puis il déclenche
une EngineeringTargetInvocationException.
Pour les entraînements SINAMICS G, les valeurs de para‐
mètres ne peuvent être écrites que lorsqu'un Power Module
(PM) est configuré.
Exemple
List<string> names = new List<string>();
List<string> values = new List<string>();
names.add("p300[0])");
values.add("17");
names.add("p5391[0])");
values.add("20");
cu.WriteParameters(names, values, true);
7.28.3.12 EncoderConfiguration
EncoderConfiguration
La classe EncoderConfiguration enregistre les données de capteurs (codeurs) non
Siemens.
● L'objet ConfigurationEntryComposition doit être rempli par l'utilisateur.
● L'objet RequiredConfigurationEntries doit également être rempli.
Siemens.Engineering.MC.Drives.DFI
Siemens.Engineering.MC.Drives.Enum


RequiredConfiguration ConfigurationEntr Entrées de configuration accessibles de la
Entries yComposition configuration de moteur.
Parent IEngineeringObjec Élément parent Engineering Object Model de
t cet objet.
7.28.3.13 HardwareProjection
La classe HardwareProjection sert à la mise en service du moteur et du capteur. L'objet
peut se trouver dans DriveFunctionInterface et OnlineDriveFunctionInterface.
Pour les entraînements G120, la configuration peut être effectuée aussi bien en ligne qu'hors
ligne pour les moteurs et les capteurs. Pour les entraînements S120, la configuration n'est en
revanche possible qu'hors ligne.
Pour les groupes d'entraînement G120, il n'est possible d'accéder à l'objet
HardwareProjection que lorsque le Power Module est inséré dans le groupe
d'entraînement. Sinon, lors de l'appel des fonctions HardwareProjection, null ou une
exception est renvoyé.
Lors d'une configuration hors ligne, utilisez la configuration matérielle de
DriveFunctionInterface. Lors d'une configuration en ligne, utilisez la configuration
matérielle de OnlineDriveFunctionInterface.
Siemens.Engineering.MC.Drives.Enums
Nom Description
SetMotorType(MotorType type, Règle le type de moteur sur la Control Unit (uniquement pour
ushort driveDataSet) G120).
GetCurrentMotorConfiguration( Détermine la plage de configuration actuellement existante
ushort driveDataSet) en fonction du numéro d'enregistrement de l'entraînement.
ProjectMotorConfiguration(Mot Définit la configuration de moteur d'un groupe d'entraîne‐
orConfiguration motConfig, ment en fonction du numéro d'enregistrement de l'entraîne‐
ushort driveDataSet) ment.
SetEncoder(EncoderType type, Règle le capteur (codeur) sur la Control Unit (uniquement
EncoderInterface pour G120).
interfaceType,
AbsoluteIncrementalFlag
absIncFlag, RotaryLinearFlag
rotLinFlag, ushort
encDataSet)

Nom Description
GetCurrentEncoderConfiguratio Détermine la plage de configuration actuellement existante
n(ushort encDataSet) en fonction du numéro d'enregistrement du capteur.
ProjectEncoderConfiguration(E Définit la configuration de moteur d'un groupe d'entraîne‐
ncoderConfiguration ment en fonction du numéro d'enregistrement du capteur
encConfig, ushort encDataSet) (codeur).

Parent IEngineeringObject Élément parent Engineering Object Model de
cet objet.
7.28.3.14 MotorConfiguration
MotorConfiguration
La classe MotorConfiguration sert à la mise en service des moteurs et des capteurs.
Siemens.Engineering.MC.Drives.Enums
Comportement avec des moteurs Siemens :

Pour régler le type de moteur, l'action SetMotortype doit être appelée. Cette action se
compose d'un Enum MotorType et d'un numéro qui représente DriveDatasetNumber.
Le tableau suivant décrit les Enums :
Nom de l'Enum Description

NoMotor 0 : No motor
InductionMotor 1 : Induction motor
SynchronousMotor 2 : Synchronous motor
NoCodeNumber1LE1InductionMoto 10 : 1LE1 induction motor (not a code number)
r
NoCodeNumber1LG6InductionMoto 13 : 1LG6 induction motor (not a code number)
r
NoCodeNumber1xx1SIMOTICSFDInd 14 : 1xx1 SIMOTICS FD induction motor (not a code number)
uctionMotor
NoCodeNumber1LA7InductionMoto 17 : 1LA7 induction motor (not a code number)
rNoCodeNumber
MotorSeriesNumber1LA81PQ8Stan 18 : 1LA8 / 1PQ8 standard induction motor series
dardInduction
NoCodeNumber1LA9InductionMoto 19 : 1LA9 induction motor (not a code number)
r

Comportement avec des moteurs non Siemens :

La classe MotorConfiguration est utilisée pour la sauvegarde des paramètres moteur des
moteurs non Siemens. Elle contient 2 objets ConfigurationEntryComposition qui
doivent être remplis par les données correspondantes du moteur lors de la mise en service.
L'objet RequiredConfigurationEntries doit également être rempli. L'objet
OptionalConfigurationEntries ne doit pas obligatoirement être rempli.

RequiredConfigurat ConfigurationEntryC Entrées de configuration accessibles de cette
ionEntries omposition configuration de moteur.
OptionalConfigurat ConfigurationEntryC Entrées de configuration accessibles de cette
ionEntries omposition configuration de moteur.
Parent IEngineeringObject Élément parent Engineering Object Model de
cet objet.
7.28.3.15 OnlineDriveObject
OnlineDriveObject
La classe OnlineDriveObject permet l'accès en ligne à l'objet entraînement. L'objet
entraînement permet d'accéder aux paramètres d'entraînement.
public sealed class OnlineDriveObject

Parameters DriveParameter‐ Renvoie une liste des paramètres disponibles de l'objet en‐
Composition (Pa‐ traînement en ligne.
ge 716) null si le mode est "Hors ligne".
En mode hors ligne, l'appel d'une méthode ou l'accès en
écriture à un paramètre déclenche une exception.
Voir aussi
Déterminer un objet entraînement (Page 728)
Lire et écrire des paramètres (Page 745)
Lire et écrire des paramètres en ligne (Page 747)

7.28.3.16 OnlineDriveObjectContainer
OnlineDriveObjectContainer
Le OnlineDriveObjectContainer est un service de l'objet entraînement (DeviceItem)
de l'appareil actuel (Device).
Le tableau suivant décrit les navigateurs du OnlineDriveObjectContainer :

OnlineDriveObj OnlineDriveOb Renvoie une liste des objets entraînement en ligne disponi‐
ects jectCompositi bles (OnlineDriveObject (Page 720)). Les objets entraîne‐
on ment permettent d'accéder aux paramètres d'entraînement.
7.28.3.17 StartDriveDownloadCheckConfiguration
StartDriveDownloadCheckConfiguration
La classe StartDriveDownloadCheckConfiguration est dérivée de la
classe DownloadCheckConfiguration et a les mêmes propriétés. La
classe DownloadCheckConfiguration est décrite dans l'aide Openness standard.
Cette classe fournit à l'utilisateur les réglages de configuration via des case à cocher.

Checked bool Renvoie le réglage actuel de la configuration ou active/
désactive la configuration.
Voir aussi
Téléchargement (Page 730)
7.28.3.18 SafetyTelegram
SafetyTelegram
La classe SafetyTelegram correspond à un télégramme de l'objet entraînement. En cas
d'erreurs dans les attributs d'écriture,
l'exception EngineeringTargetInvocationException apparaît.


TelegramNumbe Int32 Numéro du télégramme principal. Les télégrammes libres
r sont identifiés par la valeur 999.
Type TelegramType (Pa‐ Le type de télégramme renvoyé en tant qu'Enum "Tele‐
ge 724) gramType".
Addresses AddressComposi‐ Composition de toutes les adresses d'un télégramme.
tion (Page 710)
PKW Telegram (Pa‐ Composition de tous les canaux PKW du télégramme.
ge 722) null si le télégramme ne comporte aucune partie PKW.
7.28.3.19 Telegram
Telegram
public sealed class Telegram

TelegramNumb Int32 Renvoie le numéro du télégramme principal ou définit ce nu‐
er méro.
Un télégramme libre porte le numéro 999.
Type TelegramType (Pa‐ Renvoie le type du télégramme sous la forme Enum
ge 724) TelegramType.
Addresses AddressComposi‐ Renvoie une AdressComposition avec des informations
tion (Page 710) sur l'adresse.
PKW Telegram Renvoie le canal PKW sous forme de Telegram.
null si la propriété n'est pas disponible
Un télégramme avec PKW est, par exemple, le télégramme
353.
Nom Description
CanChangeTelegram(Int32) Renvoie true si le télégramme peut être modifié dans le type
standard paramétré.
GetSize(AddressIoType (Page 711)) Renvoie la taille des entrées ou des sorties du télégramme.

Nom Description
ChangeSize(AddressIoType (Pa‐ Renvoie true si la taille du télégramme a pu être modifiée
ge 711), Int32, bool) comme elle a été paramétrée.
7.28.3.20 TelegramComposition
TelegramComposition
entraînement. La structure d'un télégramme peut être lue via la classe Telegram (Page 722).
Notez que la classe TelegramComposition peut invalider des objets référencés. Par ex.,
après modification de la taille du télégramme, l'objet Telegram (Page 722) devient invalide.
public sealed class TelegramComposition
Nom Description
CanInsertAdditionalTelegr Renvoie true si une extension peut être générée conformément
am(Int32, Int32) aux tailles paramétrées (tailles d'entrée et de sortie).
CanInsertTorqueTelegram Lors de l'ajout d'un nouveau télégramme Torque avec un numéro
(Int32, telegramNumber) de télégramme déjà existant, vérifie si cela est possible.
CanInsertSupplementaryTel Renvoie true si un télégramme supplémentaire peut être généré
egram(Int32) conformément au numéro de télégramme paramétré.
EraseTelegram(TelegramTyp Supprime un télégramme avec un type de télégramme connu de
e) l'objet entraînement.
Renvoie true si le télégramme paramétré a pu être supprimé.
Si un télégramme Torque est utilisé comme type, l'objet "torque‐
Telegram" est supprimé.
Si un télégramme Safety Integrated est utilisé comme type, l'objet
"safetyTelegram" est supprimé.
Les télégrammes standard ne peuvent pas être supprimés.
En cas d'erreur,
une EngineeringTargetInvocationException est déclen‐
chée.

Nom Description
Find(TelegramType) Renvoie l'objet Telegram (Page 722) s'il a pu être trouvé via le type
de télégramme ou le type de télégramme Safety Integrated para‐
métré.
null si le télégramme n'est pas trouvé.
Si un télégramme Torque est utilisé comme type,
l'objet torqueTelegram est renvoyé s'il existe.
Si un télégramme Safety Integrated est utilisé comme type, l'ob‐
jet safetyTelegram est renvoyé s'il existe.
Exemple
Telegram telegram =
telegrams.Find(TelegramType.MainTelegram);
InsertAdditionalTelegram( Génère, pour l'objet entraînement, une extension conformément
Int32, Int32) aux tailles paramétrées et revoie true si l'extension a pu être
insérée.
En cas d'erreur,
chée.
InsertTorqueTelegram Ajoute à un objet entraînement un nouveau télégramme Torque
(Int32, telegramNumber) avec un numéro de télégramme déjà existant.
InsertSafetyTelegram Ajoute un télégramme Safety Integrated avec son numéro de té‐
(Int32, telegramNumber) légramme par défaut à un objet entraînement.
InsertSupplementaryTelegr Génère le télégramme supplémentaire avec le numéro de télé‐
am(Int32) gramme paramétré et renvoie true si le télégramme a pu être
inséré.
En cas d'erreur,
chée.
7.28.3.21 TelegramType
TelegramType
public enum TelegramType

Nom Description
MainTelegram ID du télégramme principal
SupplementaryTelegram ID du télégramme supplémentaire
AdditionalTelegram ID d'une extension
7.28.3.22 TorqueTelegram
TorqueTelegram
La classe TorqueTelegram correspond à un télégramme de l'objet entraînement. En cas
d'erreurs dans les attributs d'écriture,
l'exception EngineeringTargetInvocationException apparaît.

TelegramNumbe Int32 Numéro du télégramme.
r
Type TelegramType (Pa‐ Le type de télégramme renvoyé en tant qu'Enum "Tele‐
ge 724) gramType".
Addresses AddressComposi‐ Composition de toutes les adresses d'un télégramme.
tion (Page 710)
PKW Telegram (Page 722) Composition de tous les canaux PKW du télégramme.
null si le télégramme ne comporte aucune partie PKW.
7.28.4 Exemples de code
7.28.4.1 Déterminer l'état d'activation

Les exemples suivants montrent comment déterminer l'état d'activation des entraînements
S120 en ligne ou hors ligne :
Déterminer l'état d'activation d'un entraînement S120 hors ligne


Déterminer l'état d'activation d'un entraînement S120 hors ligne

DriveFunctionInterface dfi = ...
DriveObjectActivation driveObjectActivation =
dfi.DriveObjectFunctions.DriveObjectActivation;
//driveObjectActivation can be null in case of the actual driveobject does not support
activation.
//change activation state

driveObjectActivation.ChangeActivationState(DriveObjectActivationState.Deactivate);
//get the activation state

DriveObjectActivationState activationState = driveObjectActivation.ActivationState;
//get the Is Active property

bool isActive = driveObjectActivation.IsActive;
Déterminer l'état d'activation d'un entraînement S120 en ligne

OnlineDriveFunctionInterface onlinedfi = ...
DriveObjectActivation driveObjectActivation = onlinedfi.DriveObjectActivation;
//driveObjectActivation can be null in case of the actual driveobject does not support
activation in online.
//change activation state

driveObjectActivation.ChangeActivationState(DriveObjectActivationState.Deactivate);
//get the activation state

DriveObjectActivationState activationState = driveObjectActivation.ActivationState;
//get the IsActive property

bool isActive = driveObjectActivation.IsActive;
7.28.4.2 Exécuter des fonctions d'entraînement

Les exemples suivants montrent comment accéder de manière simple hors ligne et en ligne
aux fonctions d'entraînement :
Exécuter des fonctions d'entraînement hors ligne

DriveObject driveObject = ...
DriveFunctionInterface dfi = driveObject.GetService<DriveFunctionInterface>();
// dfi can be null in case of the actual driveobject does not support it.
Exécuter des fonctions d'entraînement en ligne


Exécuter des fonctions d'entraînement en ligne

OnlineDriveObject onlineDriveObject = ...
OnlineDriveFunctionInterface onlineDfi =
onlineDriveObject.GetService<OnlineDriveFunctionInterface>();
// onlineDfi can be null in case of the actual onlineDriveObject

// does not support it or if the device is offline.
7.28.4.3 Créer un groupe d'entraînement

La méthode CreateWithItem() de la collection Devices permet de créer un groupe
d'entraînement.
Les groupes d'entraînement sont spécifiés via les paramètres de la méthode. Le format des
paramètres est décrit ci-après.
Créer un groupe d'entraînement G120

Format des paramètres pour G120 :
CreateWithItem(@"OrderNumber: mlfb / FirmwareVersion /",
"NameOfTheDevice", positionNumber)
L'exemple suivant montre comment créer un groupe d'entraînement G120.
Créer un groupe d'entraînement G120

Device s120Device =
tiaproject.Devices.CreateWithItem(@"OrderNumber:6SL3246-0BA22-1FA0/4.7.6/"
, "Device_0", null);
Créer un groupe d'entraînement S120, S150, MV, G130, G150

Format des paramètres pour S120, S150, MV, G130, G150 :
CreateWithItem(@"OrderNumber: mlfb / FirmwareVersion /
AdditionalTypeIdentifier", "NameOfTheDevice", positionNumber)
Valeurs possibles pour AdditionalTypeIdentifier :
● Chaîne vide (par ex. pour G120)
● S120
● S150
● MV
● G130
● G150

L'exemple suivant montre comment créer un groupe d'entraînement S120.
Créer un groupe d'entraînement S120

Device s120Device =
tiaproject.Devices.CreateWithItem(@"OrderNumber:6SL3040-1MA01-0Axx/V4.8/
S120", "Device_0", null);
7.28.4.4 Créer un composant d'entraînement

La méthode PlugNew() d'un objet Device permet de créer un composant d'entraînement
pour un groupe d'entraînement.
L'exemple suivant montre comment créer un composant d'entraînement.
Créer un Motor Module

DeviceItem subModul = sdrDevice.PlugNew(@"OrderNumber:6SL3xxx-xxxxx-xxxx",
"MotorModul", 65535);
7.28.4.5 Déterminer un objet entraînement

Les exemples suivants montrent comment déterminer des objets entraînement hors ligne et en
ligne.
Déterminer un objet entraînement hors ligne

//G device
Project project = portal.Projects.Open("..."); //Destination folder to
open the project
DeviceItem item = project.Devices[0].Items[0].Items[0];
DriveObject driveObject =
item.GetService<DriveObjectContainer>().DriveObjects[0];
//S device
open the project
DeviceItem item = project.Devices[0].Items[0];
DriveObject driveObject =
item.GetService<DriveObjectContainer>().DriveObjects[0];
Déterminer un objet entraînement en ligne


Déterminer un objet entraînement en ligne

//G device
open the project
DeviceItem item = project.Devices[0].Items[0].Items[0];
OnlineDriveObject onlineDriveObject =
item.GetService<OnlineDriveObjectContainer>().OnlineDriveObjects[0];
//S device
open the project
7.28.4.6 Déterminer le type d'objet entraînement

L'exemple suivant montre comment déterminer le type d'objet entraînement actuel et les autres
types réglables.
Déterminer les types d'objet entraînement

using Siemens.Engineering.MC.Drives.DFI;
DriveObjectTypeHandler driveObjectTypeHandler =
dfi.DriveObjectFunctions.DriveObjectTypeHandler;
// driveObjectTypeHandler can be null, if the actual driveObject does not support it.
// Get the possible drive object types on the drive object.

DriveObjectTypeComposition possibleDriveObjectTypes =
driveObjectTypeHandler.PossibleDriveObjectTypes;
// Get the current drive object type on the drive object.

DriveObjectType currentDriveObjectType = driveObjectTypeHandler.CurrentDriveObjectType;
//Call the ChangeDriveObjectType method with the current drive object type.
//The method parameter should be the target drive object type.
driveObjectTypeHandler.ChangeDriveObjectType(possibleDriveObjectTypes[0]);
7.28.4.7 Lire et écrire des paramètres FCOM

L'exemple suivant montre comment lire et écrire des valeurs de paramètres FCOM. Pour
l'accès, un objet entraînement est nécessaire.
Lire des paramètres FCOM


Lire des paramètres FCOM

DriveParameter bicoSink= driveObject.Parameters.Find("p681");
if(bicoSink!=null)
{
if(bicoSink.Value is DriveParameter)
{
DriveParamter bicoSourceValue = bicoSink.Value as DriveParameter;
Console.WriteLine("The value of parameter " + bicoSink.Name + ": " +
bicoSource.Name + " " + bicoSource.ParameterText);
}
else if (bicoSink.Value == null)
{
Console.WriteLine("Value contains an invalid connection or the source
parameter is not accessible via Openness");
}
else
{
Console.WriteLine("The value of parameter " + bicoSink.Name + ": " +
bicoSink.Value.ToString());
}
}
Écrire des paramètres FCOM

DriveParameter bicoSource= driveObject.Parameters.Find("r19");
DriveParameter bicoSink = driveObject.Parameters.Find("p738");
if(bicoSource != null)
{
try
{
bicoSink.Value = bicoSource;
}
catch(UserException ex)
{
Console.WriteLine("Write failure :" + ex.Message);
}
}
7.28.4.8 Téléchargement
Après le lancement du téléchargement, vous devez adapter ou confirmer les réglages de
configuration. Les réglages de configuration sont fournis en tant qu'objets enfants de
l'objet DownloadConfiguration et disponibles dans trois types distincts :
● StartDriveDownloadCheckConfiguration
● DownloadSelectionConfiguration
● DownloadPasswordConfiguration

L'exemple suivant montre l'évaluation des différents types de réglages de configuration dans
PreDownload Delegate.
Évaluation des réglages de configuration après lancement du téléchargement

using Siemens.Engineering.Online;
static void PreDownload(DownloadConfiguration configuration)
{
Console.WriteLine(configuration.Message);
StartDriveDownloadCheckConfiguration sdcc = configuration as
StartDriveDownloadCheckConfiguration;
if (sdcc != null)
{
sdcc.Checked = true;
return;
}
DownloadPasswordConfiguration downloadPasswordConfiguration =
configuration as DownloadPasswordConfiguration;
if (downloadPasswordConfiguration != null)
{
SecureString s = new SecureString();
string passwordText = "password";
foreach (var str in passwordText)
{
s.AppendChar(str);
}
downloadPasswordConfiguration.SetPassword(s);
return;
}
DownloadSelectionConfiguration downloadSelectionConfiguration =
configuration as DownloadSelectionConfiguration;
if (downloadSelectionConfiguration != null)
{
downloadSelectionConfiguration.SelectedIndex = 0;
return;
}
}
L'exemple suivant montre comment charger un projet dans l'appareil.
Téléchargement dans l'appareil S120

using Siemens.Engineering.Online;

Téléchargement dans l'appareil S120

try
{
DeviceItem item = ... //device item of the CU (e.g. :
project.Devices[0].Items[0].Items[0])
DownloadProvider downloadProvider = item.GetService<DownloadProvider>();
DownloadConfigurationDelegate pre = PreDownload;

DownloadConfigurationDelegate post = PostDownload;
ConnectionConfiguration connConfiguration =
downloadProvider.Configuration;
ConfigurationMode configurationMode = connConfiguration.Modes.Find("PN/
IE");
ConfigurationPcInterface pcInterface = configurationMode.PcInterfaces[0];
ConfigurationSubnet subnet = pcInterface.Subnets.Find(/*subnet name*/);
IConfiguration configuration = subnet.Addresses.Find(/*IP address of the
device*/);
downloadProvider.Download(configuration, pre, post,
}
catch (Exception e)
{
}
//configuration handling before download

static void PreDownload(DownloadConfiguration configuration)
{
StartDriveDownloadCheckConfiguration dcc = configuration as
StartDriveDownloadCheckConfiguration ;
if (dcc != null)
{
dcc.Checked = true;
}
}
//configuration handling after download

static void PostDownload(DownloadConfiguration configuration)
{
}
7.28.4.9 Éditer les connexions DRIVE-CLiQ

L'exemple suivant montre comment éditer les connexions DRIVE-CLiQ avec Openness.
Éditer les connexions DRIVE-CLiQ


Éditer les connexions DRIVE-CLiQ

Project tiaproject = portal.Projects.Open(new FileInfo(@"C:\Users\testUser
\Documents\Automation\Project109\Project109.ap15")); //The path of the
project
Device device =
tiaproject.Devices.CreateWithItem(@"OrderNumber:6SL3040-1MA01-0Axx/V4.8/
S120", "Device_0", null); //Create the device
DeviceItem subModul = device.PlugNew(@"OrderNumber:6SL3x2x-1xxxx-xxxx",

"", 65535); //Plug a submodul (in this case : Motor modul)
DeviceItem cu = device.DeviceItems[1]; // The CU is always the 1

indexed in the DeviceItems of the Device
DeviceItem subModulDQInterface = subModul.DeviceItems[0]; //We need

the DQ interface from the submodul
DeviceItem cuDQInterface = cu.DeviceItems[3]; //This is the
DQ interface of the CU
NetworkPort subModulDQ =
((IEngineeringServiceProvider)subModulDQInterface.DeviceItems[0]).GetServi
ce<NetworkPort>(); //We need the DriveCliq port of the DQ interface from
the submodul
NetworkPort cuDQ =
((IEngineeringServiceProvider)cuDQInterface.DeviceItems[0]).GetService<Net
workPort>(); //We need the DriveCliq port of the DQ interface
from the CU
cuDQ.DisconnectFromPort(subModulDQ); //Delete the connection between the

two ports (automatically created when plugging a modul)
cuDQ.ConnectToPort(subModulDQ); //Create a new connection
7.28.4.10 Exécuter la mise en route dans Startdrive

L'exemple suivant montre comment localiser ou générer un processus TIA Portal en cours.
Trouver ou générer un processus TIA Portal

// Get the list of the running TIA Portal processes.
IList<TiaPortalProcess> procs = TiaPortal.GetProcesses();
TiaPortal portal;
// When there is at least one running TIA Portal, we will attach to the first from the list.
if (procs.Count != 0)
{
portal = procs[0].Attach();
}
// When there is no running TIA Portal, we create one.
else
{
portal = new TiaPortal(TiaPortalMode.WithUserInterface);
}

L'exemple suivant montre comment localiser ou générer un projet Startdrive.
Trouver ou générer un projet Startdrive

Project project;
// When the portal has one project, we save it in a variable.
if (portal.Projects.Count == 1)
{
project = portal.Projects[0];
}
// When there is no existing project, we create one with a specific path, and the actual time
else
{
project = portal.Projects.Create(
new DirectoryInfo(@"C:\Projects\Project_" + DateTime.Now.Ticks),
DateTime.Now.Ticks.ToString());
}
L'exemple suivant montre comment déterminer si une variante spécifique de Startdrive

(package et version) est installée.
Déterminer si la version souhaitée de Startdrive est installée

if (tiaProcess.InstalledSoftware.Any(sw => sw.Name.Equals("SINAMICS Startdrive Advanced")
&& sw.Version.Equals("V15"))) { Console.WriteLine("Startdrive is available");}
// "V15" is the current startdrive version started at December 2017.
// "V15.1" will be the current startdrive version beginning with December 2018.
// "SINAMICS Startdrive Basic" and "SINAMICS Startdrive Advanced" are the 2 possible
startdrive function packages.
7.28.4.11 Définir le type de capteur

L'exemple suivant montre comment régler le type de capteur ou le numéro d'enregistrement du
capteur hors ligne.
Régler le type de capteur ou le numéro d'enregistrement du capteur hors ligne via la configuration matérielle
using Siemens.Engineering.MC.Drives
using Siemens.Engineering.MC.Drives.DFI
using Siemens.Engineering.MC.Drives.Enums;

Régler le type de capteur ou le numéro d'enregistrement du capteur hors ligne via la configuration matérielle
DeviceItem cuDeviceItem = m_Device.DeviceItems[1];
DriveObject cuDriveObject =
cuDeviceItem.GetService<DriveObjectContainer>().DriveObjects[0];
DriveFunctionInterface cuDriveFunctionInterface =
cuDriveObject.GetService<DriveFunctionInterface>();
HardwareProjection hardwareProjection = cuDriveFunctionInterface.HardwareProjection;
// To enable the setting of an EncoderType, the value of p96 should

// be set to 0 (Application class == [0] Expert) if it is present on
// the current G drive.
DriveParameter p96 = cuDriveObject.Parameters.Find("p96");
if (p96 != null)
{
p96.Value = 0;
}
// Setting Encoder 1 on the drive.

// In case of encoders, we have to set several enums to define an
// encoder type. These enums are: EncoderInterface, EncoderType,
// AbsoluteIncrementalFlag, and RotaryLinearFlag.
// There can be a problem, if the given enum combination is not valid.

// In that case, it has to give back a feedback.
hardwareProjection.SetEncoder(
EncoderInterface.Terminal,
EncoderType.HTLTTL,
AbsoluteIncrementalFlag.Incremental,
RotaryLinearFlag.Rotary,
1);
// It is possible to set 2 encoders to a motor, one with encoderNumber == 1

// and the other with encoderNumber == 2
L'exemple suivant montre comment régler le type de capteur ou le numéro d'enregistrement du

capteur avec une connexion en ligne.
Régler le type de capteur ou le numéro d'enregistrement du capteur en ligne via la configuration matérielle

Régler le type de capteur ou le numéro d'enregistrement du capteur en ligne via la configuration matérielle
OnlineDriveObject cuOnlineDriveObject =
cuDeviceItem.GetService<OnlineDriveObjectContainer>().OnlineDriveObjects[0];
OnlineDriveFunctionInterface cuDriveFunctionInterface =
cuOnlineDriveObject.GetService<OnlineDriveFunctionInterface>();
// To enable the setting of an Encoder, the value of p96 should

// be set to 0 (Application class == [0] Expert) if it is present
// the current G drive.
DriveParameter p96 = cuOnlineDriveObject.Parameters.Find("p96");
if (p96 != null)
{
p96.Value = 0;
}
// Setting Encoder 1 on the drive.

// In case of encoders we have to set several enums to define an
// encoder type. These enums are: EncoderInterface, EncoderType,
// AbsoluteIncrementalFlag, and RotaryLinearFlag.
// There can be a problem, if the given enum combination is not valid.

// In that case, it has to give back a feedback.
EncoderType.HTLTTL,
1);
// It is possible to set 2 encoders to a motor, one with encoderNumber == 1

// and the other with encoderNumber == 2

L'exemple suivant montre comment lire la configuration actuelle du capteur depuis

l'entraînement.
Lire la configuration du capteur

HardwareProjection encoderProjection = cuDriveFunctionInterface.HardwareProjection;
// Before setting an encoder, p96 should be 0

// (See section "Projecting EncoderConfiguration")
encoderProjection.SetEncoder(
EncoderType.HTLTTL,
1);
EncoderConfiguration encoderConfiguration =
encoderProjection.GetCurrentEncoderConfiguration(1);
L'exemple suivant montre comment définir hors ligne la configuration actuelle du capteur.
Configurer le capteur hors ligne


Configurer le capteur hors ligne

// Project encoder configuration in Offline state
// Before setting an encoder type, p96 should be 0

// To Project an EncoderConfiguration, first set e.g. Encoder 1 with .SetEncoder(...).
EncoderType.HTLTTL,
1);
// Get the current configuration of Encoder 1.

EncoderConfiguration config = hardwareProjection.GetCurrentEncoderConfiguration(1);
// Fill out Encoder 1's configuration values.

config.RequiredConfigurationEntries.ToList().ForEach(ce =>
{
switch (ce.Name)
{
case "p405.0":
ce.Value = 0;
break;
case "p405.1":
ce.Value = 1;
break;
case "p408":
ce.Value = 1024;
break;
case "p425":
ce.Value = 2048;
break;
default:
break;
}
});
// Project the Encoder 1 configuration to the device.

bool result =
cuDriveFunctionInterface.HardwareProjection.ProjectEncoderConfiguration(config, 1);

L'exemple suivant montre comment définir en ligne la configuration actuelle du capteur.
Configurer le capteur en ligne


Configurer le capteur en ligne

// Project encoder configuration in Online state
DeviceItem cuDeviceItemForOnline = m_Device.DeviceItems[0];
//You need the rack for going online on G120 Device, which is .DeviceItems[0]
// GoOnline...
// To use these function in Online, you have to use the OnlineDriveFunctionInterface
HardwareProjection hardwareProjection = onlineDfi.HardwareProjection;
// Before setting an encoder, p96 should be 0

// To Project an EncoderConfiguration, first set e.g. Encoder 1 with .SetEncoder(...).
EncoderType.HTLTTL,
1);
// Get the current configuration of Encoder 1.

EncoderConfiguration config = hardwareProjection.GetCurrentEncoderConfiguration(1);
// Fill out Encoder 1's configuration values.

{
switch (ce.Name)
{
case "p405.0":
ce.Value = 0;
break;
case "p405.1":
ce.Value = 1;
break;
case "p408":
ce.Value = 1024;
break;
case "p425":
ce.Value = 2048;
break;
default:
break;
}
});
// Project the Encoder 1 configuration to the device.

bool result = onlineDfi.HardwareProjection.ProjectEncoderConfiguration(config, 1);

L'exemple suivant montre comment écrire l'entrée de configuration dans la console.
Écrire l'entrée de configuration

MotorConfiguration motorConfig = hardwareProjection.GetCurrentMotorConfiguration(0);
foreach (var configurationEntry in motorConfig.RequiredConfigurationEntries)

{
Console.WriteLine(configurationEntry.Name);
}
EncoderConfiguration encConfig = hardwareProjection.GetCurrentEncoderConfiguration(1);
foreach (var configurationEntry in encConfig.RequiredConfigurationEntries)

{
Console.WriteLine(configurationEntry.Name);
}
7.28.4.12 Effectuer une configuration de l'appareil

L'exemple suivant montre comment effectuer hors ligne une configuration de l'appareil pour les
entraînements S120 et G120.
Effectuer une configuration de l'appareil hors ligne pour les groupes d'entraînement S120 ou G120
HardwareProjection hardwareProjection = dfi.HardwareProjection;
// hardwareProjection can be null, if the actual driveObject does not support it.
// For example: On G120 drives, you have to use the CU as driveobject. On S120
// drives, you have to use the MotorModul as driveObject.
L'exemple suivant montre comment effectuer en ligne une configuration de l'appareil pour les
entraînements G120.
Effectuer une configuration de l'appareil en ligne pour les groupes d'entraînement G120

// hardwareProjection can be null, if the actual onlineDriveObject
// does not support it.
// For example: On G120 drives, you have to use the CU as onlineDriveObject. On
// S120 drives, you have to use the MotorModul as onlineDriveObject.

7.28.4.13 Créer un composant pour un composant d'entraînement (uniquement S120)

Pour S120, il est possible de créer un composant sous un composant d'entraînement.
Pour distinguer les capteurs, indiquez en plus une désignation de type. Les désignations de
type possibles et les restrictions pour les capteurs (codeurs) sont répertoriées dans le tableau
ci-dessous.
L'exemple suivant montre comment créer un composant sous un composant d'entraînement.
Créer un moteur et un capteur sous un Motor Module

DeviceItem subModul = sdrDevice.PlugNew(@"OrderNumber:6SL3xxx-xxxxx-xxxx",
"MotorModul", 65535);
//Plug a motor to the motor modul

subModul.Container.PlugNew(@"OrderNumber:1PH2092-4WG4x-xxxx",
"Motor_1",65535);
//Plug an encoder to the motor modul

subModul.Container.PlugNew(@"OrderNumber:XExxxxx-xxxxx-xxxx//DRIVE-
CLIQ.202", "Encoder_1",65535);
Désignations de type pour les capteurs et restrictions

Lors de l'insertion de capteurs via Openness, les restrictions suivantes s'appliquent :
● Pour certains capteurs, il n'est possible de créer qu'un Sensor Module non spécifié lors de
l'insertion via Openness. Dans ce cas, vous devez configurer le type concret de Sensor
Module dans TIA Portal.
● Pour un Motor Module, il est possible d'insérer au maximum deux capteurs.
Le tableau suivant dresse la liste des désignations de type disponibles pour les capteurs.
DRIVE-CLiQ Resolver sin/cos SSI sin/cos+SSI HTL/TTL HTL/TTL EnDat 2.1

+SSI
DRIVE- Resolver.0 SIN_COS.0 SSI.0 SIN_COS_ HTL_TTL.0 HTL_TTL En‐
CLIQ.202 +_SSI.0 +SSI.0 Dat_2.1.2051
DRIVE- Resol‐ SIN_COS.20 SSI.3081 SIN_COS_ HTL_TTL.30 HTL_TTL En‐
CLIQ.204 ver.1001 01 +_SSI.2081 01 +SSI.3088 Dat_2.1.2052
DRIVE- Resol‐ SIN_COS.20 ‑ SIN_COS_ HTL_TTL.30 ‑ En‐
CLIQ.242 ver.1004 04 +_SSI.2084 05 Dat_2.1.2055
DRIVE- Resol‐ SIN_COS.20 ‑ SIN_COS_ HTL_TTL.30 ‑ En‐
CLIQ.244 ver.9999 05 +_SSI.9999 06 Dat_2.1.2151
DRIVE- ‑ SIN_COS.20 ‑ ‑ HTL_TTL.30 ‑ En‐
CLIQ.9999 06 07 Dat_2.1.9999
DRIVE- ‑ SIN_COS.20 ‑ ‑ HTL_TTL.30 ‑ En‐
CLIQ.10100 07 08 Dat_2.1.1010
0

DRIVE-CLiQ Resolver sin/cos SSI sin/cos+SSI HTL/TTL HTL/TTL EnDat 2.1

+SSI
‑ ‑ SIN_COS.20 ‑ ‑ HTL_TTL.30 ‑ ‑
08 09
‑ ‑ SIN_COS.20 ‑ ‑ HTL_TTL.30 ‑ ‑
10 11
‑ ‑ SIN_COS.20 ‑ ‑ HTL_TTL.30 ‑ ‑
12 20
‑ ‑ SIN_COS.20 ‑ ‑ HTL_TTL.31 ‑ ‑
13 09
‑ ‑ SIN_COS.21 ‑ ‑ HTL_TTL.99 ‑ ‑
10 99
‑ ‑ SIN_COS.21 ‑ ‑ ‑ ‑ ‑
11
‑ ‑ SIN_COS.21 ‑ ‑ ‑ ‑ ‑
12
‑ ‑ SIN_COS.99 ‑ ‑ ‑ ‑ ‑
99
7.28.4.14 Définir le type de moteur et la configuration de moteur

Les exemples suivants montrent comment régler le type de moteur pour les entraînements
G120 via la configuration de l'appareil :
Régler le type de moteur hors ligne via la configuration matérielle

//Offline (Only on G120 drives)
DriveFunctionInterface dfi = ...
// hardwareProjection can be null in case of the actual driveObject

// does not support activation.
// Setting the required MotorType and DriveDataSetNumber on the drive.
// It is only supported on G120 drives.
//First parameter is the MotorType, Second parameter is the DriveDataSetNumber

hardwareProjection.SetMotorType(MotorType.InductionMotor, 0);
// There can be a problem, if the selected MotorType is not available

// on the drive. In that case, it has to give back a feedback.
Régler le type de moteur en ligne via la configuration matérielle


Régler le type de moteur en ligne via la configuration matérielle

//Online (Only on G120 drives)
OnlineDriveFunctionInterface onlineDfi = ...
// hardwareProjection can be null in case of the actual

// onlineDriveObject does not support activation.
// Setting the required MotorType and DriveDataSetNumber on
// the drive. It is only supported on G120 drives.
// First parameter is the MotorType, Second parameter is the DriveDataSetNumber

// There can be a problem, if the selected MotorType is not available on

// the drive. In that case, it has to give back a feedback.
Les exemples suivants montrent comment lire le type de moteur pour les entraînements G120
depuis l'entraînement :
Déterminer la configuration de moteur hors ligne

// Offline
// WARNING: You have to set the MotorType on G drives before
// you would like to get the current configuration, otherwise
// you will get an exception/feedback, which informs you that
// there is no motor set.
// On S120 drives, you don't have to do that, but you have to
// plug a motor to motor modul.( later on)

// Get the current motor configuration
// It needs a datasetnumber, which is currently only supported on G120 drives.
MotorConfiguration motorConfiguration = hardwareProjection.GetCurrentMotorConfiguration(0);
Déterminer la configuration de moteur en ligne

// Online
// WARNING: You have to set the MotorType on G drives before
// you would like to get the current configuration, otherwise
// you will get an exception/feedback, which informs you that
// there is no motor set.
// On S120 drives, it is not possible??

// Get the current motor configuration
// It needs a datasetnumber, which is currently only supported on G120 drives.
MotorConfiguration motorConfiguration = hardwareProjection.GetCurrentMotorConfiguration(0);

L'exemple suivant montre comment effectuer une configuration de moteur pour les
entraînements G120 :
Définir une configuration de moteur


MotorConfiguration config = hardwareProjection.GetCurrentMotorConfiguration(0);
{
switch (ce.Number)
{
case 305:
ce.Value = 20;
break;
case 307:
ce.Value = 30;
break;
case 311:
ce.Value = 200;
break;
case 304:
ce.Value = 450;
break;
case 310:
ce.Value = 50;
break;
case 335:
ce.Value = 1;
break;
default:
break;
}
});
bool result =
cuDriveFunctionInterface.HardwareProjection.ProjectMotorConfiguration(config, 0);
7.28.4.15 Lire et écrire des paramètres

L'exemple suivant montre comment lire et écrire des valeurs de paramètres d'entraînement.
Pour l'accès, un objet entraînement est nécessaire.
Accès aux paramètres



//Access a parameter via its name
DriveParameter parameter = driveObject.Parameters.Find("p5391[0]");
//Example of reading parameter attributes

if (parameter != null)
{
Console.WriteLine("The Name of the parameter is : " + parameter.Name);
Console.WriteLine("The value of the parameter is : " +
parameter.Value.ToString());
Console.WriteLine("The minvalue of the parameter is : " +
parameter.MinValue);
Console.WriteLine("The MaxValue of the parameter is : " +
parameter.MaxValue);
Console.WriteLine("The Unit of the parameter is : " + parameter.Unit);
//Example for write:

parameter.Value = 60;
}
// Access a parameter via Number and ArrayIndex// Note that

// - arrayless parameters (e.g. p96 on G120) are indexed by -1
// - parameters that consist of only a bit array do not count as
// array parameters, they are indexed by -1 as well and the
// further bit values can be accessed by the 'Bits' property
// of the given parameter (e.g. r2139 on G120). For further
// information about accessing bit parameters see the next
// section of this code snippet
DriveParameter r947_6 = driveObject.Parameters.Find(947, 6); // returns

r947[6]if (r947_6 != null)
{
Console.WriteLine("The Name of the parameter is : " + r947_6.Name);
Console.WriteLine("The value of the parameter is : " +
r947_6.Value.ToString());
}
//Accessing bit values

DriveParameter p2720 = driveObject.Parameters.Find(2720, 0);if (p2720 !=
null)
{
// Note that in general, pXXX.Bits[YYY] is not necessarily equivalent to
pXXX.YYY.
// pXXX.Bits is an array of available bit values in ascending order by
their names
// and not an array of bit values indexed by their names.
// For example: let the available bit values be [pXXX.0, pXXX.2, pXXX.3],
then
// pXXX.Bits[2] == pXXX.3, not pXXX.2
DriveParameter p2720Bit1 = p2720.Bits[1]; // returns p2720[0].1

if (p2720Bit1 != null)
{
Console.WriteLine("The name of the parameter is : " + p2720Bit1.Name);
Console.WriteLine("The value of the second bit of the parameter is : "
+ p2720Bit1.Value.ToString());
}


}
//Get the enum values of a parameter

DriveParameter r47 = driveObject.Parameters.Find("r47");
foreach (var enumItem in r47.EnumValueList)
{
Console.WriteLine("Enum value: " + enumItem.Key.ToString() + " = " +
enumItem.Value);
}
7.28.4.16 Lire et écrire des paramètres en ligne

L'exemple suivant montre comment recevoir une liste des paramètres en ligne disponibles.
Pour l'accès, un objet entraînement en ligne est nécessaire.
L'accès en lecture et en écriture à des paramètres en ligne individuels à partir de la liste des
paramètres est identique à l'exemple Lire et écrire des paramètres (Page 745).
Accès aux paramètres en ligne

DeviceItem item = ... //device item of the CU (e.g. :
project.Devices[0].Items[0].Items[0])
if (onlineDriveObject != null)
{
var parameters = onlineDriveObject.Parameters;
}
7.28.4.17 Enregistrer le paramétrage

L'exemple suivant montre comment déterminer le paramétrage depuis les entraînements
S120, S210 ou G120.
Déterminer le paramétrage en ligne depuis les entraînements


Déterminer le paramétrage en ligne depuis les entraînements

DriveDomainFunctions driveDomainFunctions = onlineDfi.DriveDomainFunctions;

// driveDomainFunctions can be null, if the actual onlineDriveObject

// For example: On G120 and S210 drives, you have to use the CU to get the
onlineDriveObject.
// Please, pay attention at S120 drives. Here you can use any module (CU, MotorModul,
lineModul) as onlineDriveObject but preferable the CU, because it will run on CU!
L'exemple suivant montre, pour les entraînements S120, S210 ou G120, comment copier le
paramétrage de la RAM vers la ROM pour ainsi l'enregistrer en mémoire non volatile.
Effectuer une sauvegarde de la RAM vers la ROM

//In case of G120 device.
OnlineDriveObject cuDriveObject =
//In case of S120 and S210 device you should generally get the CU driveobject.
DeviceItem cuDeviceItem = m_Device.DeviceItems[0];OnlineDriveObject cuDriveObject =
// To use the function, you have to use the OnlineDriveFunctionInterface.

OnlineDriveFunctionInterface cuDriveFunctionInterface =
cuDriveObject.GetService<OnlineDriveFunctionInterface>();
DriveDomainFunctions driveDomainFunctions = cuDriveFunctionInterface.DriveDomainFunctions;
// This function will perform a RAM to ROM copy on all device.

// It is important that the CU should be in online state before you call this function
anyway the program will give an exception.
// This call may take a few moments before be finished.
bool result = DriveDomainFunctions.PerformRAMtoROMCopyAllDriveObject();
7.28.4.18 Utiliser les télégrammes Safety Integrated

L'exemple suivant montre comment utiliser les télégrammes Safety Integrated (par ex. 30)
dans Openness.
Utiliser les télégrammes Safety Integrated


Utiliser les télégrammes Safety Integrated




uint watchDogTime = (uint)safetyTgrm.GetAttribute("Failsafe_FMonitoringtime");

if (safetyTgrm.CanChangeTelegram(newSafetyTelegramNumber))
{
safetyTgrm.TelegramNumber = newSafetyTelegramNumber;
}

7.28.4.19 Insérer et étendre des télégrammes




Console.WriteLine("The Cu has the telegram: " + telegram.TelegramNumber);


{
{
Console.WriteLine("The Setpoint channel-specific starting address of
the connected PLC is: " + address.StartAddress);
}
{
Console.WriteLine("The Actual value channel-specific starting address
of the connected PLC is: " + address.StartAddress);
}
}
// Add an additional Telegram

if (drvObj.Telegrams.CanInsertAdditionalTelegram(2,4))
{
drvObj.Telegrams.InsertAdditionalTelegram(2,4);
}

{
}
7.28.4.20 Utiliser les télégrammes Torque

L'exemple suivant montre comment utiliser les télégrammes Torque (par ex. 750) dans
Openness.
Utiliser les télégrammes Torque

const int torqueTelegramNumber = 750;
// Add a new torque telegram

if (drvObj.Telegrams.CanInsertTorqueTelegram(torqueTelegramNumber))
{
drvObj.Telegrams.InsertTorqueTelegram(torqueTelegramNumber);
}
// Find torque telegram

Telegram torqueTelegram = drvObj.Telegrams.Find(TelegramType.TorqueTelegram);

7.29 Fonctions pour DCC
7.28.4.21 Restaurer les réglages d'usine

L'exemple suivant montre comment restaurer les réglages d'usine pour les entraînements
S120, S210 ou G120.
Restaurer les réglages d'usine

DriveDomainFunctions driveDomainFunctions = onlineDfi.DriveDomainFunctions;

// saveParametrization can be null, if the actual onlineDriveObject
// For example: On G120 and S210 drives, you have to use the CU to get the
onlineDriveObject.
// S120 drives, you can use any modul (CU, MotorModul, lineModul) as onlineDriveObject but
preferable the CU.
7.29.1 Introduction
via TIA Portal.
que vous créez. Il est également possible de créer et d'utiliser des programmes pour
l'application TIA Portal "DCC".
Avant de compiler un programme unique pour DCC à partir des exemples de codes énumérés
ci-dessous, prenez connaissances des informations générales sur Openness, présentes dans
cette aide sous les mots clés suivants :

7.29.2 DCC Openness
Introduction
TIA Portal Openness V16 permet de programmer des applications qui automatisent l'ingénierie
dans TIA Portal.
Fonctions d'Openness en association avec SINAMICS DCC

Les fonctions suivantes sont implémentées dans la version V16 :
● Importer des diagrammes (Page 758)
● Exporter un diagramme (Page 758) ou exporter tous les diagrammes (dossier
"Diagrammes") (Page 758)
● Importer des bibliothèques DCB Extension dans la bibliothèque du projet (Page 761)
● Trouver des diagrammes avec le nom (Page 759)
● Supprimer des diagrammes dans le dossier "Diagrammes" (Page 760)
● Optimiser la séquence d'exécution des blocs dans un diagramme (Page 760)
Remarque
Sous-diagrammes
Les diagrammes qui contiennent des sous-diagrammes peuvent être importés avec
Openness. Néanmoins, il n'est pas possible d'accéder aux sous-diagrammes avec Openness.
Plus d'informations
Voir système d'information TIA "Openness : automatisation de la création de projet".

7.29.3 Modèle d'objet DCC Openness
Vue d'ensemble
Le diagramme suivant décrit le modèle d'objet DCC Openness :
7.29.4 Références
7.29.4.1 DriveControlChartContainer
DriveParameter
DriveControlChartContainer est un service qui représente le conteneur de diagrammes DCC
sous un DriveObject de sorte qu'il puisse être appelé depuis le DriveObject correspondant. Si
le DriveObject ne provient pas d'un appareil pris en charge, le service n'est pas disponible.

Le tableau suivant décrit les navigateurs de DriveControlChartContainer :
Nom Type de données Écriture Description

Charts DriveControlChartComposition Lecture seule Lecture du layout de diagramme dans
le conteneur de diagrammes
7.29.4.2 DriveControlChartComposition
Propriétés de DriveControlChartComposition
DriveControlChartComposition montre une liste des diagrammes disponibles.
Le tableau suivant décrit les méthodes de DriveControlChartComposition :
Nom Type de valeur Paramètres Description Exceptions

retournée
Import DccImportRe‐ string path, Description de la méthode : DccImpor‐
sultData (Pa‐ DccImportOptions Importation de diagrammes d'un fichier d'exporta‐ tException
ge 755) (Page 755) impor‐ tion DCC. (Pa‐
tOptions Description des paramètres : ge 764)
path : chemin d'accès complet du fichier importé
importOptions : options utilisées pour l'importation,
voir DccImportOptions (Page 755).
Export - string path Description de la méthode : DccExpor‐
Exportation de tous les diagrammes dans un fichier tException
d'exportation DCC. (Pa‐
Description du paramètre : ge 764)
Chemin d'accès complet au fichier à exporter.
GetChartSe‐ DriveControl‐ - Lecture de tous les diagrammes du conteneur dans -
quence Chart (Pa‐ l'ordre chronologique d'exécution
ge 755)
Find DriveControl‐ string name Identification d'un diagramme en fonction de son -
Chart (Pa‐ nom dans le conteneur de diagrammes
ge 755)
Voir aussi
Exceptions DriveControlChartComposition (Page 764)
DccImportResultData (Page 755)
DriveControlChart (Page 755)
DccImportOptions (Page 755)

7.29.4.3 DccImportOptions
DccImportOptions
Les réglages suivants sont possibles pour importer des diagrammes :
● DccImportOptions.None :
L'importation est réussie s'il n'y a pas de conflit de nom. Sinon, l'exception
DccImportChartWithSameNameAlreadyAvailableException est émise.
● DccImportOptions.RenameOnConflict :
S'il y a un conflit de nom des diagrammes, le nouveau diagramme importé reçoit un nom qui
est automatiquement généré par CFC. Si, par exemple, le diagramme nommé CFC_1
existe déjà au moment de l'importation, le nouveau diagramme importé est nommé CFC_2.
Voir aussi
DriveControlChartComposition (Page 754)
7.29.4.4 DccImportResultData
DriveParameter
DccImportResultData contient des informations relatives au résultat d'une importation de
diagrammes.
Le tableau suivant décrit les attributs de DccImportResultData :
Nom d'attribut Type de données Écriture Description

RemappedParame‐ IDictiona‐ Lecture Pendant une importation, il est possible qu'un paramètre DCC à
terNumbers ry<UInt16,UInt16> seule importer existe déjà. Dans ce cas, un nouveau numéro est attribué
au paramètre importé. Ce dictionnaire contient tous les nouveaux
paramètres assignés. La valeur clé est le numéro de paramètre
précédent au moment de l'exportation, et la valeur est le nouveau
paramètre créé.
Voir aussi
7.29.4.5 DriveControlChart
DriveControlChart Features
DriveControlChart correspond à un diagramme dans le conteneur de diagrammes (les sous-
diagrammes ne sont pas pris en charge par Openness).

Le tableau suivant décrit les attributs de DriveControlChart :
Nom d'attribut Type de don‐ Écriture Description

nées
Nom string Lecture seule Nom du diagramme
Le tableau suivant décrit les méthodes de DriveControlChart :
Nom Type de va‐ Paramètres Description Exceptions

leur retournée
Export - string path Description de la méthode : DccExportException
Exporte exclusivement ce diagramme (Page 764)
Description des paramètres :
path : chemin d'accès complet au fichier à exporter.
Delete - - Description de la méthode : -
Supprime le diagramme.
OptimizeRunS - - Description de la méthode : DccLicenseUnavai‐
equence Optimise la séquence d'exécution du diagramme. Le lableException (Pa‐
mécanisme d'optimisation est mis à disposition par ge 764)
CFC.
Remarque :
L'optimisation de la séquence d'exécution n'est pos‐
sible que si une licence DCC est disponible.
Voir aussi
Exceptions DriveControlChart (Page 764)
Supprimer des diagrammes (Page 760)
7.29.4.6 Importation de la bibliothèque DCB Extension
ImportDCBextensionlibrary
Le tableau suivant décrit les méthodes de ImportDCBextensionlibrary :
Nom Valeur re‐ Para‐ Description

tournée mètres
ImportDcbLibrary - string Arguments de la méthode :
path path : chemin d'accès complet au fichier zip de la biblio‐
thèque DCB Extension.
Description de la méthode :
Importation d'une bibliothèque DCB Extension dans la bi‐
bliothèque du projet

7.29.5 Exemples de codes
7.29.5.2 Accès à DriveControlChartContainer avec DriveObject

L'exemple suivant montre comment accéder à DriveControlChartContainer avec un objet
entraînement.
Accès à DriveControlChartContainer
using Siemens.Engineering.MC.Drives.DCC;
open the project
DriveObject
driveObject = item.GetService<DriveObjectContainer>().DriveObjects[0];
DriveControlChartContainer
chartContainer = driveObject.GetService<DriveControlChartContainer>();
//chartContainer can be null in case the DriveObject does not support DCC.
7.29.5.3 Appeler les diagrammes

L'exemple suivant montre comment appeler des diagrammes.
Appeler les diagrammes
DriveControlChartComposition charts = chartContainer.Charts;
7.29.5.4 Accéder à des diagrammes

L'exemple suivant montre comment accéder à des diagrammes.
Accéder à des diagrammes
DriveControlChartComposition charts = ...

DriveControlChart firstChart = charts[0];
// or looping...
foreach(DriveControlChart chart in charts)
{
...
}

7.29.5.5 Importer des diagrammes

L'exemple suivant montre comment importer des diagrammes.
Importer des diagrammes
try
{
DccImportResultData result = charts.Import(@"c:\Charts.dcc",
DccImportOptions.None);
}
catch (DccImportException exc)
{
}
Voir aussi
DCC Openness (Page 752)
7.29.5.6 Exporter des diagrammes

L'exemple suivant montre comment exporter des diagrammes.
Exporter des diagrammes
try
{
DriveControlChart chart;
...
chart.Export(@"c:\CFC_1.dcc");
}
catch (DccExportException exc)
{
}
Voir aussi
7.29.5.7 Exporter tous les diagrammes

L'exemple suivant montre comment exporter tous les diagrammes.
Exporter tous les diagrammes

Exporter tous les diagrammes

try
{
charts.Export(@"c:\Charts.dcc");
}
catch (DccExportException exc)
{
}
Voir aussi
7.29.5.8 Appeler des diagrammes dans l'ordre chronologique d'exécution

L'exemple suivant montre comment appeler des diagrammes dans l'ordre chronologique
d'exécution.
Appeler les diagrammes

IList<DriveControlChart> chartSequence = charts.GetChartSequence();
7.29.5.9 Trouver des diagrammes avec le nom

L'exemple suivant montre comment rechercher des diagrammes avec le nom.
Trouver des diagrammes

DriveControlChart chart = charts.Find("CFC_1");
Voir aussi
7.29.5.10 Afficher le rapport d'importation

L'exemple suivant montre comment afficher le rapport d'une importation.
Afficher le rapport d'importation

Afficher le rapport d'importation

DccImportResultData importResultData = charts.Import(@"d:\Charts.dcc",
DccImportOptions.None);
IDictionary<ushort, ushort> remappedParameters = importResultData.RemappedP
arameterNumbers;
foreach (KeyValuePair<ushort, ushort> remappedParameter in remappedParamete
rs)
{
System.Console.WriteLine($"ParameterNumber <{remappedParameter.Key}> has
been changed to <{remappedParameter.Value}> during import.");
}
7.29.5.11 Supprimer des diagrammes

L'exemple suivant montre comment supprimer des diagrammes.
Supprimer des diagrammes
try
{
...
chart.Delete();
}
{
}
Voir aussi
7.29.5.12 Optimiser la séquence d'exécution

L'exemple suivant montre comment optimiser l'ordre chronologique d'exécution des
diagrammes.
Optimiser la séquence d'exécution des diagrammes
try
{
...
chart.OptimizeRunSequence();
}
catch (DccLicenseUnavailableException exc)
{
}

Voir aussi
7.29.5.13 Importer une bibliothèque DCB Extension

L'exemple suivant montre comment importer une bibliothèque DCB Extension.
Importer une bibliothèque DCB Extension
try
{
Project myProject;
...
myProject.ProjectLibrary.ImportDcbLibrary(@"c:\GMCV5_1_sinamics5_1_(5.1.15
).zip");
}
{
}
Voir aussi

7.29.6 Exceptions DCC Openness
7.29.6.1 Traitement des exceptions
Traitement des exceptions

Pour les applications pouvant échouer en raison d'erreurs de l'utilisateur, DCC Openness
déclenche une exception propre à DCC, qui est déduite
de EngineeringTargetInvocationException. Les exceptions ont une structure
hiérarchique permettant de déduire toutes les exceptions spécifiques de l'exception
générale DccException :

Si vous ne souhaitez pas examiner ou exploiter en détail les différentes causes des erreurs, la
solution la plus simple consiste à intercepter l'exception générale DccException :
try
{
Project myProject;
…
myProject.ProjectLibrary.ImportDcbLibrary(@"c:\GMCV5_1_sinamics5_1_(5.1.15
).zip");
...
DriveControlChartContainer chartContainer = driveObject.GetService<DriveC
ontrolChartContainer>();
chartContainer.Charts.Import(@"d:\Charts.dcc", DccImportOptions.None);
}
catch (DccException exc)
{
}
Interceptez toutes les exceptions pertinentes si vous voulez varier la réaction en fonction du
type d'erreur :
try
{
DriveControlChartContainer
chartContainer = driveObject.GetService<DriveControlChartContainer>();
chartContainer.Charts.Import(@"d:\Charts.dcc", DccImportOptions.None);
}
catch (DccImportLibraryIsMissingException missingLibExc)
{
}
catch (DccImportChartWithSameNameAlreadyAvailableException sameNameExc)
{
}
{
}
catch (DccException exc)
{
}

7.29.6.2 Exceptions DriveControlChart
Exceptions
Exceptions pouvant être émises lors d'une exportation :
● DccExportException :
Émise pour tout type d'erreur d'exportation.
Exceptions pouvant être émises lors de l'exécution de la fonction d'optimisation de l'ordre

chronologique d'exécution des diagrammes :
● DccLicenseUnavailableException :
Émise lorsque la licence DCC n'est pas disponible. Dans ce cas, la fonction d'optimisation
de l'ordre chronologique d'exécution n'est pas disponible.
Voir aussi
7.29.6.3 Exceptions DriveControlChartComposition
Exceptions
Exceptions émises lors de l'importation :
● DccImportException :
Exception d'importation générale émise par DCC en cas d'erreur d'importation.
● DccImportBlockCreationException :
Émise lorsqu'un groupe ne peut pas être créé lors d'une importation.
● DccImportBlockTypeNotFoundException :
Émise lorsqu'un type de groupe DCB référencé ne peut être trouvé ni dans une bibliothèque
DCB standard ni dans une bibliothèque DCB Extension.
● DccImportChartCreationException :
● émise lorsqu'un diagramme ne peut pas être créé lors d'une importation.
● DccImportChartWithSameNameAlreadyAvailableException :
Émise lorsque le conteneur de diagrammes contient déjà un diagramme du même nom et
que DccImportOptions.None est utilisé.
● DccImportLibraryIsMissingException :
Émise lorsqu'une bibliothèque DCB Extension référencée n'existe pas dans le projet.
● DccImportFileAlreadyInUseException :
Émise lorsqu'un fichier à importer est déjà utilisé par un autre processus.
● DccImportDcbTypeDifferentVersionAlreadyUsedException :
Émise lorsqu'un type DCB est déjà utilisé dans une autre version de la même bibliothèque
DCB Extension dans l'appareil.

7.30 Exceptions
Voir aussi
7.29.6.4 Exceptions ImportDcbLibrary
Exceptions
Exceptions émises par ImportDcbLibrary :
● DccImportException :
Émise pour tout type d'erreur d'importation.
● DccLibraryImportAlreadyAvailableException :
Émise lorsqu'une bibliothèque DCB Extension de la même version existe déjà dans le
projet.
● DccLibraryImportCorruptedStudioLibraryException :
Émise lorsque le fichier zip de la bibliothèque DCB Extension est compromis et ne peut pas
être importé.
● DccLibraryImportIntegrityBrokenException :
Émise lorsque l'intégrité du fichier zip de la bibliothèque DCB Extension est compromise.
● DccLibraryImportOverallPinLimitExceededException :
Émise lorsque la bibliothèque DCB Extension contient un type DCB dont le nombre de
broches dépasse le nombre de broches maximal.
● DccLibraryImportStandardLibraryAlreadyAvailableException :
Émise lorsque la bibliothèque DCB Extension sélectionnée pour l'importation est la
bibliothèque DCB standard déjà existante.
● DccLibraryImportUnsupportedLibraryTypeException :
Émise lorsque la bibliothèque DCB Extension sélectionnée n'est pas prise en charge par
DCC et par les entraînements SINAMICS.
7.30 Exceptions
7.30.1 Traitement des exceptions
Exceptions en cas d'accès à TIA Portal via des API TIA Portal Openness
Lors de l'exécution d'une application TIA Portal Openness avec la TIA Portal Openness API,
toutes les erreurs qui se sont produites sont signalées comme des exceptions. Ces exceptions
contiennent des informations qui vous aident à éliminer les erreurs survenues.

7.30 Exceptions
Il existe deux types d'exception :

● Recoverable (Siemens.Engineering.EngineeringException)
Avec cette exception, vous continuez d'accéder à TIA Portal sans interruption. Vous pouvez
également couper la liaison au portail TIA.
Les EngineeringExceptions contiennent les types suivants :
– Exceptions de sécurité (EngineeringSecurityException), par exemple en cas d'absence
de droits d'accès.
– Exceptions lors de l'accès aux objets (EngineeringObjectDisposedException), par ex.
lors de l'accès à des objets qui n'existent plus.
– Exceptions lors de l'accès aux attribut (EngineeringNotSupportedException), par ex.
lors de l'accès à des attributs qui n'existent plus.
– Exceptions générales lors de l'appel (EngineeringTargetInvocationException), par ex.
en cas d'erreur malgré des appels valides de la TIA Portal Openness API.
– Exceptions lors de l'appel (EngineeringRuntimeException), par ex. lors d'une affectation
invalide.
– Exceptions si les ressources sont insuffisantes dans l'instance de TIA Portal affectée
(EngineeringOutOfMemoryException)
– Exceptions lorsque les appels sont terminés (EngineeringUserAbortException), par ex.
lors de l'interruption du processus d'importation par l'utilisateur.
– Exceptions lors de l'appel de l'API par un délégué mis à disposition par un client
(EngineeringDelegateInvocationException). Cette exception est dérivée de l'exception
Les EngineeringExceptions ont les attributs suivants :
– ExceptionMessageData messageData: Contient la cause pour laquelle l'exception
a été déclenchée.
– ExceptionMessageData detailMessageData: Contient des informations
supplémentaires sur la cause. Le résultat est fourni en retour sous forme de <IList>.
– String message : Fournit en retour le résultat issu de MessageData et
de DetailMessageData.
ExceptionMessageData fournit en retour les informations suivantes :
– String Text : Contient la cause pour laquelle l'exception a été déclenchée.
● NonRecoverable (Siemens.Engineering.NonRecoverableException)
Dans le cas de cette exception, le portail TIA est fermé et la liaison au portail TIA est coupée.
Vous devez redémarrer le TIA Portal avec l'application TIA Portal Openness.

7.30 Exceptions
Code de programme
L'exemple suivant montre les possibilités que vous avez pour réagir à des exceptions :
try
{
...
}
catch(EngineeringSecurityException engineeringSecurityException)
{
Console.WriteLine(engineeringSecurityException);
}
catch(EngineeringObjectDisposedException engineeringObjectDisposedException)
{
Console.WriteLine(engineeringObjectDisposedException.Message);
}
catch(EngineeringNotSupportedException engineeringNotSupportedException)
{
Console.WriteLine(engineeringNotSupportedException.MessageData.Text);
foreach(ExceptionMessageData detailMessageData in
engineeringNotSupportedException.DetailMessageData)
{
Console.WriteLine(detailMessageData.Text);
}
}
catch (EngineeringTargetInvocationException)
{
throw;
}
catch (EngineeringException)
{
//Do not catch general exceptions
throw;
}
catch(NonRecoverableException nonRecoverableException)
{
Console.WriteLine(nonRecoverableException.Message);
}

7.30 Exceptions
7.30.2 Exception personnalisée
Introduction
L'exception personnalisée est un mécanisme utilisé par un développeur d'application
Openness pour définir de nombreuses exceptions relatives au traitement de scénarios d'erreur
afin d'assurer un traitement d'erreur fiable à long terme. Grâce à l'assistance de
CustomException, le développeur peut créer avec l'API Openness ses propres exceptions
personnalisées dans EOM à l'aide de EOM Designer. Les utilisateurs de l'API Openness
interceptent ensuite ces exceptions dans le code de l'API Openness, en plus des exceptions
prédéfinies. Les exceptions définies par l'utilisateur dans EOM doivent être jointes à une action
Openness, qui peut déclencher l'exception personnalisée correspondante, afin que vous
puissiez intercepter l'exception. Faute de quoi, une exception
CustomException dans EOM Designer

EOM Modeler crée une exception personnalisée avec EOM Designer. L'exception peut être
créée dans un espace de noms quelconque.
CustomException dans l'application Openness

À l'aide de l'application TIA Portal Openness, vous pouvez interroger une CustomException
directement au moyen du code Openness :
static void Main(string[] args)

{
try
{
SomeEOMType someEOMType = // Get some EOM type.
someEOMType.ActionThatThrowsException();
}
catch(AnEomCustomException ex)
{
//if AnEomCustomException is attached to someEOMType.ActionThatThrowsException() as
throwable exception.
}
catch(EngineeringTargetInvocationException ex)
{
}
}

7.30 Exceptions
Nouveau type EOM

CustomException est un nouveau type dans EOM, mais une classe dans
Siemens.Engineering.dll. CustomException présente la structure suivante dans EOM :
<CustomException name="MaxCharactersExceededException" publicationLevel="Published"

createPublicationLevel="Published" accessModifier="Public">
<Product>Automation-Main</Product>
<Extends>
<Class name="Siemens.Engineering.EngineeringTargetInvocationException" />
</Extends>
<Mapping
ServerException="Siemens.Automation.CustomIdentity.BusinessLogic.Exceptions.MaxCharactersE
xceededException"> </CustomException>
Affectation
Chaque EOM Modeler doit affecter l'exception ServerException, qui fait partie des exceptions
CustomException, à une exception serveur dans le composant client de sorte qu'une
CustomException soit déclenchée dans le code Openness correspondant à l'utilisateur de l'API
Openness lorsque le composant client déclenche l'exception serveur. L'exception serveur est
indiquée sous forme de nom complet de l'exception correspondante sur le serveur (composant
client). L'exception serveur définie dans le client doit être dérivée de
Siemens.Automation.CommonServices.UserExceptionBase.
Niveau de publication
Le niveau de publication pour CustomException ne doit pas être "Elevated" ou "System" et le
niveau de publication pour une exception système Openness doit être "Published".
Extensions
L'exception personnalisée que vous avez créée doit être dérivée de
EngineeringTargetInvocationException ou d'une dérivée de
EngineeringTargetInvocationException. EOM Designer offre des possibilités d'extension de
l'exception.

7.30 Exceptions
Règles
Pour EOM Modeler, EOM Designer affiche des erreurs générales et des erreurs de générateur
survenues lors de la génération de l'Engineering Assembly en cas de violation des règles dans
les scénarios suivants :
● Erreur :
– Le nom de l'exception personnalisée doit se terminer par "Exception". Exemple :
MaxCharactersExceededException
– Le modificateur d'accès d'une exception personnalisée doit être "Public".
– Il doit être dérivé de EngineeringTargetInvocationException ou d'une autre dérivée de
– Une exception doit être affectée à ServerException afin que l'exception puisse être
déclenchée côté client. Sinon, l'exception sera disponible dans EOM mais ne pourra pas
être déclenchée par un composant.
– ServerException mise à disposition doit être unique.
– Le niveau de publication pour CustomException ne doit pas être "Elevated" ou "System".
● Info
– Lorsque l'exception déclenchable ("Throwable") est jointe à une action "Create", elle est
seulement utilisée à des fins de documentation de l'action "Create".
Ces règles ne s'appliquent qu'aux exceptions CustomException qui ont été créées par des
utilisateurs Openness. Exemple : SampleException.
Les règles décrites ci-dessus ne s'appliquent pas aux exceptions système Openness ci-après :
● EngineeringException
● EngineeringSecurityException
● EngineeringObjectDisposedException
● EngineeringNotSupportedException
● EngineeringTargetInvocationException
● EngineeringRuntimeException
● EngineeringOutOfMemoryException
● EngineeringUserAbortException
● EngineeringDelegateInvocationException
● NonRecoverableException
Exception déclenchable d'une action

Openness Designer permet au développeur de l'API Openness de joindre une
CustomException à une action. Des exceptions système dans Openness, comme
EngineeringTargetInvocationException, EngineeringObjectDisposedException, etc., ne
peuvent être jointes qu'à certaines actions. Vous ne pouvez intercepter une CustomException
que si l'exception serveur déclenchée par le composant serveur TIA-Portal a été affectée à une
CustomException dans EOM et que l'exception CustomException est jointe à l'action appelée.

7.30 Exceptions
Lorsqu'une exception personnalisée est jointe à une action spécifique comme "Create" ou
"Delete", l'exception déclenchable est seulement utilisée à des fins de documentation pour
l'API. Si une exception personnalisée affectée dans EOM correspondant à l'exception du
composant client est présente côté EOM, vous avez la possibilité d'intercepter l'exception
CustomException pour des actions spécifiques (par ex. l'action "Create").
Règles pour les exceptions déclenchables

● Seuls les niveaux de publication "Published", "Developer" et "Pilot" sont autorisés pour une
exception personnalisée.
● Les niveaux "Elevated" et "System" ne sont pas autorisés pour une exception
personnalisée.
● Une exception personnalisée ne peut être jointe aux actions avec les niveaux de publication
suivants :
Niveau de publication de l'ac‐ Niveau de publication de l'ex‐ Une exception personnalisée

tion EOM ception personnalisée est-elle autorisée avec l'action ?
Published Published Oui
Published Developer Non
Published Pilot Non
Developer Developer Oui
Developer Published Oui
Developer Pilot Non
Pilot Pilot Oui
Pilot Published Oui
Pilot Developer Non
Elevated Pilot Non
Elevated Published Oui
Elevated Developer Non
System Published Oui
System Pilot Non
System Developer Non
Remarque
● En cas d'incompatibilité entre les niveaux de publication de l'action EOM et l'exception
personnalisée, OPNS Designer affiche une erreur.
● Les erreurs de compatibilité de niveaux de publication entraînent l'échec de génération de
l'Engineering Assembly.

7.30 Exceptions

Exportation/importation 8
8.1 Vue d'ensemble
8.1.1 Notions élémentaires sur l'importation/exportation
Introduction
Vous pouvez exporter certaines données de configuration puis les réimporter après édition,
soit dans le même projet, soit dans un autre.
Remarque
L'utilisation de cette description pour éditer et exploiter manuellement le fichier source
n'entraîne aucune obligation ni garantie d'aucune sorte. Siemens décline donc toute
responsabilité en cas d'utilisation de cette description ou de parties de cette description.
Objets exportables et importables

Vous pouvez également importer ou exporter les données de configuration suivantes par le
biais de la TIA Portal Openness API :
Tableau 8-1 Projets
Objets Exportation Importation

Bibliothèque de graphiques X X
Tableau 8-2 API

Blocs X X
Blocs avec protection Know How X –
Blocs F X X
Blocs système X –
Tables de variables API X X
Objets technologiques X X
Variables et constantes API X X
Types de données utilisateur X X

Exportation/importation
8.1 Vue d'ensemble
Tableau 8-3 IHM

Vues X X
Modèles de vue X X
Vues globales X X
Vues contextuelles X X
Vues Slide-in X X
Scripts X X
Listes de textes X X
Listes de graphiques X X
Cycles X X
Connexions X X
Table des variables X X
Variables X X
Exportation complète ou de références ouvertes

Les types d'objets dont la liste est dressée ci-dessus sont exportés ou importés avec tous les
objets lorsqu'ils appartiennent à la même arborescence. Cela vaut également pour les objets
référencés de la même arborescence.
Les objets référencés dans d'autres arborescences ne peuvent pas, quant à eux contraire, être
complètement exportés ou importés. Des "références ouvertes" à ces objets sont exportées ou
importées à leur place.
Les objets référencés de la même arborescence sont exportés uniquement s'ils font partie du
groupe des objets exportables. Toutes les dynamisations s'appliquant à des objets sont
traitées comme des objets lors de l'importation/exportation et sont également exportées et
importées.
Lors de l'exportation, tous les attributs d'objet qui ont été modifiés durant la configuration sont
exportés. Cela s'applique toujours, qu'un attribut modifié soit utilisé ou non.
Exemple : Vous avez configuré un champ d'E/S graphique avec le mode "Entrée/Sortie" et
sélectionné le réglage "Visible après avoir cliqué" pour l'attribut "Barre de défilement". Puis
vous avez basculé le mode sur "Deux états" pendant la configuration. Dans ce mode, l'attribut
"Barre de défilement" n'est pas disponible. Étant donné que l'attribut "Barre de défilement" a
été modifié, il est exporté lors de l'exportation, bien qu'il ne soit pas utilisé.
Importation de références ouvertes

Vous pouvez également importer des objets assortis de références ouvertes (voir Importation
de données de configuration (Page 780)).
Si les objets référencés se situent dans le projet cible, les références ouvertes sont
automatiquement liées à nouveau aux types d'objet. Ces objets doivent se situer au même
endroit et porter le même nom que pour l'exportation. Si les objets référencés ne sont pas

8.1 Vue d'ensemble
situés dans le projet cible, les références ouvertes ne peuvent pas être résolues. Aucun objet
supplémentaire n'est créé pour la résolution des références ouvertes.
Importation et exportation du format de fichier

Le format de fichier à exporter et à importer est XML. Le format AML est requis uniquement
pour les données CAx. Vous trouverez les différentes définitions de schéma pour tous les
formats dans le chapitre correspondant du présent manuel :
● Format XML pour les données d'un appareil IHM (Page 788)
● Format XML pour les données d'un appareil API (Page 840)
● Format AML pour les données CAx (Page 939)
Importation et exportation de polices de caractère

Les polices définies pour des objets sont également exportées et importées.
Si vous importez des polices qui ne sont pas incluses dans le projet, la police par défaut
s'affiche pour l'objet après l'importation. La police importée est toutefois enregistrée dans la
gestion des données.
Si les attributs d'une police ne sont pas définis dans le fichier d'importation, les attributs sont
dotés de valeurs par défaut après l'importation.
Importer et exporter des objets technologiques

À partir de TIA Portal ≥ V16, vous pouvez exporter et importer les objets technologiques de la
version ≥ V5.0 suivants pour S7-1500 et S7-1500 :
● SpeedAxis
● PositioningAxis
● SynchronousAxis
● ExternalEncoder
● Cam
● OutputCam
● CamTrack
● Cinématique
● LeadingAxisProxy
À partir de TIA Portal ≥ V16, vous pouvez exporter et importer les objets technologiques
suivants pour S7-1200 :
● PositioningAxis/CommandTable
À partir de TIA Portal ≥ V16, vous pouvez exporter et importer les objets technologiques
suivants pour S7-300, S7-400, S7-1200, S7-1500 :
● PID

8.1 Vue d'ensemble
Restrictions
Le format d'exportation est interne et n'est valable que pour la version actuelle de TIA Portal
Openness. Le format d'exportation peut être modifié pour les versions ultérieures.
Toutes les erreurs survenant au cours de l'importation ou de l'exportation sont signalées
comme des exceptions.
Pour plus d'informations sur les exceptions, veuillez vous référer au chapitre Traitement des
exceptions (Page 765).
Voir aussi
Domaine d'utilisation de l'importation/exportation (Page 776)
Exportation de données de configuration (Page 778)
8.1.2 Domaine d'utilisation de l'importation/exportation
Introduction
La fonction d'importation/exportation vous permet d'exporter certains objets de manière ciblée.
Vous pouvez éditer les données exportées avec un programme externe ou les réutiliser telles
quelles dans d'autres projets TIA Portal.
Si vous structurez correctement le fichier d'importation, vous pouvez également importer sans
exportation préalable des données de configuration créées en externe.
Remarque
L'importation de données de configuration créées en externe avec des erreurs de code ou de
structure erronée peut provoquer des erreurs inattendues.
Domaine d'application
Exporter et importer des données est utile pour les tâches suivantes :
● éditer des données de configuration en externe,
● importer des données de configuration générées en externe, telles que des listes de textes
et des variables,
● distribuer à différents projets des données de configuration prédéfinies, p. ex. une vue de
processus modifiée qui doit être utilisée dans plusieurs projets.
● Pour la réplication et l'adaptation de la configuration matérielle entre le projet TIA Portal et
un programme ECAD.
Voir aussi
Notions élémentaires sur l'importation/exportation (Page 773)

8.1 Vue d'ensemble
8.1.3 Importation SimaticML spécifique à la version
Application
L'importation SimaticML est utilisable avec toutes les versions à partir de TIA Portal Openness
V14 SP1. Vous pouvez importer vos anciens fichiers d'exportation au moins dans les deux
versions supérieures.
Chaque version de l'API Openness permet d'importer des fichiers SIMATIC-ML depuis la
version correspondante et depuis toute version antérieure prise en charge. Par exemple,
l'importation de fichiers SIMATIC-ML V14 SP1, V15 et V15.1 dans Openness API V16 est prise
en charge.
Le tableau ci-après indique un exemple de quelle version de SIMATIC-ML est importée depuis
quelle version de l'API Openness.
Version de Fichier SIMATIC-ML Fichier SIMATIC- Fichier SIMA‐ SIMATI ML V16

l'API Open‐ V14 SP1 ML V15 TIC-ML V15.1
ness
V14 SP1 Importation prise en Importation non Importation non Importation non prise
charge prise en charge prise en charge en charge
V15 SP1 Importation prise en Importation prise Importation non Importation non prise
charge en charge prise en charge en charge
V15.1 Importation prise en Importation prise Importation pri‐ Importation non prise
charge en charge se en charge en charge
V16 Importation prise en Importation prise Importation pri‐ Importation prise en
charge en charge se en charge charge
Les différentes versions de l'API Openness prennent en charge l'exportation de fichiers

SIMATIC-ML. La version du fichier SIMATIC-ML exporté doit cependant correspondre avec la
version de TIA Portal et non avec la version de l'API Openness utilisée.
Pour prendre en charge cette caractéristique, les fichiers SimaticML contiennent maintenant
les informations de version de modèle représentées ci-dessous :
<?xml version="1.0" encoding="utf-8"?>

<Document>
<Engineering version="V14 SP1"/>
<DocumentInfo>
...
</DocumentInfo>
<SW.DataBlock ID="0">
...
</SW.DataBlock>
</Document>
Remarque
Si ces informations de version ne sont pas présentes dans le fichier SimaticML, le système
utilise la version de modèle actuelle.

8.1 Vue d'ensemble
8.1.4 Edition du fichier XML
Introduction
Pour éditer un fichier XML destiné à l'importation de données de configuration, vous utilisez un
éditeur XML ou un éditeur de texte.
Si vous effectuez des modifications importantes ou si vous créez vous-même des structures
d'objet, il est recommandé d'utiliser un éditeur XML disposant d'une fonction de complément
automatique.
Remarque
La modification du contenu XML requiert de solides connaissances de la structure et des règles
de validation dans XML. Evitez les erreurs de validation et ne modifiez manuellement la
structure XML qu'exceptionnellement.
8.1.5 Exportation de données de configuration
Introduction
Les données de configuration sont à chaque fois exportées dans un fichier XML par objet de
départ (racine).
L'édition du fichier d'exportation requiert des connaissances en XML. Pour une édition
simplifiée, utilisez un éditeur XML.
Exemple
Vous avez une vue de processus qui contient un champ E/S. Une variable externe est
configurée pour ce champ E/S. Si vous exportez la vue de processus, la vue et le champ E/S
sont exportés. La variable et la liaison utilisée par la variable ne sont pas exportées, seule une
référence ouverte est exportée.

8.1 Vue d'ensemble
Contenu du fichier d'exportation

À partir de l'objet de départ, tous les objets d'une arborescence sont stockés, ainsi que leurs
attributs. En revanche, toutes les références aux objets d'autres arborescences sont exportés
comme références ouvertes uniquement. Les attributs correspondants des objets référencés
dans différentes arborescences ne sont pas écrits dans le fichier d'exportation.
Remarque
L'exportation de types d'objet de la bibliothèque n'est pas prise en charge.
Vous pouvez créer des objets comme type dans la bibliothèque. Les instances du type d'objet
utilisées dans le projet peuvent être éditées avec l'application TIA Portal Openness comme
d'autres objets. Si vous exportez des objets, les instances sont exportées sans les informations
de type.
Si vous réimportez ces objets dans le projet, les instances des types d'objet sont écrasées et
l'instance est coupée du type d'objet.
Le fichier d'exportation ne contient pas nécessairement tous les attributs d'un objet. C'est vous
qui définissez les données à exporter :
● ExportOptions.None
Ce paramétrage n'exporte que les données modifiées ou différentes des données standard.
Le fichier d'exportation contient, de plus, toutes les valeurs obligatoires pour une
importation ultérieure des données.
● ExportOptions.WithDefaults1
De plus, les valeurs par défaut sont exportées.
● ExportOptions.WithReadOnly1
De plus, les valeurs protégées en écriture sont exportées.
1
: vous pouvez combiner ces deux options avec la syntaxe suivante :
Export(path,ExportOptions.WithDefaults |
ExportOptions.WithReadOnly);
Le contenu du fichier d'exportation est entièrement en anglais. Indépendamment de cela, les
textes de projet sont exportés et importés dans toutes les langues disponibles.
Dans le fichier d'exportation, les données de configuration sont toutes structurées comme
objets XML.
Voir aussi
Exporter des blocs (Page 896)

8.1 Vue d'ensemble
8.1.6 Importation de données de configuration
Introduction
Les données de configuration sont importées depuis un fichier XML exporté au préalable et
édité ou bien depuis un fichier XML que vous créez vous-même. Les données contenues dans
ce fichier sont contrôlées lors de l'importation. Cela garantit que l'importation ne provoquera
pas une incohérence des données de configuration dans TIA Portal.
Restrictions
● Tous les objets racine dans le fichier d'importation doivent être du même type, par ex. tables
de variables, blocs, etc.
● Si plusieurs objets racine sont indiqués dans un fichier d'importation et que l'un de ces
objets n'est pas valide, le contenu du fichier d'importation n'est pas importé en entier.
● Lors de l'importation de textes, les langues du projet correspondantes doivent être
paramétrées dans le projet cible pour éviter que l'importation n'échoue. Si nécessaire, vous
pouvez modifier les paramètres linguistiques via TIA Portal Openness.
● Si vous indiquez, dans le fichier d'importation, des attributs d'un objet invalides non
éditables dans l'interface utilisateur graphique de TIA Portal, l'importation est annulée.
● Seul les pointeurs de zone sous "separately for each connection" peuvent être importés ou
exportés.
● L'importation de types d'objet de la bibliothèque n'est pas prise en charge. Vous pouvez
créer des objets comme type dans la bibliothèque. Les instances du type d'objet utilisées
dans le projet peuvent être éditées avec l'application TIA Portal Openness comme d'autres
objets. Si vous exportez des objets, les instances sont exportées sans les informations de
type. Si vous réimportez ces objets dans le projet, les instances des types d'objet sont
écrasées et l'instance est coupée du type d'objet.
● L'importation de blocs de sécurité n'est pas prise en charge.
Remarque
Plages de valeurs pour les attributs graphiques en fonction de l'appareil
Si les valeurs d'attributs graphiques se situent en dehors de la plage de valeurs valide, ces
valeurs sont remises aux valeurs maximales possibles pour l'appareil IHM lors de l'importation.
Comportement d'importation différent

Si les objets à importer existent déjà dans le projet, vous devez commander le comportement
d'importation à l'aide de différents codes de programme. Faute de quoi, les objets sont de
nouveau créés dans le projet lors de l'importation.

8.1 Vue d'ensemble
Les paramétrages suivants peuvent être effectués pour définir le comportement d'importation :
● ImportOptions.None
Ce paramètre permet d'importer les données de configuration sans écrasement.
Si un objet existe déjà dans le projet lors de l'importation depuis un fichier XML, le processus
est annulé par une exception.
● ImportOptions.Override
Ce paramètre est utilisé pour l'importation des données de configuration avec écrasement
automatique.
Vous pouvez décider d'écraser les objets existants au sein du projet pendant l'importation.
Les objets pertinents sont supprimés du projet avant l'importation et recréés avec des
valeurs par défaut. Lors de l'importation, ces valeurs par défaut sont écrasées par des
valeurs issues de l'importation. Si l'objet existant et le nouvel objet ne sont pas dans le
même groupe, ces valeurs ne peuvent pas être écrasées. Pour éviter des conflits de noms,
l'importation est annulée et une exception est générée.
Marche à suivre pour l'importation

Pour importer un fichier XML, il faut que les données qu'il contient satisfassent à certaines
règles. Le contenu du fichier d'importation doit avoir la forme correcte. Il ne doit présenter
aucune erreur de syntaxe ni aucune erreur dans la structure des données. En cas de
modifications importantes, utilisez un éditeur XML, car ce dernier contrôle ces critères avant
l'importation.
Lors de l'importation du fichier XML dans TIA Portal, les données contenues dans le fichier sont
d'abord contrôlées afin d'exclure toute erreur formelle dans le code XML. Si des erreurs sont
détectées lors de la vérification, l'importation est interrompue et les erreurs s'affichent dans une
exception (voir Traitement des exceptions (Page 765)).
Voir aussi

8.2 Importation/exportation de données du projet
8.2.1 Bibliothèque de graphiques
8.2.1.1 Exportation/importation de graphiques
Introduction
L'exportation de données de configuration de TIA Portal vers le fichier XML ne contient pas de
graphique sélectionné ni de graphique référencé par un objet. Ils sont enregistrés séparément
lors de l'exportation. Dans le fichier XML, les graphiques sont référencés avec un chemin relatif
et le nom de fichier. Dans le fichier XML, une référence à un graphique est structurée comme
objet et contient, comme les autres objets, une liste d'attributs ainsi qu'une liste de liens le cas
échéant.
Exporter des graphiques

L'exportation des données de configuration contient uniquement les graphiques qui ont été
directement sélectionnés pour l'exportation. Les graphiques pouvant être exportés sont
enregistrés dans TIA Portal pour la langue considérée. Lorsqu'un projet est configuré dans
plusieurs langues, toutes les versions de langue utilisées sont exportées.

Lors de l'exportation de graphiques, un nouveau dossier est créé dans le dossier du fichier
d'exportation. Le nom du dossier est construit en connectant le nom du fichier XML avec des
"fichiers". Ce dossier contient les graphiques exportés. Si ce dossier existe déjà, un nouveau
dossier est créé, dont le nom est complété avec un numéro d'ordre.
Les graphiques sont enregistrés dans le même format de fichier que dans le projet. Le format
n'est ni modifié, ni converti, et la résolution ainsi que la profondeur de couleur restent
également inchangées.
L'identifiant "default" est utilisé comme extension de fichier pour la langue sélectionnée comme
langue par défaut.
Si le dossier contient déjà un fichier du même nom, le nom de fichier du graphique exporté est
complété par un numéro d'ordre.
Importer des graphiques

Les conditions pour l'importation de graphiques sont les suivantes :
● Les graphiques doivent avoir un format de fichier pris en charge par TIA Portal.
● Dans le fichier XML, les graphiques doivent être référencés avec un chemin relatif.
Après l'exportation d'un graphique, celui-ci peut être édité à l'aide d'un programme graphique
en dehors de TIA Portal puis réimporté.
Voir aussi
8.2.1.2 Exporter les graphiques d'un projet
Conditions
Utilisation
Vous avez le choix entre exporter un graphique individuel ou exporter tous les graphiques de
la bibliothèque de graphiques d'un projet dans toutes les langues. Un fichier XML contenant
toutes les entrées du graphique du projet concernées est créé lors de l'exportation et référencé
avec les graphiques exportés. Les graphiques concernés sont stockés avec le fichier XML
dans le même répertoire du système de fichiers.
Pour que les graphiques exportés ("*.jpg", "*.bmp", "*.png", "*.ico" etc.) puissent être modifiés,
ces graphiques ne sont pas protégés en écriture.

Code du programme : Exporter un graphique

Pour exporter le graphique requis, utilisez le code de programme suivant :
//Exports all language variants of a single grafic

Project project = …;
MultiLingualGraphicComposition graphicsComposition = project.Graphics;
MultiLingualGraphic graphic = graphicsComposition.Find("graphicName");
graphic.Export(new FileInfo(@"D:\ExportFolder\graphicName.xml"),
ExportOptions.WithDefaults);
Code du programme : Exporter tous les graphiques

Pour exporter tous les graphiques de la bibliothèque de graphiques, modifiez le code de
programme suivant :
//Exports all graphics of a graphic library

MultiLingualGraphicComposition graphicsComposition = project.Graphics;
foreach(MultiLingualGraphic graphic in graphicsComposition)
{
graphic.Export(new FileInfo(string.Format(@"D:\Graphics\{0}.xml", graphic.Name)),
}
8.2.1.3 Importer des graphiques dans un projet
Conditions requises
Utilisation
Un fichier XML est stocké avec les différentes versions linguistiques d'un graphique dans un
répertoire de votre système de fichiers.
Vous pouvez référencer tous les graphiques dans un chemin relatif de votre fichier XML.
Vous pouvez désormais importer toutes les versions linguistiques d'un graphique contenu
dans le fichier XML dans la bibliothèque de graphiques.
Veuillez également tenir compte de ce qui suit Importation de données de configuration
(Page 780).

Code du programme
Pour importer un ou plusieurs graphiques, modifiez le code de programme suivant :
//Import all language variants of a single graphic

MultiLingualGraphicComposition graphicComposition = project.Graphics;
graphicComposition.Import(new FileInfo(@"D:\Graphics\Graphic1.xml"),
ImportOptions.Override);
8.2.2 Textes du projet
8.2.2.1 Exportation de textes de projet
Conditions
Utilisation
Dans TIA Portal, les textes de projet se trouvent sous le nœud "Langues et ressources" d'un
projet. Ces textes sont exportés dans un fichier *.xlsx qui peut, par exemple, être utilisé pour
des traductions. Les restrictions valables pour l'interface utilisateur s'appliquent également à
l'exportation et l'importation de textes de projet. Restrictions valables :
● Les textes exportés peuvent être importés uniquement dans le projet dont ils ont été
exportés.
● Les textes ne peuvent être traduits que dans les langues existant dans le projet. Si
nécessaire, vous pouvez ajouter des langues du projet via TIA Portal Openness.
● Seuls les textes existants peuvent être réimportés. Une fois que des textes ont été
supprimés du projet d'origine ou créés à nouveau, l'importation de ces textes échoue.
Vous devez définir les paramètres suivants :
Nom Exemple Description

pah new FileInfo ("D:\Test\Project‐ Chemin du fichier d'exportation
Text.xlsx")
sourceLanguage new CultureInfo("en-US") Langue de référence de laquelle le texte doit être traduit
targetLanguage new CultureInfo("de-DE") Langue de référence dans laquelle le texte doit être traduit

Remarque
Les textes multilingues sont exportés avec l'objet de niveau supérieur auquel ils appartiennent.
Les textes multilingues ne peuvent pas être exportés de manière explicite.
Code de programme : exporter depuis le nœud "Langues et ressources"

Des paramètres de l'exemple utilisé, il résulte le code de programme suivant pour l'exportation
de textes de projet :
project.ExportProjectTexts(new FileInfo(@"D:\Test\ProjectText.xlsx"), new CultureInfo("en-

US"), new CultureInfo("de-DE"));
Structure XML d'un élément de texte multilingue exporté
8.2.2.2 Importation de textes de projet
Conditions

Utilisation
Dans TIA Portal, les textes de projet se trouvent sous le nœud "Langues et ressources" d'un
projet. Vous pouvez importer des textes de projet d'un fichier *.xlsx, ce qui peut servir à des fins
de traduction, par exemple. Les restrictions valables pour l'interface utilisateur s'appliquent
également à l'exportation et l'importation de textes de projet. Restrictions valables :
● Les textes exportés peuvent être importés uniquement dans le projet dont ils ont été
exportés.
● Les textes traduits peuvent être importés uniquement dans les langues disponibles dans le
projet dont ils ont été exportés.
● Seuls les textes existants peuvent être réimportés. Une fois que des textes ont été
supprimés du projet d'origine ou créés à nouveau, l'importation de ces textes échoue.
Vous devez définir les paramètres suivants :

path new FileInfo(@"D:\Test\Project‐ Chemin du fichier d'importation
Text.xlsx")
updateSourceLangua‐ true Pour "true", le texte de la langue de référence est actualisé à
ge l'aide du fichier d'exportation.
Pour "false", le texte de la langue de référence n'est pas ac‐
tualisé.
Remarque
Les textes multilingues sont importés avec l'objet de niveau supérieur auquel ils appartiennent.
Les textes multilingues ne peuvent pas être importés de manière explicite.
Code de programme
Des paramètres de l'exemple utilisé, il résulte le code de programme suivant pour l'importation
de textes de projet :
ProjectTextResult result = project.ImportProjectTexts(new FileInfo(@"D:\Test

\ProjectText.xlsx"), true);
L'importation de textes de projet fournit en retour un objet qui affiche l'état de l'importation et
indique le chemin où le journal d'importation est enregistré. Pour accéder à ces attributs, vous
pouvez utiliser les codes suivants :
ProjectTextResultState resultState = result.State;

FileInfo logFilePath = result.Path;

8.3 Importation/exportation de données d'un appareil IHM
8.3.1 Structure d'un fichier XML
Introduction
Les données du fichier d'exportation issues de l'importation/exportation sont organisées au
moyen d'une structure de base.
Structure de base d'un fichier d'exportation

Le fichier d'exportation est créé au format XML.
Le fichier XML commence par des informations sur le document. Il comporte les données de
l'installation spécifique à l'ordinateur avec laquelle le projet a été exporté.
Le fichier d'exportation comprend les deux zones suivantes :
● Informations sur le document
Cette zone vous permet d'indiquer vos propres informations relatives à l'exportation et ce
dans une syntaxe XML valide. L'importation ignore le contenu.
Vous pouvez par ex. insérer un bloc <IntegrityInformation>...</
IntegrityInformation> en plaçant des informations supplémentaires à la validation.
Après la transmission du fichier XML, le destinataire peut vérifier avant l'importation avec ce
bloc si le fichier XML a été modifié.
● Objet
Cette zone contient les éléments à exporter.

,QIRUPDWLRQV
VXUOH
GRFXPHQW
2EMHWJUDSKLTXH

Objets graphiques d'un fichier d'exportation

Les éléments exportés sont disponibles dans d'autres éléments du fichier XML.
+PL6FUHHQ6FUHHQ,' ಯಯ!
$WWULEXWH/LVW!
$FWLYH/D\HU!$FWLYH/D\HU!
$WWULEXWVGH
%DFN&RORU!%DFN&RORU!
O
REMHWJUDSKLTXH
1DPH!6FUHHQB1DPH!
$WWULEXWH/LVW!
/LQN/LVW!
2EMHWJUDSKLTXH /LHQVGH 7HPSODWH7DUJHW,' ಯ#2SHQ/LQNಯ!
O
REMHWJUDSKLTXHYHUV 1DPH!7HPSODWHB1DPH!
G
DXWUHVREMHWV 7HPSODWH!
/LQN/LVW!
2EMHFW/LVW!
2EMHWV
VXERUGRQQ«V 2EMHFW/LVW!
+PL6FUHHQ6FUHHQ!
Voir aussi
8.3.2 Structure des données pour l'importation/exportation
Objets
La structure de base est la même pour tous les objets.
Chaque objet du fichier XML débute par son type, p. ex. "Hmi.Screen.Button" et un ID. L'ID est
automatiquement générée durant l'exportation.
Excepté l'objet de départ, chaque objet contient également un attribut XML

"CompositionName". La valeur de cet attribut est prédéfinie. Dans quelques cas, vous devez
spécifier cet attribut, p. ex. pour changer d'inscription quand un bouton est enfoncé ou relâché.

Attributs
Chaque objet comprend des attributs qui sont contenus dans une section appelée
"AttributeList". Chaque attribut est structuré comme élément XML, p. ex. "BackColor". La
valeur d'un attribut est structurée comme contenu XML, p. ex "204, 204, 204".
Pour référencer des objets, chaque objet reçoit au besoin une section appelée "LinkList". Cette
section contient des liaisons à d'autres objets à l'intérieur ou à l'extérieur du fichier XML.
Chaque liaison est structurée comme élément XML. La désignation d'une liaison est prédéfinie
par l'objet cible dans le fichier modèle. Chaque liaison comprend également l'attribut
"TargetID". Si l'objet cible se trouve dans le fichier XML, la valeur de l'attribut "TargetID" est l'ID
de l'objet référencé, précédé de dièse "#". Si l'objet cible ne se trouve pas dans le fichier XML,
la valeur de l'attribut "TargetID" est égale à "@OpenLink". La référence à l'objet proprement
dite est structurée comme un élément XML subordonné.

Corrélation entre les objets et la structure XML

Les figures ci-dessous montrent la corrélation entre la structure XML exportée et les objets
correspondants dans WinCC.

Figure 8-1 Corrélation entre l'interface utilisateur WinCC et la structure XML
Figure 8-2 Corrélation entre les paramètres de WinCC et la structure XML
8.3.3 Cycles
8.3.3.1 Exportation de cycles
Conditions
Utilisation
L'interface TIA Portal Openness API prend en charge l'exportation de tous les cycles d'un
appareil IHM connu vers un fichier XML. La génération du fichier d'export correspondant
indique que l'export est terminé.

Code du programme
Pour exporter des cycles d'un appareil IHM vers un fichier XML, modifiez le code de
programme suivant :
//Exports cycles from an HMI device

private static void ExportCyclesFromHMITarget(HmiTarget hmitarget)
{
CycleComposition cycles = hmitarget.Cycles;
foreach(Cycle cycle in cycles)
{
cycle.Export(new FileInfo(string.Format(@"C:\Samples\{0}.xml", cycle.Name)),
}
}
8.3.3.2 Importer des cycles
Conditions
Utilisation
Si vous utilisez ImportOptions.None, le numéro de la composition (Composition count)
vous permet de détecter les cycles effectivement importés. Vous avez accès à ces cycles
importés.
Remarque
Les cycles standard ont des attributs qui ne peuvent être édités dans l'interface utilisateur. Si
vous indiquez dans le fichier d'importation que ces attributs doivent être modifiés, l'importation
déclenche une NonRecoverableException et ferme TIA Portal.

Code du programme
Pour importer un cycle ou plusieurs cycles dans un appareil IHM depuis un fichier XML,
//Imports cycles to an HMI device

private static void ImportCyclesToHMITarget(HmiTarget hmitarget)
{
CycleComposition cycles = hmitarget.Cycles;
string dirPathImport = @"C:\OpennessSamples\Import\";
string cycleImportFileName = "CycleImport.xml";
string fullFilePath = Path.Combine(dirPathImport, cycleImportFileName);
cycles.Import(new FileInfo(fullFilePath), ImportOptions.None);

}
Voir aussi
8.3.4 Table des variables
8.3.4.1 Exporter des tables de variables IHM
Conditions
Voir Établir une liaison à TIA Portal (Page 79)
Utilisation
Un fichier XML est exporté par table de variables IHM. L'API prend en charge ce processus
d'exportation. L'exportation de tables de variables est aussi disponible dans les sous-dossiers.

Code du programme : Exporter toutes les tables de variables IHM à partir d'un dossier indiqué
Pour exporter toutes les tables de variables IHM d'un dossier défini, modifiez le code de
programme suivant :
//Exports all tag tables from a tag folder

private static void ExportAllTagTablesFromTagFolder(HmiTarget hmitarget)
{
TagTableComposition tables = folder.TagTables;
foreach (TagTable table in tables)

{
FileInfo info = new FileInfo(string.Format(@"C:\OpennessSamples\TagTables\{0}.xml",
table.Name));
table.Export(info, ExportOptions.WithDefaults);
}
}
Code du programme : Exporter une table de variables IHM

Pour exporter une seule table de variables IHM, modifiez le code de programme suivant :
//Exports a tag table from an HMI device

private static void ExportTagTableFromHMITarget(HmiTarget hmitarget)
{
string tableName = "Tag table XYZ";
TagTable table = tables.Find(tableName);
if (table != null)
{
FileInfo info = new FileInfo(string.Format(@"C:\OpennessSamples\TagTables\{0}.xml",
table.Name));
table.Export(info, ExportOptions.WithDefaults);
}
}

Code du programme : Exporter toutes les tables de variables IHM

Pour exporter toutes les tables de variables IHM, modifiez le code de programme suivant :
//Exports all tag tables from an HMI device

private static void ExportAllTagTablesFromHMITarget(HmiTarget hmitarget)
{
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)

{
TagTableComposition tables = folderToExport.TagTables;
{
string fullFilePath = string.Format(@"C:\OpennessSamples\TagTables\{0}.xml",
table.Name);
table.Export(new FileInfo(fullFilePath), ExportOptions.WithDefaults);
}
}
private static void ExportTablesInSystemFolder(TagSystemFolder folderToExport)

{
TagTableComposition tables = folderToExport.TagTables;
{
string fullFilePath = string.Format(@"C:\OpennessSamples\TagTables\{0}.xml",
table.Name);
table.Export(new FileInfo(fullFilePath), ExportOptions.WithDefaults);
}
}

8.3.4.2 Importer une table de variables IHM
Conditions
Code du programme
Pour importer la table de variables IHM d'un fichier XML dans un dossier personnalisé ou un
dossier système, modifiez le code de programme suivant :
//Imports a single HMI tag table from a XML file

private static void ImportSingleHMITagTable(HmiTarget hmitarget)
{
FileInfo info = new FileInfo(@"D:\Samples\Import\myExportedTagTable.xml");

tables.Import(info, ImportOptions.Override);
}
Importation erronée de variables

Si vous utilisez les caractères spéciaux suivants dans des noms de variables ou de variables
référencées, l'importation de variables échoue :
● . (Point)
● \ (Barre oblique inversée)
Solution 1 :
Vérifiez avant une exportation que les noms des variables à exporter ou des variables
référencées ne contiennent aucun point ou barre oblique inversée.
Solution 2 :
Ajoutez dans le fichier d'importation des guillemets aux noms des variables ou de variables
référencées.
Exemple
● Nom de variable avec caractère spécial :
<name>Siemens.Simatic.Hmi.Utah.Tag.HmiTag:41000_Options_Time_Date
\DB_SFX0908_HMI1.Actual_Date_Time.Hour</name>
● Nom de variable avec caractère spécial, entre guillemets :
<name>"Siemens.Simatic.Hmi.Utah.Tag.HmiTag:41000_Options_Time_Date
\DB_SFX0908_HMI1.Actual_Date_Time.Hour"</name>

8.3.4.3 Exporter des variables individuelles d'une table de variables IHM
Conditions
Utilisation
Les types d'objet de modèle d'objet suivants peuvent exister sous la forme d'éléments
subordonnés d'une variable HMI et sont pris en compte à l'exportation :
MultilingualText Pour commentaire, TagValue, DisplayName

TagArrayMemberTag Pour éléments de tableau IHM
TagStructureMember Pour éléments de structure IHM
Event Pour événements configurés
MultiplexEntry Pour les entrées multiplex configurées de variables
Code du programme
Pour exporter une seule variable d'une table de variables IHM vers un fichier XML, modifiez le
//Exports a selected tag from a tag table

private static void ExportSelectedTagFromTagTable(HmiTarget hmitarget)
{
TagSystemFolder tagFolder = hmitarget.TagFolder;
TagTable mytable = tagFolder.TagTables.Find("MyTagTable");
TagComposition containingTags = mytable.Tags;

Tag myTag = containingTags.Find("MyTag");
if (myTag != null)
{
FileInfo info = new FileInfo(string.Format(@"C:\OpennessSamples\Tags\{0}.xml",
myTag.Name));
myTag.Export(info, ExportOptions.WithDefaults);
}
}

8.3.4.4 Importer des variables individuelles d'une table de variables IHM
Conditions
Utilisation
Les types d'objet de modèle d'objet suivants peuvent exister sous la forme d'éléments
subordonnés d'une variable HMI et être pris en compte à l'importation :
MultilingualText Pour commentaire, TagValue, DisplayName

TagArrayMemberTag Pour éléments de tableau IHM
TagStructureMember Pour éléments de structure IHM
Event Pour événements configurés
MultiplexEntry Pour les entrées multiplex configurées de variables
Code du programme
Pour importer une variable IHM dans une table de variables IHM depuis un fichier XML,
//Imports a tag into a tag table

private static void ImportTagIntoTagTable(HmiTarget hmitarget)
{
TagSystemFolder tagFolder = hmitarget.TagFolder;
TagTable myTable = tagFolder.DefaultTagTable;
TagComposition tagComposition = myTable.Tags;
FileInfo info = new FileInfo(@"D:\Samples\Import\myExportedTag.xml");

tagComposition.Import(info, ImportOptions.Override);
}
8.3.4.5 Particularités de l'importation/exportation de variables IHM
Introduction
L'exportation/importation des variables IHM suivantes présentent des particularités :
● Variables IHM externes avec liaison intégrée
● Variables IHM avec le type de données "UDT"

Codes de programme similaires

Le code de programme pour les variables IHM susmentionnées est presque identique aux
codes de programme suivants :
● Code du programme : Exportation de variables IHM (Page 799)
● Code du programme : Importation de variables IHM (Page 800)
Conditions requises
Particularités de l'importation/exportation d'une variable IHM externe avec liaison intégrée

Lors de l'exportation d'une variable IHM externe avec liaison IHM intégrée, seule la liaison des
variables IHM à la variable API est enregistrée dans le fichier d'exportation, à la place des
données de variables API.
Avant l'importation, assurez-vous que l'API, les variables API correspondantes et la liaison
intégrée à l'API correspondant sont présents dans le projet. Si tel n'est pas le cas, il faut créer
ces éléments avant de lancer l'importation. Lors de l'importation consécutive de la variable IHM
externe, la liaison à la variable API est réactivée.
Les noms des variables IHM externes au-delà de toutes les tables de variables d'un projet
doivent être univoques. Si vous n'indiquez pas la table de variables correspondant à la variable
IHM lors de l'importation, l'importation est annulée.
Pour importer une variable IHM externe avec liaison intégrée, utilisez la structure XML
suivante :
<Hmi.Tag.Tag ID="1" CompositionName="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>

Particularités de l'importation/exportation d'une variable IHM du type de données "UDT"

Lors de l'exportation d'une variable IHM du type de données "UDT", le raccourci vers le type de
données est exporté. Pour l'importation, seuls les types de données versionnés sont pris en
charge.
Les types de données doivent être enregistrés dans la bibliothèque de projet. Les types de
données de la bibliothèque globale ne sont pas pris en charge.
Les règles suivantes doivent être respectées pour l'importation :
● Les types de données référencés doivent figurer dans la bibliothèque de projet.
L'importation est annulée si le type de données ne figurent pas dans la bibliothèque de
projet.
● Le type de données référencé doit être versionné. L'attribution de versions est prise en
charge à partir de TIA Portal V13 SP1.
Si le type de données n'est pas versionné, une exception est déclenchée.
Remarque
Le premier type de données trouvé est utilisé pour la résolution de la référence lors de
l'importation.
Tenez compte ici des points suivants : Le répertoire racine de la bibliothèque est d'abord
parcouru, puis les sous-dossiers.
Pour importer une variable IHM du type de données "UDT", utilisez la structure XML suivante :
<Hmi.Tag.Tag ID="1" CompositionName="Tags">

...
<LinkList>
<DataType TargetID="@OpenLink">
<Name>HmiUdt_1 V 1.0.0</Name> <- Must exist in the project library
</DataType>
...
</LinkList>
...
</Hmi.Tag.Tag>
8.3.5 Scripts VB
8.3.5.1 Exporter des scripts VB
Conditions

Utilisation
Tous les dossiers personnalisés de niveau inférieur sont pris en compte au cours de
l'exportation. Pour chaque script VB exporté est créé un fichier XML spécifique.
Code du programme : Exporter un script VB

Pour exporter un script VB sélectionné d'un appareil IHM vers un fichier XML, modifiez le code
//Exports a single vbscript of an HMI device

private static void ExportSingleVBScriptOfHMITarget(HmiTarget hmitarget)
{
VBScriptComposition vbScripts = vbScriptFolder.VBScripts;
VBScript vbScript = vbScripts.Find("MyVBScript");
FileInfo info = new FileInfo(string.Format(@"C:\OpennessSamples\Export\Scripts

\{0}.xml", vbScript.Name));
vbScript.Export(info, ExportOptions.None);
}
8.3.5.2 Exporter des scripts VB à partir d'un dossier
Conditions
Utilisation
Pour chaque script VB exporté est créé un fichier XML spécifique.

Code du programme : exporter un script VB d'un dossier personnalisé

Pour exporter un script VB d'un dossier personnalisé vers un fichier XML, modifiez le code de
programme suivant :
//Exports vbscripts of a selected vbscript system folder

private static void ExportVBScriptOfSelectedVBScriptSystemFolder(HmiTarget hmitarget)
{
VBScriptUserFolderComposition vbUserFolders = vbScriptFolder.Folders;
VBScriptUserFolder vbUserFolder = vbUserFolders.Find("MyVBUserFolder");
VBScriptComposition vbScripts = vbUserFolder.VBScripts;
foreach (VBScript script in vbScripts)

{
FileInfo info = new FileInfo(String.Format(@"C:\OpennessSamples\Export\Scripts
\{0}.xml", script.Name));
script.Export(info, ExportOptions.None);
}
}
Code du programme : Exporter tous les scripts VB à partir d'un dossier système
Pour exporter tous les scripts VB du dossier système, modifiez le code de programme suivant :
//Exports all vbscripts by using a foreach loop

private static void ExportAllVBScripts(HmiTarget hmitarget)
{
if (vbScripts == null) return;
foreach (VBScript script in vbScripts)

{
FileInfo info = new FileInfo(string.Format(@"C:\OpennessSamples\Export\Scripts
\{0}.xml", script.Name));
script.Export(info, ExportOptions.None);
}
}
8.3.5.3 Importer des scripts VB
Conditions

Utilisation
Les importations groupées sont prises en charge : Sinon, vous pouvez aussi utiliser un code de
programme avec une boucle Foreach (Exporter des scripts VB (Page 802)).
Code du programme
Pour importer un script VB dans un appareil IHM depuis un fichier XML, modifiez le code de
programme suivant :
private static void ImportSingleVBScriptToHMITarget(HmiTarget hmitarget)

{
if (vbScripts 00 null) return;
{
FileInfo info = new FileInfo(@"D:\Samples\Import\VBScript.xml");
vbScripts.Import(info, ImportOptions.None);
}
}
8.3.6 Listes de textes
8.3.6.1 Exporter des listes de textes à partir d'un appareil IHM
Conditions
Utilisation
L'exportation de listes de textes et de graphiques inclut toutes les entrées des listes. Les listes
de textes et de graphiques peuvent être exportées séparément.
Les listes de textes d'un appareil IHM sont exportées. Pour chaque liste de textes exportée, un
fichier XML spécifique est créé.

Code du programme
Pour exporter des listes de textes d'un appareil IHM, modifiez le code de programme suivant :
//Export TextLists
private static void ExportTextLists(HmiTarget hmitarget)
{
TextListComposition text = hmitarget.TextLists;
foreach (TextList textList in text)
{
FileInfo info = new FileInfo(string.Format(@"D:\Samples\Export\{0}.xml",
textList.Name);
textList.Export(info, ExportOptions.WithDefaults);
}
}
8.3.6.2 Importer une liste de texte dans un appareil IHM
Conditions requises
Utilisation
L'interface API prend en charge l'importation d'une liste de textes dans un appareil IHM depuis
un fichier XML.
Code du programme
Pour importer une liste de textes dans un appareil IHM depuis un fichier XML, modifiez le code
//Imports a single TextList

private static void ImportSingleTextList(HmiTarget hmitarget)
{
TextListComposition textListComposition = hmitarget.TextLists;
IList<TextList> importedTextLists = textListComposition.Import(new
FileInfo(@"D:\SamplesImport\myTextList.xml"), ImportOptions.Override);
}

8.3.6.3 Formats XML avancés pour l'exportation/importation de listes de textes
Conditions requises
● Exportation standard de listes de textes
Voir Exporter des listes de textes à partir d'un pupitre opérateur (Page 805)
● Importation standard de listes de textes
Voir Importer des listes de textes dans un pupitre opérateur (Page 806)
Utilisation
Une liste de textes peut aussi contenir des textes formatés Cela concerne pour l'essentiel les
formatages suivants :
● Formatage de texte
● Références aux autres objets dans le texte
Les formatages textuels purs dans une liste de textes à exporter conduisent à un format
d'exportation XML étendu. Les références aux objets sont exprimés sous la forme d'Open
Links. De même que les listes de textes à importer avec des textes formatés.
Les formats d'exportation XML étendus peuvent aussi nettement se complexifier. A titre
d'exemple, d'autres liens que le seul nom de l'objet peuvent parfois exister dans la liste de
textes, p. ex. via un Open Link vers une variable API d'un autre appareil. Si tel est le cas, toutes
les informations doivent être codées en une chaîne de caractères pour supprimer l'Open Link.


8.3.7 Listes de graphiques
8.3.7.1 Exporter les listes de graphiques
Conditions
Utilisation
L'exportation de listes de textes et de graphiques inclut toutes les entrées des listes. Les listes
de textes et de graphiques peuvent être exportées séparément.
Un fichier XML est créé par liste de graphiques. Les objets graphiques globaux contenus dans
les listes de graphiques sont exportés sous la forme d'Open Links.
Code du programme
Pour exporter des listes de graphiques d'un pupitre opérateur, modifiez le code de programme
suivant :
//Exports GraphicLists
private static void ExportGraphicLists(HmiTarget hmitarget)
{
GraphicListComposition graphic = hmitarget.GraphicLists;
foreach (GraphicList graphicList in graphic)
{
graphicList.Name));
graphicList.Export(info, ExportOptions.WithDefaults);
}
}
8.3.7.2 Importer les listes de graphiques
Conditions requises

Utilisation
L'interface API prend en charge l'importation d'une liste de graphiques dans un appareil IHM
depuis un fichier XML.
Tous les objets graphiques référencés de la liste de graphiques sont inclus dans l'importation.
Les références aux graphiques globaux ne sont pas incluses. Si les graphiques globaux
référencés existent dans le projet cible, les références aux graphiques globaux sont rétablies
lors de l'importation.
Code du programme
Pour importer une liste de graphiques dans un appareil IHM depuis un fichier XML, modifiez le
//Imports a single GraphicList

private static void ImportSingleGraphicList(HmiTarget hmitarget)
{
GraphicListComposition graphicListComposition = hmitarget.GraphicLists;
IList<GraphicList> importedGraphicLists = graphicListComposition.Import(new
FileInfo(@"D:\Samples\Import\myGraphicList.xml"), ImportOptions.Override);
}
8.3.8 Connexions
8.3.8.1 Exporter des connexions
Conditions
Utilisation
L'interface API prend en charge l'exportation de toutes les liaisons d'un appareil IHM vers un
fichier XML.
Remarque
Exporter des connexions intégrées
L'exportation de connexions intégrées n'est pas prise en charge.
Pour chaque connexion exportée, un fichier XML spécifique est créé.

Code du programme
Pour exporter toutes les connexions d'un appareil IHM vers un fichier XML, modifiez le code de
programme suivant :
//Exports communication connections from an HMI device

private static void ExportConnectionsFromHMITarget(HmiTarget hmitarget)
{
ConnectionComposition connections = hmitarget.Connections;
foreach(Connection connection in connections)
{
connection.Name));
connextion.Export(info, ExportOptions.WithDefaults);
}
}
8.3.8.2 Importation de connexions
Conditions requises
Utilisation
L'interface API prend en charge l'importation de toutes les liaisons d'un appareil IHM dans un
appareil IHM depuis un fichier XML. Si vous souhaitez importer plusieurs liaisons de
communication, importez à chaque fois le fichier XML pour la connexion correspondante.
Remarque
Si vous importez une liaison dans un projet dans lequel une liaison intégrée est déjà configurée,
cette liaison n'est pas écrasée. L'importation est annulée et une Exception est déclenchée.

Code du programme
Pour importer une seule liaison d'un appareil IHM dans un appareil IHM depuis un fichier XML,
//Imports Communication connections to an HMI device

private static void ImportConnectionsToHMITarget(HmiTarget hmitarget)
{
ConnectionComposition connections = hmitarget.Connections;
IList<Connection> importedConnectionLists = connections.Import(new
FileInfo(@"D:\Samples\Import\myConnectionImport.xml"), ImportOptions.Override);
}
8.3.9 Vues
8.3.9.1 Vue d'ensemble des objets graphiques pouvant être exportés
Utilisation
Vous pouvez exporter et importer les vues suivantes par le biais d'API TIA Portal Openness :
Tableau 8-4 Vues prises en charge
Objet Exportation/importation pos‐

sible
Vue Oui
Vue globale Oui
Modèle de vue Oui
Fenêtre permanente Oui
Vue contextuelle Oui
Vue Slide-in Oui

Vous pouvez exporter ou importer les objets de vue suivants par le biais d'API TIA Portal
Openness :
Tableau 8-5 Objets graphiques pris en charge
Zone Type d'objet Exportation/importation pos‐

sible
Objets simples Ligne Oui
Ligne polygonale Oui
Polygone Oui
Ellipse Oui
Segment d'ellipse –
Segment de cercle –
Arc d'ellipse –
Arc de cercle –
Cercle Oui
Rectangle Oui
Connecteur –
Champ de texte Oui
Affichage graphique Oui
Tuyau –
Double raccord en T –
Raccord en T –
Coude –


sible
Eléments Champ d'E/S Oui
Champ d'E/S graphique Oui
Champ de texte éditable –
Champ de liste –
Zone de liste déroulante –
Bouton Oui
Bouton rond –
Bouton-poussoir lumineux Oui
Commutateur Oui
Champ d'E/S symbolique Oui
Champ date/heure Oui
Bargraphe Oui
Bibliothèque d'icônes Oui
Curseur Oui
Barre de défilement –
Case à cocher –
Bouton d'option –
Instrument à aiguille Oui
Horloge Oui
Vue de l'espace mémoire –
Touches de fonction (touches programmables) Oui
Groupes Oui
Instances de bloc d'affichage Oui


sible
Eléments de com‐ Fenêtre de vues –
mande Vue des utilisateurs Oui
Travail d'impression/Diagnostic de script –
Affichage caméra –
Affichage PDF –
Vue de recette –
Vue des alarmes –
Indicateur d'alarme –
Fenêtre d'alarmes –
Vue de courbes f(x) –
Vue de courbes f(t) –
Vue tabellaire –
Table des valeurs –
Navigateur HTML –
Media Player –
Diagnostic de voie –
WLAN - Réception –
Zone - Nom –
Zone - Signal –
Nom de la plage d'action –
Nom de la plage d'action (RFID) –
Signal de la plage d'action –
Etat de chargement –
Molette –
Indicateur d'aide –
Vue Sm@rtClient –
Visualisation/forçage –
Vue de l'espace mémoire –
Affichage de section de programme NC –
Vue de diagnostic système –
Fenêtre de diagnostic système –
Voir aussi

8.3.9.2 Exporter toutes les vues d'un appareil IHM
Conditions
Utilisation
Un autre code de programme est nécessaire pour exporter toutes les vues agrégées de tous
les dossiers personnalisés d'un appareil IHM.
Code du programme : Exporter toutes les vues d'un appareil

Pour exporter les vues d'un dossier de vues personnalisé d'un appareil IHM et le dossier de
vues système, modifiez le code de programme suivant :
private static void ExportScreensOfDevice(string rootPath, HmiTarget hmitarget)

{
DirectoryInfo info = new DirectoryInfo(rootPath);
info.Create();
//export the ScreenFolder recursive
string screenPath = Path.Combine(rootPath, "Screens");

info = new DirectoryInfo(screenPath);
info.Create();
ExportScreens(screenPath, hmitarget);
}
Code de programme : Exporter toutes les vues d'un dossier personnalisé

Pour exporter les vues d'un dossier de vues personnalisé d'un appareil IHM et le dossier de
vues système, modifiez le code de programme suivant :
private static void ExportScreensOfDevice(HmiTarget hmitarget)

{
ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Find("MyScreenFolder");
foreach(Screen screen in screens)
{
FileInfo info = new FileInfo(string.Format(@"D:\Samples\Screens\{0}\{1}.xml",
folder.Name, screen.Name));
screen.Export(info, ExportOptions.WithDefaults);
}
}

Code du programme : exporter toutes les vues d'un appareil quel que soit l'utilisateur
Pour exporter toutes les vues, modifiez le code de programme suivant :
public static void ExportScreens(string screenPath, HmiTarget target)

{
foreach(Screen screen in target.ScreenFolder.Screens)
{
screen.Export(new FileInfo(Path.Combine(screenPath, screen.Name + ".xml")),
}
foreach(ScreenUserFolder subfolder in target.ScreenFolder.Folders)
{
ExportScreenUserFolder(Path.Combine(screenPath, folder.Name), subfolder);
}
}
private static void ExportScreenUserFolder(string screenPath,ScreenUserFolder folder )

{
foreach(Screen screen in folder.Screens)
{
screen.Export(new FileInfo(Path.Combine(screenPath, screen.Name + ".xml")),
}
foreach(ScreenUserFolder subfolder in folder.Folders)
{
ExportScreenUserFolder(Path.Combine(screenPath, subfolder.Name), subfolder);
}
}
8.3.9.3 Exporter une vue à partir d'un dossier de vues
Conditions

Utilisation
Les données suivantes d'une vue sont exportées :
Vue Données
Attributs ActiveLayer, BackColor, Height, Width, Name, Number, HelpText
Ouvrir des liens Template
Compositions ● Layers
● Animations
Toutes les animations basées sur Runtime Advanced configurées sont ex‐
portées.
● Events
Tous les événement basés sur Runtime Advanced configurés sont exportés.
● Softkeys
Toutes les touches programmables configurées sont exportées.
Pour chaque couche, les données suivantes sont exportées :
Remarque
le nom de la couche dans TIA Portal est un texte vide par défaut.
Si vous ne modifiez pas le nom de la couche dans TIA Portal, le nom de la couche exportée est
vide. Dans ce cas, le nom de la couche affiché dans TIA Portal dépend de la langue de
l'interface utilisateur.
Si vous modifiez le nom de la couche dans TIA Portal, le nom modifié sera affiché dans toutes
les langues correspondantes.
Couche Données
Attributs Name, Index, VisibleES
Compositions ScreenItems (avec éléments graphique)
Les éléments suivants ne sont pas inclus dans l'exportation :

● Attributs spécifiques SCADA
● Couches qui ne contiennent pas d'éléments graphiques et dont les attributs ne se
distinguent pas des valeurs par défaut.

Code du programme
Pour exporter une seule vue à partir du dossier utilisateur ou du dossier système d'un appareil
IHM, modifiez le code de programme suivant :
//Exports a single screen from a screen folder

private static void ExportSingleScreenFromScreenFolder(HmiTarget hmitarget)
{
Screen screen = screens.Find("Screen_1.xml");
if (screen == null) return;
{
}
}
8.3.9.4 Importer des vues dans un appareil IHM
Conditions
Utilisation
Les vues ne peuvent être importées que dans un type donné d'appareil IHM. L'appareil IHM et
l'appareil à partir duquel les vues ont été exportées sont du même type d'appareil.
Les données suivantes d'une vue sont exportées :
Vue Données
Attributs ActiveLayer, BackColor, Height, Width, Name, Number, HelpText
Ouvrir des liens Templates
● Animations
Toutes les animations configurables pour des vues sont importées.
● Events
Toutes les animations configurables pour des événements sont importées.
● Softkeys
Toutes les animations configurables pour des touches programmables sont
importées.

Pour chaque couche, les données suivantes sont importées :
Remarque
Si vous avez indiqué un texte vide pour le nom de la couche avant l'importation, le nom de la
couche affiché dans TIA Portal dépend de la langue de l'interface utilisateur après l'importation.
Si vous avez attribué un nom à la couche, le nom indiqué est affiché dans toutes les langues
correspondantes après l'importation.
Couche Données
Attributs Name, Index
Compositions ScreenItems
Restrictions
● Lorsque la largeur et la hauteur d'une vue ne correspondent pas aux dimensions de
l'appareil, le processus d'importation est interrompu et une Exception est déclenchée.
L'ajustement des éléments graphiques compris n'est pas pris en charge. C'est pourquoi,
certains éléments graphiques peuvent se trouver en-dehors des limites de la vue. Si tel est
le cas, un avertissement du compilateur est émis.
● Le numéro de vue doit être univoque pour toutes les vues de l'appareil. L'importation d'une
vue est annulée si une vue avec un numéro de vue qui a déjà été créé dans l'appareil, est
trouvé. Si vous n'avez pas encore attribué de numéro à la vue, un numéro de vue univoque
est affecté à la vue pendant le processus d'importation.
● L'ordre des éléments graphiques au sein de l'ordre Z doit être univoque et sans lacunes
pour chaque couche dans la vue. C'est pourquoi une vérification de la cohérence, qui répare
l'ordre si nécessaire, est effectuée après l'importation de la vue. Ce processus peut
entraîner la modification d'"Indices de tabulation" pour certains éléments graphiques.
Vous pouvez modifier manuellement l'ordre Z des éléments graphiques dans le fichier XML.
L'élément graphique au premier emplacement se trouve tout à la fin de l'ordre Z.
Remarque
Vous pouvez modifier les valeurs de largeur et hauteur d'un élément graphique dans le fichier
XML si l'attribut "Adapter la taille au contenu" est activée pour l'élément graphique.
Remarque
L'importation de types de vue de la bibliothèque n'est pas prise en charge
À partir de WinCC V12 SP1, vous pouvez créer une vue en tant que type dans la bibliothèque.
Les instances du type de vue utilisées dans le projet peuvent être éditées avec l'application TIA
Portal Openness comme d'autres vues. Si vous exportez des vues, les instances des types de
vue sont exportées sans les informations de type.
Si vous réimportez ces vues dans le projet, les instances du type de vue sont écrasées et
l'instance est remplacée par le type de vue.

Code du programme : Importer des vues dans un appareil IHM

Pour importer des vues avec la boucle For each dans un appareil IHM, modifiez le code de
programme suivant :
//Imports all screens to an HMI device

private static void ImportScreensToHMITarget(HmiTarget hmitarget)
{
FileInfo[] exportedScreens = new FileInfo[] {new FileInfo(@"D:\Samples\Import
\Screen_1.xml"), new FileInfo(@"D:\Samples\Import\Screen_2.xml")};
foreach (FileInfo screenFileInfo in exportedScreens)
{
folder.Screens.Import(screenFileInfo, ImportOptions.Override);
}
}
Code du programme : Importer dans un dossier utilisateurs nouvellement créé

Pour importer une vue dans un dossier utilisateur venant d'être créé d'un appareil IHM,
//Imports a single screen to a new created user folder of an HMI device

private static void ImportSingleScreenToNewFolderOfHMITarget(HmiTarget hmitarget)
{
ScreenUserFolder folder = hmitarget.ScreenFolder.Folders.Create("MyFolder");
folder.Screens.Import(new FileInfo(@"D:\Samples\Import\myScreens.xml"),
}
8.3.9.5 Exporter une fenêtre permanente
Conditions requises

Utilisation
Les données suivantes de la fenêtre permanente sont exportées :
Fenêtre permanente Données

Attributs ActiveLayer, BackColor, Height, Width, Name
Compositions Layers
Couche Données
Compositions ScreenItems (avec éléments graphiques)
Code du programme
Pour exporter une fenêtre permanente d'un appareil IHM vers un fichier XML, modifiez le code
//Exports a permanent area

private static void ExportScreenoverview(HmiTarget hmitarget)
{
ScreenOverview overview = hmitarget.ScreenOverview;
if (overview == null) return;
FileInfo info = new FileInfo(@"D:\Samples\Screens\ExportedOverview.xml");

overview.Export(info, ExportOptions.WithDefaults);
}
8.3.9.6 Importer une fenêtre permanente
Conditions
Utilisation
Les données suivantes de la fenêtre permanente sont importées :
Fenêtre permanente Données

Attributs ActiveLayer, BackColor, Height, Width, Name, Visible, Number
Compositions Layers

Couche Données
Lorsque la largeur et la hauteur d'une vue ne correspondent pas aux dimensions de l'appareil,
le processus d'importation est interrompu et une Exception est déclenchée. L'ajustement des
éléments d'appareil compris (éléments graphiques) n'est pas pris en charge. C'est pourquoi,
certains éléments d'appareil peuvent se trouver en-dehors des limites de la vue. Si tel est le
cas, un avertissement du compilateur est émis.
L'ordre des éléments d'appareil dans la fenêtre permanente doit être univoque et ne présenter
aucune lacune. C'est pourquoi une vérification de la cohérence, qui répare l'ordre si
nécessaire, est effectuée après l'importation de la fenêtre permanente. Ce processus peut
entraîner la modification d'"Indices de tabulation" pour certains éléments d'appareil.
Code du programme
Pour importer une fenêtre permanente dans un appareil IHM depuis un fichier XML, modifiez
//Imports a permanent area

private static void ImportScreenOverview(HmiTarget hmiTarget)
{
FileInfo info = new FileInfo(@"D:\Samples\Screens\ExportedOverview.xml");
hmiTarget.ImportScreenOverview(info, ImportOptions.Override);
}
8.3.9.7 Exporter tous les modèles de vue d'un appareil IHM
Conditions
Utilisation
Un fichier XML est créé par modèle de vue.
Les exportations groupées n'étant pas prises en charge, vous devez énumérer tous les
modèles de vue et les exporter séparément. Ce faisant, veillez à ce que les noms utilisés pour
les modèles de vue correspondent aux conventions de dénomination de fichiers de votre
système de fichiers.

Code de programme : exporter tous les modèles de vue d'un appareil

Pour exporter tous les modèles de vue d'un certain dossier, modifiez le code de programme
suivant :
public static void ExportScreenTemplatesOfDevice(string rootPath ,

ScreenTemplateUserFolder folder)
{
string screenPath = Path.Combine(rootPath, "Screens");
DirectoryInfo info = new DirectoryInfo(screenPath);
info.Create();
//export the ScreenTemplateFolder recursive

ExportScreenTemplates (screenPath, hmitarget);
}
Code de programme : exporter tous les modèles de vue d'un dossier défini
Pour exporter tous les modèles de vue, modifiez le code de programme suivant :
//Exports all screen templates of a selected folder

private static void ExportScreenTemplates(string templatePath, HmiTarget hmitarget)
{
foreach (ScreenTemplate screen in hmitarget.ScreenTemplateFolder.ScreenTemplates)
{
screen.Export(new FileInfo(Path.Combine(templatePath, screen.Name + ".xml")),
}
foreach (ScreenTemplateUserFolder folder in hmitarget.ScreenTemplateFolder.Folders)
{
ExportScreenTemplates(Path.Combine(templatePath, folder.Name), hmitarget);
}
}
8.3.9.8 Exporter des modèles de vue à partir d'un dossier
Conditions

Utilisation
Les données suivantes du modèle de vue sont exportées :
Modèles de vue Données

Attributs ActiveLayer, BackColor, Height, Width, Name
● Animations
Toutes les animations configurées sont exportées. Les animations SCADA
ne sont pas exportées.
● Softkeys
Toutes les touches programmables configurées sont exportées.
Couche Données
Code du programme : exporter un modèle de vue d'un dossier personnalisé

Pour exporter un seul modèle de vue à partir du dossier système ou d'un dossier personnalisé,
private static void ExportSingleScreenTemplate(string templatePath, HmiTarget hmiTarget)

{
hmiTarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder");
//or ScreenTemplateSystemFolder folder = hmiTarget.ScreenTemplateFolder;
ScreenTemplateComposition templates = folder.ScreenTemplates;
ScreenTemplate template = templates.Find("templateName");
if(template == null) return;
FileInfo info = new FileInfo(string.Format(@"D:\Samples\Templates\{0}\{1}.xml",

folder.Name, template.Name));
template.Export(info, ExportOptions.WithDefaults);
}

Code du programme : exporter tous les modèles de vue d'un dossier personnalisé
Pour exporter tous les modèles de vue d'un certain dossier, modifiez le code de programme
suivant :
public static void ExportScreenTemplateUserFolder(string rootPath,

ScreenTemplateUserFolder folder)
{
DirectoryInfo info = new DirectoryInfo(rootPath);
info.Create();
foreach (ScreenTemplate screen in folder.ScreenTemplates)

{
screen.Export(new FileInfo(Path.Combine(info.FullName, screen.Name + ".xml")),
}
foreach (ScreenTemplateUserFolder subfolder in folder.Folders)
{
ExportScreenTemplateUserFolder(Path.Combine(info.FullName, subfolder.Name),
subfolder);
}
}
Code de programme : exporter tous les modèles de vue d'un dossier défini
Pour exporter tous les modèles de vue, modifiez le code de programme suivant :
//Exports all screen templates of a selected folder

private static void ExportScreenTemplates(string templatePath, ScreenTemplateUserFolder
folder)
{
foreach (ScreenTemplate screen in folder.ScreenTemplates)
{
screen.Export(new FileInfo(Path.Combine(templatePath, screen.Name + ".xml")),
}
foreach (ScreenTemplateUserFolder subfolder in folders.Folders)
{
ExportScreenTemplates(Path.Combine(templatePath, subfolder.Name), subfolder);
}
}
8.3.9.9 Importer des modèles de vue
Conditions

Utilisation
Les données suivantes d'un modèle de vue sont importées :
Modèle de vue Données

Attributs ActiveLayer, BackColor, Height, Width, Name, SetTabOrderInFront
● Animations
Toutes les animations configurables pour des vues sont importées.
● Softkeys
Toutes les animations configurables pour des touches programmables sont
importées.
Couche Données
Lorsque la largeur et la hauteur d'un modèle de vue ne correspondent pas aux dimensions de
l'appareil, le processus d'importation est interrompu et une Exception est déclenchée.
L'ajustement des éléments graphiques compris n'est pas pris en charge. C'est pourquoi,
certains éléments graphiques peuvent se trouver en-dehors des limites de la vue. Si tel est le
cas, un avertissement du compilateur est émis.
L'ordre des éléments d'appareil dans le modèle de vue doit être univoque et ne présenter
aucune lacune. C'est pourquoi une vérification de la cohérence, qui répare l'ordre si
nécessaire, est effectuée après l'importation du modèle de vue. Ce processus peut entraîner
la modification d'"Indices de tabulation" pour certains éléments graphiques.
Code du programme : Importation générale

Pour importer tous les modèles de vues avec la boucle For each dans un appareil IHM,
//Imports screen templates to an HMI device

private static void ImportScreenTemplatesToHMITarget(HmiTarget hmitarget)
{
hmitarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder");
// or ScreenTemplateSystemFolder folder = hmitarget.ScreenTemplateFolder;
FileInfo[] exportedTemplates = {new FileInfo[] { new FileInfo(@"D:\Samples\Import
\Template_1.xml"), new FileInfo(@"D:\Samples\Import\Template_n.xml") };};
foreach (FileInfo templateFileName in exportedTemplates)
{
folder.ScreenTemplates.Import(templateFileName, ImportOptions.Override);
}
}

Code du programme : Importer dans un dossier utilisateurs nouvellement créé

Pour importer un modèle de vue dans un dossier utilisateur venant d'être créé d'un appareil
IHM, modifiez le code de programme suivant :
//Imports screen templates to a user folder of an HMI device

private static void ImportScreenTemplatesToFolderOfHMITarget(HmiTarget hmitarget)
{
ScreenTemplateUserFolder screenTemplateFolder =
hmitarget.ScreenTemplateFolder.Folders.Find("MyTemplateFolder");
ScreenTemplateUserFolder folder = screenTemplateFolder.Folders.Create("MyNewFolder");
folder.ScreenTemplates.Import(new FileInfo(@"D:\Samples\Import\ScreenTemplate.xml"),
}
8.3.9.10 Exportation d'une vue contextuelle
Conditions
Utilisation
Les données suivantes de la vue contextuelle sont exportées :

Attributs ActiveLayer, BackColor, GridColor, Height, Name, ScrollbarBackgroundColor,
ScrollbarForegroundColor, Width
● Events
Tous les événements configurés sont exportés.
Couche Données
Tous les objets graphiques exportables sont exportés.

Code du programme : Exportation d'une vue contextuelle à partir d'un dossier

Pour exporter une seule vue contextuelle à partir du dossier système ou d'un dossier
personnalisé, modifiez le code de programme suivant :
//Exports a single pop-up screen

private static void ExportSinglePopUpScreen(HmiTarget hmitarget)
{
ScreenPopupUserFolder folder =
hmitarget.ScreenPopupFolder.Folders.Find("MyPopupFolder");
//or ScreenPopupSystemFolder folder = hmitarget.ScreenPopupFolder;
ScreenPopupComposition popups = folder.ScreenPopups;
ScreenPopup popup = popups.Find("popupName");
if(popup == null) return;

folder.Name, popup.Name);
popup.Export(info, ExportOptions.WithDefaults);
}
8.3.9.11 Importation d'une vue contextuelle
Conditions
Utilisation
Les données suivantes de la vue contextuelle sont importées :

Attributs ActiveLayer, BackColor, GridColor, Height, Name, ScrollbarBackgroundColor,
ScrollbarForegroundColor, Width
● Events
L'existence des attributs suivants est obligatoire pour l'importation :

● Name
● Height
● Width

Couche Données
Tous les objets graphiques importables sont importés.
Restrictions
Lorsque l'appareil ne prend pas en charge les vues contextuelles, le processus de copie est
annulé et une exception est déclenchée.
Lorsque la largeur et la hauteur d'une vue contextuelle ne correspondent pas aux dimensions
de l'appareil, le processus d'importation est interrompu et une Exception est déclenchée.
● Hauteur minimale = 1 pixel
● Largeur minimale = 1 pixel
● Hauteur maximale = six fois la hauteur de l'écran de l'appareil
● Largeur maximale = deux fois la largeur de l'écran de l'appareil
● Pour les appareils avec la version de Runtime V13 SP1, la hauteur et la largeur maximales
correspondent à la hauteur et à la largeur de l'écran de l'appareil.
Code du programme : Importation d'une vue contextuelle dans un dossier

Pour importer une vue contextuelle dans un dossier système de vue contextuelle ou dans un
dossier personnalisé, modifiez le code de programme suivant :
//Imports a pop-up screen to an HMI device

private static void ImportPopupScreenToHMITarget(HmiTarget hmitarget)
{
FileInfo info = new FileInfo(string.Format(@"D:\Samples\Screens\PopupScreen.xml"));
hmitarget.ScreenPopupFolder.ScreenPopups.Import(info, ImportOptions.None);
}
8.3.9.12 Exportation d'une vue encastrable
Conditions

Utilisation
Les données et valeurs suivantes de la vue Slide-in sont exportées :
Modèles de Données
vue
Attributs Activate false
ActiveLayer 0
BackColor (182 ; 182 ; 182)
GridColor (0, 0, 0)
Dimension 427
L'attribut "Dimension" indique soit la largeur, soit la hauteur
de la vue Slide-in, en fonction du type de vue encastrable.
LineColor1 (223 ; 223 ; 223)
LineColor2 (32 ; 32 ; 32)
OperatableAreaColor (128 ; 128 ; 128)
SlideinType En haut, en bas, à gauche, à droite
Les vues Slide-in n'ont pas de nom mais un SlideinType.
Visibility FadeOut
Compositions Layers
Remarque
Les vues Slide-in n'ont pas de nom mais un SlideinType.
Couche Données
Attributs Name,
Index
VisibleES
Compositions ScreenItems Tous les objets graphiques exportables sont exportés.

Code du programme : Exportation d'une vue Slide-in

Pour exporter une seule vue Slide-in du dossier système, modifiez le code de programme
suivant :
//Exports a single slide-in screen

private static void ExportSingleSlideinScreen(HmiTarget hmitarget)
{
ScreenSlideinSystemFolder systemFolder = hmitarget.ScreenSlideinFolder;
var screens = systemFolder.ScreenSlideins;
ScreenSlidein slidein = screens.Find(SlideinType.Bottom);
if (slidein == null) return;
FileInfo info = new FileInfo(string.Format(@"D:\Samples\Screens\{0}\{1}.xml"));

slidein.Export(info, ExportOptions.WithDefaults);
}
8.3.9.13 Importation d'une vue encastrable
Conditions
Utilisation
Les données et valeurs suivantes d'une vue Slide-in sont importées :

Attributs Activate = false
ActiveLayer = 0
Authorization
BackColor = (182; 182; 182)
Dimension = 427
L'attribut "Dimension" indique soit la largeur soit la hauteur de la vue Slide-in, en
fonction de celui des deux attributs qui peut être modifié pour le type de la vue
Slide-in.
GridColor = (0; 0; 0)
LineColor1 = (223; 223; 223)
LineColor2 = (32; 32; 32)
OperateableAreaColor = (128; 128; 128)
SlideinType = Top, Bottom, Left, Right
Visibility = FadeOut
Compositions Layers

L'existence de l'attribut suivant est obligatoire pour l'importation :

● SlideinType
Couche Données
Tous les objets graphiques importables sont importés.
Restrictions
● Lorsque l'appareil ne prend pas en charge les vues Slide-in, l'importation est annulée et une
exception est déclenchée.
● Si une vue Slide-in est référencée par un autre élément, celle-ci doit être référencée par
openlink et non par SlideinType, par ex. dans la fonction système "ShowSlideinScreen").
Le tableau suivant représente l'attribut "SlideinType" avec l'openlink correspondant :
SlideinType Nom de l'openlink

Top GraphX_Slidein_Top
Right GraphX_Slidein_Right
Bottom GraphX_Slidein_Bottom
Left GraphX_Slidein_Left
Code du programme : Importation d'une vue Slide-in dans un dossier

Pour importer une vue Slide-in dans un dossier système de vue Slide-in, modifiez le code de
programme suivant :
//Imports a slide-in screen to an HMI device

private static void ImportSlideinScreenToHMITarget(HmiTarget hmitarget)
{
FileInfo info = new FileInfo(@"D:\Samples\Screens\SlideInScreen.xml");
hmitarget.ScreenSlideinFolder.ScreenSlideins.Import(info, ImportOptions.None);
}
8.3.9.14 Exportation d'une vue avec masque de saisie
Conditions

Utilisation
Les données suivantes d'une instance de bloc d'affichage sont exportées dans une vue :
Vue Données
Attributs Left, Top, Width, Height, ObjectName, Resizing, TabIndex, FaceplateTypeName
Attributs d'interfaces Tous les attributs d'interface configurés d'une instance de bloc d'affichage sont
exportés en tant qu'éléments graphiques exportables.
Compositions ● Animations
Toutes les images animées sont exportées.
Les animations de variables sont basées sur les attributs de l'interface.
● Événements
Tenez compte des consignes suivantes pour les attributs exportés d'instances de blocs
d'affichage :
● Resizing
L'attribut "Resizing" est exporté dans tous les cas, quelles que soient les options
d'exportation.
● FaceplateTypeName
L'attribut "FaceplateTypeName" identifie le type correspondant et la version du bloc
d'affichage, par ex. "Faceplate_1 V 0.0.2".
Remarque
Type de bloc d'affichage dans un dossier de bibliothèque
Si un type de bloc d'affichage se trouve dans un dossier de bibliothèque, vous avez besoin
du chemin et du nom complets pour identifier le type de bloc d'affichage. Le mot-clé "@$@"
est utilisé pour séparer les dossiers et/ou les noms des types de bloc d'affichage, par ex.
"Folder_1@$@SubFolder_1@$@Faceplate_1 V 0.0.2".
Les données suivantes d'éléments graphiques dans une instance de bloc d'affichage sont
exclues de l'exportation :
Élément graphique Attribut

Champ d'E/S Flashing on limit violation
Champ d'E/S graphi‐ Fit embedded graphic object to screen size
que

Code du programme
Pour exporter une seule vue avec une instance de bloc d'affichage, modifiez le code de
programme suivant :
//Exports a single screen including a faceplate instance

private static void ExportSingleScreenWithFaceplateInstance(HmiTarget hmitarget)
{
ScreenFolder folder = hmitarget.ScreenFolder.Folders.Find("MyScreenFolder");
Screen screen = screens.Find("ScreenWithFaceplateName");
if (screen == null) return;
{
FileInfo info = new FileInfo(string.Format(@"D:\Samples\Faceplates\{0}\{1}.xml",
}
}
8.3.9.15 Importation d'une vue avec masque de saisie
Conditions
Utilisation
Les données suivantes d'une instance de bloc d'affichage sont importées sur une vue :
Vue Données
Attributs Left, Top, Width, Height, ObjectName, Resizing, TabIndex, FaceplateTypeName
Attributs d'interfaces Tous les attributs d'interface configurés d'une instance de bloc d'affichage sont
importés en tant qu'éléments graphiques importables.
Compositions ● Animations
Toutes les images animées sont importées.
Les animations de variables sont basées sur les attributs de l'interface.
● Événements
Tous les événement configurés sont importés.
L'existence des attributs suivants est obligatoire pour l'importation :

● ObjectName
● FaceplateTypeName

Les données suivantes d'éléments graphiques dans une instance de bloc d'affichage sont
exclues de l'exportation et de l'importation :
Élément graphique Attribut

Champ d'E/S Flashing on limit violation
Champ d'E/S graphi‐ Fit embedded graphic object to screen size
que

Restrictions
● Bloc d'affichage, événement ou attribut de l'interface inconnu
Si un faceplate type name, un event name ou un interface attribute name n'existant pas
dans le projet est indiqué dans le fichier d'importation, l'importation est annulée et une
exception est déclenchée.
● Comportement de mise à l'échelle d'une instance de bloc d'affichage
L'attribut "Resizing" est importé dans tous les cas, quelles que soient les options
d'exportation.
Exemples :
Si "Resizing" est réglé sur "KeepRatio", l'attribut "Height" est utilisé pour calculer la valeur
d'attribut "Width".
– La taille d'un type de bloc d'affichage est de 100 x 100 pixels. Si une instance de bloc
d'affichage ayant une taille de 300 x 100 pixels est importée et que la valeur "FixedSize"
est paramétrée sur l'attribut "Resizing", l'importation est réussie et la taille du bloc
d'affichage est réglée sur 100 x 100 pixels.
– La taille d'un type de bloc d'affichage est de 100 x 50 pixels. Si une instance de bloc
d'affichage ayant une taille de 100 x 100 pixels est importée et que la valeur "KeepRatio"
est paramétrée sur l'attribut "Resizing", l'importation est réussie et la taille du bloc
d'affichage est réglée sur 200 x 100 pixels.
Remarque
Comportement de mise à l'échelle des instances de bloc d'affichage importées
Les valeurs de "Resizing" et les valeurs des attributs d'interface peuvent influer sur la taille
des instances de bloc d'affichage importées et même sur la taille des éléments graphiques
qui y sont incorporés.
Pour éviter toute modification intempestive de la mise en forme d'une instance de bloc
d'affichage, importez-la dans sa taille initiale et sans les valeurs d'attribut "Width" et
"Height".
● Valeurs d'attribut d'interfaces différentes

– Si vous modifiez les attributs pour l'importation, la dernière valeur d'attribut d'interface
utilisée est importée.
– En cas d'interdépendance des attributs, il se peut que d'autres attributs soient modifiés
au cours de l'importation.
Exemple : Un bloc d'affichage contient un champ d'E/S. L'attribut "Mode de
fonctionnement" est connecté à un attribut d'interface. Si vous réglez d'abord le mode de
fonctionnement sur "Sortie" puis l'attribut "Entrée cachée" sur Vrai, la valeur de l'"Entrée
cachée" n'est pas utilisée après l'importation. L'attribut "Entrée cachée" a été mis en
lecture seule lors de la première modification et la valeur ne peut pas être utilisée.
– Si une valeur d'attribut ne respecte pas les restrictions imposées par WinCC, la valeur
du type de bloc d'affichage s'affiche.
Exemple : La plage d'affichage d'un instrument à aiguille est paramétrée sur 10 - 80. Les
attributs "Maximum" et "Minimum" sont configurés comme attributs d'interfaces. Si vous
paramétrez une valeur minimale qui dépasse la valeur maximale, par ex. 100, la valeur
du type de bloc d'affichage pour "Minimum" s'affiche après l'importation.

8.4 Exporter/importer des tables de visualisation et de forçage permanent
– Si un attribut d'interface est associé à plusieurs attributs d'éléments graphiques au sein

du type de bloc d'affichage, l'attribut d'interface sur l'instance de bloc d'affichage affiche
alors la valeur d'attribut utilisée du premier élément graphique associé.
Exemple : Un bloc d'affichage contient deux instruments à aiguille avec des valeurs
maximales différentes. Les valeurs minimales de ces deux instruments sont reliées à un
seul attribut d'interface.
Si vous paramétrez une seule valeur minimale utilisable pour les deux instruments à
aiguille, les deux valeurs sont paramétrées.
Si vous paramétrez une valeur utilisable uniquement pour le deuxième instrument à
aiguille, la valeur est paramétrée uniquement pour celui-ci. En revanche, la valeur du
premier instrument à aiguille s'affiche comme attribut d'interface.
Code du programme : Importer des images avec une instance de bloc d'affichage
Pour importer une vue avec une instance de bloc d'affichage, modifiez le code de programme
suivant :
//Imports single screen including a faceplate instance

private static void ImportSingleScreenWithFaceplateInstance(HmiTarget hmitarget)
{
FileInfo info = new FileInfo(@"D:\Samples\Screens\ScreenFaceplate.xml");
hmitarget.ScreenFolder.Screens.Import(info, ImportOptions.None);
}
Conditions :
Application
Avec TIA Portal Openness, vous pouvez exporter la table de visualisation et la table de forçage
permanent depuis TIA Portal dans SIMATIC ML et importer la table de visualisation et la table
de forçage depuis SIMATIC ML.

Code de programme : Exporter une table de visualisation et une table de forçage permanent
Vous pouvez modifier le code de programme suivant pour exporter la table de visualisation :
((IEngineeringServiceProvider)item).GetService<SoftwareContainer>();
PlcSoftware plcSoftware = softwareContainer.Software as PlcSoftware;
PlcWatchTableComposition exportWatchTables =
plcSoftware.PlcWatchAndForceTableGroup.WatchTables;
PlcWatchTable watchTable = exportWatchTables.Find(watchTableName);
if(watchTable != null)
{
watchTable.Export((FileInfo) fileInfo, ExportOptions.None);
}
Remarque
Les options d'exportation doivent être paramétrées dans la table de visualisation (None,
WithDefaults, WithReadOnly, WithDefaultsAndReadOnly). Une table de visualisation possède
une seule propriété publiée, son nom. Il est publié à la lecture.
Vous pouvez modifier le code de programme suivant pour exporter la table de forçage
permanent :
PlcForceTableComposition exportForceTables =
plcSoftware.PlcWatchAndForceTableGroup.ForceTables;
PlcForceTable forceTable = exportForceTables[0];
forceTable.Export((FileInfo) fileInfo, ExportOptions.None);
Remarque
Dans chaque situation, il n'existe qu'une seule table de forçage permanent, dont le nom est
protégé en écriture.
Code de programme : Importer une table de visualisation et une table de forçage permanent
Vous pouvez modifier le code de programme suivant pour importer la table de visualisation :
PlcWatchTableComposition importWatchTables =
plcSoftware.PlcWatchAndForceTableGroup.WatchTables;
IList<PlcWatchTable> WatchTables = importWatchTables.Import((FileInfo)fileInfo,
ImportOptions.None);

8.5 Importer/exporter les données d'un appareil API
Remarque
La table de visualisation importée est ajoutée à la liste des tables de visualisation. Dans la table
de visualisation, les options d'importation requises doivent être paramétrées (None, Override).
Les tables de forçage permanent peuvent être importées de la même façon, cependant, une et
une seule table de forçage permanent est autorisée. Si, à la place de Override, vous utilisez
l'option None et qu'une table de forçage permanent (non vide) est présente, l'importation
échoue avec l'exception suivante RecoverableException: : Une seule table de forçage
permanent peut être importée. Utilisez l'option d'importation Override, pour écraser la table
existante.
8.5.1 Blocs
8.5.1.1 Structure XML de la section interface du bloc
Principe de base
moyen d'une structure de base. Chaque fichier d'importation doit répondre aux conditions
structurelles de base.
Le fichier d'exportation contient toutes les variables et constantes traitées de la section
d'interface d'un bloc exporté. Tous les attributs avec "ReadOnly = "TRUE"" et "Informative
= "TRUE"" sont exclus.
Quand les informations sont redondantes, elles doivent être identiques dans le fichier XML
d'importation et dans le fichier de projet. Autrement, l'importation lance une exception
récupérable.
Les données de projet contiennent plus de données que le fichier XML d'importation, par ex.
un type externe peut avoir des membres supplémentaires.
Seules les valeurs accessibles en écriture peuvent être importées via TIA Portal Openness
XML.
En fonction des paramètres d'exportation réglés dans TIA Portal Openness, le fichier
d'exportation contient un jeu déterminé d'attributs et d'éléments. Le fichier XML exporté avec
des versions ultérieures du produit n'est pas compatible avec la procédure d'importation dans
des versions antérieures de TIA Portal.

Structure de base
La section d'interface d'un bloc exporté est contenue dans l'élément <Interface> dans la
SimaticML d'un bloc. L'objet racine est l'élément <Sections> qui représente la section
d'interface d'un bloc exporté. Dans la description ci-dessous, les éléments figurent dans l'ordre
requis pour le fichier de saisie.
● Section
La section représente un paramètre particulier ou des données locales d'un bloc de
programme.
● Membre
Le membre représente les variables ou constantes utilisées dans le bloc de programme.
Selon le type de données d'une variable, les membres peuvent être imbriqués ou posséder
d'autres sous-éléments structurels.
Par exemple, pour le type de données "ARRAY", l'élément structurel "Subelement Path"
représente l'indice de composants d'un élément du tableau.
Seuls sont exportés les membres qui ont été édités par l'utilisateur.
● AttributeList
La <AttributeList> englobe tous les attributs définis d'un membre. Les attributs
déterminés par le système ou affectés d'une valeur par défaut ne figurent pas dans la
structure XML.
Les attributs de membre <ReadOnly> et <Informative> ne sont écrits dans le fichier
d'exportation XML que s'ils ont la valeur VRAI.

● StartValue
L'élément <StartValue> est écrit seulement quand la valeur par défaut de la variable ou
de la constante est déterminée par l'utilisateur.
● Commentaire
L'élément <Comment> est écrit quand il est déterminé par l'utilisateur. Les commentaires
d'une variable ou d'une constante sont exportés comme textes multilingues :

Attributs
● Attributs principaux
Les attributs principaux sont écrits dans l'élément <Member> dans la structure XML.
Le tableau ci-dessous indique les attributs principaux d'une variable ou d'une constante
dans la section Interface du bloc.
Nom Type de Valeur par défaut Condition d'importa‐ Commentaire

données tion
Nom STRING - Nécessaire
Type de don‐ ENUM - Nécessaire
nées
Version STRING - Optionnel
Rémanence ENUM NonRetain - N'est écrit que
s'il ne s'agit pas
de u paramétra‐
ge par défaut
Accessibilité ENUM Public - Prédéfini par le
système,
ne peut être mo‐
difié par l'utilisa‐
teur
Informatif BOOL FALSE -
Les membres avec le mémento "Informative" ne sont pas pris en considération lors de
l'importation. Quand l'attribut est effacé ou mis à FALSE, une exception est lancée.
Remarque
Valeur de rémanence "Positionner dans IDB"
Quand une variable ou une constante a la valeur de rémanence "Positionner dans IDB", la
rémanence déterminée dans le bloc de données d'instance doit être la même pour toutes
les autres variables et constantes dont la rémanence est "SetInIDB".
Le premier membre importé avec l'attribut "Positionner dans IDB" détermine la rémanence
attendue dans le bloc de données d'instance pour les variables et constantes suivantes
dont la rémanence est "SetInIDB".
● Attributs de membre définis par le système

Les attributs de membre définis par le système sont listés dans
l'élément <AttributeList>. Les attributs de membre définis par le système sont repérés
par le mémento <Informative> et ne sont pas pris en considération lors de l'importation.

Name Type Valeur par défaut SimaticML proté‐ Commentaire

gé en écriture (in‐
formatif)
At String "" FALSE Des parts du
membre alternent
avec un autre
membre dans cet‐
te structure
SetPoint Bool FALSE FALSE Le membre peut
être synchronisé
avec la mémoire
de travail
UserReadOnly Bool FALSE TRUE L'utilisateur ne
peut pas modifier
les attributs de
membre (y com‐
pris le nom)
UserDeletable Bool TRUE TRUE Le membre ne
peut pas être sup‐
primé dans l'édi‐
teur
HmiAccessible Bool TRUE FALSE Pas d'accès HMI,
pas d'élément de
structure
HmiVisible Bool TRUE FALSE Filtre pour réduire
le nombre de
membres affichés
d'abord
Offset Int - TRUE DB, FB, FC
(temp). Pour les
API classiques et
les API Plus où la
rémanence clas‐
sique est réglée.

Name Type Valeur par défaut SimaticML proté‐ Commentaire

formatif)
PaddedSize Int - TRUE DB, FB, FC
(temp). Pour les
API classiques et
les API Plus où la
rémanence clas‐
sique est réglée.
Uniquement pour
tableaux.
HiddenAssign‐ Bool FALSE FALSE Masquer l'affecta‐
ment tion lors de l'appel
quand elle corres‐
pond à Predefine‐
dAssignment.
PredefinedAs‐ String "" FALSE Saisie pour le pa‐
singment ramètre utilisé
quand l'appel se
trouve placé.
ReadOnlyAssign‐ Bool FALSE FALSE Lors de l'appel,
ment l'utilisateur ne
peut pas modifier
l'affectation pré‐
définie.
UserVisible Bool TRUE TRUE Ce membre ne
s'affiche pas dans
l'interface utilisa‐
teur.
HmiReadOnly Bool TRUE TRUE Ce membre est
protégé en écritu‐
re pour HMI.
CodeReadOnly Bool FALSE TRUE -
● Attributs définis par l'utilisateur

Les attributs définis par l'utilisateur sont repérés par le mémento <ReadOnly>. Les
membres avec ce mémento ne sont pas pris en considération lors de l'importation. Quand
le mémento est effacé ou mis à FALSE, une exception est lancée.
Les attributs définis par l'utilisateur non édités sont exclus de l'exportation.
Nom Type Valeur par défaut SimaticML proté‐ Commentaire

formatif)
CFC IBlockAttribute --- FALSE Ceci est un char‐
gement

Type de données "STRUCT"

Les composants du type de données "STRUCT" sont représentés comme membres imbriqués
dans la structure XML d'un fichier d'importation/exportation :
Type de données "ARRAY", type de base

Les composants du type de données de base "ARRAY" sont représentés comme sous-
éléments avec l'attribut "Path" dans la structure XML d'un fichier d'importation/exportation :

Type de données "ARRAY", d'un UDT

Les composants du type de données "ARRAY" d'un UDT sont représentés comme nouvel
élément <sections> dans un élément <member> dans la structure XML d'un fichier
d'importation/exportation. Les membres dans la nouvelle section pour UDT dans un ARRAY
sont affectés en tant que sous-éléments avec l'attribut "Path" :
Type de données "ARRAY", dans "ARRAY"

Les composants du type de données "ARRAY" dans un autre ARRAY sont représentés comme
sous-éléments avec l'attribut "Path" dans la structure XML d'un fichier d'importation/
exportation.
Les membres dans un autre ARRAY sont affectés en tant que sous-éléments avec l'attribut
"Path" quand le composant est édité par l'utilisateur :

Types de données API (UDT)

La structure XML d'un type de données API dépend des paramètres d'exportation réglés dans
Les membres du type de données API sont écrits seulement quand la valeur par défaut d'un
composant au moins est déterminée par l'utilisateur. Pour ces membres, seuls les deux
attributs supplémentaires "Name" et "Datatype" sont écrits pour identifier le membre
auquel appartient la <StartValue>. Les autres membres et attributs ne sont pas écrits.
● ExportOptions.WithDefaults
Les attributs suivants sont toujours écrits :
– Name
– Datatype
– ExternalAccessible
– ExternalVisible
– ExternalWritable
– SetPoint
– StartValue
Ils sont écrits dans XML seulement quand la valeur par défaut dans ce type est
déterminée par l'utilisateur. Quand elle est déterminée uniquement dans le type de
données API, elle n'est pas écrite.
● ExportOptions.ReadOnly
Pour les types de données API, ce paramètre n'entraîne pas un résultat probant. Combiné
à d'autres paramètres, il n'a aucune influence sur le résultat.

Variables écrasées
Quand une variable est écrasée par un nouveau type de données, les membres sont
représentés dans la structure XML du nouveau type de données. La structure XML ci-dessous
montre un type de données WORD qui est écrasé par un ARRAY of BYTE.

Interface de bloc
Tous les attributs avec ReadOnly = "TRUE" et Informative = "FALSE" sont exclus. La
structure XML d'une interface de bloc dépend des paramètres d'exportation réglés dans TIA
Portal Openness
Avec ce réglage, seules sont exportées les données modifiées ou celles qui n'ont pas leur
valeur par défaut.
Quand la définition de l'attribut n'indique pas de valeur par défaut, l'attribut est toujours écrit.
Le fichier d'exportation contient aussi toutes les valeurs obligatoires pour l'importation
ultérieure des données.
● ExportOptions.WithDefaults
Les attributs suivants sont toujours écrits :
– Name
– Datatype
– HmiAccessible exporté comme ExternalAccessible
– HmiVisible exporté comme ExternalVisible
– ExternalWritable
– SetPoint (si existant)
– Offset (si existant)
– PaddedSize (si existant)
Tous les autres attributs sont écrits seulement quand ils n'ont pas leur valeur par défaut.
L'élément <StartValue n'est écrit dans XML que s'il a été déterminé explicitement.
● ExportOptions.ReadOnly
Pour les interfaces de bloc, ce paramètre n'entraîne pas un résultat probant. Combiné à
d'autres paramètres, il n'a aucune influence sur le résultat.
8.5.1.2 Modifications du modèle d'objet et format de fichier XML
Introduction
Pour importer un fichier XML personnalisé ou édité par le biais de TIA PortalOpenness avec
succès dans TIA Portal, le fichier doit respecter des schémas définis.
Chaque fichier XML se compose de deux parties principales :
● Interface
● Unité de compilation
La section qui suit propose une description des schémas à respecter par les fichiers.

Interface
Une interface peut contenir plusieurs segments (par ex. Input, InOut, Static) : Vous trouverez
tous ces segments dans le répertoire suivant :
● C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas
\SW.InterfaceSections_v3.xsd
● C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas
\SW.Interface.Snapshot .xsd
Unité de compilation
Il existe des schémas différents pour les unités de compilation des blocs GRAPH, CONT/LOG,
LIST et SCL. Vous trouverez les schémas correspondants dans les répertoires suivants :
● GRAPH : C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas
\SW.PlcBlocks.Graph_v4.xsd
● CONT/LOG : C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas
\SW.PlcBlocks.LADFBD_v3.xsd
● LIST : C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas
\SW.PlcBlocks.STL_v3.xsd
● SCL : C:\Pogrammes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas\
SW.PlcBlocks.SCL_v2.xsd
Sous-schémas
Il existe les définitions de schéma supplémentaires suivantes, utilisées par toutes les unités de
compilation :
● Accès
● Généralités
Accès
Le nœud d'accès décrit par ex. :
● membres locaux/globaux et utilisations constantes
● Appels de FB, FC, d'instructions
● DB pour les appels
Vous trouverez le schéma d'accès dans le répertoire suivant :
C:\Programmes\Siemens\Automation\Portal V*\PublicAPI\V*\Schemas
\SW.PlcBlocks.Access_v3.xsd
Généralités
Regroupe les attributs et éléments généraux utilisés, par ex. commentaires de toutes sortes,
textes et jetons.
Vous trouverez le schéma général dans le répertoire suivant :

C:\Pogrammes\Siemens\Automation\Portal V*\PublicAPI\V*.\Schemas\SW.Common_v2.xsd
Remarque
V* fait référence à la version installée de TIA Portal.
8.5.1.3 Exporter des blocs de données avec des instantanés
Conditions
Voir Ouvrir d'un projet (Page 109)
Application
TIA Portal Openness vous permet d'exporter les DB avec des valeurs d'instantané au format
XML et de comparer les valeurs de différents instantanés. Sur la base des résultats de la
comparaison, vous pouvez modifier manuellement différentes valeurs initiales dans l'interface
utilisateur et les enregistrer pour une restauration ultérieure. Le schéma
"SW.Interface.Snapshot.xsd" vous assiste dans l'évaluation ou le traitement du fichier
XMLexporté.
Code de programme
Modifiez le code de programme suivant pour exporter des valeurs d'instantanés avec le service
d'instantané :
InterfaceSnapshot interfaceSnapshot = dataBlock.GetService<InterfaceSnapshot>();

interfaceSnapshot.Export(new FileInfo("C:\temp\MyInterfaceSnapshot.xml"),
ExportOptions.None);
Le service d'instantané "InterfaceSnapshot" est mis à disposition dans l'espace de noms

"Siemens.Engineering.SW.Blocks". Le traitement des fichiers (par exemple si le répertoire
d'exportation n'existe pas ; la création du répertoire d'exportation ; si le répertoire d'exportation
est protégé en écriture ; si le fichier d'exportation existe déjà) est similaire à l'exportation
normale via l'interface standard d'Openness. Le service d'instantané est pris en charge pour
des blocs de données, des blocs de données d'instance et des blocs de données Array.
Remarque
L'exportation de valeurs d'instantané avec le service d'instantané dépend de l'exportation via
l'interface standard d'Openness et n'influence donc pas l'exportation existant déjà des
membres de l'interface. Le fichier XML exporté ne peut plus être importé.

Les valeurs d'instantané sont exportées comme suit :

<Document>
<Engineering version="V15 SP1" />
<DocumentInfo>
...
</DocumentInfo>
<SW.Blocks.InterfaceSnapshot ID="0">
<AttributeList>
<Name>GlobalDB</Name>
<Snapshot ReadOnly="true"><SnapshotValues>
<SnapshotValues>
<Value Path="Static_1" Type="Bool">TRUE</Value>
<Value Path="Static_2[0]" Type="Int">1</Value>
<Value Path="Static_3" Type="DTL">DTL#1973-01-01-00:00:00</Value>
<Value Path="Static_4.Element_1" Type="Int">7</Value>
<Value Path="Static_4.Element_2[0]" Type="Bool">FALSE</Value>
<Value Path="Static_4.Element_2[1]" Type="Bool">TRUE</Value>
<Value Path="Static_4.Element_2[2]" Type="Bool">TRUE</Value>
<Value Path="Static_4.Element_3.Element_1" Type="Int">5</Value>
<Value Path="Static_4.Element_3.Element_2.Element_1" Type="Bool">TRUE</Value>
<Value Path="Static_4.Element_3.Element_2.Element_2[0]" Type="Int">100</Value>
<Value Path="Static_4.Element_3.Element_2.Element_2[1]" Type="Int">200</Value>
</SnapshotValues></Snapshot>
<SnapshotDate ReadOnly="true">2017-12-06T08:04:11.4590585Z</SnapshotDate>
<StructureModified ReadOnly="true">2017-12-06T08:22:13.3292585Z</StructureModified>
</AttributeList>
</SW.Blocks.InterfaceSnapshot>
</Document>
Si un bloc de données ne contient aucune valeur d'instantané, le contenu du fichier exporté

peut ressembler à ceci :
<SnapshotValues xlmns="http://www.siemens.com/automation/Openness/SW/Interface/Snapshot/
v1"></SnapshotValues>
Voir aussi

8.5.1.4 Exporter des blocs avec protection know-how
Conditions requises
Utilisation
Le fichier XML qui en résulte ressemble au fichier d'exportation d'un bloc sans protection know-
how. Avec PlcBlockProtectionProvider, vous pouvez débloquer un bloc à protection know-how
en entrant le mot de passe dans l'API Openness, puis en exportant un bloc KHP complet avec
son code. Un bloc peut être importé, puis à nouveau être protégé par un mot de passe via l'API.
Lorsque le bloc est exporté sans déblocage, seule l'interface de bloc publique est exportée.
● Bloc TIA Portal -> Débloquer -> Exporter le fichier sans protection
● Importer le fichier sans protection -> Bloquer -> Bloc TIA Portal
La liste d'attributs du bloc indique que le bloc correspondant possède une protection know-how.
Code du programme
Pour exporter les données visibles d'un bloc doté d'une protection know-how vers un fichier
XML, modifiez le code de programme suivant :
private static void ExportBlock(PlcSoftware plcSoftware)

{
plcBlock.Export(new FileInfo(string.Format(@”D:\Samples\{0}.xml”, plcBlock.Name)),
}
8.5.1.5 Exportation/importation de blocs SCL
Instructions SCL avec variables XML pour l'exportation

L'opération d'exportation pour les blocs SCL effectue l'exportation de vos variables XML
correspondants sur la base du type d'instructions SCL. Cette opération prend en charge les
réseaux d'instructions SCL des instructions SCL dans les blocs CONT/LOG des instructions
SCL. Les instructions SCL sont classées en éléments de texte, opérandes, expressions,
instructions de commande, etc. Le schéma SW.PlcBlocks.SCL_v2.xsd est disponible pour
vous assister dans le traitement des blocs SCL avec les tags d'exportation XML. Les
instructions de bloc SCL avec leurs tags XMLet leurs attributs correspondants exportés sont
indiqués ci-dessous.

Nouvelle ligne
De nouvelles lignes dans les blocs SCL sont représentées par des variables NewLine XML.
● Contient l'attribut non signé Num avec la valeur par défaut 1.
● L'attribut Num n'est pas réglé sur la valeur 0.
● Pris en charge uniquement pour SCL.
Bloc SCL Balise XML

<NewLine Num="2" />
Vide
Les espaces dans les blocs SCL sont représentés par des variables Blank XML .
● Contient l'attribut non signé Num avec la valeur par défaut 1.
● L'attribut Num n'est pas réglé sur la valeur 0.
● Pris en charge uniquement pour SCL.
● Ne prend pas en charge l'attribut Integer, qui est disponible dans les autres langages de
STEP 7.
Bloc SCL Balise XML

<Blank Num="2"/>
Indentation d'instructions de bloc SCL

Dans les paramètres de TIA Portal vous pouvez modifier l'indentation du code SCL via Options/
Settings/General/Script/text editiors . Le type d'indentation est défini dans le tableau suivant,
sur la base du mode d'identification.
Mode d'identification Résultat

Sans L'opération d'importation insère les espaces com‐
me indiqués dans les fichiers source.
Paragraphe ou Smart L'opération d'importation insère les espaces
d'identification indiqués dans le fichier importé.
Sur la base de l'indentation sélectionnée, celle-ci est effectuée dans le XML file importé du bloc
SCL.
Commentaire
Les commentaires sur ligne unique et plusieurs lignes dans les blocs SCL sont représentés par
des variables LineComment XML .
● Seule la variable LineComment (pour commentaire unilingue) est pris en charge par SCL.
● La variable Comment (pour commentaire multilingue) n'est pas pris en charge par SCL.
● Contient l'attribut Inserted avec la valeur par défaut false.

● Inserted="false" affiche "//" un commentaire sur une seule ligne dans les blocs SCL.
● Inserted="true" affiche "(**)" un commentaire sur plusieurs lignes dans les blocs SCL.
● NoClosingBracket="true" affiche des commentaires sans parenthèses dans les blocs SCL.
Cet attribut est facultatif et a la valeur par défaut false.
● XML n'indique aucune hiérarchie de commentaires dans les blocs SCL.
Bloc SCL Balise XML

// one line comment <LineComment>
<Text>one line comment</Text>
</LineComment>
(* one line comment <LineComment Inserted="true">
second line *) <Text>one linecomment
secondline</Text>
</LineComment>
(* first comment (* second comment <LineComment Inserted=”true”>
*) end first comment *) <Text> first comment (*
second comment *) end first comment</
Text>
</LineComment >
Le commentaire imbriqué fait partie du texte de
commentaire externe.
(* comment without closing bracket <LineComment Inserted="true"
NoClosingBracket="true">
<Text> comment without
closing bracket</Text>
</LineComment >
Région
Les régions dans les blocs SCL sont sont représentées par des variables Token XML.
● La balise Text XML représente le nom de la région (region_name).
● La casse (majuscule et minuscule) n'a pas d'importance pour l'attribut Text de la balise
Token XML.
● La casse est prise en compte lors de la procédure d'importation et l'éditeur affiche les mots-
clés tels qu'ils sont configurés dans les paramètres de TIA Portal.
● Si le mot-clé end_region se termine par ";" (point-virgule) dans le bloc SCL, le caractère ";"
est présent dans la variable Text XML.

Bloc SCL Balise XML

region myregion <Token Text="REGION" />
... <Blank />
end_region here is the end of <Text>myregion</Text>
myregion <NewLine />
...
<Token Text="END_REGION" />
<Blank />
<Text>here is the end of myregion</
Text>
<NewLine />
region <Token Text="REGION" />
// here are no blanks <NewLine />
... <LineComment .../>
end_region <Token Text="END_REGION" />
<NewLine />
region <Token Text="REGION" />
... <NewLine />
end_region; ...
<Token Text="END_REGION" />
<Text>;</Text>
<NewLine />
Pragma
LesPragma dans les blocs SCL sont représentés par des variables Token XML. Les
paramètres sont affichés dans la balise XML Access avec l'attribut Scope en tant que
LiteralConstant.

Bloc SCL Balise XML

{PRAGMA_BEGIN 'Param1', 'Param2' <Token Text="{" />
(*parm 2*)} <Token Text="PRAGMA_BEGIN" />
// something else <Blank />
{PRAGMA_END} <Access Scope="LiteralConstant">
<Constant>
<ConstantValue>'Param1'</
ConstantValue>
</Constant>
</Access>
<Token Text="," />
<Blank />
<Access Scope="LiteralConstant">
<Constant>
<ConstantValue>'Param2'</
ConstantValue>
</Constant>
</Access>
<Blank />
<LineComment Inserted="True">
<Text>param 2</Text>
</LineComment>
<Token Text="," />
<Blank />
<Token Text="}" />
<NewLine />
<LineComment>
<Text> something else</Text>
</LineComment>
<NewLine />
<Token Text="{" />
<Token Text="PRAGMA_END" />
<Token Text="}" />
Constantes : Constantes littérales

Les constantes dans les blocs SCL sont représentées par des variables Access XML.
● L'attribut Scope peut être réglé sur des valeurs telles que LiteralConstant, TypedConstant,
LocalConstant, et GlobalConstant..
● Les noms des constantes qui portent le caractère "#" en préfixe sont ignorés dans XML.
● Le caractère "#" est ajouté lors du processus d'importation de XML.
● La valeur des constantes globales, représentée par des guillemets, est ignorée dans XML.
● Les guillemets sont ajoutés lors du processus d'importation de XML.

Type de constante Bloc SCL Balise XML

Constante littérale : Nombre #Out := 10; <Access Scope="LiteralConstant">
entier <Constant>
<ConstantValue>10</ConstantValue>
<ConstantTypeInformative="true">LINT</
ConstantType>
</Constant>
</Access>
Constante littérale : String #myString := 'Hello <Access Scope="LiteralConstant">
world'; <Constant>
<ConstantValue>Hello world</
ConstantValue>
<ConstantTypeInformative="true">STRING</
ConstantType>
</Constant>
</Access>
Constante littérale : Typé #Out := int#10; <Access Scope="TypedConstant">
<Constant>
<ConstantValue>int#10</ConstantValue>
</Constant>
</Access>
Format de XML après exportation avec réglage ExportOp‐
tions.ReadOnly.
<Access Scope="TypedConstant">
<Constant>
<ConstantValue>int#10</ConstantValue>
<StringAttribute Name="Format"
Informative="true">Dec_signed</
StringAttribute>
<StringAttribute Name="FormatFlags"
Informative="true">TypeQualifier</
StringAttribute>
</Constant>
</Access>
Constante locale #Out := #mylocal; <Access Scope="LocalConstant">
<Constant Name="mylocal" />
</Access>
tions.ReadOnly
<Access Scope="LocalConstant">
<Constant Name="mylocal">
<ConstantType Informative="true">Int</
ConstantType>
<ConstantValue Informative="true">10</
ConstantValue>
StringAttribute>
</Constant>
</Access>

Type de constante Bloc SCL Balise XML

Constante globale #Out := "myglobal"; <Access Scope="GlobalConstant">
<Constant Name="myglobal" />
</Access>
tions.ReadOnly.
<Access Scope="GlobalConstant">
<Constant Name="myglobal">
<ConstantType Informative="true">Int</
ConstantType>
<ConstantValue Informative="true">10</
ConstantValue>
StringAttribute>
</Constant>
</Access>
Les constantes d'adresse ne sont pas prises en charge dans les blocs SCL et sont ignorées
dans ce tableau.
Variables
Les variables locales et globales dans les blocs sont représentées par des variables Access
XML.
● L'attribut Scope possède les valeurs de LocalVariable et de GlobalVariable.
● La balise XML permettant d'attribuer la valeur 10 est ignorée ici.
Type de variable Bloc SCL Balise XML

Variable locale #Out := 10; <Access Scope="LocalVariable">
<Symbol>
<Component Name="Out" />
</Symbol>
</Access>
Variable globale "Tag_3":= 10; <Access Scope="GlobalVariable">
<Symbol>
<Component Name="Tag_3" />
</Symbol>
</Access>
tions.ReadOnly.
<Access Scope="GlobalVariable">
<Symbol>
<Address Area="Memory" Type="Int"
BitOffset="96" Informative="true" />
</Symbol>
</Access>

Expressions
Les expressions simples dans les blocs SCL sont représentées par les variables Access XML.
L'attribut Scope possède la valeur de LocalVariable pour les expressions.
Bloc SCL Balise XML

#a := #b + #c; <Access Scope="LocalVariable">
<Symbol>
<Component Name="a" />
</Symbol>
</Access>
<Blank />
<Token text=":=" />
<Blank />
<Access Scope="LocalVariable">
<Symbol>
<Component Name="b" />
</Symbol>
</Access>
<Blank />
<Token text="+" />
<Blank />
<Symbol>
<Component Name="c" />
</Symbol>
</Access>
<Token text=";" />
Structures de commande dans les blocs SCL

Les instructions de commande telles que IF, CASE, FOR, WHILE, REPEAT, GOTO, EXIT,
CONTINE, and RETURN sont représentées par des balises Token XML .
● Les symboles conditionnels utilisés dans le bloc SCL, tels que >, <, & sont représentés dans
XML sous forme de séquences d'échappement (< > &amp) .
● Cette combinaison de variables XMLn'est valide que pour les blocs SCL. Une exception
sera déclenchée dans les autres langages.

Nom du bloc Bloc SCL Balise XML

IF IF #a<#c THEN <Token Text="IF" />
; <Blank />
END_IF; <Access Scope="LocalVariable">
<Symbol>
</Symbol>
</Access>
<Token Text="<" />
<Symbol>
</Symbol>
</Access>
<Blank />
<Token Text="THEN" />
<NewLine />
<Blank Num="4" />
<Token Text=";" />
<NewLine />
<Token Text="END_IF" />
<Token Text=";" />


CASE CASE #a OF <Tok en Text="CASE" /><Blank />
1 (*test*): // Statement <Access Scope="LocalVariable">
section case 1 <Symbol>
; <Component Name="a" />
2..4: // Statement section </Symbol>
case 2 to 4 </Access>
; <Blank />
ELSE // Statement section <Token Text="OF" />
ELSE <NewLine />
;
END_CASE; <Blank Num="2"/>
<Constant>
<ConstantType
Informative="true">LINT</ConstantType>
</Constant>
</Access>
<Blank />
<LineComment Inserted=”true”>
<Text>test</Text>
</LineComment >
<Token Text=":" />
<Blank />
<LineComment>
<Text> Statement section case 1</Text>
</LineComment >
<NewLine />
<Blank Num="4"/>
<Token Text=";" />
<NewLine />
<Blank Num="2"/>
<Constant>
<ConstantType
</Constant>
</Access>
<Token Text=".." />
<Blank Num="2"/>
<Constant>
<ConstantType
</Constant>
</Access>
<Blank />
<LineComment>
<Text> Statement section case 2 to 4</Text>
</LineComment >
<NewLine />

<Blank Num="4"/>
<Token Text=";" />
<NewLine />
<Blank Num="2"/>
<Token Text="ELSE" />
<NewLine />
<Blank Num="4"/>
<Token Text=";" />
<NewLine />
<Token Text="END_CASE" />

<Token Text=";" />
FOR FOR #i := #a TO #b DO <Token Text="FOR" />
// Statement section FOR <Blank />
; <Access Scope="LocalVariable">
END_FOR; <Symbol>
<Component Name="i" />
</Symbol>
</Access>
<Blank />
<Token Text=":=" />
<Blank />
<Symbol>
</Symbol>
</Access>
<Blank />
<Token Text="TO" />
<Blank />
<Symbol>
</Symbol>
</Access>
<Blank />
<Token Text="DO" />
<NewLine />
<Blank Num="2" />

<LineComment>
<Text> Statement section FOR</Text>
</LineComment >
<NewLine />
<Blank Num="2" />

<Token Text=";" />
<NewLine />
<Token Text="END_FOR" />

<Token Text=";" />


WHILE WHILE #a<#b DO <Token Text="WHILE" />
// Statement section WHILE <Blank />
; <Access Scope="LocalVariable">
END_WHILE; <Symbol>
</Symbol>
</Access>
<Token Text="<" />
<Symbol>
</Symbol>
</Access>
<Blank />
<Token Text="DO" />
<NewLine />
<Blank Num="2" />

<LineComment>
<Text> Statement section WHILE</Text>
</LineComment >
<NewLine />
<Blank Num="2" />

<Token Text=";" />
<NewLine />
<Token Text="END_WHILE" />

<Token Text=";" />


REPEAT REPEAT <Token Text="REPEAT" />
// Statement section REPEAT <NewLine />
;
UNTIL #a<#b END_REPEAT; <Blank Num="2" />
<LineComment>
<Text> Statement section REPEAT</Text>
</LineComment >
<NewLine />
<Blank Num="2" />

<Token Text=";" />
<NewLine />
<Token Text="UNTIL" />

<Blank />
<Symbol>
</Symbol>
</Access>
<Token Text="<" />
<Symbol>
</Symbol>
</Access>
<Blank />
<Token Text="END_REPEAT" />
<Token Text=";" />


GOTO here Exemple XML pour la définition d'étiquettes GOTO
// well
: // this is goto statement <Blank Num="3"/>
<Access Scope="Label">
<Label Name="here">
<NewLine />
<Blank Num="3"/>
<LineComment>
<Text> well</Text>
</LineComment>
<NewLine />
<Token Text=":" />
<Blank />
</Label>
</Access>
<LineComment>
<Text> this is goto statement</Text>
</LineComment>
GOTO (*comment*) here; Exemple XML pour l'utilisation d'étiquettes GOTO
<Token Text="GOTO" />

<Blank />
<LineComment inserted=”true”>
<Text>comment</Text>
</LineComment>
<Blank />
<Access Scope="Label">
<Label Name="here" />
</Access>
<Token Text=";" />
Attributs de référencement
Les attributs de référencement de blocs SCL sont représentées par l'attribut AccessModifier de
la balise Component.
● Pour la référence simple, AccessModifer est réglé sur la valeur Reference.
● Pour la référence Array, AccessModifier est réglé sur la valeur ReferenceToArray..

Bloc SCL Balise XML

RefToUDT^(*RefToUDT*).element <Symbol>
<Component Name="RefToUDT"
AccessModifier="Reference" />
<Token Text="^" />
<Text>RefToUDT</Text>
</LineComment>
<Token Text="." />
<Component Name="element" />
</Symbol>
RefToArrayOfUDT^(*RefToArrayOfUDT*)[#i].ele‐ <Symbol>
ment <Component Name="RefToArrayOfUDT"
AccessModifier="ReferenceToArray" />
<Token Text="^" />
<Text>RefToArrayOfUDT</Text>
</LineComment>
<Token Text="[" />
<Access Scope=LocalVariable>
<Symbol>
</Symbol>
</Access>
<Token Text="]" />
</Component>
<Token Text="." />
<Component Name="element" />
</Symbol>
8.5.1.6 Exportation/importation de types structurés de blocs SCL
Types SCL structurés avec variables XML pour l'exportation

Dans les types SCL structurés, vous pouvez insérer des espaces, de nouvelles lignes et des
commentaires aux instructions SCL. Les instructions structurées SCL avec leurs variables
XML et attributs exportés correspondants sont indiqués ci-dessous.
Accès global
Dans les instructions SCL, les variables et les constantes pour l'accès global sont mises entre
guillemets. Les commentaires entre les variables et des parties d'adresse sont représentés par
la balise LineComment XML.

Bloc SCL Balise XML

"Bloc de données_1".(*Commentaire <Access Scope="GlobalVariable">
1*)Statique_1(*Commentaire <Symbol>
2*).Statique_2 <Component
Name="Data_block_1" />
<Token Text="." />
<Text>comment 1</Text>
</LineComment>
<Component Name="Static_1" /
>
<LineComment
Inserted="True">
<Text>comment 2</Text>
</LineComment>
<Token Text="." />
>
</Symbol>
</Access>
"Data_block_1".Static_1 := 10 Format de XML après exportation avec réglage
ExportOptions.None
<Symbol>
<Component
<Token Text="." />
>
</Symbol>
</Access>
Format de XML après exportation avec réglage
ExportOptions.ReadOnly
<Symbol>
<Component
<Token Text="." />
>
<Address Area="DB"
Type="Word" BlockNumber="1"
BitOffset="0" Informative="true" />
</Symbol>
</Access>

Utilisation de guillemets et de #
Les guillemets utilisés au premier niveau décrivent le type de variable et font office de
séquences Escape pour les caractères spéciaux dans les instructions SCL. Si les guillemets
sont utilisés dans le premier niveau, définissez la variable en tant que variable globale. Si les
guillemets sont utilisés après #, ils représentent la séquence d'échappement de caractères
spéciaux comme # ou d'espaces.
● Dans le fichier XML, la balise BooleanAttributes avec l'attribut Name est utilisée pour
représenter l'utilisation différente. Le Name contient des valeurs telles que HasQuotes et
HasHash.
● # est spécifié pour définir la structure dans l'attribut d'étendue.
● Ces valeurs s'appliquent uniquement à SCL.
● Les valeurs par défaut pour ces balises sont initialement FALSE, mais les valeurs ne sont
jamais exportées, y compris avec le paramètre ExportOptions.WithDefaults.
Bloc SCL Balise XML

"a".#b."c".#"d" <Access Scope="GlobalVariable">
<Symbol>
<Token Text="." />
<Component Name="b">
<BooleanAttribute
Name=”HasHash”>TRUE</
BooleanAttribute>
</Component>
<Token Text="." />
<Component Name="c">
<BooleanAttribute
Name=”HasQuotes”>TRUE</
BooleanAttribute>
</Component>
<Token Text="." />
<Component Name="d">
<BooleanAttribute
Name=”HasQuotes”>TRUE</
BooleanAttribute>
<BooleanAttribute
Name=”HasHash”>TRUE</
BooleanAttribute>
</Component>
</Symbol>
<Access />

Tableau
SCL permet l'insertion de commentaires dans les indices de tableau avec "[" et "]". Dans le
fichier XML, l'attribut AccessModifier dans la balise Component sert à marquer la présence de
tableaux.
● Si Accessmodifier comporte la valeur Array, une balise Access subordonnée est obligatoire
afin d'indiquer la variable d'indice du tableau.
● La valeur par défaut de AccessModifier est None.
Bloc SCL Balise XML

#a.b[#i+#j,#k+#l].c <Access Scope="LocalVariable">
<Symbol>
<Token Text="." />
<Component Name="b"
AccessModifier="Array" />
<Token Text="[" />
<Symbol>
</Symbol>
</Access>
<Token Text="+" />
<Symbol>
<Component Name="j" />
</Symbol>
</Access>
<Token Text="," />
<Symbol>
<Component Name="k" />
</Symbol>
</Access>
<Token Text="+" />
<Symbol>
<Component Name="l" />
</Symbol>
</Access>
<Token Text="]" />
</Component>
<Token Text="." />
</Symbol>
</Access>

Accès absolu
SCL permet différents types d'accès, par ex. l'accès absolu, décalage absolu, mixte (base de
données et variable membre), par tranche, périphérique et direct. L'accès absolu est
représenté dans XML par la balise Address.
● Le signe % dans DB n'est pas écrit dans XML . Il est créé automatiquement lors de
l'importation.
● Des espaces sont autorisés entre les parties de l'adresse.
Bloc SCL Balise XML

%DB20 . DBW10 <Access Scope="Address">
<Symbol>
<Address Area="DB"
BlockNumber="20" />
<Blank />
<Token Text="." />
<Blank />
<Address Area="DB"
BitOffset="80" Type="Word"/>
</Symbol>
</Access>
%DB20.DBX10.3 := true; L'instruction XML suivante s'applique à tous les
langages sauf SCL.
<Access Scope="Address">
<Address Area="DB" BlockNumber="20"
BitOffset="83" Type="Bool" />
</Access>
L'instruction XML suivante s'applique à SCL.
<Access Scope="Address">
<Symbol>
<Address Area="DB"
BlockNumber="20" />
<Token Text="." />
<Address Area="DB"
BitOffset="83" Type="Bool"/>
</Symbol>
</Access>
Type d'accès "décalage absolu"

Dans LIST, la balise AbsoluteOffset représente le type d'accès "Décalage absolu". Dans SCL,
la variable Address est utilisé pour l'accès absolu.

Bloc SCL Balise XML

#Input_DB_ANY.%DBX2.3 := TRUE; <Access Scope="LocalVariable">
<Symbol>
<Component Name="Input_DB_ANY" /
>
<Token Name="." />
<Address BitOffset="19"
Type="Bool" />
</Symbol>
</Access>
Type d'accès "en tranche" (slice)

Dans SCL, l'attribut SliceAccessModifier n'est pas pris en charge, et le type d'accès "en
tranche" est représenté par la variable Token .
Bloc SCL Balise XML

"tag_1"(*1*).(*2*)member(*3*).(*4*) <Access Scope="GlobalVariable">
%x1 <Symbol>
<Component Name="tag_1" />
<Text>1</Text>
</LineComment>
<Token Text="." />
<Text>2</Text>
</LineComment>
<Component Name="member"/>
<Text>3</Text>
</LineComment>
<Token Text="." />
<Text>4</Text>
</LineComment>
<Token Text="%x1" />
</Symbol>
</Access>
Accès périphérique
L'accès périphérique est représenté par la balise Token.

Bloc SCL Balise XML

"tag_1"(*1*).(*2*)member:P <Access Scope="GlobalVariable">
<Symbol>
<Component Name="tag_1" />
<Text>1</Text>
</LineComment>
<Token Text="." />
<Text>2</Text>
</LineComment>
<Component Name="member"/>
<Token Text=":P" />
</Symbol>
</Access>
Type d'accès "direct"

Les instructions TypeOf et TypeOfDB sont exécutées soit avec un type défini par le système,
soit avec un type défini par l'utilisateur. Les types sont indiqués dans la balise Access par
l'attribut Scope et les valeurs SystemType et UserType.
Bloc SCL Balise XML

Exemple de type défini par le système <Token text="=" />
if TypeOf( #inVariant ) = </Blank>
TO_SpeedAxis then … end_if <Access Scope="SystemType">
<DataType>TO_SpeedAxis</DataType>
</Access>
Exemple de type défini par l'utilisateur <Token text="=" />
if TypeOf( #inVariant ) = </Blank>
"aUserDefinedType" then … end_if <Access Scope="UserType">
<DataType>aUserDefinedType</
DataType>
</Access>
8.5.1.7 Exportation/importation de blocs d'appel SCL
Blocs d'appel SCL avec les variables XML pour l'exportation

Les paramètres d'appel SCL sont représentés dans XML par la variable Parameter . L'attribut
informative est utilisé pour représenter les paramètres non-affectés et les valeurs en retour
telles que l'horodatage, les informations de mémento, etc. Le format XML suit le même ordre
arbitraire que dans le bloc SCL.
Voici un exemple d'appel de bloc :


Bloc SCL Balise XML

#Callee_Instance(Input_1 := 5); Format de XML après exportation avec réglage
ExportOptions.None
<Access Scope="Call">
<CallInfo BlockType="FB">
<Instance
Scope="LocalVariable">
<Component
Name="Callee_Instance" />
</Instance>
<Token text="(" />
<Parameter Name="Input_1">
<Blank />
<Token text=":=" />
<Blank />
<Constant>
<ConstantType>Int</
ConstantType>
<ConstantValue>5</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Token text=")" />
</CallInfo>
</Access>
<Token text=";" />
<IntegerAttribute
Name="BlockNumber"
Informative="true">1</
IntegerAttribute>
<DateAttribute
Name="ParameterModifiedTS"
Informative="true">2016-10-24T08:27:
34</DateAttribute>
<Instance
<Component
</Instance>
<Token text="(" />
<StringAttribute
Name="InterfaceFlags"
Informative="true">S7_Visible</
StringAttribute>
<Blank />
<Token text=":=" />

Bloc SCL Balise XML

<Blank />
<Constant>
<ConstantType>Int</
ConstantType>
<ConstantValue>5</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Token text=")" />
</CallInfo>
</Access>
<Token text=";" />
Exemple de paramètres indépendants

Le FB quatre paramètres, parmi lesquels a, b, c ainsi que d. b et d ne sont pas connectés.

Bloc SCL Balise XML

"Block_4_DB"(a:=TRUE,c:=TRUE); <Access Scope="Call">
<CallInfo Name="Block_4"
BlockType="FB">
<Instance
Scope="GlobalVariable">
<Component Name="Block_4_DB" /
>
</Instance>
<Token text="(" />
<Parameter Name="a">
<Token text=":=" />
<Access
Scope="LiteralConstant">
<Constant>
<ConstantType>Bool</
ConstantType>
<ConstantValue>TRUE</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Token text="," />
<Parameter Name="b"
Informative="true"/>
<Parameter Name="c" >
<Token text=":=" />
<Access
<Constant>
ConstantType>
<ConstantValue>True</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Parameter Name="d"
Informative="true"/>
<Token text=")" />
</CallInfo>
</Access>
Exemple pour "un paramètre"

Le bloc SCL permet l'omission du nom du paramètre. Ce paramètre est représenté par la balise
NamelessParameter. La variable NamelessParameter ne possède pas d'attributs et s'applique
uniquement à SCL.

Bloc SCL Balise XML

"Block_4_DB"(TRUE); <Access Scope="Call">
BlockType="FB">
<Instance
<Component Name="Block_4_DB" /
>
</Instance>
<Token text="(" />
<NamelessParameter>
<Access
<Constant>
ConstantType>
ConstantValue>
</Constant>
</Access>
</NamelessParameter>
<Token text=")" />
</CallInfo>
</Access>

Expression sous forme de paramètre effectif
Bloc SCL Balise XML

#Callee_Instance(Input_1 := #a+3); <Access Scope="Call">
<Instance
<Component
</Instance>
<Token text="(" />
<Blank />
<Token text=":=" />
<Blank />
<Symbol>
</Symbol >
</Access>
<Token text="+" />
<Access
<Constant>
<ConstantType>Int</
ConstantType>
<ConstantValue>3</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Token text=")" />
</CallInfo>
</Access>
<Token text=";" />

Expression sous forme de paramètre effectif sans paramètre formel
Bloc SCL Balise XML

#Callee_Instance(#a+3); <Access Scope="Call">
<Instance Scope="LocalVariable">
<Component
</Instance>
<Token text="(" />
<NamelessParameter>
<Symbol>
</Symbol >
</Access>
<Token text="+" />
<Access
<Constant>
<ConstantType>Int</
ConstantType>
<ConstantValue>3</
ConstantValue>
</Constant>
</Access>
<Token text=")" />
</CallInfo>
</Access>
<Token text=";" />
Appel de fonction
Bloc SCL Balise XML

#myInt := "MyFunction"(Param_1 := 1, <Access Scope="LocalVariable">
Param_2 := 15, Param_3 := TRUE); <Symbol>
<Component Name="myInt" />
</Symbol>
</Access>
<Blank />
<Token text=":=" />
<Blank />
<CallInfo Name="MyFunction"
BlockType="FC">
<Token text="(" />
<Parameter Name="Param_1">
...

Appel absolu
Dans SCL, l'appel peut être lancé via l'adresse absolue du DB. L'attribut Name du nœud
CallInfo est vide en raison de l'adresse absolue.
Une exception récupérable est déclenchée par l'importation si
● un nœud "Address" avec une valeur valide de l'attribut Name est disponible ;
● le nœud "Address" n'est pas disponible et n'est pas une valeur valide de l'attribut Name.
Bloc SCL Balise XML

%DB20(...); <Access Scope="Call">
<CallInfo Name="" BlockType="FB">
<Instance
<Address Area="DB"
BlockNumber="20" />
</Instance>
<Token text="(" />
<Parameter>
…
</Parameter>
<Token text=")" />
</CallInfo>
</Access>
Instruction
L'instruction dans le bloc SCL est vérifiée dans la bibliothèque système lors du processus
d'importation et les versions d'instructions ne sont pas exportées lors du processus
d'exportation.
Le type d'instruction général est donné ci-dessous.


Bloc SCL Balise XML

#myInt := ATTACH(OB_NR := 1, Format de XML après exportation avec réglage
EVENT := 15, ADD := TRUE); ExportOptions.ReadOnly
<Symbol>
<Component Name="myInt" />
</Symbol>
</Access>
<Blank />
<Token text=":=" />
<Blank />
<Instruction Name="ATTACH">
<Token text="(" />
<Parameter Name="OB_NR">
<Blank />
<Token text=":=" />
<Blank />
<Constant>
<ConstantType>OB_ATT</
ConstantType>
<ConstantValue>1</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Token text="," />
<Blank />
<Parameter Name="EVENT">
<Blank />
<Token text=":=" />
<Blank />
<Constant>
<ConstantType>EVENT_ATT</
ConstantType>
<ConstantValue>15</
ConstantValue>
</Constant>
</Access>
</Parameter>
<Token text="," />
<Blank />
<Parameter Name="ADD">
<Blank />
<Token text=":=" />
<Blank />
<Constant>
ConstantType>
ConstantValue>

Bloc SCL Balise XML

</Constant>
</Access>
</Parameter>
<Parameter Name="RET_VAL"
Informative="true" />
<Token text=")" />
</Instruction>
</Access>
<Token text=";" />
Instruction avec modèle

Si le paramètre de modèle complète les noms d'instruction, l'exportation du paramètre de
modèle est nécessaire. Lorsqu'une balise "TemplateValue" avec l'attribut Type="Type" suit la
balise Instruction, le processus d'importation enchaîne la valeur de modèle avec le nom de
l'instruction.

Bloc SCL Balise XML

"tag_4" := MIN_DINT( IN1:="Tag_1", <Access Scope="GlobalVariable">
IN2:="Tag_2", IN3:="Tag_3" ); <Symbol>
</Symbol>
</Access>
...
<Instruction Name="MIN">
<TemplateValue
Name="value_type" Type="Type">DInt</
TemplateValue>
...
<Parameter Name="IN1">
...
<Symbol>
</Symbol>
</Access>
</Parameter>
...
<Parameter Name="IN2">...
<Symbol>
</Symbol>
</Access>
</Parameter>
...
<Parameter Name="IN3">
...
<Symbol>
</Symbol>
</Access>
</Parameter>
...
</Instruction>
</Access>
...
Conversion
Avec les fonctions de conversion, le vrai nom de l'instruction et son modèle ne sont pas
exportés. Au lieu de cela, le nom utilisé dans le bloc SCL est exporté.

Bloc SCL Balise XML

#output_1 := <Access Scope="LocalVariable">
TIME_TO_S5TIME(#input_1); <Symbol>
<Component Name="output_1" />
</Symbol>
</Access>
...
<Instruction
Name="TIME_TO_S5TIME">
<Token text="(" />
<NamelessParameter>
<Symbol>
<Component Name="input_1" /
>
</Symbol>
</Access>
<Token text=")" />
</Instruction>
</Access>
...
Instruction avec instance

L'instance et l'instruction sont séparées par des espaces. Les espaces sont facultatifs, et ils
peuvent être représentés par de nouvelles lignes et de nouveaux commentaires. L'instruction
TON est représentée par l'attribut Name de la balise Instruction.

Bloc SCL Balise XML

IEC_Timer_0_DB . TON (IN:="Tag_1", <Access Scope="GlobalAccess">
PT:="Tag_2"); <Symbol>
<Component
Name="IEC_Timer_0_DB" />
</Symbol >
</Access>
<Blank />
<Token text="." />
<Blank />
<Instruction Name="TON">
<Blank />
<Token text="(" />
<Parameter Name="IN">
<Symbol>
</Symbol>
</Access>
</Parameter>
...
<Token text=")" />
</Instruction>
</Access>
<Token text=";" />
Constante d'alarme
Les constantes d'alarme ne sont utilisées que dans les API S7 400 , et le code XML exporté est
similaire à d'autres langages.

Bloc SCL Balise XML

"Block_1_DB"(16#0000_0001); Format de XML après exportation avec
réglage ExportOptions.None
BlockType="FB">
<Instance Scope="GlobalVariable">
<Component Name="Block_1_DB" />
</Instance>
<NamelessParameter>
<Access Scope="AlarmConstant">
<Constant>
<ConstantType>C_Alarm_8</
ConstantType>
<ConstantValue>16#0000_0001</
ConstantValue>
</Constant>
</Access>
</NamelessParameter >
</CallInfo>
</Access>
BlockType="FB">
<Instance Scope="GlobalVariable">
<Component Name="Block_1_DB" />
</Instance>
<NamelessParameter>
<Access Scope="AlarmConstant" >
<Constant>
<ConstantValue>16#00000001</
ConstantValue>
<ConstantType>C_Alarm</
ConstantType>
<StringAttribute
Name="Format"
Informative="true">Hex</
StringAttribute>
</Constant>
</Access>
</CallInfo>
</Access>

ENO (sortie de validation)

Afin de prendre en charge la sortie de validation ENO dans le bloc SCL, l'attribut "Scope" est
utilisé avec la valeur "PredefinedVariable" dans la variable "Access". Il contient également la
balise "PredefinedVariable" en tant qu'élément subordonné de la balise Access.
● La balise "PredefinedVariable" possède un attribut obligatoire "Name".
● Le volume "PredefinedVariable" et la variable "PredefinedVariable" ne sont autorisés que
pour SCL.
Bloc SCL Balise XML

Call(…, ENO => ENO); <Access Scope="Call">
<CallInfo BlockType="FC">
<Token text="(" />
…
<Token text="," />
<Blank />
<Parameter Name="ENO">
<Blank />
<Token text="=>" />
<Blank />
<Access
Scope="PredefinedVariable">
<PredefinedVariable
Name="ENO" />
</Access>
</Parameter>
<Token text=")" />
</CallInfo>
</Access>
<Token text=";" />
IF ENO = #c THEN … <Token text="IF" />
<Blank />
<Access Scope="PredefinedVariable">
<PredefinedVariable Name="ENO" />
</Access>
<Blank />
<Token Text="=" />
<Blank />
<Symbol>
</Symbol>
</Access>
<Blank />
<Token Text="THEN" />

8.5.1.8 Exporter/importer des commentaires multilingues dans SCL
Conditions
Application
Dans TIA Portal Openness, vous pouvez importer et exporter des commentaires multilingues
dans l'éditeur SCL selon l'une des méthodes suivantes :
● Lors de l'exportation de SCL dans Openness, tous les commentaires multilingues et les
traductions correspondantes, dépendant des langues du projet activées, sont exportés
dans le même fichier XML Openness.
● Lors de l'importation de Openness dans SCL, tous les commentaires multilingues et les
traductions correspondantes, dépendant des langues du projet activées, sont réimportés à
partir du même fichier XML Openness. Cela doit être affiché dans la zone de texte pour le
projet. La langue est alors activée si elle n'était pas activée lors de l'importation dans le
projet.
● Après l'importation, vous devez vérifier si tous les commentaires multilingues présents dans
l'éditeur SCL sont liés aux commentaires correspondants dans le texte du projet.
Exemple
La figure suivante montre un exemple de commentaire multilingue dans l'éditeur SCL:
La figure suivante montre un exemple d'exportation d'un commentaire multilingue dans le

fichier XML Openness :

Voir aussi
8.5.1.9 Exporter des blocs F
Exporter des blocs de sécurité

Il est à présent possible d'importer et d'exporter les blocs de sécurité, cependant, les blocs
système F ne peuvent pas être exportés.
Importer des blocs de sécurité

Les blocs F cohérents peuvent être exportés et à nouveau importés. Ils sont créés comme
blocs F.
Ils sont importés comme blocs standard si vous supprimez le préfixe "F_" de la valeur de tous
les attributs "ProgrammingLanguage".
Voir aussi
Exporter des blocs (Page 896)
Exporter des blocs avec protection know-how (Page 854)
8.5.1.10 Exporter des blocs système
Conditions requises
● Le projet contient un bloc système.

● Le bloc système n'est pas un bloc F.

Utilisation
Seuls les blocs système visibles sont disponibles dans la composition des blocs, donc pas de
SFB ni de SFC. Le fichier XML qui en résulte ressemble au fichier d'exportation d'un bloc.
Code du programme
Pour exporter les données visibles d'un bloc vers un fichier XML, modifiez le code de
programme suivant :
//Exports system blocks

private static void ExportSystemBlocks(PlcSoftware plcsoftware)
{
PlcSystemBlockGroup sbSystemGroup = plcsoftware.BlockGroup.SystemBlockGroups[0];
foreach (PlcSystemBlockGroup group in sbSystemGroup.Groups)
{
foreach (PlcBlock block in group.Blocks)
{
block.Export(new FileInfo(string.Format(@”D:\Samples\{0}.xml”, block.Name)),
}
}
}
8.5.1.11 Exporter des blocs GRAPH avec texte multilingue
Structure XML de blocs GRAPH avec texte multilingue

Le fichier d'exportation XML de blocs GRAPH contient les noms d'étapes et de transitions
compilés du graphe. Ces textes multilingues traduits sont représentés respectivement sous les
éléments de niveau supérieur Step et Transition comme éléments StepName et
TransitionName. Ces éléments contiennent un élément MultiLanguageText pour chaque
langue prise en charge. Les textes dans des langues non paramétrées de manière explicite ne
sont pas exportés. Si aucune traduction n'est disponible, les éléments StepName et
TransitionName ne sont pas exportés. Les éléments StepName et TransitionName sont
optionnels. L'opération d'importation XML TIA Portal Openness déclenche une exception
restaurable pour les versions de Graph antérieures à V5.0.

Exemple pour l'élément StepName
<Steps>
<Step Number="1" Init="true" Name="Step1" MaximumStepTime="T#10S" WarningTime="T#7S">
<StepName>
<MultiLanguageText Lang="de-DE">stepDE</MultiLanguageText>
<MultiLanguageText Lang="en-US">stepEN</MultiLanguageText>
<MultiLanguageText Lang="it-CH">stepIT</MultiLanguageText>
</StepName>
..
</Step>
..
</Steps>
Exemple pour l'élément TransitionName
<Transitions>
<Transition IsMissing="false" Name="Trans1" Number="1" ProgrammingLanguage="LAD">
<TransitionName>
<MultiLanguageText Lang="de-DE">transDE</MultiLanguageText>
<MultiLanguageText Lang="en-US">transEN</MultiLanguageText>
<MultiLanguageText Lang="it-CH">transIT</MultiLanguageText>
</TransitionName>
..
</Transition>
..
</Transitions>
8.5.1.12 Importer un bloc
Conditions

Utilisation
La TIA Portal Openness API prend en charge l'importation de blocs avec les langages de
programmation "LIST", "LOG", "GRAPH", "SCL" ou "CONT" à partir d'un fichier XML. Les types
de bloc suivants sont pris en charge :
● Blocs fonctionnels (FB)
● Fonctions (FC)
● Blocs d'organisation (OB)
● Blocs de données globaux (DB)
Remarque
Importation de blocs de données optimisés
Les blocs de données optimisés sont uniquement pris en charge par les CPU à partir de
S7-1200. Si vous importez des blocs de données optimisés dans une S7-300 ou S7-400, une
exception est déclenchée et l'importation échoue.
Réaction à l'importation
Pour l'importation d'un bloc, les règles à respecter sont les suivantes :
● Le fichier XML peut contenir moins de données que le bloc se trouvant dans le projet, par
ex. moins de paramètres.
● Les informations redondantes telles que les informations d'appel doivent être identiques
dans le projet et dans le fichier XML. Faute de quoi, une exception est lancée.
● Les données du fichier XML peuvent être "incohérentes" en ce qui concerne leur capacité
à être compilées dans TIA Portal.
● Les attributs possédant les attributs "ReadOnly=True" et "Informative=True" ne sont pas
importés.
● Les DB d'instance manquants ne sont pas automatiquement créés.
● Si aucun numéro de bloc n'est indiqué dans le fichier XML, il est automatiquement attribué.
● Si le bloc ne figure pas dans le projet et si aucune information de version n'est indiquée dans
le fichier XML, la version "0.1" est attribuée.
Code de programme
//Import blocks
private static void ImportBlocks(PlcSoftware plcSoftware)
{
PlcBlockGroup blockGroup = plcSoftware.BlockGroup;
IList<PlcBlock> blocks = blockGroup.Blocks.Import(new FileInfo(@"D:\Blocks
\myBlock.xml"), ImportOptions.Override);
}

//Import system blocks

private static void ImportSystemBlocks(PlcSoftware plcSoftware)
{
PlcBlockSystemGroup systemblockGroup = plcSoftware.BlockGroup;
IList<PlcBlock> blocks = systemblockGroup.Blocks.Import(new FileInfo(@"D:\Blocks
\myBlock.xml"), ImportOptions.Override);
}
8.5.1.13 Exporter des blocs
Conditions
Utilisation
L'interface API prend en charge l'exportation de blocs et types de données utilisateur cohérents
vers un fichier XML.
Le fichier XML se voit attribuer le nom du bloc. Les types de bloc suivants sont pris en charge :
● Blocs fonctionnels (FB)
● Fonctions (FC)
● Blocs d'organisation (OB)
● Blocs de données globaux (DB)
Les types de langages de programmation suivants sont pris en charge :
● LIST
● LOG
● CONT
● GRAPH
● SCL
Attributs valables pour tous les blocs

Les attributs suivants sont exportés avec les ExportOptions sélectionnées dans tous les
blocs (voir Exportation de données de configuration (Page 778)). Les attributs représentés en
caractères gras sont toujours exportés.

Vous trouverez plus d'informations dans le système d'informations du TIA Portal, sous "Aperçu
des attributs du bloc".
Attribut Type Valeur par défaut Protégé en écriture

AutoNumber Bool true false
CodeModifiedDate DateTime - true
CompileDate DateTime - true
CreationDate DateTime - true
HeaderAuthor String "" false
HeaderFamily String "" false
HeaderName String "" false
HeaderVersion String "0,1" false
Interface String interface non occupée false
InterfaceModifiedDate DateTime - true
IsConsistent Bool - true
IsKnowHowProtected1 Bool false true
IsWriteProtected Bool false true
MemoryLayout enum MemoryLayout - false
ModifiedDate DateTime - true
Name String - false
Number Int32 prochain numéro disponible false
ParameterModified DateTime - true
PLCSimAdvancedSupport Bool false true
ProgrammingLanguage enum ProgrammingLangua‐ - false
ge
StructureModified DateTime - true
1
L'attribut IsKnowHowProtected est également valable pour les UDT.
Remarque
Sous certaines conditions, l'attribut MemoryLayout est protégé en écriture.

Attributs généraux accessibles de façon dynamique

Les attributs suivants sont uniquement protégés en écriture sous certaines conditions :
Attribut État ReadOnly

AutoNumber All KnowHowProtected blocks, All Classic OBs; Plus OBs: DiagnosticErrorInterrupt, IOAccessError, Pro‐
grammingError, PullOrPlugOfModules, RackOrStationFailure, Status, TimeErrorInterrupt, Update
HeaderVer‐ System- and KnowHowProtected DBs; ArrayDBs that originated from system library
sion
HeaderName
HeaderFamily
HeaderAuthor
Memory‐ Classic blocks, System Know how protected blocks, ArrayDBs, IDBofFBs, Graph blocks
Layout
Attributs valables pour les blocs ArrayDB

Les attributs suivants sont exportés avec les ExportOptions. sélectionnées pour les blocs
ArrayDB :

ArrayDataType String - true
ArrayLimitUpperBound Int32 - true
Attributs valables pour les blocs DB

DB :

IsOnlyStoredInLoadMemory Bool false false
IsPLCDB Bool false false
IsWriteProtectedInAS Bool false false
Attributs valables pour les blocs FB

FB :

AssignedProDiagFB String - -
ISMultiInstanceCapable Bool - true
Supervisions String no supervisions true pour IDB of FB et false
pour FB

Attributs valables pour les blocs DB et FB

DB et FB :

IsIECCheckEnabled Bool false false
IsRetainMemResEnabled 1
Bool false false
MemoryReserve Unsigned 0 false
RetainMemoryReserve 2
Unsigned 0 false
2
Si la valeur de l'attribut "IsRetainMemResEnabled" est "false" et que l'attribut "RetainMemoryReserve" n'est pas égal à "0",
le système déclenche une exception.
Attributs valables pour les blocs FB, blocs de données et IDB

FB, blocs de données et IDB :

DownloadWithoutReinit Bool false true
Attributs valables pour les blocs FB et FC

FB et FC :

LibraryType String - true
LibraryTypeVersionGuid String - true
Attributs valables pour les blocs FB et FC (LIST)

FB et FC (LIST) :

ParameterPassing Bool false false
Attributs valables pour les FB, FC et DB d'instance de blocs FB

Les attributs suivants sont exportés avec les ExportOptions. sélectionnées pour FB, FC et
DB d'instance de blocs FB :


UDABlockProperties String "" false
UDAEnableTagReadback Bool false false
Attributs valables pour les DB d'instance de FB et UDT

Les attributs suivants sont exportés avec les ExportOptions. sélectionnées pour les DB
d'instance de blocs FB et UDT :

InstanceOfName String "" false
InstanceOfNumber Unsigned Short - true
InstanceOfType enum BlockType - true
OfSystemLibElement String "" false
OfSystemLibVersion String "" false
Attributs valables pour les blocs OB

OB pour des API Plus spécifiques :

ApplicationCycle Single - true
AutomaticMinimum Bool - true
ConstantName String - true
CycleTimeDistributedIO Single - true
CyclicApplicationCycleTime Single - true
CyclicTime Int32 100000 true
DataExchangeMode OBDataExchangeMode Cyclic true
DelayTime Double - true
DistributedIOName String - true
DistributedIONumber Int32 - true
EnableTimeError Bool - true
EventClass String - true
EventsToBeQueued Int32 - true
EventThresholdForTimeError Int32 - true
Execution OBExecution Never true
Factor Single - true
PhaseOffset Int32 0 true
PriorityNumber Int32 - true
ProcessImagePartNumber UInt32 - true


ReportEvents Bool - true
SecondaryType 3
String - false
StartDate DateTime 1/1/2012 true
SynchronousApplicationCy‐ Single - true
cleTime
TimeMode OBTimeMode System true
TimeOfDay DateTime 12:00 AM true
TransformationDBNumber UInt16 0xffff true
3
Lors de l'exportation d'un OB, le SecondaryType est défini par ailleurs à l'aide du numéro d'OB. L'affectation est vérifiée
pendant le processus d'importation. Si l'affectation est incorrecte, une exception de type "Recoverable" est déclenchée.
Attributs valables pour les blocs FB, FC et OB

FB, FC et OB :

HandleErrorsWithinBlock Bool false true
Attributs valables pour les blocs FB, FC et UDT

FB, FC et UDT :

LibraryConformanceStatus String - false
Attributs valables pour les blocs GRAPH

GRAPH :

AcknowledgeErrorsRequired Bool true false
CreateMinimizedDB Bool false false
ExtensionBlockName String - -
GraphVersion String - false
InitialValuesAcquisition String - -
LanguageInNetworks String - false
LockOperatingMode Bool false false


PermanentILProcessingIn‐ Bool false false
MANMode
SkipSteps Bool false false
Attributs valables pour les blocs GRAPH FB

GRAPH FB :

WithAlarmHandling Bool true false
Attributs valables pour les blocs SCL

SCL. Ces attributs sont exportés sur la base du type des API.

CheckArrayLimits Bool false false
ExtendedStatus Bool false false
DBAccessibleFromOPCUA Bool true false
Attributs valables pour les blocs GRAPH, SCL et CONT/LOG

GRAPH, SCL et CONT/LOG :

SetENOAutomatically Bool - false
Attributs valables pour les blocs de programme (hors OB) et les blocs DB et UDT.
Les attributs suivants sont exportés pour les blocs de programme (hors OB) et les blocs DB et
UDT sous une unité avec les ExportOptions sélectionnées :

Access UnitAccessType Unpublished false

Comportement d'importation pour l'attribut Access'
Importation sous unité Importation non sous unité Importation non sous unité
(sans SWImportOp‐ (avec SWImportOp‐
tions.IgnoreUnitAttributes) tions.IgnoreUnitAttributes)
Exportation XML sous unité 'Access' utilisé et défini RecoverableException dé‐ 'Access' ignoré
clenchée
Exportation XML non sous 'Access' contient la valeur par 'Access' est manquant 'Access' est manquant
unité défaut
Code de programme
Pour exporter un bloc dépourvu de protection Know-how vers un fichier XML, modifiez le code
//Exports a regular block

private static void ExportRegularBlock(PlcSoftware plcSoftware)
{
plcBlock.Export(new FileInfo(string.Format(@”D:\Samples\{0}.xml”, plcBlock.Name)),
}
8.5.1.14 Importer des blocs/UDT avec référence ouverte
Conditions
Application
Avec l'API Openness, vous pouvez utiliser pour des objets STEP 7 un nouveau mode
d'importation dans lequel vous pouvez également importer des blocs et des UDT si un objet
correspondant manque.
L'interface Openness prend en charge le nouveau mode d'importation dans les conditions
suivantes :
Importation depuis Référence d'objet

UDT UDT
DB (global) UDT
IDBofUDT UDT
IDBofFB FB

Importation depuis Référence d'objet

ArrayDB Tableau d'UDT
FB UDT (interface), multi-instance
FC UDT (interface)
Code de programme
Vous pouvez utiliser le nouveau module grâce à une nouvelle surcharge de la méthode Import
correspondante. La nouvelle surcharge indique un paramètre supplémentaire qui accepte une
valeur de la nouvelle énumération sélectionnée SWImportOptions. Pour permettre
l'importation, vous pouvez également utiliser
SWImportOptions.IgnoreMissingReferencedObject si l'objet de la référence manque.
Flagged Enum SWImportOptions

{
None = 0,
IgnoreStructuralChanges = 1,
IgnoreMissingReferencedObjects = 2
}
... // All kinds of blocks
PlcBlockComposition.Import(file, ImportOptions.None,
SWImportOptions.IgnoreMissingReferencedObject);
...
... // UDTs
PlcTypeComposition.Import(file, ImportOptions.None,
SWImportOptions.IgnoreMissingReferencedObject);
...
Voir aussi
8.5.1.15 Importer des blocs/UDT pour des objets de modification de structure
Conditions


Application
Avec l'API Openness, vous pouvez également importer des objets et des UDT lorsque des
données d'instance sont perdues en raison d'une modification de structure dans les objets
correspondants.
L'interface Openness prend en charge le nouveau mode d'importation dans les conditions
suivantes :
Importation depuis Références d'objet

Variable UDT
UDT UDT
DB (global) UDT
IDBofUDT UDT
IDBofFB FB
ArrayDB Tableau d'UDT
FB UDT (interface), multi-instance
FC UDT (interface)
Code de programme
Vous pouvez utiliser le nouveau module grâce à une nouvelle surcharge de la méthode Import
correspondante. La nouvelle surcharge indique un paramètre supplémentaire qui accepte une
valeur de la nouvelle énumération sélectionnée SWImportOptions. Pour permettre
l'importation, même s'il existe des modifications structurelles et qu'une perte de données risque
de se produire, utilisez "SWImportOptions.IgnoreStructuralChanges".
Flagged Enum SWImportOptions

{
None = 0,
IgnoreStructuralChanges = 1,
IgnoreMissingReferencedObjects = 2
}
...
// All kinds of blocks
PlcBlockComposition.Import(file, ImportOptions.None,
SWImportOptions.IgnoreStructuralChanges);
...
...
// UDTs
PlcTypeComposition.Import(file, ImportOptions.None,
SWImportOptions.IgnoreStructuralChanges);
...

Voir aussi
8.5.1.16 Exportation/importation de l'attribut de publication spécifique à l'unité des blocs et types
Conditions
Application
L'attribut 'Access' est uniquement présent pour les blocs, les types d'API et les tables de
variables qui se trouvent sous une unité. C'est pourquoi il est contenu dans le fichier XML
exporté. Le fichier XML exporté du même bloc, du même type ou de la même table de variables
dans un environnement hors de l'unité ne contient pas l'attribut.
Les règles d'importation XML d'Openness n'autorisent pas les fichiers XML avec des attributs
inconnus/non définis. En raison de ces règles, les fichiers XML exportés d'un objet dans un
environnement sous une unité ne peuvent pas être importés dans un environnement hors
d'une unité. Cela génèrerait une restriction importante de l'utilisabilité. C'est pourquoi
l'extension suivante est définie.
Trois paramètres sont transmis en fonction de la surcharge de la méthode import (). Ceux-ci
sont :
Paramètre Type de valeur en retour Description

path String Indique le chemin du fi‐
chier SIMATIC ML à im‐
porter
importOptions enum: Siemens.Engineering.ImportOptions Indique les options d'im‐
portation générales à uti‐
liser lors de l'importation.
swImportOptions enum: Siemens.Engineering.SW.SWImportOp‐ Indique les options d'im‐
tions portation spécifiques
pour STEP 7.
Les Siemens.Engineering.SW.SWImportOptions du type enum sont étendues des nouvelles

options d'importation suivantes :
● IgnoreUnitAttributes: indique que l'opération d'importation ne doit pas être interrompue si
des attributs liés à l'unité sont présents dans le fichier XML et que l'importation s'effectue
dans un environnement hors de l'unité.

Le 'IgnoreUnitAttributes' est pris en compte uniquement lorsque le fichier XML

● est exporté d'une unité
● contient l'attribut 'Access'
● est importé dans un environnement hors d'une unité
Lorsque le fichier XML exporté ne contient pas l'attribut Openness 'Access' et/ou s'il est importé
dans une unité, la nouvelle option d'importation n'est pas prise en compte par la logique
d'importation.
Code de programme :

PlcSoftware plcSoftware = plcTarget.GetService<SoftwareContainer>() as PlcSoftware;
PlcUnit plcUnit1 = plcUnitProvider.UnitGroup.Units[0];
//assuming Unit_1 is already existing
PlcUnit plcUnit2 = plcUnitProvider.UnitGroup.Units[1];
//assuming Unit_2 is already existing
PlcBlock block1 = plcUnit1.BlockGroup.Blocks.Find("Block_1");
//assuming Block_1 is already existing under Unit_1
PlcBlock block2 = plcUnit2.BlockGroup.Blocks.Find("Block_2");
//assuming Block_2 is already existing under Unit_2
PlcBlock block3 = plcSoftware.BlockGroup.Blocks.Find("Block_3");
//assuming Block_3 is already existing under the PLC
Code de programme : L'objet est exporté d'une unité et importé dans une unité
Les exemples suivants montrent le comportement de la nouvelle option d'importation à l'aide
de blocs. Le même comportement vaut cependant aussi pour les types d'API et les tables de
variables.
Modifiez le code de programme suivant pour exporter un bloc pour lequel l'attribut 'Access' est
mis à la valeur 'Unpublished' (valeur par défaut) et les ExportOptions.WithDefaults et les
SWImportOptions.None sont :
block1.SetAttribute("Access", UnitAccessType.Unpublished);
block1.Export(new FileInfo("somepath"), ExportOptions.WithDefaults);
block1.Delete();
plcUnit2.BlockGroup.Blocks.Import(new FileInfo("somepath"), ImportOptions.None,
SWImportOptions.None);

SWImportOptions.IgnoreUnitAttributes sont :
block1.Delete();
SWImportOptions.IgnoreUnitAttributes);
mis à la valeur 'Published' et les ExportOptions.None et les SWImportOptions.None sont :
block1.SetAttribute("Access", UnitAccessType.Published);
block1.Export(new FileInfo("somepath"), ExportOptions.None);
block1.Delete();
mis à la valeur 'Published' et les ExportOptions.None et les
block1.Export(new FileInfo("somepath"), ExportOptions.None);
block1.Delete();
Remarque
Dans toutes les sections de code de programme ci-dessus avec des scénarios d'erreur,
aucune exception récupérable n'est déclenchée et l'opération d'importation réussit.
Code de programme : L'objet est exporté d'une unité et importé dans un environnement hors d'une unité
SWImportOptions.None sont :
block1.Delete();

Remarque
Dans le code de programme ci-dessus, l'opération d'importation échoue et une exception
récupérable est déclenchée.
block1.Delete();
Remarque
Dans le code du programme ci-dessous, l'opération d'importation réussit et aucune exception
n'est déclenchée.
mis à la valeur 'Published' et les ExportOptions.None et les SWImportOptions.None sont :
block1.Export(new FileInfo(„somepath"), ExportOptions.None);
block1.Delete();
Remarque
Dans le code de programme ci-dessus, l'opération d'importation réussit et une exception
récupérable est déclenchée.
mis à la valeur 'Published' et les ExportOptions.None options d'importation
block1.Export(new FileInfo(„somepath"), ExportOptions.None);
block1.Delete();

Remarque
Dans toutes les sections de code de programme ci-dessus, aucune exception récupérable
n'est déclenchée et l'opération d'importation réussit.
L'objet est exporté de l'environnement hors d'une unité et importé dans une unité
Le fichier XML exporté ne contient pas l'attribut Openness 'Access' ; à l'importation, l'attribut a
la valeur par défaut 'Unpublished'.
L'objet est exporté d'un environnement hors d'une unité et importé dans un environnement hors d'une
unité
Le fichier XML exporté ne contient pas l'attribut Openness 'Access' ; à l'importation du fichier,
rien ne se produit.
Voir aussi
8.5.2 Tables des variables
8.5.2.1 Exporter des tables de variables API
Conditions requises
Utilisation
Un fichier XML est exporté par table des variables API.
L'interface TIA Portal Openness API prend en charge l'exportation de toutes les tables de
variables API du groupe système et de ses sous-groupes.

Code du programme
Pour exporter toutes les tables de variables API du groupe système et de ses sous-groupes,
private static void ExportAllTagTables(PlcSoftware plcSoftware)

{
// Export all tables in the system group
ExportTagTables(plcTagTableSystemGroup.TagTables);
// Export the tables in underlying user groups
foreach(PlcTagTableUserGroup userGroup in plcTagTableSystemGroup.Groups)
{
ExportUserGroupDeep(userGroup);
}
}
private static void ExportTagTables(PlcTagTableComposition tagTables)

{
foreach(PlcTagTable table in tagTables)
{
table.Export(new FileInfo(string.Format(@”D:\Samples\{0}.xml”, table.Name)),
}
}
private static void ExportUserGroupDeep(PlcTagTableUserGroup group)

{
ExportTagTables(group.TagTables);
foreach(PlcTagTableUserGroup userGroup in group.Groups)
{
ExportUserGroupDeep(userGroup);
}
}
Voir aussi
8.5.2.2 Importer une table de variables API
Conditions requises

Code du programme
Pour importer des tables de variables API ou une structure de dossiers avec des tables de
variables API dans le groupe système ou un groupe personnalisé depuis un fichier XML,
//Imports tag tables to the tag system group

private static void ImportTagTable(PlcSoftware plcSoftware)
{
PlcTagTableComposition tagTables = plcTagTableSystemGroup.TagTables;
tagTables.Import(new FileInfo(@"D:\Samples\myTagTable.xml"), ImportOptions.Override);
// Or, to import into a subfolder:
// plcTagTableSystemGroup.Groups.Find("SubGroup").TagTables.Import(new
FileInfo(@"D:\Samples\myTagTable.xml"), ImportOptions.Override);
}
Voir aussi
Remarques sur la performance de TIA Portal Openness (Page 45)
8.5.2.3 Exporter des variables ou constantes individuelles d'une table de variables API
Conditions
Utilisation
L'interface API prend en charge l'exportation d'une variable ou d'une constante depuis une
table de variables API vers un fichier XML. Ce faisant, veillez à ce que les noms utilisés pour
les tables des variables correspondent aux conventions de dénomination de fichiers de votre
système de fichiers.
Le commentaire d'une variable ou d'une constante n'est exporté que si au moins une langue
est définie pour le commentaire. Si le commentaire n'est pas défini pour toutes les langues du
projet, il est uniquement exporté pour les langues du projet définies.
Remarque
Constantes système API
Les constantes système API sont exclues de l'exportation et de l'importation.

Code de programme
Pour exporter une variable ou une constante déterminée d'une table de variables API vers un
fichier XML, modifiez le code de programme suivant :
//Exports a single tag or constant of a controller tag table

private static void ExportTag(PlcSoftware plcSoftware, string tagName)
{
PlcTag tag = plcTagTableSystemGroup.TagTables[0].Tags.Find(tagName);
if(tag 0= null) return;
tag.Export(new FileInfo(string.Format(@”D:\Samples\{0}.xml”, tag.Name)),

}
private static void ExportUserConstant(PlcSoftware plcSoftware, string userConstantName)

{
PlcUserConstant plcConstant =
plcTagTableSystemGroup.TagTables[0].UserConstants.Find(userConstantName);
if(plcConstant== null) return;
plcConstant.Export(new FileInfo(string.Format(@”D:\Samples\{0}.xml”,
plcConstant.Name)), ExportOptions.WithDefaults);
}
Voir aussi
8.5.2.4 Importer une seule variable ou constante dans une table de variables API
Conditions requises
Utilisation
Lors d'un appel d'importation, vous pouvez importer soit des variables soit des constantes.

Remarque
Les constantes peuvent uniquement être importées comme constantes utilisateur.
Code du programme
Pour importer des groupes de variables ou certaines variables ou constantes depuis un fichier
XML, modifiez le code de programme suivant :
//Imports tags into a plc tag table

private static void ImportTag(PlcSoftware plcSoftware, string tagtableName)
{
PlcTagTableSystemGroup plcTagTableSystemgroup = plcSoftware.TagTableGroup;
PlcTagTable tagTable = plcTagTableSystemgroup.TagTables.Find(tagtableName);
if(tagTable == null) return;
tagTable.Tags.Import(new FileInfo(@"D:\Samples\myTags.xml"), ImportOptions.Override);

}
//Imports constants into a plc tag table

private static void ImportConstant(PlcSoftware plcSoftware, string tagtableName)
{
PlcTagTableSystemGroup plcTagTableSystemgroup = plcSoftware.TagTableGroup;
PlcTagTable tagTable = plcTagTableSystemgroup.TagTables.Find(tagtableName);
if(tagTable == null) return;
tagTable.UserConstants.Import(new FileInfo(@"D:\Samples\myConstants.xml"),
}
Voir aussi

8.5.3 Objets technologiques
8.5.3.1 Vue d'ensemble des objets technologiques et des versions
Le tableau suivant indique les objets technologiques disponibles pour l'importation et
l'exportation.
CPU Technologie Objet technologique Version de Firmware de la

l'objet techno‐ CPU
logique
S7-1200 Commande de TO_PositioningAxis ≥ V7.0 ≥ V4.4
mouvement TO_CommandTable
Régulation PID PID_Compact V2.3 ≥ V4.2
PID_3Step V2.3
PID_Temp V1.1
S7-1500 Commande de TO_SpeedAxis ≥ V5.0 ≥ V2.8
mouvement TO_PositioningAxis
TO_ExternalEncoder
TO_SynchronousAxis
TO_OutputCam
TO_CamTrack
TO_MeasuringInput
TO_Cam (S7-1500T)
TO_Kinematics (S7-1500T)
TO_LeadingAxisProxy
(S7-1500T)
Comptage et me‐ High_Speed_Counter ≥ V4.1 au choix
sure SSI_Absolute_Encoder ≥ V3.1
Régulation PID PID_Compact ≥ V2.3 ≥ V2.0
PID_3Step V2.3
PID_Temp V1.1
CONT_C
CONT_S
TCONT_CP
TCONT_S

CPU Technologie Objet technologique Version de Firmware de la

l'objet techno‐ CPU
logique
S7-300/400 Régulation PID CONT_C V1.1 Chaque
CONT_S
TCONT_CP
TCONT_S
TUN_EC
TUN_ES
PID_CP V2.0
PID_ES
EMC AXIS_REF V2.0
8.5.3.2 Structure XML de la section d'interface de bloc
Principe de base
Les données dans le fichier XML d'importation/exportation sont organisées en référence à un
format de fichier XML Openness. Chaque fichier d'importation doit répondre aux conditions
structurelles.
Le fichier d'exportation contient toutes les variables et constantes traitées de la section
d'interface d'un objet technologique exporté. Les données de projet peuvent contenir plus de
données que le fichier XML d'importation, par exemple des références externes. Celles-ci
doivent être exportés séparément. Seules les valeurs accessibles en écriture peuvent être
importées par TIA Portal Openness XML.
En fonction des paramètres d'exportation dans TIA Portal Openness, le fichier d'exportation
contient un jeu déterminé d'attributs et d'éléments. Les fichiers d'exportation de versions
supérieures de TIA Portal ne sont pas compatibles avec les versions antérieures de TIA Portal
et ne peuvent pas être importés dans ces versions. Les fichiers SimaticML exportés avec la
dernière version TechObject sont également pris en charge pour les versions plus récentes.
Format de fichier XML de Openness

Le fichier d'exportation est créé au format XML et contient toutes les variables et constantes
traitées de la section interface d'un bloc exporté. L'ordre de la description suivante des
éléments représente l'ordre requis dans le fichier de saisie.
Attributs
Le format SimaticML est largement adopté par le format d'exportation/importation des blocs
d'utilisateurs.
Les attributs supplémentaires suivants sont particulièrement importants :
● OfSystemLibElement
● OfSystemLibVersion
● Interface

L'attribut OfSystemLibVersion contient la version de l'objet technologique et l'attribut

OfSystemLibElement contient le type de l'objet technologique.
L'attribut Interface contient tous les membres du bloc de données de l'objet technologique,
y compris les éléments de structure et les versions.
Figure 8-3 Exemple de TO_SpeedAxis pour S7-1500
Les données technologiques qui ne sont pas mémorisées dans le bloc de données lui-même
sont mémorisées dans un attribut supplémentaire ParameterData.

8.5.3.3 Exporter des objets technologiques
Conditions
● Un projet contient l'objet technologique à exporter.
Utilisation
L'API Openness de TIA Portal prend en charge l'exportation de tous les objets technologiques
du tableau Vue d'ensemble des objets technologiques et des versions (Page 915) dans un
fichier XML. Vous ne pouvez exporter que des objets technologiques cohérents. HWCN ou
TagTable ne sont pas exportés avec l'objet technologique, mais doivent être exportés
séparément. Vous pouvez vérifier la cohérence d'un objet technologique avec l'attribut
IsConsistent. Ce mémento peut être défini lors d’une compilation réussie de l’objet
technologique correspondant. La génération du fichier d'exportation correspondant indique
que l'exportation est terminé.

Exceptions
● Si vous essayez d'exporter un objet technologique incohérent, une exception est
déclenchée.
● Si vous essayez d'exporter l'objet technologique qui ne prend pas en charge la
fonctionnalité d'exportation, une exception est déclenchée. Cette exception est également
déclenchée sur les anciennes versions d'objet technologique qui ne prennent pas en
charge l'exportation.
● Si vous essayez d'exporter l'objet technologique alors que vous êtes dans le mode en ligne,
une exception est déclenchée.
Autres paramètres
La plupart des paramètres d'objets technologiques pour la commande de mouvement sont
directement assignés à des variables de bloc de données, mais il existe également quelques
autres paramètres qui ne sont pas directement assignés à des blocs de données. Voir
aussi Attributs spécifiques pour TO_PositioningAxis et TO_CommandTable (Page 922),
Attributs spécifiques pour les objets technologiques d'axe et de codeur (Page 925), Attributs
spécifiques pour les objets technologiques came, piste de came et palpeur de mesure
(Page 929).
Code du programme
void Export(FileInfo path, ExportOptions options);
Le paramètre path décrit le chemin d'accès et le nom de fichier du fichier d'exportation à créer.
Le paramètre (ExportOptions options) spécifie les options pour l'exportation (Page 778).
ExportOptions.None N'exporte que des paramètres modifiés.
ExportOptions.WithDefaults Cette option exporte les paramètres qui ont leur valeur par défaut. La
valeur par défaut elle-même n'est pas exportée. Le même comportement
est également défini pour les parties de l'exportation XML spécifiques à
l'objet technologique. Les valeurs par défaut correspondantes exportées
sont définies pour chaque type d'objet technologique.
ExportOptions.WithReadOnly Cette option exporte des attributs et des valeurs supplémentaires à titre
d'information. Lors de l'importation, les valeurs protégées en écriture ne
sont pas réécrites dans le bloc de données. Les valeurs protégées en
écriture correspondantes exportées sont définies pour chaque type d'ob‐
jet technologique.
ExportOptions.WithDefaults | ExportOptions.Wi‐ Combinaison des deux options ci-dessus.
thReadOnly

Pour rechercher un objet technologique et l'exporter dans un fichier XML, modifiez le code du
programme suivant :
// Find a specific technology object by its name and export this

private static void ExportTechnologicalObject(FileInfo path, ExportOptions options,
PlcSoftware plcSoftware, String nameOfTO)
{
// Find by name
TechnologicalInstanceDBComposition technologicalObjects = plcSoftware.TechnologicalObje
ctGroup.TechnologicalObjects;
TechnologicalInstanceDB technologicalObject = technologicalObjects.Find(nameOfTO);
// Export TO
technologicalObject.Export(path, options);
}
Pour exporter un objet technologique OutputCam dans un fichier XML, modifiez le code du
programme suivant :
// Export OutputCam
private static void ExportTechnologicalObject(FileInfo path, ExportOptions options,
PlcSoftware plcSoftware, String nameOfTO)
{
//Get access to TO_OutputCam container
TechnologicalInstanceDBComposition outputcamCamtrackContainer = container.OutputCams;
//Find technology object TO_OutputCam
TechnologicalInstanceDB outputCam = outputcamCamtrackContainer.Find("OutputCamName");
// Export
outputCam.Export(path, options);
}
8.5.3.4 Importer des objets technologiques
Conditions


Utilisation
L'API Openness de TIA Portal prend en charge l'importation d'objets technologiques à partir
d'un fichier XML.
Exceptions
Si les données d'importation contiennent des paramètres qui ne sont pas définis pour le type
d'objet technologique concerné, une EngineeringTargetInvocationException sera signalée.
Si la valeur d'un paramètre a un format incorrect et ne peut pas être convertie dans le type du
paramètre, une EngineeringTargetInvocationException est signalée. L'importation est
effectuée, mais un défaut est généré lors de la compilation.
Connexion ouverte
Les connexions ouvertes sont créées dans TIA Portal lorsqu'une balise connectée avec un
objet technologique est supprimée. Le comportement ultérieur de connexions ouvertes est
identique au comportement de connexions ouvertes créées par la suppression d'une variable
connectée. Si l'objet technologique partenaire est manquant lors de l'importation, une
connexion ouverte est créée. Ceci s'applique également aux types d'objets technologiques qui
ne peuvent pas être utilisés pour certaines connexions.
Code du programme
IList<SW.TechnologicalObjects.TechnologicalInstanceDB>
Import(FileInfo path, ImportOptions options);
Pour importer un ou plusieurs objets technologiques d'un fichier XML, modifiez le code du
programme suivant : Pour plus d'informations sur les ImportOptions , voir Importation de
données de configuration (Page 780).
// Import technology objects

private static void Import(FileInfo path, ImportOptions options, PlcSoftware plcSoftware)
{
// Create technological instance
// Import TO
technologicalObjects.Import(path, options);
}

Attributs spécifiques pour TO_PositioningAxis et TO_CommandTable
Utilisation
L'API prend en charge l'exportation et l'importation d'objets technologiques.
Les paramètres de TO_PositioningAxis et TO_CommandTable, qui sont membres du bloc de
données, sont exportés dans la section "Interface" du fichier d'exportation. Des paramètres
supplémentaires sont exportés dans la section "ParameterData" du fichier d'exportation. Le
chapitre suivant montre tous les paramètres supplémentaires.
Pour une liste contenant toutes les variables disponibles, voir la description fonctionnelle
SIMATIC STEP 7 S7-1200 Motion Control sur Internet (https://support.industry.siemens.com/
cs/ww/fr/view/109754206).
Remarque
Les informations sur le type de données ne sont exportées que pour les paramètres
appartenant à la section "Interface".
Paramètres supplémentaires TO_PositioningAxis

Les paramètres supplémentaires suivants ne sont pas directement assignés aux membres du
bloc de données et sont exportés dans la section ParameterData, en fonction de ExportOption :
Nom du paramètre Valeurs possibles

_Actor.Interface.PTO Données de générateur d'impulsions :
0: Pulse_1
1: Pulse_2
2: Pulse_3
3: Pulse_4
_Actor.Interface.EnableDriveOutput Nom de variable de l'adresse de l'appareil con‐
necté
_Actor.Interface.DriveReadyInput Nom de variable de l'adresse de l'appareil con‐
necté
_Actor.Interface.DataConnection 0 : Entraînement
1 : DB
_Actor.Interface.DataBlock Voir la vue de fonction pour les valeurs possi‐
bles
_Actor.Interface.Analog Voir la vue de fonction pour les valeurs possi‐
bles
_Actor.Interface.ProfiDriveIn Nom de variable de l'adresse de l'appareil con‐
necté
_Actor.Interface.ProfiDriveOut Nom de variable de l'adresse de l'appareil con‐
necté
_Actor.DataAdaptionOffline TRUE ou FALSE

_Sensor[1].Interface.ProfiDriveIn Nom de variable de l'adresse de l'appareil con‐

necté
_Sensor[1].Interface.ProfiDriveOut Nom de variable de l'adresse de l'appareil con‐
necté
_ Sensor[1].Interface.EncoderConnection 4 : HSC
7 : Codeur sur PROFINET/PROFIBUS
_Sensor[1].DataAdaptionOffline TRUE ou FALSE
_Sensor[1].Interface.DataConnection 0 : Codeur
1 : DB
_ Sensor[1].Interface.HSC HSC number:
0: HSC_1
1: HSC_2
2: HSC_3
3: HSC_4
_ Sensor[1].Interface.DataBlock Voir la vue de fonction pour les valeurs possi‐
bles
_ Sensor[1].PassiveHoming.DigitalInput Nom de variable de l'adresse de l'appareil con‐
necté
_ Sensor[1].ActiveHoming.DigitalInput Nom de variable de l'adresse de l'appareil con‐
necté
_PositionLimits_HW.MinSwitch Nom de variable de l'adresse de l'appareil con‐
necté
_PositionLimits_HW.MaxSwitch Nom de variable de l'adresse de l'appareil con‐
necté
Paramètres supplémentaires TO_CommandTable

Les paramètres supplémentaires suivants ne sont pas directement assignés aux membres du
bloc de données :
Nom du paramètre Valeurs possibles

_WarningsEnable TRUE ou FALSE
_UseAxisParametersFrom "Sample axis", nom de l'axe

Références externes
Références externes sur TO_PositioningAxis

L'éditeur d'objet technologique de TO_PositioningAxis affiche des informations qui ne sont pas
mémorisées dans la TO DB. Ces informations externes ne font donc pas partie de l'exportation/
importation de l'objet technologique et doivent être exportées/importées ou traitées
séparément. Pour le TO_PositioningAxis cela, ce sont les données suivantes :
● TagTable
Les variables utilisées par l'axe (assignation entre nom symbolique et adresse) sont
mémorisées dans le tag table et doivent être fournies à l'objet technologique par leur
intermédiaire. Une possibilité pour cela est l'exportation/importation séparée du TagTable.
● HW Config
Certaines informations sont mémorisées dans HW Config , par exemple, la configuration
d'appareil du mécanisme d'entraînement / du codeur, les réglages d'un générateur
d'impulsions et les réglages de compteurs rapides.
Dans HW Config , tous les paramètres ne peuvent pas être exportés/importés. Les
paramètres pertinents pour l'objet technologique de HW Config peuvent être définis via
l'API de paramètre Openness d'objet technologique : Voir Écriture de paramètres d'un objet
technologique (Page 553)
Réglages de la configuration matérielle

Lors de l'importation d'Openness, aucun réglage de la configuration matérielle n'est spécifié.
Les paramètres suivants doivent être définis directement via l'API de paramètre Openness
d'objet technologique, sauf s'ils ont déjà été réglés dans la configuration matérielle.
Pour axe PTO :

Un ensemble explicite de _Actor.Interface.PTO doit être exécuté via l'API de paramètre
Openness d'objet technologique pour connecter le TO à la PTO-Output.
Les paramètres suivants peuvent être réglés via l'API Openness :
● _Actor.Interface.PTO_OutputA
● _Actor.Interface.PTO_OutputBEnable
● _Actor.Interface.PTO_OutputB
● _Actor.Interface.PTO_SignalType
Si des entrées Homing- or Position Limit sont utilisées dans l'axe PTO, l'activation de
EdgeDetection a lieu avec le réglage des paramètres suivants via l'API de paramètre
Openness d'objet technologique :
● _Sensor[1].ActiveHoming.DigitalInput
● _Sensor[1].PassiveHoming.DigitalInput
● _PositionLimits_HW.MaxSwitch
● _PositionLimits_HW.MinSwitch

Pour Analog/ProfiDrive :
Un ensemble explicite des paramètres suivants doit être exécuté via l'API de paramètre
Openness d'objet technologique pour connecter le PIP au OB-Servo.
● _Actor.Interface.ProfiDriveOutName
● _Actor.Interface.ProfiDriveInName
● _Sensor[1].Interface.ProfiDriveOutName
● _Sensor[1].Interface.ProfiDriveInName
Si HSC est utilisé pour la connexion du codeur :

Un ensemble explicite de _Sensor[1].Interface.HSC doit être exécuté via l'API de paramètre
Openness d'objet technologique pour connecter TO au HSC et activer le HSC dans la
configuration matérielle.
Les paramètres suivants peuvent être réglés via l'API Openness :
● _ Sensor[1].Interface.HSC_OperatingMode
● _ Sensor[1].Interface.HSC_InputA
● _ Sensor[1].Interface.HSC_InputB
Attributs spécifiques pour les objets technologiques d'axe et de codeur
Utilisation
L'API prend en charge l'importation et l'exportation d'objets technologiques. La section
suivante décrit les attributs spécifiques.
Exporter TO_SpeedAxis, TO_PositioningAxis, TO_SynchronousAxis et TO_ExternalEncoder

Pour les types d'objet technologique TO_SpeedAxis, TO_PositioningAxis,
TO_SynchronousAxis et TO_ExternalEncoder , l'attribut EOM ParameterData contient les
paramètres tels que décrits dans les tableaux suivants. Les paramètres correspondant aux
membres du bloc de données de l'objet technologique ont le type de données et la valeur par
défaut tels que définis dans le bloc de données de l'objet technologique.
Nom TO_SpeedAxis TO_PositioningAxis / TO_Syn‐ TO_ExternalEncoder

chronousAxis
VirtualAxis.Mode X X -
Actor.Type X X -
Actor.Interface.EnableDri‐ X X -
veOutput
Actor.Interface.DriveRea‐ X X -
dyInput

Actor.Interface.EnableTor‐ X X -
queData
Sensor[n].Existent1) - X -
Sensor[n].Interface.Number 1)
- X -
Sensor[n].Type1) - X -
Sensor.Interface.Number - - X
Sensor.Type - - X
CrossPlcSynchronousOpera‐ - X X
tion.Interface[1].EnableLea‐
dingValueOutput
Paramètres correspondant aux membres du bloc de données de l'objet technologique pour TO_SpeedAxis,
TO_PositioningAxis, TO_SynchronousAxis et TO_ExternalEncoder
1) S7-1500 CPU : n=1 ; S7-1500T CPU : 1≤n≤4
Les paramètres énumérés dans le tableau suivant correspondent à des

"TechnologicalParameters supplémentaires". Ces paramètres ont le même type de données
dans SimaticML que les TechnologicalParameters correspondants dans l'API Openness.
Nom Valeur par défaut TO_SpeedAxis TO_Positionin‐ TO_ExternalEncoder

gAxis / TO_Syn‐
chronousAxis
_Properties.MotionType 0 - X X
_Properties.UseHighResolu‐ false - X X
tionPositionValues
_CrossPlcSynchronousOpera‐ true - X X
tion.ActivateLocalLeadingVa‐
lueDelayTimeCalculation
_Units.LengthUnit 1013 (mm) - X X
_Units.VelocityUnit 1062 (mm/s) 1083 (1/mm) X X
_Units.TorqueUnit 1126 (Nm) X X -
_Units.ForceUnit 1120 (N) - X -
_Actor.Interface.Telegram 0 X X -
_Sensor[n].Interface.Telegram1) 0 - X -
_Sensor.Interface.Telegram 0 - - X
_Actor.DataAdaptionOffline false X X -

_Sensor[n].DataAdaptionOffli‐ false - X -
ne1)
_Sensor.DataAdaptionOffline false - - X
Paramètres correspondants à des TechnologicalParameters supplémentaires pour TO_SpeedAxis, TO_PositioningAxis,

TO_SynchronousAxis et TO_ExternalEncoder
1) S7-1500 CPU : n=1 ; S7-1500T CPU : 1≤n≤4
En revanche, des TechnologicalParameters supplémentaires qui renvoient aux variables dans
l'API Openness sont traitées différemment dans SimaticML. Les paramètres concernés sont
indiqués dans le tableau suivant. Dans l'API Openness, ils ont le type de données
SW.Tags.PlcTag, mais dans SimaticML, le nom de la variable connectée est exporté.
Nom TO_SpeedAxis TO_PositioningAxis / TO_ExternalEn‐

TO_SynchronousAxis coder
_Actor.Interface.EnableDriveOutputAddress X X -
_Actor.Interface.DriveReadyInputAddress X X -
_Sensor[n].ActiveHoming.DigitalInputAd‐ - X -
dress1)
_Sensor[n].PassiveHoming.DigitalInputAd‐ - X -
dress1)
_PositionLimits_HW.MinSwitchAddress - X -
_PositionLimits_HW.MaxSwitchAddress - X -
_CrossPlcOperation.Interface[1].AddressOut - X X
_Sensor.PassiveHoming.DigitalInputAd‐ - - X
dress
Paramètres correspondants à des paramètres technologiques supplémentaires renvoyant à des variables pour
TO_SpeedAxis, TO_PositioningAxis, TO_SynchronousAxis et TO_ExternalEncoder .
1) S7-1500 CPU : n=1 ; S7-1500T CPU : 1≤n≤4
Connection d'élément XML

La connexion d'élément XML décrit une connexion d'une interface d'objet technologique. Les
noms et les valeurs des attributs énumérés ci-dessous correspondent aux noms de paramètre
et aux valeurs de la AxisEncoderHardwareConnectionInterface.

● Attribut requis "Interface"

– Valeurs possibles :
Valeur TO_SpeedAxis TO_PositioningAxis / TO_Syn‐ TO_ExternalEncoder

chronousAxis
Actor X X -
Sensor - - X
Sensor[n]1) - X -
Torque X X -
1) S7-1500 CPU : n=1 ; S7-1500T CPU : 1≤n≤4
● Attributs optionnels InputAddress et OutputAddress
– Les attributs doivent être présents ensemble ou alors ils ne peuvent pas être utilisés du
tout.
– Les valeurs possibles sont des adresses de bit (comme dans l'API).
– L'attribut décrit des connexions à DeviceItems et Channels.
● Attribut optionnel ConnectOption
– Ne peut être utilisé qu'avec InputAddress et OutputAddress.
– L'attribut correspond au paramètre de méthode du même nom sous
AxisEncoderHardwareConnectionInterface.Connect .
– L'attribut a, comme valeurs possibles, Default et AllowAllModules.
● Attribut optionnel SensorIndexInActorTelegram
– L'attribut est utilisé pour des connexions à la partie capteur dans le télégramme d'acteur.
– Les règles sont les mêmes que celles définies pour l'attribut API correspondant.
● Attribut optionnel PathToDBMember
– L'attribut a les mêmes valeurs possibles que les paramètres de la méthode
correspondante.
– Décrit une connexion à un membre du bloc de données.
● Attribut optionnel OutputTag
– La valeur est le nom du PlcTag connecté.
– L'attribut décrit une connexion à une variable analogique.
Connecter TO_SynchronousAxis à des valeurs pilotes

Ils connectent TO_SynchronousAxis via le service SynchronousAxisMasterValues à des
valeurs pilotes, voir Connecter un axe synchrone à des valeurs pilote (Page 580).

Attributs spécifiques pour les objets technologiques came, piste de came et palpeur de mesure
Conditions
Utilisation
Exporter TO_OutputCam, TO_CamTrack et TO_MeasuringInput

Pour les types d'objet technologique TO_OutputCam, TO_CamTrack et TO_MeasuringInput,
l'attribut EOM ParameterData contient les paramètres tels que décrits dans les tableaux
suivants. Les paramètres correspondant aux membres du bloc de données de l'objet
technologique ont le type de données et la valeur par défaut tels que définis dans le bloc de
données de l'objet technologique.
L'attribut ParameterData contient les paramètres suivants pour TO_OutputCam et
TO_MeasuringInput :
Nom TO_OutputCam TO_MeasuringInput

Interface.LogicOperation X -
Parameter.MeasuringInputType - X
Paramètres correspondant aux membres du bloc de données de l'objet technologique pour TO_OutputCam et
TO_MeasuringInput
TO_CamTrack n'a pas d'élément dans l'attribut ParameterData. Le paramètre
"_AssociatedObject" n'est pas utilisé lors de l'exportation.
"Connection" d'élément XML
Valeur Description TO_OutputCam TO_CamTrack TO_MeasuringInput

Interface Seule valeur possible : OutputCam X - X
OutputAddress ● La valeur est une adresse de bit. X X -
● Elle décrit une connexion à un
channel.

OutputTag ● La valeur est le nom du PlcTag con‐ X X -

necté.
● Elle décrit une connexion à une va‐
riable analogique.
InputAddress ● La valeur est une adresse de bit. - - X
● Elle décrit une connexion à un De‐
viceItem ou à un channel.
Attributs spécifiques pour les objets technologiques de profils de came
Utilisation
Exporter TO_Cam
Pour le type d'objet technologique TO_Cam, l'attribut EOM ParameterData contient les
paramètres tels que décrits dans les tableaux suivants. Les paramètres correspondant aux
paramètres TO DB ont le type de données et la valeur par défaut tels que définis dans la TO
DB.
Éléments XML
Élément XML Description

ParameterData L'attribut ParameterData contient les paramètres tels que décrits
ci-dessous.
ProfileData L'élément XML ProfileData est élément de niveau inférieur unique
de paramètres au sein de l'attribut deEOM ParameterData.
Élément d'extension de niveau supérieur contenant l'élément
XML GeneralConfiguration, suivi de l'élément XML Elements.
GeneralConfiguration L'élément GeneralConfiguration décrit la configuration générale
valide pour le profil de profil de came complet.
De plus, les attributs optionnels suivants sont utilisés :
● Attribut StandardContinuity
Les valeurs possibles sont Position, Velocity,Acceleration (va‐
leur par défaut) et Jerk.
● Attribut StandardOptimizationGoal
Les valeurs possibles sont Aucun (valeur par défaut), Velocity,
Acceleration, Jerk et DynamicMoment.
● Attribut InterpolationMode
Les valeurs possibles sont Linear, CubicSpline (valeur par dé‐
faut) et BezierSpline.
● Attribut BoundaryConditions
Les valeurs possibles sont NoConstraint (valeur par défaut) et
FirstDerivative.


DesignLeadingRange Décrit la plage de valeurs pilotes de la définition de la courbe.
Les deux attributs optionnels suivants avec le type de données
xsd:float sont utilisés :
● Attribut Start
La valeur par défaut est 0.
● Attribut End
La valeur de Start doit être inférieure à la valeur de End.
DesignFollowingRange L'élément décrit la plage de valeurs suivante de la définition de la
courbe.
● Attribut Start
La valeur par défaut est -1.
● Attribut End
Elements L'élément contient la liste des éléments du profil de profil de la
came. Un tel élément est décrit par un élément XML et peut être
un type de point ou de segment.
Les types de segment possibles sont :
● Line
● Polynomial
● VDITransition
● Sine
● InverseSine
● PointGroup
Tous les types de segment partagent les deux attributs XML gé‐
néralement requis StartX et EndX du type xsd:float. Ces attributs
contiennent la coordonnée X au début ou à la fin du segment.
Point L'élément décrit un seul point. Les attributs suivants sont utilisés,
ils ont tous le type de données xsd:float et la valeur par défaut 0 :
● Attribut requis X
● Attribut requis Y
● Attribut optionnel Velocity
● Attribut optionnel Acceleration
● Attribut optionnel Jerk
Line Décrit un segment de Line. Les attributs suivants sont utilisés, ils
ont tous le type de données xsd:float et la valeur par défaut 0 :
● Attribut optionnel StartY
Contient la coordonnée Y au début de la ligne.
● Attribut optionnel EndY
Contient la coordonnée Y à la fin de la ligne.
● Attribut optionnel Gradient
Contient le gradient de la ligne.
Deux de ces trois attributs optionnels doivent être présents dans
le fichier XML d'exportation.


Polynomial L'élément décrit un segment polynomial. L'élément XML Polyno‐
mial a les sous-éléments TrigonometricValues, Coefficients et
Constraints.TrigonometricValues peut être utilisé facultativement,
mais Coefficients ou Constraints doit être présent.
TrigonometricValues L'élément TrigonometricValues peut éventuellement être utilisé
en tant que sous-élément de polynôme.
Il possède les attributs suivants avec le type de données xsd:float:
● Attribut optionnel Amplitude
● Attribut optionnel StartPhase
● Attribut optionnel EndPhase
La valeur par défaut est 6,2831853071795862.
● Attribut optionnel Frequency
● Attribut optionnel PeriodLength
Deux des attributs StartPhase, EndPhase, Frequency et Perio‐
dLength doivent être utilisés. En outre, au moins StartPhase ou
EndPhase doivent être présents.
Coefficients L'élément Coefficients peut éventuellement être utilisé en tant que
sous-élément de Polynomial. Il a les attributs optionnels C0, C1,
C2, C3, C4, C5 and C6. Chacun d'eux a le type de données
xsd:float et la valeur par défaut 0.
Constraints L'élément peut éventuellement être utilisé en tant que sous-élé‐
ment de Polynomial.
Il a les attributs suivants avec le type de données xsd:float et la
valeur par défaut 0 :
Attribut optionnel LeftValue
Attribut optionnel RightValue
Attribut optionnel LeftVelocity
Attribut optionnel RightVelocity
Attribut optionnel LeftAcceleration
Attribut optionnel RightAcceleration
Attribut optionnel LeftJerk
Attribut optionnel RightJerk
Attribut optionnel Lambda
En outre, il possède l'attribut optionnel LambdaMode qui prend en
charge les valeurs Relative etAbsolute (valeur par défaut).
VDITransition L'élément décrit un segment de transition VDI.
Il a les attributs optionnels LeftContinuity et RightContinuity qui
peuvent avoir peut avoir les valeurs AsProfile (valeur par défaut),
Position, Velocity, Acceleration et Jerk.
De plus, l'attribut optionnel OptimizationGoal peut être utilisé avec
les valeurs possibles AsProfile (valeur par défaut), None, Velocity,
Acceleration, Jerk et DynamicMoment.


InverseSine L'élément décrit un segment de InverseSine Il a les attributs fa‐
cultatifs suivants :
● InterpolationPointCount
● MaxFollowingValueTolerance
● MathStartX
● MathEndX
● Minimum
● Maximum
● Inversed
Sine Décrit un segment de Sine. Chaque segment de Sine a les attri‐
buts suivants :
● Amplitude
● StartPhase
● EndPhase
● Frequency
● PeriodLength
● Inclination
● StartOffset
● EndOffset
PointGroup L'élément décrit un segment PointGroup contenant plusieurs
points. L'élément PointGroup a les attributs optionnels suivants :
● ApproximationDataPoints
● ApproximationTolerance
● LeadingValueMode
● FollowingValueMode
● ApproximationMode
Attributs spécifiques pour objets technologiques de cinématique
Utilisation
Exporter TO_Kinematics
Pour le type d'objet technologique TO_Kinematics, l'attribut EOM ParameterData contient les
paramètres suivants.
Les paramètres suivants correspondant aux paramètres TO DB ont défini le type de données
et la valeur par défaut tels que définis dans le TO DB: :
● Kinematics.TypeOfKinematics
● MotionQueue.MaxNumberOfCommands

Les paramètres suivants ont le même type de données dans SimaticML que les
TechnologicalParameterscorrespondants dans l'API Openness :
● _X_Minimum
● _X_Maximum
● _Y_Minimum
● _Y_Maximum
● _Z_Minimum
● _Z_Maximum
● _A3_Maximum
Éléments XML

AdditionalData L'élément contient jusqu'à quatre éléments KinematicsAxis, suivis
d'un élément ConveyorTrackingLeadingValues.
KinematicsAxis L'élément décrit un axe de cinématique connecté. Chaque élé‐
ment XML a les attributs suivants :
● Attribut requis Index
Les valeurs possibles sont comprises entre 1 et 4
Les valeurs d'indice indiquent l'indice de l'axe connecté à
TO_Kinematics, raison pour laquelle elles doivent être uni‐
ques.
● Attribut requis Ref
Indique le nom de l'objet technologique connecté.
● Attribut requis Type
Contient le type d'objet technologique associé (indépendant
de la version).
ConveyorTrackingLeadingValues L'élément contient les éléments pour SetPointCoupling, suivis par
des éléments pour ActualValueCoupling, DelayedCoupling.
SetPointCoupling L'élément décrit un objet technologique de valeur pilote connecté
qui est couplé par des valeurs de consigne. Il possède les attributs
suivants :
● Attribut requis Ref
Indique le nom de l'objet technologique connecté.
● Attribut requis Type
Contient le type d'objet technologique associé (indépendant
de la version).
ActualValueCoupling L'élément décrit un objet technologique de valeur pilote connecté
qui est couplé par des valeurs réelles. Il utilise les mêmes attributs
que les éléments SetPointCoupling.
DelayedCoupling L'élément décrit un objet technologique de valeur pilote connecté
qui est couplé par des valeurs réelles. Il utilise les mêmes attributs
que les éléments SetPointCoupling.

Attributs spécifiques pour les objets technologiques représentant un axe pilote
Utilisation
Exporter TO_LeadingAxisProxy
Pour le type d'objet technologique TO_LeadingAxisProxy, l'attribut EOM ParameterData
contient des paramètres supplémentaires _Interface.AddressIn. Le TechnologicalParameter
supplémentaire renvoie à une variable. Ici, les mêmes règles que celles décrites sousAttributs
spécifiques pour les objets technologiques d'axe et de codeur (Page 925) s'appliquent.
8.5.3.7 Régulation PID
Attributs spécifiques pour PID_Compact

L'interface API prend en charge l'exportation et l'importation d'objets technologiques. Vous
trouverez une liste de tous les paramètres disponibles dans l'information produit "Paramètres
d'objets technologiques dans TIA Portal Openness" sur Internet (https://
Exporter
Pour le type d'objet technologique PID_Compact, tous les paramètres correspondent aux
membres du bloc de données de l'objet technologique et ont le type de données et la valeur par
défaut tels que définis dans le bloc de données de l'objet technologique. L'attribut
EOM ParameterData est vide.
Importation
Les paramètres suivants pour PID_Compact ne font pas partie de l'importation :
● PhysicalUnit
● PhysicalQuantity
● _Config.OutputSelect
● _Retain.CtrlParams.SetByUser
Ces paramètres ont la valeur par défaut après l'importation.
Remarque
Restaurez manuellement les réglages associés après l'importation d'un fichier d'exportation
PID_Compact. Cela peut être fait à l'aide de la fonction Écrire le paramètre (Page 553).

Attributs spécifiques pour PID_3Step et PID_Temp

Exporter
Pour les types d'objet technologique PID_3Step et PID_Temp, tous les paramètres
correspondent aux membres du bloc de données de l'objet technologique et ont le type de
données et la valeur par défaut tels que définis dans le bloc de données de l'objet
technologique. L'attribut EOM ParameterData est vide.
Importation
Les paramètres suivants pour PID_3Step et PID_Temp ne font pas partie de l'importation :
● PhysicalUnit
● PhysicalQuantity
Ces paramètres ont la valeur par défaut après l'importation. Si vous souhaitez le modifier, vous
devez utiliser la fonction Écrire le paramètre (Page 553).
Remarque
Restaurez manuellement les réglages associés après une importation d'un fichier
d'exportation PID_3Step ou PID_Temp.
8.5.3.8 Comptage

Pour les types d'objet technologique High_Speed_Counter et SSI_Absolute_Encoder, tous les
paramètres correspondent aux membres du bloc de données de l'objet technologique et ont le
type de données et la valeur par défaut tels que définis dans le bloc de données de l'objet
technologique. L'attribut EOM ParameterData est vide.
8.5.3.9 Easy Motion Control

Pour le type d'objet technologique AXIS_REF, tous les paramètres correspondent aux
membres du bloc de données de l'objet technologique et ont le type de données et la valeur par

défaut tels que définis dans le bloc de données de l'objet technologique. L'attribut EOM
ParameterData est vide.
8.5.4 Exporter un type de données utilisateur
Conditions requises
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT
Code de programme
Pour exporter un type de données utilisateur vers un fichier XML, modifiez le code de
programme suivant :
//Exports a user defined type

private static void ExportUserDefinedType(PlcSoftware plcSoftware)
{
string udtname = "udt name XYZ";
PlcType udt = types.Find(udtname);
udt.Export(new FileInfo(string.Format(@"C:\OpennessSamples\udts\{0}.xml", udt.Name)),
}
8.5.5 Importer un type de données utilisateur
Conditions requises
AUTOHOTSPOT
AUTOHOTSPOT
Utilisation
L'interface API prend en charge l'importation de types de données utilisateur à partir d'un fichier
XML.

Syntaxe du fichier d'importation

L'exemple de code suivant présente un extrait d'un fichier d'importation d'un type de données
utilisateur :
<Section Name="Input">
<Member Name="Input1" Datatype=quot;myudt1">
<Sections>
<Section Name="None">
<Member Name="MyUDT1Member1" Datatype="bool"/>
<Member Name="MyUDT1Member2" Datatype="myudt1">
<Sections...
Remarque
Syntaxe pour les types de données personnalisés d'éléments
Si le type de données personnalisé d'un élément présente une mauvaise syntaxe dans le
fichier d'importation pour types de données utilisateur, une exception est déclenchée.
Assurez-vous que " est utilisé pour noter les types de données personnalisés.
Code du programme
Pour importer un type de données utilisateur, modifiez le code de programme suivant :
//Imports user data type

private static void ImportUserDataType(PlcSoftware plcSoftware)
{
FileInfo fullFilePath = new FileInfo(@"C:\OpennessSamples\Import\ExportedPlcType.xml");
IList<PlcType> importedTypes = types.Import(fullFilePath, ImportOptions.Override);
}
8.5.6 Exportation de données au format OPC UA XML
Conditions
Voir AUTOHOTSPOT
Voir AUTOHOTSPOT

8.6 Importation/exportation de données matérielles
Utilisation
TIA Portal Openness vous permet d'exporter des données API dans un fichier au format OPC
UA XML. En paramètre d'entrée de l'action, vous avez besoin d'un chemin de répertoire absolu
dans lequel sera enregistré le fichier XML.
Code de programme
Modifiez le code de programme suivant pour exporter des données API dans un fichier au
format OPC UA XML.
//Export PLC data as OPC UA XML file

private static void OpcUaExport(Project project, DeviceItem plc)
{
OpcUaExportProvider opcUaExportProvider = project.HwUtilities.Find("OPCUAExportProvider")
as OpcUaExportProvider;
if (opcUaExportProvider == null) return;
opcUaExportProvider.Export(plc, new FileInfo(string.Format(@"D:\OPC UA export files
\{0}.xml", plc.Name)));
}
8.6.1 Format de fichier AML
Introduction
AutomationML est un format de données neutre basé sur XML pour l'enregistrement et
l'échange d'informations d'ingénierie d'une installation et qui est proposé sous forme de
standard ouvert. L'objectif d'AutomationML est la connexion du paysage hétérogène des outils
d'ingénierie modernes dans leurs différentes disciplines telles que la conception mécanique
d'installations, la conception électrique, IHM, API, la commande de robots.
Le modèle de classification utilisé pour l'exportation et l'importation de données CAx est basé
sur les normes AML suivantes :
● Whitepaper AutomationML partie 1 – AutomationML Architecture, octobre 2014
● Whitepaper AutomationML partie 2 – AutomationML Architecture, octobre 2014
● Whitepaper AutomationML partie 4 – AutomationML Logic, mai 2010
● Whitepaper AutomationML – AutomationML Communication, septembre 2014
● Whitepaper AutomationML – AutomationML and eCl@ss Integration, novembre 2015
● Recommandations d'utilisation : Automation Project Configuration - AR_001E Version
1.0.0, Mai 2017

Schéma
Le modèle d'échange de données AutomationML est décrit par le schéma CAEX, version 2.15.
Vous pouvez télécharger ce fichier sur la page d'accueil AutomationML e.V. (https://
www.automationml.org/o.red.c/dateien.html)
8.6.2 Pruned AML
Introduction
Pruning (élagage) décrit le processus d'optimisation du contenu par la suppression de certains
éléments qui ne doivent pas nécessairement être indiqués. Avec des outils externes comme
EPLAN, les informations de sous-modules créées automatiquement n'ont aucune signification
quant à EPLAN dans une configuration matérielle. C'est pourquoi ces outils génèrent un fichier
AML en supprimant de la configuration matérielle les informations de sous-modules créées
automatiquement. Ce fichier est appelé Pruned AML.
Génération du fichier Pruned AML

La génération de Pruned AML est basée sur les règles suivantes dans cet ordre.
1. Si un élément d'appareil est enfichable, aucun Pruning n'est effectué.
2. Si un élément d'appareil est de type "Interface" ou "Port", aucun Pruning n'est effectué.
3. Si un élément d'appareil est intégré et se trouve sur le châssis, aucun Pruning n'est effectué.
4. Les objets d'adresse de type "Diagnostic" ne sont pas pertinents pour l'algorithme de
Pruning.
5. Les objets d'adresse reliés aux sous-modules créés automatiquement sont indiqués sous
l'élément directement supérieur (qui ne doit pas être un sous-module créé
automatiquement).
6. Les objets d'adresse sont inclus dans la même séquence que celle affichée par TIA Portal
Openness.

8.6.3 Vue d'ensemble des objets et paramètres de l'importation/exportation CAx
Objets et attributs de l'exportation/importation

La figure suivante représente les objets exportables avec leurs attributs et dépendances dans
l'importation/exportation CAx.

$XWRPDWLRQ3URMHFW
3URMHFW1DPH
3URMHFW0DQXIDFWXUHU
3URMHFW6LJQ
3URMHFW5HYLVLRQ
3URMHFW,QIRUPDWLRQ
6XEQHW 'HYLFH 'HYLFH8VHU)ROGHU
1DPH 1DPH 1DPH

7\SH 7\SH,GHQWLILHU
&RPPHQW
'HYLFH,WHP
1DPH
7\SH1DPH 7DJ7DEOH 7DJ8VHU)ROGHU
'HYLFH,WHP7\SH
3RVLWLRQ1XPEHU 1DPH 1DPH
%XLOW,Q $VVLJQ7R'HIDXOW
7\SH,GHQWLILHU
)LUPZDUH9HUVLRQ
3ODQW'HVLJQDWLRQ,(&
/RFDWLRQ,GHQWLILHU,(&
&RPPHQW
$GGUHVV>Q@6WDUW$GGUHVV/HQJWK,27\SH
&KDQQHO 7DJ
7\SH 1DPH
,R7\SH 'DWD7\SH
1XPEHU /RJLFDO$GGUHVV
/HQJWK &RPPHQW
&RPPXQLFDWLRQ,QWHUIDFH
/DEHO
1RGH ,R6\VWHP &RPPXQLFDWLRQ3RUW
7\SH 1XPEHU /DEHO

1HWZRUN$GGUHVV 1DPH

8.6.4 Structure des données CAx pour l'importation/exportation

moyen d'une structure de base. Le fichier d'exportation est créé au format AML.
Le fichier AML commence par une information sur le document. Ce fichier comporte les
données de l'installation spécifique à l'ordinateur du projet exporté.
À partir de TIA Portal Openness V16, vous aurez la possibilité d'exporter et d'importer des
fichiers AML avec une nouvelle version de "AR APC V1.0.0".
TIA Portal V16 peut importer des fichiers AML avec "AR APC V1.0.0" et "AR APC V1.1.0".
Exporter et importer des fichiers AML créés avec des versions antérieures (comme V14 SP1,
V15, V15.1) de TIA Portal devrait rester possible avec "AR APC V1.0.0".

Le fichier d'exportation comprend les deux zones suivantes :

● Pour plus d'informations...
<WriterHeader> contient des informations sur le processus d'exportation ou
d'importation. L'importation ignore le contenu de la zone <AdditionalInformation>.
Vous pouvez par ex. insérer un bloc avec <AdditionalInformation>...</
AdditionalInformation> et y placer des informations supplémentaires à la validation.
Après la transmission du fichier AML, le destinataire peut vérifier avant l'importation avec ce
bloc si le fichier AML a été modifié.
Remarque
CAx exporte et importe la version de AR APC dans un fichier AML conformément à la
version de TIA Portal qui est installée.
● Hiérarchie d'instance
Cette zone contient l'ordre hiérarchique des éléments internes exportés.

Éléments internes
Tous les objets dans la hiérarchie d'instance du fichier AML sont InternalElements.
L'élément interne AutomationProject contient tous les éléments internes de toutes les
classifications de rôles. Chaque élément interne prend en charge un ensemble d'attributs.
L'attribut <TypeIdentifier> identifie chaque type d'objet d'un objet matériel pouvant être
créé via TIA Portal Openness.
Remarque
Objets automatiquement créés
Les objets automatiquement créés peuvent uniquement être créés par d'autres objets. Ils n'ont
aucun attribut ni aucun identifiant de type. Ils sont inclus dans le fichier exporté mais vous ne
pouvez pas lancer l'exportation d'un objet spécifique automatiquement créé.

À la fin de l'élément AML d'un élément interne, ce qui suit est défini :
● Classification des rôles
L'élément SupportedRoleClass définit le type d'objet d'un élément interne. Le type
d'objet est défini dans la bibliothèque de classification des rôles qui représente la norme
AML pour le modèle d'objet TIA Portal Openness et TIA Portal.
● Liens internes
L'élément InternalLink définit les partenaires de communication d'une connexion.

Attributs
Les attributs sont affectés à des éléments internes comme suit :
Manipulation des attributs

La manipulation d'attributs est définie comme suit pour chaque attribut :
● Ignoré
L'attribut est ignoré lors de l'importation et n'est pas présent dans le fichier d'exportation.
● Obligatoire
L'attribut doit être présent dans un fichier d'importation et ne peut pas être supprimé du
fichier d'exportation.
● Optionnel
Si cet attribut est absent du fichier d'exportation, sa valeur par défaut est définie. Cet attribut
est absent dans le fichier d'exportation s'il n'est pas utilisable pour un objet, par ex. si les
modules n'ont pas tous une version de firmware.

● Exporter seulement
L'attribut, tel que le nom de type de l'élément de l'appareil, est défini en interne par TIA
Portal. Si celui-ci est présent dans un fichier d'importation, il est ignoré par TIA Portal lors
de l'importation.
● Importer seulement
L'attribut peut influer sur le comportement de l'importation. Si cet attribut est absent du
fichier d'importation, le comportement correspondra à la valeur par défaut de l'attribut.
Voir aussi
Identifiants de type AML (Page 948)
8.6.5 Identifiants de type AML
Éléments internes
La chaîne TypeIdentifier est constituée des parties suivantes :
● <TypeIdentifierType>:<Identifier>
Les valeurs suivantes de TypeIdentifierType sont admissibles ici :
● OrderNumber sert à indiquer des modules physiques
● GSD sert à indiquer des appareils basés sur GSD/GSDML
● System sert à indiquer des systèmes et des appareils génériques
Identifiant de type : OrderNumber

OrderNumber est l'identifiant de type général pour tous les modules dans le catalogue de
matériel, à l'exception de GSD. Les identifiants de type AML ne correspondent pas toujours aux
identifiants de type TIA Portal Openness. Les identifiants de type AML n'ont pas d'information
sur FirmwareVersion. Les informations sur la version de firmware se trouvent dans l'attribut
AML séparé "FirmwareVersion".

Le format pour cet identifiant de type est l'un des suivants :

● <OrderNumber>
Exemple : Numéro de référence : 3RK1 200-0CE00-0AA2
Remarque
Caractères génériques dans les numéros de référence
Il existe quelques rares modules dans le catalogue du matériel, qui utilisent des caractères
"génériques" représentant un certain groupe de matériel réel dans leurs numéros de
référence, par exemple les différentes longueurs des châssis de S7-300.
Dans ce cas, l'on peut utiliser à la fois les OrderNumber spécifiques et les "caractères
génériques" OrderNumber pour créer une instance de l'objet matériel. Vous ne pouvez
toutefois pas utiliser les caractères génériques à n'importe quel emplacement. Exemple :
Un châssis de S7-300 peut être créé comme suit :
Numéro de référence : 6ES7 390-1***0-0AA0
ou
Numéro de référence : 6ES7 390-1AE80-0AA0
Veuillez noter que la structure suivante ne peut pas être utilisée par exemple :
Numéro de référence : 6ES7 390-1AE80-0A*0
La valeur retournée de l'identification de type lue est toujours le numéro de référence du
catalogue du matériel.
Exemple : Numéro de référence : 6ES7 390-1AE80-0AA0 correspond à Numéro
de référence : 6ES7 390-1***0-0AA0
Identifiant de type : GSD

L'identifiant de type pour les appareils basés sur GSD et GSDML est TypeIdentifier =
GSD:<Identifier>
L'identifiant se compose des éléments suivants
● GsdName : nom du GSD ou GSDML en lettres majuscules
● GsdType : est l'un des suivants :
– D : appareil (Device)
– R : châssis (Rack)
– DAP : module de tête
– M : module
– SM : sous-module
● GsdId : ID du GSD ou GSDML

Les formats suivants pour les identifiants de type sont pris en charge pour l'importation/
exportation CAx :
● GSD.<GsdName>/<GsdType>
Exemples :
GSD:SIEM8139.GSD/DAP
GSD:GSDML-V2.31-SIEMENS-SINAMICS_DCP-20140313.XML/D
● <GsdName>/<GsdType>/<GsdId>
Exemple :
GSD:SIEM8139.GSD/M/4
GSD:GSDML-V2.31-SIEMENS-SINAMICS_G110M-20140704.XML/M/IDM_DRIVE_47
Identifiant de type : Système

System. est l'identification des objets qui ne peuvent pas être définis par d'autres
identifications. Les formats de ces TypeIdentifierType sont les suivants :
● <SystemTypeIdentifier>
Exemples :
System:Device.S7300
System:Subnet.Ethernet
● <SystemTypeIdentifier>/<AdditionalTypeIdentifier>
La AdditionalTypeIdentifier est requise si SystemTypeIdentifier n'est pas
univoque.
La SystemTypeIdentifier a un préfixe pour certains types d'objet :
Subnet.
Device.
Rack.
Exemple : System:Rack.S71600/Large
Un châssis avec numéro de référence est identifié via la OrderNumber.

Afficher les identifiants de type dans TIA Portal

Lorsque vous devez connaître un identifiant de type, vous le déterminez comme suit dans TIA
Portal :
1. Activez le paramètre "Affichage de l'identifiant de type pour les appareils et les modules"
sous "Options > Paramètres > Configuration matérielle > Affichage de l'identifiant de type".
2. Ouvrez l'éditeur "Appareils & Réseaux".
3. Sélectionnez un appareil dans le catalogue.
L'identifiant de type s'affiche sous "Information".
8.6.6 Exportation/importation d'informations sur la BaseUnit via AML
Conditions
Application
Vous pouvez dans TIA Portal exporter et importer des informations sur la BaseUnit de TIA
Portal pour faciliter l'échange d'informations avec d'autres outils tels que EPLAN.
Pour l'exportation d'un projet de et l'importation de celui-ci dans TIA Portal, deux types de
BaseUnit sont pris en charge :
● BaseUnit en simple
● BaseUnit en double

Exportation d'une BaseUnit

Exemple : CAx exporte, pour un module configuré avec des informations sur la BaseUnit dans
TIA Portal, les informations relatives à la BaseUnit comme "sous-module" sous un module
intégré dans un fichier AML.
Le sous-module de la BaseUnit est toujours exporté avec les attributs suivants :
● PositionNumber : 0
● DeviceItemType : Accessoires
● BuiltIn : False
● TypeIdentifier : "ID de type de BaseUnit"
● ID : GUID généré de manière aléatoire.
Exportation d'une BaseUnit simple

L'exemple suivant montre un fichier AML correspondant à un module d'entrées TOR configuré
avec une BaseUnit simple dans TIA Portal :
<InternalElement ID="6f76c890-5c5d-41c4-9ade-96543b0222ac" Name="DI 8x24VDC ST_1">

...
<InternalElement ID="69233c1f-7ef7-4999-8e84-691d0ff3a210" Name="BaseUnit">
<Attribute Name="DeviceItemType" AttributeDataType="xs:string">
<Value>Accessory</Value>
</Attribute>
<Attribute Name="PositionNumber" AttributeDataType="xs:int">
<Value>0</Value>
</Attribute>
<Attribute Name="BuiltIn" AttributeDataType="xs:boolean">
<Value>false</Value>
</Attribute>
<Attribute Name="TypeIdentifier" AttributeDataType="xs:string">
<Value>OrderNumber:6ES7 193-6BP00-0DA0</Value>
</Attribute>
<SupportedRoleClass RefRoleClassPath="AutomationProjectConfigurationRoleClassLib/
DeviceItem" />
</InternalElement>
...
Exportation d'une BaseUnit double

L'exemple suivant montre un fichier AML correspondant à deux modules d'entrées TOR
configurés avec une BaseUnit dans TIA Portal. Exemple : Le premier module de la BaseUnit
est configuré avec le préfixe IX300 et le deuxième correspondant à la même BaseUnit en
double est configuré avec le préfixe IX301.
Lors de l'exportation, seul le premier module de la BaseUnit possédant le préfixe IX300 est
exporté avec le sous-module correspondant à la BaseUnit dans le fichier AML. Le deuxième

module, c'est-à-dire le module possédant le préfixe IX301, n'est inséré dans aucun sous-
module inférieur.
<InternalElement ID="6f76c890-5c5d-41c4-9ade-96543b0222ac" Name="DI 8x24VDC ST_1">

...
<InternalElement ID="3a1bee8a-12d0-4ec4-849c-333d45113d9c" Name="BaseUnit">
<Value>Accessory</Value>
</Attribute>
<Value>0</Value>
</Attribute>
</Attribute>
<Value>OrderNumber:6ES7 193-6BP60-0DA0</Value>
</Attribute>
DeviceItem" />
</InternalElement>
...
<InternalElement ID="5f843491-b053-4dc8-b879-9ac327ee2a7e" Name="DI 8x24VDC ST_2">
...
<InternalElement ID="55c30280-6f8a-4c37-9b2d-41bb90941258" Name="DI 8x24VDC ST_2">
<Value>1</Value> </Attribute>
<Value>true</Value>
</Attribute>
...
Importation d'une BaseUnit

Il est possible d'importer dans un fichier AML un module configuré dans un sous-module
correspondant à une BaseUnit.
Lors de l'importation d'une BaseUnit
● Les attributs GUID, PositionNumber, BuiltIn et DeviceItem ne sont pas pertinents et ne sont
donc pas affichés dans TIA Portal.
● Si un module imprévu dans le fichier AML possède un sous-module correspondant à une
BaseUnit, Openness ne renvoie pas l'attribut "BaseUnit" correspondant. Par conséquent,
CAx affiche une alarme correspondante dans le fichier journal.
● CAx ne vérifie pas si le numéro de référence produit (MLFB) de la BaseUnit présent dans
le fichier AML est exact (sauf pour déterminer s'il s'agit d'une BaseUnit simple ou en
double). CAx essaie de définir le numéro de référence produit (MLFB) de la BaseUnit via
Openness. Si une erreur survient dans Openness, le message d'erreur correspondant est
affiché.
● L'importation de la version précédente du fichier AML avec/sans informations sur la
BaseUnit a réussi si des informations sont importées dans TIA Portal.

Importation d'une BaseUnit simple

Lors de l'importation d'une BaseUnit simple, seul le module contenant le sous-module
correspondant à la BaseUnit dans le fichier AML avec les informations sur la BaseUnit est
importé dans TIA Portal.
La BaseUnit en simple est identifiée au moyen du TypeIdentifier et du modèle suivant dans le
fichier AML :
OrderNumber:xxxx 193-6[B|U|T]xYx-xxxx où la valeur Y (11e position) se situe dans une plage
de 0 à 5.
Importation d'une BaseUnit double :
Lors de l'importation d'une BaseUnit double, deux modules (voisins) contenant des
informations sur la BaseUnit sont affichés dans TIA Portal. Le premier module avec un sous-
module correspondant à une BaseUnit en double dans le fichier AML est importé avec une
BaseUnit double en ajoutant le suffixe |X300 au numéro de référence produit (MLFB) de la
BaseUnit. Le deuxième module ne possédant pas de sous-module inférieur correspondant à
une BaseUnit est importé avec la même BaseUnit en ajoutant le suffixe |X301 au numéro de
référence produit (MLFB) de la BaseUnit. La BaseUnit en double est identifiée au moyen du
TypeIdentifier et du modèle suivant dans le fichier AML :
OrderNumber:xxxx 193-6[B|U|T]x6x-xxxx
Voir aussi
8.6.7 Exportation/importation d'un fichier AML en connexion avec le châssis d'extension
Conditions
Application
TIA Portal vous permet d'exporter les appareils avec plusieurs châssis possédant une
connexion de châssis d'extension au fichier AML et de les réimporter afin d'obtenir la même
configuration d'appareil que celle qui a été créée dans le projet TIA Portal.

Exemple : appareil avec plusieurs châssis possédant une connexion de châssis d'extension
Structure AML
Dans TIA Portal les connexions de châssis d'extension entre plusieurs châssis sont structurées
directement sous les modules émetteur et récepteur (tous deux étant des objets DeviceItem).
Toutefois, conformément à la recommandation AR APC, ces connexions sont structurées
comme des liaisons port à port sous un port de communication. Pour respecter cette
recommandation, une CommunicationInterface et un CommunicationPort factices sont insérés
dans le module IM.

L'exemple suivant montre une structure d'élément partielle du fichier AML exporté pour la
configuration de l'appareil ci-dessus :

<InternalElement ID="1ddb8d5c-d6cc-42c9-b1d8-621219b139f6" Name="RackExtension">

<Attribute Name="Type" AttributeDataType="xs:string">
<Value>ExtensionRack</Value>
</Attribute>
...
<InternalElement ID="f25e531a-1793-4896-ade5-a87bd98de06e" Name="IM 46x SenderPort_1">
<Attribute Name="Label" AttributeDataType="xs:string">
<Value>X1</Value>
</Attribute>
<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<ExternalInterface ID="9a824a06-89b9-4ba8-bee0-83c89b1f5e53"
Name="CommunicationPortInterface"
RefBaseClassPath="AutomationProjectConfigurationInterfaceClassLib/
CommunicationPortInterface" />
CommunicationPort" />
</InternalElement>
CommunicationInterface" />
</InternalElement>
...
<InternalElement ID="d841278f-558a-41ab-9f03-91eeb454dc6b" Name="RackExtension">
</Attribute>
...
<InternalElement ID="2e1ff3b2-8a3e-4d5b-a95c-3ed027287db9" Name="IM 46x ReceiverPort_1">
<Value>X1</Value>
</Attribute>
<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<ExternalInterface ID="98460c75-a05d-4c23-8f88-33878ccd79c5"
</InternalElement>
<InternalElement ID="7615a32e-09dc-4171-88ed-118026357bae" Name="IM 46x SenderPort_1">
<Value>X2</Value>
</Attribute>
<Value>2</Value>
</Attribute>


<Value>true</Value>
</Attribute>
<ExternalInterface ID="846093a9-6473-4946-acf4-95a7813924df"
</InternalElement>
</InternalElement>
...
<InternalElement ID="f4eb31c6-41d4-4a6e-ac33-de9c054a8c74" Name="RackExtension">
</Attribute>
...
<InternalElement ID="c11d2227-91db-41ae-9d94-d822e3ab9c7a" Name="IM 46x ReceiverPort_1">
<Value>X1</Value>
</Attribute>
<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<ExternalInterface ID="a9b2cce1-7078-4347-b5f2-428da1ad5326"
</InternalElement>
</InternalElement>
...
<InternalLink Name="Link To Port_1" RefPartnerSideA="f25e531a-1793-4896-ade5-
a87bd98de06e:CommunicationPortInterface" RefPartnerSideB="2e1ff3b2-8a3e-4d5b-
a95c-3ed027287db9:CommunicationPortInterface" />
<InternalLink Name="Link To Port_2"
RefPartnerSideA="7615a32e-09dc-4171-88ed-118026357bae:CommunicationPortInterface"
RefPartnerSideB="c11d2227-91db-41ae-9d94-d822e3ab9c7a:CommunicationPortInterface" />

Remarque
L'interface de châssis d'extension n'est donc exportée que si des connexions de châssis
d'extension existent. De même, le nombre de ports factices sur l'interface de châssis
d'extension dépend des ports abonnés de la connexion de châssis présents au niveau de
module. Dans l'exemple ci-dessus, le module "IM 460-0_1" prend en charge deux ports (IM 46x
SenderPort_1 et IM 46x SenderPort_2). Mais dans TIA Portal un seul port de liaison est
configuré. C'est pourquoi le fichier AML exporté ne contient qu'un seul port sous l'interface de
châssis d'extension.
Liaison de châssis d'extension

La représentation XML des liaisons de châssis d'extension entre plusieurs châssis s'effectue
dans le format décrit ci-après.
ExternalInterface-
L'élément interne <ExternalInterface> doit être inséré sous l'élément interne
<CommunicationPort> qui participe à la liaison.
<InternalElement ID="[IM Module Unique ID]" Name="[IM Module Name]">

...
<InternalElement ID="[Dummy Interface Unique ID]" Name="RackExtension">
</Attribute>
...
<InternalElement ID="[Dummy Port Unique ID]" Name="[IM Module Sender/Receiver Name]">
...
<ExternalInterface ID="[External Interface Unique ID]" Name="CommunicationPortInterface"
</InternalElement>
<InternalElement ID="[Dummy Port Unique ID]" Name="[IM Module Sender/Receiver Name]">
...
<ExternalInterface ID="[External Interface Unique ID]" Name="CommunicationPortInterface"
</InternalElement>
</InternalElement>
DeviceItem" />
</InternalElement>

Lien interne
Les liaisons de châssis d'extension sont représentées à l'aide de variables <InternalLink>. Les
variables <InternalLink> doivent être insérées sous l'élément supérieur commun des différents
châssis (par ex. appareil). Le nom du lien doit être unique dans l'élément supérieur commun.
<InternalLink Name="Link To [Internal link Name]" RefPartnerSideA="[Communication Port

UniqueID]:[Communication Port External Interface Name]" RefPartnerSideB="[Communication
Port UniqueID]:[Communication Port External Interface Name]" />
8.6.8 Gestion de connexions pour les châssis d'extension
Conditions
Application
À l'aide de TIA Portal Openness vous pouvez appeler, ajouter et supprimer des relations pour
les châssis d'extension. Vous pouvez ainsi aussi utiliser la prise en charge de TIA Portal
Openness pour la réalisation de relations pour des châssis d'extension lors de l'importation/
exportation CAx.
Code de programme
ImConnection imConnection = portDeviceItem.GetService<ImConnection>();

imConnection.Connect(partnerport);
imConnection.Disconnect();
imConnection.GetPartnerPort();
var imConnectionOwner = imConnection.OwnedBy;
Voir aussi

8.6.9 Exportation de données CAx
Conditions
Utilisation
Dans TIA Portal, vous pouvez exporter votre configuration dans un fichier AML, dans l'éditeur
"Appareils et réseaux". Cette fonction basée sur TIA Portal Openness permet d'exporter des
données de matériel du niveau projet ou appareils.
TIA Portal Openness offre les moyens suivants pour exporter des données CAx :
● Fonction d'exportation
La fonction d'exportation est accessible par le service CaxProvider. Pour le
service CaxProvider, appelez la méthode GetService pour l'objet Project.
● Interface de ligne de commande
Vous exécutez "Siemens.Automation.Cax.AmiHost.exe" sous "C:\Programmes\Siemens
\Automation\Portal V..\Bin\" en transmettant des arguments spécifiques dans la ligne de
commande.
Restrictions pour CAx relatives à l'exportation et à l'importation

CAx ne prend pas en charge l'exportation et l'importation
● des connexions port-port
● des connexions vers et entre des châssis d'extension
● des multi CPU
● Appareils IHM à l'exception des Push Button Panels et des Key Panels
● Entraînements
● du mode de sortie et de la plage de sortie de voies analogiques
● des adresses comprimées
CAx ne prend pas en charge l'exportation et l'importation des appareils et des entraînements
suivants :
● 6AV2 104-0XXXX-XXXX
● 6AV2 155-0XXXX-XXXX
● 6ES7 XXX-XXXXX-XXXX
● 6ES7 370-0AA01-0AA0
● 6ES7 451-3AL00-0AE0
● 6GK5 414-3FC00-2AA2

● 6GK5 414-3FC10-2AA2
● 6GK5 495-8BA00-8AA2
● 6GK5 496-4MA00-8AA2
● 6GK5 602-0BA00-2AA3
● 6GK5 602-0BA10-2AA3
● 6GK5 612-0BA00-2AA3
● 6GK5 612-0BA10-2AA3
● 6GK5 613-0BA00-2AA3
● 6GK5 623-0BA10-2AA3
● 6GK5 627-2BA10-2AA3
● System:Device.Scalance/S627
● System:IPIProxy.Device
● System:IPIProxy.Rack
Code de programme : accéder au service CaxProvider

Pour accéder au service CaxProvider, modifiez le code de programme suivant :
Project project = tiaPortal.Projects.Open(...);

CaxProvider caxProvider = project.GetService<CaxProvider>();
if(caxProvider != null)
// Perform CAx export and import operation
Exportation CAx au niveau projet

Pour exporter des données CAx au niveau projet, utilisez la méthode Export avec les
paramètres suivants :

ProjectToEx‐ tiaPortal.Projects[0] Objet projet à exporter
port
ExportFilePath new FileInfo(@"D:\Temp\ProjectEx‐ Chemin complet de fichier d'exportation
port.aml") pour le fichier AML
LogFilePath new FileInfo(@"D:\Temp\ProjectEx‐ Chemin complet du fichier-journal
port_Log.log")

Pour exporter toutes les données CAx au niveau du projet, modifiez le code de programme
suivant :
caxProvider.Export(project, new FileInfo(@"D:\Temp\ProjectExport.aml"),

new FileInfo(@"D:\Temp\ProjectExport_Log.log"));
Exportation CAx au niveau appareils

Pour exporter des données CAx au niveau appareils, utilisez la méthode Export avec les
paramètres suivants :

DeviceToExport project.Devices[0] Objet appareil à exporter
ExportFilePath new FileInfo(@"D:\Temp\ProjectEx‐ Chemin complet de fichier d'exporta‐
port.aml") tion pour le fichier AML
port_Log.log")
Pour exporter toutes les données CAx au niveau du projet, modifiez le code de programme
suivant :
caxProvider.Export(device, new FileInfo(@"D:\Temp\DeviceExport.aml"), new

FileInfo(@"D:\Temp\DeviceExport_Log.log"));
Exportation CAx via la ligne de commande

Pour exporter des données CAx via la ligne de commande, utilisez
Siemens.Automation.Cax.AmiHost.exe avec les paramètres suivants :
Paramètre Exemple Description

-p -p "D:\Temp\MyProject.ap*" Indique un chemin d'accès complet à
un projet TIA Portal.
-d -d "S7300/ET200M station_1" Paramètre optionnel. Si aucun appareil
n'est indiqué, l'exportation est effectuée
au niveau projet.
Indique le nom de l'appareil ou de la
station à exporter au sein du projet TIA
spécifié.
-m -m "AML" Indique le mode d'importation/exporta‐
tion (format d'exportation/importation):.
"AML" exporte au format AML
-e -e "D:\Import" Indique le chemin complet d'accès au
-e "D:\Import\CAx_Export.aml" fichier AML à exporter. Le nom du projet
est utilisé comme nom du fichier expor‐
té, si seul un chemin d'accès est indi‐
qué.

Pour exporter toutes les données CAx au niveau projet via la ligne de commande, modifiez le
//please adapt the path and the extension apx to the installed version of
TIA Portal
Siemens.Automation.Cax.AmiHost.exe -p "D:\Temp\MyProject.apx" -m "AML" -e
"D:\Import\CAx_Export.aml"
Pour exporter des données CAx au niveau appareil via la ligne de commande, modifiez le code
TIA Portal
Siemens.Automation.Cax.AmiHost.exe -p "D:\Temp\MyProject.apx" -d "S7300/
ET200M station_1" -m "AML" -e "D:\Import\CAx_Export.aml"
8.6.10 Importation de données CAx
Conditions
Utilisation
Dans TIA Portal, vous pouvez importer votre configuration dans un fichier AML, dans l'éditeur
"Appareils et réseaux". Cette fonction permet d'importer des données de matériel du niveau
projet ou appareils.
TIA Portal Openness offre les moyens suivants pour exporter des données CAx :
● Fonction d'importation
La fonction d'importation est accessible par le service CaxProvider. Pour le
service CaxProvider, appelez la méthode GetService pour l'objet Project.
● Ligne de commande
Vous exécutez "Siemens.Automation.Cax.AmiHost.exe" sous "C:\Programmes\Siemens
\Automation\Portal V..\Bin\" en transmettant des arguments spécifiques dans la ligne de
commande :

Code de programme : accéder au service CaxProvider

//Access the CaxProvider service

Project project = tiaPortal.Projects.Open(...);
CaxProvider caxProvider = project.GetService<CaxProvider>();
if(caxProvider != null)
{
// Perform Cax export and import operation
}
Importation CAx
Pour importer des données CAx dans un projet de TIA Portal, utilisez la méthode Import avec
les paramètres suivants :

ImportFilePath new FileInfo(@"D:\Temp\ProjectEx‐ Chemin complet de fichier d'importation
port.aml") pour le fichier AML
port_Log.log")
ImportOptions CaxImportOptions.MoveToParkingLot Stratégies pour résoudre le conflit lors de
CaxImportOptions.RetainTiaDevice l'importation dans un projet existant non vi‐
de.
CaxImportOptions.OverwriteTiaDevice
Pour importer les données CAx, modifiez le code de programme suivant :
caxProvider.Import(new FileInfo(@"D:\Temp\ProjectImport.aml"), new

FileInfo(@"D:\Temp\ProjectImport_Log.log"),
CaxImportOptions.MoveToParkingLot);
Les CaxImportOptions suivantes sont données :
Option pour impor‐ Description

tation
MoveToParkin‐ Conserver dans le projet l'appareil/les appareils avec conflit de nom et importer
gLot dans un dossier parking ceux provenant des données CAx
RetainTiaDevice Conserver dans le projet l'appareil/les appareils avec conflit de nom et ne pas
importer ceux provenant des données CAx
OverwriteTiaDevi‐ Écraser l'appareil/les appareils avec conflit de nom dans le projet avec ceux pro‐
ce venant des données CAx

Importation CAx via la ligne de commande

Pour importer des données CAx via la ligne de commande, utilisez
Siemens.Automation.Cax.AmiHost.exe avec les paramètres suivants :
Paramètre Exemple Description

-p -p "D:\Temp\MyProject.ap*" Indique un chemin d'accès complet à
un projet TIA Portal.
-m -m "AML" Indique le mode d'importation/exporta‐
tion (format d'exportation/importation):.
"AML" exporte au format AML
-i -i "D:\Import\CAx_Export.aml" Indique le chemin complet d'accès au
fichier AML à importer.
-c -c "ParkingLot" Indique différentes stratégies en cas de
conflits de nom d'appareil dans les op‐
tions d'importation.
Pour importer des données CAx via la ligne de commande, modifiez le code de programme
suivant :
TIA Portal
Siemens.Automation.Cax.AmiHost.exe -p "D:\Temp\MyProject.apx" -m "AML" -i
"D:\Import\CAx_Export.aml"
Les options d'importation suivantes sont disponibles :
Option pour impor‐ Description

tation
ParkingLot Conserver dans le projet l'appareil/les appareils avec conflit de nom et importer
dans un dossier parking ceux provenant des données CAx
RetainTia Conserver dans le projet l'appareil/les appareils avec conflit de nom et ne pas
importer ceux provenant des données CAx
OverwriteTia Écraser l'appareil/les appareils avec conflit de nom dans le projet avec ceux pro‐
venant des données CAx
8.6.11 Exporter/importer des sous-modules
Conditions

Application
Entre TIA Portal et d'autres outils d'ingénierie, p. ex. un outil CAD comme EPLAN, des données
de sous-modules peuvent être échangées dans le procédé Round-Trip, une hiérarchie
commune des sous-modules devant être conservée dans le fichier AML durant l'exportation et
l'importation. Par exemple, les sous-modules comme l'adaptateur de bus doivent présenter
dans TIA Portal une autre hiérarchie interne que dans d'autres applications (p. ex. des outils
CAD comme EPLAN).
Structure AML du fichier d'exportation

Vous pouvez exporter des données de sous-réseau de la hiérarchie TIA Portal dans la
hiérarchie de fichier ALM.

L'exemple suivant montre un extrait de la structure de fichier ALM générée à l'exportation d'un
BusAdapter comme sous-module depuis TIA Portal.


<CAEXFile FileName="Project4.aml" SchemaVersion="2.15"
xsi:noNamespaceSchemaLocation="CAEX_ClassModel_V2.15.xsd">
<AdditionalInformation>
<WriterHeader>
<WriterName>Totally Integrated Automation Portal</WriterName>
<WriterID>1d4fcebb-1ad6-4881-b01d-bca335d94a46:V1.0</WriterID>
<WriterVendor>Siemens AG</WriterVendor>
<WriterVendorURL>www.siemens.com</WriterVendorURL>
<WriterVersion>15</WriterVersion>
<WriterRelease>1500.0100.0.0</WriterRelease>
<LastWritingDateTime>2018-05-03T11:23:10.3011329Z</LastWritingDateTime>
</WriterHeader>
</AdditionalInformation>
<AdditionalInformation AutomationMLVersion="2.0" />
<AdditionalInformation DocumentVersions="Recommendations">
<Document DocumentIdentifier="AR APC" Version="1.1.0" />
<InstanceHierarchy Name="APC Sample Instance Hierarchy">
<InternalElement ID="6cd7f80f-e049-4958-ba67-630481805bf0" Name="Project4">
<Attribute Name="ProjectManufacturer" AttributeDataType="xs:string" />
<Attribute Name="ProjectSign" AttributeDataType="xs:string" />
<Attribute Name="ProjectRevision" AttributeDataType="xs:string" />
<Attribute Name="ProjectInformation" AttributeDataType="xs:string" />
<InternalElement ID="b27045c4-9cb3-4b8d-916b-85f8100d1602" Name="Ungrouped devices">
<InternalElement ID="3f770698-940d-49c2-9f77-06fc458e1340" Name="ET 200SP station_1">
<Value>System:Device.ET200SP</Value>
</Attribute>
<InternalElement ID="6f52fbab-a221-4d54-9368-84c392ca7fec" Name="Rack_0">
<Attribute Name="TypeName" AttributeDataType="xs:string">
<Value>Rack</Value>
...
<InternalElement ID="f7445c0b-1c52-4a84-915f-2c8bee13af70" Name="BA 2xRJ45">
<Value>BA 2xRJ45</Value>
</Attribute>
<Value>127</Value>
</Attribute>
</Attribute>
<Value>OrderNumber:6ES7 193-6AR00-0AA0</Value>
</Attribute>
<Attribute Name="FirmwareVersion" AttributeDataType="xs:string">
<Value>V0.0</Value>
</Attribute>
<InternalElement ID="40f8bbce-35d3-4d65-907a-bece3e0144e0" Name="PROFINET interface">
<Value>X1</Value>
</Attribute>

<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<InternalElement ID="8fb775eb-96c6-48d6-af8a-96ba72418830" Name="IE1">
<Value>Ethernet</Value>
</Attribute>
<Attribute Name="NetworkAddress" AttributeDataType="xs:string">
<Value>192.168.0.1</Value>
</Attribute>
<Attribute Name="SubnetMask" AttributeDataType="xs:string">
<Value>255.255.255.0</Value>
</Attribute>
<Attribute Name="IpProtocolSelection" AttributeDataType="xs:string">
<Value>Project</Value>
</Attribute>
<SupportedRoleClass RefRoleClassPath="AutomationProjectConfigurationRoleClassLib/Node" />
</InternalElement>
<InternalElement ID="f28a3d93-d821-4556-9df1-a45f0e4ff6a6" Name="Port_1">
<Value>P1 R</Value>
</Attribute>
<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
</InternalElement>
<InternalElement ID="ad6a0faa-3b70-4528-8c54-8183018b6714" Name="Port_2">
<Value>P2 R</Value>
</Attribute>
<Value>2</Value>
</Attribute>
<Value>true</Value>
</Attribute>
</InternalElement>
...
Remarque
CAx exporte et importe la version de AR APC dans un fichier AML conformément à la version
de TIA Portal qui est installée.

Importer des sous-modules

Vous pouvez importer des sous-modules depuis des fichiers ALM générés lors de l'exportation
précédente.
Remarque
● Le nouveau comportement concernant la hiérarchie d'exportation n'est valable qu'à partir
de la version V15.1.
● La hiérarchie dans le fichier ALM ne doit pas influencer la hiérarchie interne dans TIA Portal
après l'importation.
● Des fichiers ALM générés avec d'anciennes versions de TIA Portal doivent également être
importés sans erreur.
● Ce comportement en liaison à la modification / la conversion de la hiérarchie est valable
pour les sous-modules insérés et non-insérés.
Plusieurs sous-modules sur une interface commune

Dans certains cans, plusieurs sous-modules sont disponibles sur une interface commune
Exemple : Périphérique IO : IM 155-6 PN/3 HF 6ES7 155-6AU30-0CN0/V4.2. Ce module
dispose de deux BusAdapters insérés sur la même interface. Dans ce cas, il doit être possible
d'exporter les BusAdapters de la hiérarchie TIA Portal vers la hiérarchie de fichier ALM requise.
Dans cet exemple de hiérarchie TIA Portal, l'interface PROFINET a deux BusAdapters, trois
ports et un nœud. Port_1 et Port_2 appartiennent logiquement à BA 2xRJ45 et Port_3
appartient logiquement à BA 2xRJ45_1, même si les trois ports sont regroupés sur une
interface.
Lors de l'exportation :
● L'interface originale avec les informations concernant la liaison n'est affectée qu'au premier
sous-module. Ici, l'interface originale avec les nœuds 'IE1', 'Port_1' et 'Port_2' sont affectés
à BA 2xRJ45.
● Les autres sous-modules sont affectés à une interface "dupliquée" avec des ports qui
appartiennent logiquement au sous-module. Ici, une interface "dupliquée" et Port_3 sont
affectés à BA 2xRJ45_1.
● Si le module de tête est lié à un sous-réseau/réseau IO, les informations de liaison
correspondantes (comme les liens ExternalInterface) ne sont exportées que comme
éléments du premier sous-module (lien ExternalInterface au sous-réseau vers 'Node' et lien
ExternalInterface vers le réseau IO-System sous 'Interface').
● Les informations de liaison sur la connexion de topologie font référence au port
correspondant.
Lors de l'importation :
● Vous pouvez importer plusieurs sous-modules depuis un fichier ALM générés lors de
l'exportation précédente.
● Il est possible qu'un fichier AML généré par EPLAN contienne des informations relatives
aux nœuds de l'interface secondaire.

● Les détails du nœud qui sont dupliqués à partir du nœud de l'interface primaire sont gérés
comme suit :
– Attributs de nœuds : les détails concernant les attributs de nœuds, qui sont définis
pendant le traitement de l'interface primaire, sont écrasés.
– Liaison sous-réseau : une liaison est déjà établie est ignorée de manière implicite ; sinon,
la liaison concernée est établie.
● Si le fichier AML contient des détails sur la liaison réseau IO de l'interface secondaire,
– L'établissement de la liaison est ignoré si la liaison existe déjà et l'utilisateur en est
informé via un message correspondant dans l'onglet "Info".
– La liaison est établie si elle ne l'est pas déjà.
La configuration suivante montre la configuration d'un périphérique IO avec des connexions
maître-esclave et des liaisons topologiques.

L'exemple suivant montre l'extrait d'un fichier AML généré lors de l'exportation pour la
configuration ci-dessus :


<CAEXFile FileName="MultipleBA_01.aml" SchemaVersion="2.15"
<WriterHeader>
<WriterName>Totally Integrated Automation Portal</WriterName>
<WriterID>1d4fcebb-1ad6-4881-b01d-bca335d94a46:V1.0</WriterID>
<WriterVendor>Siemens AG</WriterVendor>
<WriterVendorURL>www.siemens.com</WriterVendorURL>
<WriterVersion>15</WriterVersion>
<WriterRelease>1501.0000.0.0</WriterRelease>
<LastWritingDateTime>2018-05-17T09:36:46.9230179Z</LastWritingDateTime>
</WriterHeader>
<InternalElement ID="e005c094-1b0a-42c4-92a0-67c981508c1a" Name="Project45">
<Attribute Name="ProjectManufacturer" AttributeDataType="xs:string" />
<Attribute Name="ProjectSign" AttributeDataType="xs:string" />
<Attribute Name="ProjectRevision" AttributeDataType="xs:string" />
<Attribute Name="ProjectInformation" AttributeDataType="xs:string" />
<InternalElement ID="2782e61d-8c27-46cb-93ea-6b804157ae60" Name="PN/IE_1">
</Attribute>
<ExternalInterface ID="2d901881-a2bf-4fe7-915f-b2542b346988" Name="LogicalEndPoint_Subnet"
RefBaseClassPath="CommunicationInterfaceClassLib/LogicalEndPoint" />
Subnet" />
...
<InternalElement ID="dc5cf410-2516-4b0b-ad1a-c43117d8c9b3" Name="BA 2xRJ45">
<Value>BA 2xRJ45</Value>
</Attribute>
<Value>127</Value>
</Attribute>
</Attribute>
<Value>OrderNumber:6ES7 193-6AR00-0AA0</Value>
</Attribute>
<Value>V0.0</Value>
</Attribute>
<InternalElement ID="f04874a8-2d35-47c4-93ae-d6fdc2668479" Name="PROFINET interface">
<Value>X1</Value>
</Attribute>
<Value>1</Value>

</Attribute>
<Value>true</Value>
</Attribute>
<ExternalInterface ID="81a7d9df-99b8-4eca-8e72-404b22bd05e7"
Name="LogicalEndPoint_Interface" RefBaseClassPath="CommunicationInterfaceClassLib/
LogicalEndPoint" />
<InternalElement ID="83eb7d69-8cd5-4217-a07a-0c656d215ec7" Name="IE1">
...
Nettoyage de fichiers ALM

Le nettoyage (Pruning) décrit le processus d'optimisation du contenu par la suppression de
certains éléments qui ne doivent pas nécessairement être indiqués. Vous trouverez des
informations sur le nettoyage de fichiers ALM au chapitre Nettoyage de fichiers ALM
(Page 940).
Dans certains cas, la hiérarchie des sous-modules peut être différente dans TIA Portal et les
outils de CAO (comme EPLAN) en raison du nettoyage des sous-modules. Dans ce cas,
TIA Portal doit prendre en charge l'importation de fichiers ALM avec et sans nettoyage.
Remarque
● L'exportation de fichiers ALM sans nettoyage est toujours prise en charge dans TIA Portal.
● L'importation de fichiers ALM avec ou sans nettoyage est toujours prise en charge dans
TIA Portal.
Voir aussi
8.6.12 Importer des données CAx sans adresse logique
Conditions requises
Application
Lors de l'importation CAx dans TIA Portal, vous pouvez configurer la liaison entre voie et
variable sans indiquer l'adresse de début d'un module E/S et /ou l'adresse logique de la
variable dans le fichier AML.

L'exemple AML suivant montre le fichier XML qui doit être créé sans attributs pour l'adresse de
début et l'adresse logique.

<?xml version="1.0" encoding="utf-8"?><CAEXFile FileName="TagsExport.aml"

SchemaVersion="2.15" xsi:noNamespaceSchemaLocation="CAEX_ClassModel_V2.15.xsd">
...
<InternalElement ID="fff25423-fe9e-4334-9331-4cec118e06f7" Name="Project1">
...
<InternalElement ID="59c0b48b-aa6c-45c3-8dc8-bba5367bd4fb" Name="S7300/ET200M station_1">
...
<InternalElement ID="1b7b2b24-243b-4348-831e-bc46bc35957f" Name="Rail_0">
...
<InternalElement ID="974ca791-ad8d-482b-be80-2cf4e8dcedaf" Name="PLC_1">
...
<InternalElement ID="9564bcc2-8ea0-4be7-a950-5c55b34e474a" Name="Default tag table">
<ExternalInterface ID="7fd969e6-c2c9-45a8-b573-68833df327f5" Name="Tag_1"
RefBaseClassPath="AutomationProjectConfigurationInterfaceClassLib/Tag">
<Attribute Name="DataType" AttributeDataType="xs:string">
<Value>Bool</Value>
</Attribute>
</ExternalInterface>
<ExternalInterface ID="33899862-86c1-4171-832a-1136b6e59b9d" Name="Tag_2"
RefBaseClassPath="AutomationProjectConfigurationInterfaceClassLib/Tag">
<Attribute Name="DataType" AttributeDataType="xs:string">
<Value>Byte</Value>
</Attribute>
TagTable" />
</InternalElement>
...
<Value>8</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<Attribute Name="Address">
<RefSemantic CorrespondingAttributePath="OrderedListType" />
<Attribute Name="1">
<Attribute Name="StartAddress" AttributeDataType="xs:int">
<Value>832</Value>
</Attribute>
<Attribute Name="Length" AttributeDataType="xs:int">
<Value>128</Value>
</Attribute>
<Attribute Name="IoType" AttributeDataType="xs:string">
<Value>Input</Value>
</Attribute>
</Attribute>
<Attribute Name="StartAddress" AttributeDataType="xs:int">
<Value>832</Value>
</Attribute>
<Value>128</Value>
</Attribute>


<Value>Output</Value>
</Attribute>
</Attribute>
</Attribute>
DeviceItem" />
</InternalElement>
DeviceItem" />
</InternalElement>
<InternalElement ID="29e0bb63-0050-46e3-968a-fcecf4eb050a" Name="DI 16x24VDC_1">
<Value>DI16 x 24VDC</Value>
</Attribute>
<Value>4</Value>
</Attribute>
</Attribute>
<Value>OrderNumber:6ES7 321-1BH02-0AA0</Value>
</Attribute>
<Attribute Name="Address">
<RefSemantic CorrespondingAttributePath="OrderedListType" />
<Value>16</Value>
</Attribute>
</Attribute>
</Attribute>
</Attribute>
<ExternalInterface ID="175dc9c9-f9a3-4b10-b43e-68dfc14811fc" Name="Channel_DI_0"
RefBaseClassPath="AutomationProjectConfigurationInterfaceClassLib/Channel">
<Value>Digital</Value>
</Attribute>
</Attribute>
<Attribute Name="Number" AttributeDataType="xs:int">
<Value>0</Value>
</Attribute>
<Value>1</Value>
</Attribute>
<ExternalInterface ID="23e99053-906c-4548-9bd2-e975cacf01b2" Name="Channel_DI_1"
RefBaseClassPath="AutomationProjectConfigurationInterfaceClassLib/Channel">
<Value>Digital</Value>
</Attribute>

</Attribute>
<Attribute Name="Number" AttributeDataType="xs:int">
<Value>1</Value>
</Attribute>
<Value>1</Value>
</Attribute>
DeviceItem" />
</InternalElement>
DeviceItem" />
<InternalLink Name="Link To Tag_1" RefPartnerSideA="29e0bb63-0050-46e3-968a-
fcecf4eb050a:Channel_DI_0" RefPartnerSideB="9564bcc2-8ea0-4be7-a950-5c55b34e474a:Tag_1" />
</InternalElement>
Device" />
</InternalElement>
AutomationProject" />
</InternalElement>
</InstanceHierarchy>
</CAEXFile>
Variable du type de données Bool (%I0.0)

Dans l'exemple de fichier AML ci-dessus, l'adresse logique pour la variable est calculée à l'aide
de l'algorithme suivant lors de l'importation :
Adresse logique = ChannelIoType + ByteAddress + BitAddress
Nom Description
ChannelIoType Entrée (E) ou sortie (S)
ByteAddress ByteAddress est calculé comme suit :
StartAddress du module E/S * 8 + BitOffsetAddress du module E/S + (Channel‐
Number * ChannelLength) / 8
BitAddress BitAddress est calculé comme suit :
(BitOffsetAddress du module E/S + (ChannelNumber * ChannelLength)) % 8

Remarque
● Lorsqu'une variable s'applique à plusieurs modules : L'algorithme ci-dessus fournit
plusieurs adresses octet basées sur l'adresse de début des modules, ainsi qu'un tableau
d'adresses bit par adresse octet correspondant aux différents numéros de voies. Puis,
l'algorithme sélectionne dans le tableau la plus petite adresse octet et la plus petite adresse
bit correspondant à cet octet pour calculer l'adresse logique de la variable. Aussitôt que
l'adresse logique de la variable est affectée, la propriété globale est automatiquement prise
en compte par TIA Portal lors de l'importation.
● Seul un nombre réduit de configurations d'appareils (par ex. modules ASI) prennent en
charge l'attribut d'adresse BitOffset dans TIA Portal. Avec les modules ne prenant pas en
charge l'attribut d'adresse BitOffset, c'est la valeur par défaut "0"qui est considérée pour le
calcul ci-dessus.
La liste suivante contient les types de données variables qui prennent en charge, l'adresse de
bit dans TIA Portal :
Types de données variables Valeur de l'adresse de bit

Bool 0à7
LReal Les valeurs maximales et minimales des numéros
LWord de bit dans TIA Portal correspondent à 0.
LInt
ULInt
LTime
LDT
LTime_Of_Day
Lors de l'importation CAx, si une variable booléenne est configurée pour un type de voie, le
calcul de l'adresse logique tient compte de l'adresse BitOffset. L'adresse logique et l'adresse
BitOffset sont actualisées comme adresse logique des variables dans l'interface utilisateur de
TIA Portal.
Variable avec d'autres types de données prenant en charge l'adresse BitOffset

Lorsqu'une voie de variable est configurée entre deux types de voies différents et qu'une voie
du type Bool est affectée à une variable du type LDT comprenant plusieurs voies, le calcul de
l'adresse logique tient compte de l'adresse BitOffset utilisée pour le calcul de l'adresse logique
de la variable du type "LDT". Dans l'interface utilisateur dans TIA Portal, l'adresse logique de
la variable est actualisée avec une erreur si la valeur de l'adresse de bit est différente de "0" ;
la configuration de la voie sur variables est alors impossible.
Il faut veiller à ce que la configuration de la voie sur variables soit effectuée entre des types de
données identiques.

Variable avec un autre type de données (%IB0)

Adresse logique = ChannelIoType + TagDataType + ByteAddress
Nom Description
ChannelIoType Entrée (E) ou sortie (S)
TagDataType TagDataType est une abréviation du type de données.
Exemple : W pour Mot et B pour Bit
ByteAddress ByteAddress est calculé comme suit :
StartAddress du module E/S + (ChannelNumber * ChannelLength) / 8
L'algorithme décrit ci-dessus est utilisé pour calculer avec précision l'adresse logique d'une
variable dans les cas suivants :
● La longueur du type de données indiqué dans la variable doit être égale à celle de la voie
à laquelle le type de données est affecté.
● En cas d'affectation d'une variable du type "Octet" par exemple à une voie analogique d'une
longueur de 2 octets, lors de l'importation d'un fichier AML sans adresse logique des
variables dans TIA Portal, il faudra toujours attribuer la variable au premier octet de la voie,
indépendamment de l'octet auquel elle était initialement affectée.
Remarque
● Lorsqu'une variable s'applique à plusieurs modules : L'algorithme ci-dessus fournit
plusieurs adresses octet basées sur l'adresse de début des modules. Puis, l'algorithme
sélectionne dans le tableau la plus petite adresse octet pour calculer l'adresse logique de
la variable. Aussitôt que l'adresse logique avec la plus petite adresse octet de la variable est
affectée, la propriété globale est automatiquement gérée par TIA Portal lors de
l'importation. Lorsque l'attribut StartAddress pour le module E/S n'est pas indiqué dans le
fichier AML, la valeur standard est attribuée par TIA Portal et est ensuite utilisée pour le
calcul ci-dessus.
● Lorsque l'attribut StartAddress pour le module E/S n'est pas indiqué dans le fichier AML, la
valeur standard est attribuée par TIA Portal et est ensuite utilisée pour le calcul ci-dessus.
Après une importation réussie, la configuration de variables suivante a été créée pour
l'exemple décrit ci-dessus dans TIA Portal.
Les voies doivent être configurées avec les variables comme représenté ci-dessous.

Voir aussi
8.6.13 Exception pour l'importation et exportation de données CAx
Exception en raison de la non-disponibilité de TIA Openness

La mise en œuvre de CAx est basée sur des API TIA Openness publiques. Les API Openness
publiques ne sont disponibles que si l'utilisateur a installé le pack optionnel Openness au cours
de l'installation de TIA Portal. Il est donc important de vérifier si Openness est disponible avant
l'exécution de fonctions liées à CAx. (voir Installation de TIA Portal Openness (Page 30))
Lorsque l'utilisateur déclenche une action d'exportation ou d'importation CAx dans l'interface
utilisateur de TIA Portal, un contrôle est toujours effectué afin de déterminer si TIA Openness
est disponible dans le système. Si aucune installation de TIA Openness n'est trouvée, une
boîte de dialogue TIA Portal contenant le message d'erreur suivant est affichée.
Si l'opération CAx est exécutée via la ligne de commande, la boîte de dialogue suivante est
affichée en cas de non-disponibilité de TIA Openness.

Figure 8-4 OpennessNotInstalled-Commandline
8.6.14 Appareils et modules Round-Trip
Conditions
Utilisation
Vous pouvez échanger des données de configuration entre TIA Portal et d'autres outils
d'ingénierie tels qu'un outil de planification électrique comme EPLAN ou l'outil de sélection TIA
Selection Tool. Pour identifier les appareils à importer et exporter, on utilise un identifiant global
unique, AML GUID.
Pendant les processus Round-Trip, l'AML GUID pour les objets physiques, tels que les
appareils et les éléments d'appareils qui ne sont pas intégrés (par ex. CPU ou modules), reste
stable. Ce qui n'est pas le cas pour les objets virtuels comme les variables, les voies, etc.
Pendant la première exportation à partir de TIA Portal, l'AML GUID est généré de manière
aléatoire pour un appareil ou un élément d'appareil non intégré mais stabilisé ensuite.

2XWLOWHFKQLTXH )LFKLHU$0/ 7,$b3RUWDO
([SRUWDWLRQ $3, ,PSRUWDWLRQ

$3,
*8,' *8,'
*8,' *8,' *8,'
$3,
Si vous exportez un appareil à partir d'un outil technique dans un projet TIA Portal vide, AML
GUID est ajouté dans le commentaire de l'objet matériel. Lorsque le paramètre correspondant
est activé dans TIA Portal sous "Outils > Paramètres > CAx > Paramètres d'importation", l'AML
GUID est ajouté dans la langue d'édition actuelle. Le processus Round-Trip ne prend en
charge qu'une langue d'éditeur pour les AML GUID. Si vous importez ou exportez des
données, utilisez toujours la langue d'édition dans laquelle vous avez commencé le Round Trip.
AML GUID reste identique pour cet objet matériel pour toutes les importations et exportations
suivantes. Les modifications effectuées sur l'objet matériel sont appliquées.
Les noms d'objets doivent être uniques au sein d'un projet TIA Portal. L'importation d'un
appareil ou d'un élément d'appareil dans un projet TIA Portal dans lequel un objet avec le
même nom existe déjà entraînerait un conflit de nom. Lors de l'importation, vous avez la
possibilité de déplacer les objets avec les conflits de noms dans l'emplacement de stockage
personnalisé. "_CAX" est ajouté au nom de l'objet importé.
Lors de l'exportation CAx du GUI
)LFKLHU$0/ 7,$3RUWDO
3DUNLQJ
$3, ,PSRUWDWLRQ
*8,' *8,' *8,'
*8,'
$3, 3/&B&$;
En vue de la prise en charge des versions précédentes de projet par le processus Round-Trip,
tous les AML GUID sont désormais enregistrés sous "CustomIdentity" (ID d'application) et non
plus comme "Comment" de l'appareil/élément d'appareil lors de la mise à niveau du projet. Les
AML GUID de l'appareil/élément d'appareil doivent être uniques et peuvent être enregistrés
dans chaque langue d'édition. On suppose donc que toutes les langues d'édition de
commentaires reçoivent un AML GUID lors de la mise à niveau du projet. AML GUID de
l'appareil/élément d'appareil est certes unique, mais si un nouveau GUID avec le Regex
[AR_APC:ID:*] approprié est ajouté au commentaire dans une langue d'édition quelconque,
c'est le premier GUID sélectionné parmi les langues d'édition qui sert de AML GUID de
l'appareil/élément d'appareil.
Dès que les AML GUID sont déplacés dans le commentaire dans CustomIdentity, le
commentaire sur l'appareil/élément d'appareil est actualisé en supprimant [AR_APC:ID:*],
comme le montre la figure suivante.
Si le commentaire contient plusieurs sections [AR_APC:ID:*], le premier GUID correspondant
au modèle est mis sur CustomIdentity-Repository, puis supprimer dans le commentaire. Le
texte restant est interprété comme un commentaire.

Remarque
Copie d'un appareil importé
Si vous copiez un appareil ou un élément d'appareil avec un AML GUID, vous devez supprimer
l'AML GUID dans le commentaire de l'objet copié. Faute de quoi, il existe des appareils ou des
éléments d'appareils ayant des AML GUID identiques dans votre projet, ce qui aboutit à un
fichier AML invalide.
Paramétrage de l'importation
1. Définissez le nom de dossier de l'emplacement de stockage sous "Options > Paramètres >
CAx > Paramètres de résolution de conflit".
Le dossier de l'emplacement de stockage sert à enregistrer des objets avec des conflits de
noms.
2. Activez "Options > Paramètres > CAx > Paramètres d'importation > Enregistrer GUID
pendant l'importation".
Lors de l'importation :
● Les GUID d'un asset physique sont enregistrés comme éléments de la section
CustomIdentity.
● Lors de l'importation d'une fichier AML, les GUID sont enregistrés comme éléments de
CustomIdentity.
Remarque
AML GUID valides
Si vous éditez un AML GUID avant l'importation, celui-ci n'est plus valide et l'importation CAx
est annulée. Une information correspondante est journalisée.
Remarque
Commentaire trop long
Si l'annexe du commentaire AML GUID dépasse la longueur maximale de 500 caractères, le
commentaire de l'utilisateur est limité à 500 caractères. Une information correspondante est
journalisée.

Exporter
Lors de l'exportation :
● Le GUID à exporter est exporté de CustomIdentity pour la clé AR_APC:ID.
● Si le GUID n'est pas disponible comme élément dans CustomIdentity, le GUID multi-
utilisateur est appelé, puis exporté comme AML GUID.
● Si aucune des deux étapes décrites ci-dessus ne permet de mettre à disposition le GUID
d'un asset physique, le processus d'exportation génère de façon aléatoire un nouveau
GUID qui est considéré comme AML GUID pour les assets physiques.
Structure AML
L'identification créée est exportée dans un fichier AML comme décrit dans la section de code
suivante :
<InternalElement ID="23aeefd0-ce05-4116-a644-e33d43901eaf"
Name="PLC_1"
8.6.15 Importer AML et ignorer les artefacts inconnus
Conditions
Application
Il doit être possible d'importer un fichier AML avec des artefacts inconnus dans TIA Portal, les
artefacts inconnus étant ignorés et seules les informations pertinentes étant reprises. Les
artefacts inconnus contiennent des informations inutiles qui ne sont pas pertinentes pour les
importations CAx. Les possibles artefacts inconnus peuvent être des attributs, des sous-
attributs, des éléments internes et des interfaces externes.
Deux réactions sont possibles ici lorsqu'un artefact inconnu est rencontré lors de l'importation :
● L'artefact inconnu est "connu" mais sans importance pour TIA Portal et peut être ignoré de
manière implicite
● L'artefact inconnu est "inconnu" et il est ignoré mais signalé par un avertissement

Liste blanche – classification d'artefacts connus/inconnus

Un métafichier XML spécial "Automation-Cax-WhiteList.xml" permet de décider si un artefact
est connu ou inconnu de TIA Portal. Vous pouvez prendre en compte les artefacts présents
dans un projet d'automatisation. Ainsi, le métafichier prend en charge également la
configuration d'artefacts à l'intérieur des limites de projets d'automatisation.
Le tableau suivant contient les types de catégories de rôles disponibles pour la configuration
des artefacts inconnus à ignorer.
Élément dans la lis‐ Description

te blanche
ItemType Représente le type de catégorie de rôle. Valeurs possibles pour ItemType :
● AutomationProjectConfigurationRoleClassLib/AutomationProject
● AutomationProjectConfigurationRoleClassLib/Device
● AutomationProjectConfigurationRoleClassLib/DeviceItem
● AutomationProjectConfigurationRoleClassLib/DeviceUserFolder
● AutomationProjectConfigurationRoleClassLib/Subnet
● AutomationProjectConfigurationRoleClassLib/CommunicationInterface
● AutomationProjectConfigurationRoleClassLib/CommunicationPort
● AutomationProjectConfigurationRoleClassLib/Node
● AutomationProjectConfigurationRoleClassLib/IoSystem
● AutomationProjectConfigurationRoleClassLib/TagTable
● AutomationProjectConfigurationRoleClassLib/TagUserFolder
● AutomationProjectConfigurationInterfaceClassLib/Channel
● AutomationProjectConfigurationInterfaceClassLib/Tag
Name Représente le nom de l'attribut/sous-attribut inconnu
Structure de la liste blanche

L'exemple suivant montre le métafichier de liste blanche pour les attributs.
<?xml version="1.0" encoding="utf-8" ?>


<WhiteList>
...
...
<WhiteListItem ItemType="AutomationProjectConfigurationRoleClassLib/DeviceItem">
<AttributeList>
<Attribute Name="UnknownAttribute" /> 
</AttributeList>
</WhiteListItem>
...
...
</WhiteList>


<WhiteList>
...
<WhiteListItem ItemType="*">
<AttributeList>
<Attribute Name="UnknownAttribute" />

</AttributeList>
</WhiteListItem>
...
</WhiteList>
L'exemple suivant montre le métafichier de liste blanche pour les sous-attributs.
<?xml version="1.0"encoding="utf-8" ?>

<WhiteList>
...
<SubAttributeList>
<Attribute Name ="Address">
<Attribute Name ="2">
<SubAttribute Name="UnknownSubAttribute"/> 
</Attribute>
</Attribute>
</SubAttributeList>
</WhiteListItem>
...
</WhiteList>
<?xml version="1.0"encoding="utf-8" ?>

<WhiteList>
...
<SubAttributeList>
<Attribute Name ="Address">
<Attribute Name ="2">
<SubAttribute Name="UnknownSubAttribute"/> 
</Attribute>
</Attribute>
</SubAttributeList>
</WhiteListItem>
...
</WhiteList>

Remarque
La valeur "*" dans ItemType doit être utilisée pour ignorer toutes les survenues d'un attribut/
sous-attribut défini dans tous les éléments internes/toutes les interfaces externes d'un fichier
AML.
L'exemple de structure suivant montre le métafichier de liste blanche pour les opérations
logiques.


<WhiteList>
...
<LinkList>
<Link RefBaseClassPath ="Unknown external interface RefBaseClassPath"/> -->
<WhiteList>
...
<LinkList>
<Link RefBaseClassPath ="Unknown external interface RefBaseClassPath"/> -->
<Link RefBaseClassPath="AutomationProjectConfigurationInterfaceClassLib/
ModuleAssignment" />
</LinkList>
</WhiteListItem>
...
</WhiteList>
Remarque
ModuleAssignment est ignoré à toutes les positions dans le fichier AML.
L'exemple suivant montre le métafichier de liste blanche pour les objets.


<WhiteList>
...
<ObjectList>

<Object WhiteListKey="RefBaseClassPath"
WhiteListValue="AutomationProjectConfigurationRoleClassLib/DeviceItem"/>
</ObjectList>
</WhiteListItem>
...
</WhiteList>


<WhiteList>
...
<ObjectList>

<Object WhiteListKey="RefBaseClassPath"
WhiteListValue="AutomationProjectConfigurationRoleClassLib/DeviceItem"/>
</ObjectList>
</WhiteListItem>
...
</WhiteList>

Remarque
● ItemType représente le type de catégorie de rôle.
● En cas d'utilisation d'un * à la place de ItemType, cet élément interne est ignoré
indépendamment de sa position dans le fichier AML.
● WhiteListKey représente le RefBaseClassPath.
● WhiteListValue représente la catégorie de rôle de l'élément interne.
Voir aussi
8.6.16 Topologie de l'exportation/importation
Conditions requises
Utilisation
Dans TIA Portal, vous pouvez exporter les appareils avec leurs informations de topologie dans
un fichier AML. En cas d'importation dans un projet TIA Portal vide, les éléments d'appareil
importés conservent les informations de topologie.
L'élément <InteralLink> fournit des informations de liaison de connexions port à port entre les
éléments d'appareil. Il apparaît sous l'objet de niveau supérieur commun des appareils
connectés et contient des noms de variables uniques.
Attributs d'un élément "InternalLink"

Le tableau suivant montre les attributs correspondants des objets de fichiers d'importation et
d'exportation assistés par ordinateur :
Attribut Manipula‐ Commentaire

tion
Name Obligatoire Les noms de variables sont formatés en tant que "Link to Port_n" (n signifiant un nombre
compris entre 1 et le nombre de connexions port à port).
RefPartnerSideA Obligatoire Désigne le port relié. Formaté en tant que UniqueIDOfPort:CommunicationPortInterface
RefPartnerSideB Obligatoire Désigne le port relié. Formaté en tant que UniqueIDOfPort:CommunicationPortInterface

Exemple : vue topologique
Structure AML
La figure suivante montre une structure d'élément partielle du fichier AML exporté. Elle contient
deux ID uniques pour les ports dans des API.
L'élément <InteralLink> contient trois attributs obligatoires.
8.6.17 Importation d'un appareil avec des références de bibliothèque
Conditions

Application
Vous pouvez importer des appareils (stations)/éléments d'appareils (modules, sous-modules)
dans un fichier AML à l'aide de références de bibliothèque dans TIA Portal.
Structure AML
La structure AML suivante décrit le fichier XML à utiliser lors de l'importation dans un projet TIA
Portal.
...
<InternalElement ID="bed34f88-7a3f-4e37-a32f-df1a6dcb954a" Name="S71500/ET200MP station_1">
<Value>System:Device.S71500</Value>
<Attribute Name="TemplateReference“ AttributeDataType="xs:string">
<Value>GlobalLib://StationPlcLibrary/Master copies/DeviceFolder/S71500ET200MP station_1</
Value>
</Attribute>
</Attribute>
Device" />
...
<InternalElement ID="5082f437-4198-4dcb-b794-35b6b9fcd104" Name="PLC_1">
<Value>OrderNumber:6ES7 214-1BE30-0XB0</Value>
<Attribute Name="TemplateReference" AttributeDataType="xs:string">
<Value>GlobalLib://StationPlcLibrary/Master copies/PLC_1</Value>
</Attribute>
</Attribute>
</InternalElement>
...
</InternalElement>
...

Exemple : Configuration importée

La zone du fichier AML ci-dessus correspond à la station et à l'automate dans TIA Portal
comme illustré ci-dessous :
Voir aussi
8.6.18 Exportation d'un élément d'appareil
Conditions

Utilisation
L'objet Device est un objet conteneur pour une configuration centralisée ou décentralisée. Il
constitue l'objet de niveau supérieur pour les objets DeviceItem et l'élément interne de
niveau le plus élevé de la hiérarchie d'instance du projet TIA Portal dans la structure d'un fichier
AML.
L'exportation de données CAx prend en charge les types d'appareil indiqués par l'identifiant de
type AML :
● Modules physiques
● Appareils basés sur GSD/GSDML
● Systèmes
Les appareils peuvent être regroupés dans un objet DeviceUserFolder.
Remarque
Lors de l'exportation d'un appareil individuel, tous les sous-réseaux du projet sont exportés eux
aussi.
Attributs
Le tableau suivant montre les attributs correspondants de l'objet d'appareil de fichiers
d'importation et d'exportation assistés par ordinateur :
Attribut Manipula‐ Commentaire

tion
Name Obligatoire
TypeIdentifier Obligatoire Optionnel pour l'importation à partir d'AR APC V1.1
pour l'ex‐
portation
Comment Optionnel Paramétrage par défaut : ""

Exemple : Configuration exportée

L'exemple de structure suivant représente l'exportation de l'appareil individuel "S7-400
station_1" sans châssis ni module :
Appareil sans identifiant de type ou avec un identifiant de type générique

L'importation CAx doit être en mesure de traiter des appareils sans identifiant de type ou
possédant des identifiants de type génériques ("System:Device.Generic"). Il se peut que le
fichier AMI contienne des types d'appareils sans identifiant de type ou avec un identifiant de
type générique ('System:Device.Generic').

Mais l'importation CAx permet d'éditer ces types et de créer des appareils correctement.
Les appareils suivants prennent en charge le remplacement d'identifiants de type génériques
ou d'identifiants de type manquants :
● Appareils GSD et GSDML
● Appareils basés MDD (sauf appareils GSD/GSDML)
Pour les appareils génériques ou les appareils sans identifiant de type et avec châssis
générique et de remplacement d'identifiant de type, le module de tête (pour les appareils
décentralisés) ou l'API (dans des configurations centralisées) doit être existant dans le châssis
décrit dans le fichier AML. Sinon, les appareils sans identifiant de type ou le remplaçant de
l'identifiant de type pour appareils et châssis génériques ne seront pas traités.
La structure XML suivante montre une configuration d'appareil à identifiant de type non
générique :
<InternalElement ID="04f5d5f08-316a-4a1d-9290-9bfd75b2b2ca" Name="S7-400 station_1">

</Attribute>
<Attribute Name="Comment" AttributeDataType="xs:string">
<Value>S7400 station</Value>
</Attribute>
Device"/>
</InternalElement>
La structure XML suivante montre une configuration d'appareil à identifiant de type générique :
<InternalElement ID="04f5d5f08-316a-4a1d-9290-9bfd75b2b2ca" Name="S7-400 station_1">

<Value>System:Device.Generic</Value>
</Attribute>
<Value>S7400 Device</Value>
</Attribute>
Device"/>
</InternalElement>

La structure XML suivante montre une configuration d'appareil avec un identifiant de type pour
l'appareil :
<InternalElement ID="a887601f-3ced-4f50-88ff-a9ec6eabb682" Name="S7-400 station_1">

</Attribute>
</Attribute>
Device"/>
</InternalElement>
La structure XML suivante montre une configuration d'appareil sans identifiant de type pour
l'appareil :
<InternalElement ID="a887601f-3ced-4f50-88ff-a9ec6eabb682" Name="S7-400 station_1">

</Attribute>
Device"/>
</InternalElement>
Voir aussi
Structure des données CAx pour l'importation/exportation (Page 943)
8.6.19 Importation d'un objet d'appareil
Conditions
Utilisation
L'objet Device est un objet conteneur pour une configuration centralisée ou décentralisée. Il
constitue l'objet de niveau supérieur pour les objets DeviceItem et l'élément interne de
niveau le plus élevé de la hiérarchie d'instance du projet TIA Portal dans la structure d'un fichier
AML.

L'importation de données CAx prend en charge les types d'appareil indiqués par l'identifiant de
type AML :
● Appareils basés sur GSD/GSDML
● Systèmes
● Appareils génériques
Quand il y a déjà un objet DeviceUserFolder dans un projet TIA Portal, les appareils sont
regroupés dans le dossier correspondant.
Si vous connaissez uniquement l'identifiant (TypeIdentifier) d'un module de tête ou d'un
API et pas celui du châssis correspondant et de l'appareil, vous pouvez importer un châssis
générique.
Exemple : TypeIdentifier = System:<Prefix>.Generic
Pour l'échange d'appareils génériques, il faut que les éléments suivants soient présents dans
le châssis décrit dans le fichier AML.
● Appareils centralisés : AP
● Appareils décentralisés : module de tête
Si les appareils sont génériques, l'attribut BuiltIn définit le type de châssis ou de module :
● Physique : BuiltIn = True
● Générique : BuiltIn = False

Exemple : importer des appareils génériques

L'exemple de structure suivant représente l'importation de l'appareil générique ""S7-400
station" " sans châssis ni module.

Exemple : importer la hiérarchie d'un dossier utilisateur d'un appareil

L'exemple de structure suivant montre l'importation d'une hiérarchie de dossiers.
Hiérarchie importée des dossiers utilisateur

Le nom du dossier pour les appareils non groupés et non affectés sont attribués en fonction de
la langue. Pour cette raison, il est recommandé d'effectuer une importation avec la même
langue d'interface utilisateur que pour l'exportation. Sinon, des appareils non groupés et non
affectés sont importés dans des dossiers nommés en fonction de la langue de l'exportation.
Exemple : Vous avez exporté un projet comprenant le groupe de systèmes d'appareils
"Ungrouped devices" (en anglais) et importez le fichier AML dans la langue d'interface
utilisateur allemande. Résultat : Dans le projet, un groupe de systèmes d'appareils "Appareils
non groupés" (en allemand). Simultanément, un groupe d'utilisateurs "Ungrouped device" (en
anglais) est créé lors de l'importation CAx.
La hiérarchie suivante est importée dans le navigateur de projet :

Voir aussi
8.6.20 Exportation/importation d'un appareil avec une adresse définie
Conditions requises
Utilisation
Dans TIA Portal, vous pouvez exporter les objets d'adresse d'éléments d'appareils IO dans un
fichier AML. En cas d'importation dans un projet TIA Portal vide, les éléments d'appareil
importés conservent les objets d'adresse dans les éléments d'appareils IO correspondants.
L'attribut Address dans le fichier AML contient RefSemantic avec le paramètre obligatoire sur
la valeur indiquée OrderedListType.
Attributs d'un élément "Address"

Attri‐ Mani‐ Commentaire

but pula‐
tion
IoTy‐ Obli‐ Entrée ou sortie
pe gatoi‐
re
Lengt Op‐ Largeur de voie
h tion‐
nel
Star‐ Obli‐ Adresse de début de l'appareil IO
tAd‐ gatoi‐
dress re

Exemple : éléments d'appareils IO avec des objets d'adresse
Structure AML
La figure suivante montre une structure d'élément partielle du fichier AML exporté. Elle contient
les éléments Address et leurs attributs.
Pruned XML
Pruning (élagage) décrit le processus d'optimisation du contenu en supprimant certaines
choses qui ne doivent pas nécessairement être indiquées dans le fichier XML. Les informations
créées automatiquement sur le sous-module ne sont pas indiquées dans ce fichier XML réduit
et les objets d'adresse correspondants sont disposés sous l'élément directement supérieur.

La figure suivante montre une structure d'élément partielle du fichier AML exporté avant le
Pruning.
Les informations de sous-module like <InternalElement> sont supprimées du fichier Pruned-

AML et les objets d'adresse correspondants y sont conservés.
Voir aussi
Pruned AML (Page 940)

8.6.21 Exportation/importation d'un appareil avec des voies
Conditions
Utilisation
Dans TIA Portal, vous pouvez exporter les objets de voie d'éléments d'appareils IO dans un
fichier AML. En cas d'importation dans un projet TIA Portal vide, les éléments d'appareil
importés conservent les objets de voie dans les éléments d'appareils IO correspondants.
L'élément <ExternalInterface> est représenté dans des éléments internes de nœuds et sous-
réseaux et indique que les nœuds et sous-réseaux sont reliés.
Attributs d'un élément "ExternalInterface"

Attri‐ Mani‐ Commentaire

but pula‐
tion
IoTy‐ Obli‐ Entrée ou sortie
pe gatoi‐
re
Lengt Op‐ Largeur de voie (1 pour les signaux TOR et 16 pour les signaux analogiques)
h tion‐
nel
Num‐ Obli‐ Le numéro de voie commence par 0
ber gatoi‐
re
Type Obli‐ Analogique ou TOR
gatoi‐
re
Numérotation de voies
Les voies d'entrées TOR, de sorties TOR, d'entrées analogiques, de sorties analogiques et les
voies technologiques sont numérotées comme DI_0, DO_0, AI_0, AO_0,TO_0. Les voies sur
les éléments d'appareils eux-mêmes sont numérotées en premier et ensuite les voies sur les
éléments d'appareils inférieurs (en profondeur d'abord). Tous les autres éléments d'appareil
ont un numéro de voie propre commençant par 0.

Exemple : appareils avec des voies
Structure AML
La figure suivante montre une structure d'élément partielle du fichier AML exporté.

8.6.22 Exportation d'objets d'élément d'appareil
Conditions
Utilisation
L'exportation d'objets d'élément d'appareil n'est utilisable que sur des appareils API.
Les objets DeviceItem sont des éléments inférieurs connectés d'un objet Device : Un objet
du type DeviceItem peut être aussi bien un châssis qu'un module enfiché.
● Le premier élément qui suit un appareil est de type "châssis". Le PositionNumber d'un
châssis commence à 0. S'il existe plusieurs châssis, ceux-ci sont numérotés de manière
continue (1, 2, 3, ...).
Il n'existe aucune restriction relative à l'ordre dans un niveau hiérarchique du fichier AML.
● Tous les autres éléments suivants du type "Châssis" sont des modules.
L'exportation de données CAx prend en charge les types d'éléments d'appareil indiqués par
l'identifiant de type AML :
● Modules GSD/GSDML
Attributs
Attribut Manipulation Commentaire

Name Obligatoire
Exporter seulement pour "Buil‐
tIn" = TRUE
TypeName Exporter seulement pour "Buil‐
tIn" = FALSE
DeviceItemType Exporter seulement Uniquement pour les API (appareils centraux) et éléments d'appareil
(châssis physique, modules, module de tête).
Optionnel pour l'importation, mais tout élément d'appareil, sauf les Ba‐
seUnits ayant accessoires comme DeviceItemType, est ignoré de ma‐
nière implicite.
PositionNumber Obligatoire
BuiltIn Optionnel Paramétrage par défaut : FALSE

Attribut Manipulation Commentaire

TypeIdentifier Obligatoire pour "BuiltIn" = FAL‐ Pour les éléments d'appareils intégrés, cet attribut est exporté avec
SE l'identifiant de type de l'élément supérieur enfichable correspondant.
Ignoré pour "BuiltIn" = TRUE Sans signification pour l'importation, il est donc optionnel. Pour les
éléments d'appareils non intégrés, cet attribut est optionnel.
FirmwareVersion Optionnel, obligatoire
lorsque l'objet prend en charge
des versions de firmware
PlantDesignation Optionnel Paramétrage par défaut : ""
IEC
LocationIdentifier Optionnel Paramétrage par défaut : ""
IEC
Comment Optionnel pour "BuiltIn" = FAL‐ Paramétrage par défaut : ""
SE
ProductDesigna‐ Obligatoire L'importation n'est pas prise en charge si la longueur de ProductDesi‐
tion IEC Si cet attribut est pris en charge gnation IEC dépasse 54 caractères.
par l'objet dans TIA Portal et Exportation/importation entre éléments d'appareils comme partie de
n'est pas vide. AR APC V1.1.0 Supports pour TIA Portal V16
InstallationDate Obligatoire Exportation/importation entre éléments d'appareils comme partie de
Si cet attribut est pris en charge AR APC V1.1.0-Supports pour TIA Portal V16
par l'objet dans TIA Portal.
Address Optionnel "Address" ne possède pas d'attributs imbriqués
Le tableau suivant représente les attributs imbriqués des attributs "Address" de l'objet
"DeviceItem" :
Attributs pour "Ad‐ Manipula‐ Commentaire

dress" tion
StartAddress Obligatoire
Length Exporter L'exportation/importation d'adresses de longueur = 0 n'est pas prise en charge.
seulement
IoType Obligatoire Entrée ou sortie



L'exemple de structure suivant représente l'exportation de "UR1_0" et du module "PLC_1".


Voir aussi
Exportation/importation d'appareils et éléments d'appareils basés sur GSD/GSDML
(Page 1015)
8.6.23 Importation d'objets d'élément d'appareil
Conditions
Utilisation
L'importation d'objets d'élément d'appareil n'est utilisable que sur des appareils API.
Les objets DeviceItem sont des éléments inférieurs connectés d'un objet Device : Un objet
du type DeviceItem peut être aussi bien un châssis qu'un module enfiché.
● Le premier élément qui suit un appareil est de type Châssis. Le PositionNumber d'un
châssis commence à 0. S'il existe plusieurs châssis, ceux-ci sont numérotés de manière
continue (1, 2, 3, ...).
Il n'existe aucune restriction relative à l'ordre dans un niveau hiérarchique du fichier AML.
● Tous les autres éléments suivants du type Châssis sont des modules.
L'importation de données CAx prend en charge les types d'éléments d'appareil indiqués par
l'identifiant de type AML :
● Modules GSD/GSDML
● Modules génériques
Si vous connaissez uniquement l'identifiant (TypeIdentifier) d'un module de tête ou d'un
API et pas celui du châssis correspondant et de l'appareil, vous pouvez importer un châssis
générique.
Exemple : TypeIdentifier = System:Rack.Generic
Pour l'échange de châssis génériques, les éléments suivants doivent être présents dans le
châssis décrit dans le fichier AML.
● Appareils centralisés : AP
● Appareils décentralisés : module de tête

Un châssis générique provient du type Device. Par conséquent, un fichier AML importé dans
TIA Portal peut utiliser l'identifiant de type de ce châssis :
Dans ce cas, c'est TIA Portal qui détermine l'identifiant de type pour le châssis.
Si des châssis et des modules sont génériques, l'attribut BuiltIn définit le type de châssis ou
de module :
Restrictions
Pendant l'importation, l'attribut DeviceItemType est sans importance et il est optionnel.
Remarque
Attribut "FirmwareVersion"
Si aucune FirmwareVersion n'est indiquée dans le fichier d'importation, la dernière version
de firmware disponible dans TIA Portal est utilisée lors de l'importation CAx.
Quand l'attribut FirmwareVersion figure dans le fichier d'importation avec une valeur vide,
l'importation de l'élément d'appareil échoue et un message d'erreur est consigné dans le
journal.

Exemple : importer des appareils génériques

L'exemple de structure suivant représente l'importation du châssis générique "Rack_1".

Configuration importée
La figure suivante montre la configuration importée dans l'interface utilisateur de TIA Portal :
Voir aussi
8.6.24 Exportation/importation d'appareils et éléments d'appareils basés sur GSD/

GSDML
Conditions requises

Utilisation
L'importation/exportation CAx d'appareils et éléments d'appareils basés sur GSD/GSDML est
comparable avec l'importation/exportation d'appareils standards.
Les attributs exportables sont différents pour les appareils et éléments d'appareils basés sur
GSD/GSDML ; par ex. l'attribut "Label" existe pour GSD/GSDML.
L'importation générique d'appareils et de châssis est possible. Pour l'importation, utilisez la
même identification que pour les appareils standard :
● Importation d'appareils génériques : TypeIdentifier = System:Device.Generic
● Importation de châssis génériques : TypeIdentifier = System:Rack.Generic
Si les appareils sont génériques, l'attribut BuiltIn définit le type :
Attributs pour un appareil

Le tableau suivant montre les attributs correspondants des appareils de fichiers d'importation
et d'exportation CAx :
Attribut Manipulation de l'attribut Commentaire
Name Obligatoire pour l'exportation et l'im‐

portation
TypeIdentifier Obligatoire pour l'exportation et op‐
tionnel pour l'importation à partir
d'AR APC V1.1
Comment Optionnel pour l'importation
Attributs pour un élément d'appareil

Le tableau suivant montre les attributs correspondants d'un élément d'appareil de fichiers
d'importation et d'exportation CAx :
Attribut Manipulation de l'attribut Manipulation de l'attribut Commentaire

Intégré = FAUX Intégré = VRAI
Éléments d'appareil gé‐ Éléments d'appareil physiques
nériques
Name Obligatoire Exporter seulement
TypeName Exporter seulement -/-
DeviceItem‐ Exporter seulement Exporter seulement Uniquement pour les éléments d'appareil
Type API (appareils centralisés) et les éléments
d'appareil module de tête (appareils dé‐
centralisés)
Optionnel pour l'importation, mais tout élé‐
ment d'appareil, sauf les BaseUnits ayant
accessoires comme DeviceItemType, est
ignoré.

Attribut Manipulation de l'attribut Manipulation de l'attribut Commentaire

Intégré = FAUX Intégré = VRAI
Éléments d'appareil gé‐ Éléments d'appareil physiques
nériques
PositionNum‐ Obligatoire Obligatoire pour l'exportation
ber Cas d'exception :
Éléments d'appareils de type interfa‐
ce : Optionnel pour l'importation
Éléments d'appareils de type port :
Optionnel
BuiltIn Optionnel Paramétrage par défaut : FALSE
TypeIdentifier Obligatoire pour "BuiltIn" Ignoré pour "BuiltIn" = TRUE Pour les éléments d'appareils intégrés,
= FALSE cet attribut est exporté avec l'identifiant de
type de l'élément supérieur enfichable cor‐
respondant.
Cet attribut est sans signification pour l'im‐
portation, il est donc optionnel.
Pour les éléments d'appareils non inté‐
grés, cet attribut est sans signification.
Comment Optionnel -
Label - -
Éléments d'appareils de type interfa‐
ce : Obligatoire
Éléments d'appareils de type port :
Obligatoire
Exemple : Appareil GSD/GSDML exporté


La figure suivante indique la structure du fichier AML exporté.

Châssis générique et châssis non générique avec ou sans identifiant de type

L'importation CAx doit être en mesure de traiter des appareils sans identifiant de type ou
possédant des identifiants de type génériques, c'est-à-dire System:Device.Generic, ainsi que
des châssis à identifiants de type génériques, c'est-à-dire 'System:Rack.Generic'.
Lors de l'importation, il se peut que le fichier AMI contienne des types d'appareils sans
identifiant de type ou avec un identifiant de type générique, c'est-à-dire
'System:Device.Generic', ainsi que des éléments d'appareils châssis à identifiants de type
génériques, c'est-à-dire 'System:Rack.Generic'. Mais l'importation CAx permet d'éditer ces
appareils et de créer correctement des éléments d'appareils châssis.
Les appareils suivants prennent en charge le remplacement d'appareils génériques, de
châssis génériques et d'identifiants de type manquants :
● Appareils GSD et GSDML - tous les appareils GSD et GSDML avec châssis GSD/GSDML.
● Appareils basés MDD (sauf appareils GSD/GSDML) - appareils avec identifiants de types
châssis système.
L'exportation CAx n'est pas pertinente pour le traitement de châssis génériques. CAx exporte
toujours les identifiants de type pour les châssis non génériques.
Pour les appareils génériques ou les appareils sans identifiant de type et avec châssis
générique et de remplacement d'identifiant de type, le module de tête (pour les appareils
décentralisés) ou l'API (dans des configurations centralisées) doit être existant dans le châssis
décrit dans le fichier AML. Sinon, les appareils sans identifiant de type ou le remplaçant de
l'identifiant de type pour appareils et châssis génériques ne seront pas traités.
La structure XML suivante montre une configuration par GSDML d'appareils (avec identifiant
de type) et de châssis (avec identifiant de type) :
<InternalElement ID="bc3b50fa-5cfa-4bf3-a496-8e46080d4f86" Name="GSD device_1">

<Value>GSD:GSDML-V2.32-SIEMENS-SINAMICS_DCMASTER-20160531.XML/D</Value>
</Attribute>
<InternalElement ID="c80f2d97-66c9-4f31-bf6b-17e3e0de0509" Name="Rack">
<Value>Rack</Value>
</Attribute>
<Value>0</Value>
</Attribute>
</Attribute>
<Value>GSD:GSDML-V2.32-SIEMENS-SINAMICS_DCMASTER-20160531.XML/R/IDD_14</Value>
</Attribute>
<InternalElement ID="f519b4b9-b1f7-4011-bed2-25be85c8c2a8" Name="SINAMICS-DCMaster-CBE20">
<Value>SINAMICS DC MASTER CBE20 V1.1</Value>
</Attribute>
<Value>HeadModule</Value>
</Attribute>

La structure XML suivante montre une configuration par GSDML d'appareils (sans identifiant
de type) et de châssis (identifiant de type générique) :

<Value>Rack</Value>
</Attribute>
<Value>0</Value>
</Attribute>
</Attribute>
<Value>System:Rack.Generic</Value>
</Attribute>
</Attribute>
</Attribute>

La structure XML suivante montre une configuration par GSDML d'appareils (identifiant de type
générique) et de châssis (identifiant de type générique) :

<Value>System:Device.Generic</Value>
</Attribute>
<Value>Rack</Value>
</Attribute>
<Value>0</Value>
</Attribute>
</Attribute>
<Value>System:Rack.Generic</Value>
</Attribute>
</Attribute>
</Attribute>
</Attribute>
<Value>GSD:GSDML-V2.32-SIEMENS-SINAMICS_DCMASTER-20160531.XML/DAP/IDD_14</Value>
</Attribute>
Voir aussi
8.6.25 Exporter/importer la configuration de l'appareil avec une interface virtuelle
Conditions

Application
TIA Portal utilise pour la communication entre les appareils des ports qui se trouvent dans les
interfaces. Mais il existe certains types d'appareils sur lesquels les ports se trouvent
directement dans les éléments d'appareils qui ne sont pas des interfaces. Cela ne correspond
pas au standard AML qui spécifie que les ports doivent toujours être contenus dans les
interfaces.
CAx utilise une interface imaginaire, appelée interface virtuelle, pour l'exportation et
l'importation de la configuration de l'appareil lorsque les ports se trouvent directement dans les
éléments d'appareils.

Exportation d'un fichier AML

L'exemple suivant montre un fichier AML avec une interface virtuelle :
<InternalElement ID="822622a0-056a-494c-a802-2463c5e1b47d" Name="SCALANCE interface_1">

<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<InternalElement ID="5a604a57-bc2d-4763-8df0-7d20000faf1b" Name="VirtualInterface_1">
<Value>X1</Value>
</Attribute>
</Attribute>
<Value>true</Value>
</Attribute>
<InternalElement ID="3c4862a1-b8ed-4610-88f3-29dc8328e748" Name="Port_1">
<Value>P1</Value>
</Attribute>
<Value>1</Value>
</Attribute>
<Value>true</Value>
</Attribute>
</InternalElement>
<InternalElement ID="220dd49d-8d23-44b1-bdc1-878516540313" Name="Port_2">
<Value>P2</Value>
</Attribute>
<Value>2</Value>
</Attribute> <Attribute Name="BuiltIn" AttributeDataType="xs:boolean">
<Value>true</Value>
</Attribute>
<ExternalInterface ID="99c6253b-c546-4720-af54-92db926b8231"
</InternalElement>
</InternalElement>
DeviceItem" />
</InternalElement>

Jusqu'à TIA Portal V16 l'interface virtuelle est exportée avec les attributs suivants :
● Nom : ScalanceInterface_1
● Désignation : Switch
À partir de TIA Portal V16 l'interface virtuelle est exportée avec les attributs suivants :
● Nom : VirtualInterface_1
● Désignation : X1
● Type : Ethernet
Importer
CAx prend en charge l'importation d'interfaces virtuelles. Les ports de l'interface virtuelle sont
ensuite traités dans le fichier AML sous l'élément supérieur correct dans TIA Portal. Ici, chaque
interface portant la désignation "Switch" est interprétée comme une interface virtuelle. À partir
de TIA Portal V16, cette désignation n'est plus utilisée comme identifiant, car elle a été
remplacée par X1, ce qui correspond à une interface réelle.
Néanmoins, "Ethernet" a été défini comme attribut de type pour l'interface virtuelle ; il est
optionnel. À partir de TIA Portal V16 tous les éléments d'interface présents dans le fichier AML
qui ne sont pas désignés par "Switch" sont donc traités normalement et, chaque fois qu'ils
apparaissent dans le fichier AML, CAx effectue une tentative d'appel depuis TIA Portal.
La recherche d'interfaces virtuelles par CAx échoue, toutefois les ports contenus sont traités.
Mais si CAx ne trouve pas d'interface réelle, les ports contenus ne sont pas traités.
Voir aussi
8.6.26 Exportation/importation de sous-réseaux
Conditions
Structure AML
Les sous-réseaux décrivent un réseau physique, notamment les appareils connectés au même
réseau de type PROFIBUS, PROFINET, MPI ou ASI.

Les liaisons entre un réseau et les éléments d'appareil sont représentées comme référence
pour l'objet réseau. Il n'y a pas de référence des objets réseau aux éléments d'appareil reliés.
Les paramètres de réseau sont enregistrés dans l'objet réseau. Les paramètres concernant
une interface de réseau d'un certain élément d'appareil qui est relié à un réseau sont
enregistrés dans un objet nœud de réseau dans cet élément d'appareil. La communication est
souvent régulée par "Voies", "Ports" et "Interfaces".
Les sous-réseaux sont exportés dans le fichier AML comme éléments internes, avec la
classification de rôle "Sous-réseau" dans la hiérarchie d'instances.
Un sous-réseau a les éléments reliés suivants dans la structure AML :
● Élément interne avec la classification de rôle "Nœud"
Détermine l'interface sur un élément d'appareil.
● <InternalLink>
Détermine les partenaires reliés du sous-réseau. Le nom de variable <InternalLink>
est unique et est toujours ajouté dans le fichier AML sous l'élément interne du projet.
● <ExternalInterface>
Constate dans des éléments internes de nœuds et sous-réseaux que les nœuds et sous-
réseaux sont reliés. Lorsque les nœuds ou sous-réseaux ne sont pas reliés, les
éléments <ExternalInterface> n'existent pas pour les nœuds et sous-réseaux.
Utilisation
Dans TIA Portal V16 l'importation CAx prend en charge Ethernet et Profinet et l'exportation du
type de sous-réseau et des attributs de nœuds a lieu via Ethernet.

L'importation/exportation assistée par ordinateur prend en charge les types suivants de sous-
réseaux :
● Ethernet
● PROFIBUS
● MPI
● ASi
Remarque
● L'importation CAx prend en charge Ethernet et Profinet pour les attributs type de sous-
réseau et type de nœud.
● L'importation CAx d'un fichier AML avec des valeurs de chaînes sans faire de distinction
entre majuscules et minuscules pour les attributs (exemple : Profinet, PROFINET,
pROFINET, ProFINET, etc.) est prise en charge.
● L'exportation CAx prend en charge Ethernet.
Attributs d'un élément "sous-réseau"

Attribut Maniement Commentaire

Name Obligatoire
Type Obligatoire Ethernet ou PROFIBUS ou MPI ou ASi
Attributs d'éléments "CommunicationInterface"

Le tableau suivant montre les attributs correspondants des objets pour fichiers d'importation et
d'exportation CAx :
Attribut Traitement Commentaire

Name Obligatoire Sans signification pour les éléments d'appareils "fixes".
Label Obligatoire L'étiquette manque éventuellement quand "BuiltIn" = TRUE et "PositionNumber" sont in‐
diqués pour l'objet "DeviceItem" correspondant.
TypeIdentifier Obligatoire Pour les éléments d'appareils intégrés, cet attribut doit être exporté avec l'identifiant de
type de l'élément supérieur enfichable correspondant. Pendant l'importation, cet attribut
est sans importance.
Pour les éléments d'appareils non intégrés, cet attribut est sans signification.
FirmwareVersion Obligatoire
TypeName Unique‐ Sans signification pour les éléments d'appareils "intégrés".
ment expor‐
tation
DeviceItemType Unique‐ Uniquement pour CPU et module de tête
ment expor‐ Cet attribut est optionnel pour l'importation, mais tout élément d'appareil, sauf les BaseU‐
tation nits ayant des accessoires comme DeviceItemType, est ignoré de manière implicite.
PositionNumber Obligatoire Sans signification pour l'importation d'éléments d'appareils "intégrés".

Attribut Traitement Commentaire

BuiltIn Obligatoire Sans signification pour l'importation d'éléments d'appareils "non intégrés".
pour l'ex‐ "False" par défaut pour l'importation.
portation
Optionnel
pour l'im‐
portation
Comment Optionnel Non approprié pour éléments d'appareils "intégrés".
Attributs d'éléments "CommunicationPort"


Name Obligatoire Sans signification pour les éléments d'appareils "intégrés".
Label Obligatoire L'étiquette peut manquer lorsque "BuiltIn" = TRUE" et "PositionNumber" sont déterminés
pour l'objet "DeviceItem" correspondant.
Lors de l'importation de la valeur d'une étiquette pour le port, en comparant la valeur de
l'étiquette aucune distinction n'est faite entre majuscules et minuscules (par ex. : p1 r, P1
R, P1, p1, etc.).
Pour les ports validés pour une topologie en anneau et identifiés par le suffixe "R", l'im‐
portation doit être traitée de manière "équivalente" aux ports dont les valeurs d'étiquette ne
contiennent pas de suffixe.
Exemple : Les étiquettes de port suivantes sont traitées de manière équivalente :
● P1 égal à P1
● P1 égal à P1 R
● P1 R égal à P1
● P1 R égal à P1 R
TypeIdentifier Obligatoire Pour les éléments d'appareils intégrés, cet attribut doit être exporté avec l'identifiant de
type de l'élément supérieur enfichable correspondant. Pendant l'importation, cet attribut
est sans importance.
Pour les éléments d'appareils non intégrés, cet attribut est sans importance.
FirmwareVersion Obligatoire
TypeName Unique‐ Sans signification pour les éléments d'appareils "intégrés".
ment expor‐
tation
DeviceItemType Unique‐ Uniquement pour CPU et module de tête
ment expor‐ Optionnel pour l'importation, mais tout élément d'appareil, sauf les BaseUnits ayant ac‐
tation cessoires comme DeviceItemType, est ignoré de manière implicite.
PositionNumber Obligatoire Uniquement significatif pour l'importation d'éléments d'appareils "intégrés" quand l'attribut
"Label" n'est pas indiqué.
Quand "PositionNumber" et "Label" sont tous deux configurés, c'est "PositionNumber" qui
a la priorité.


BuiltIn Obligatoire Sans signification pour l'importation d'éléments d'appareils "non intégrés".
pour l'ex‐ "False" par défaut pour l'importation.
portation
Optionnel
pour l'im‐
portation
Comment Optionnel Non approprié pour éléments d'appareils "intégrés".
Attributs d'un élément "nœud"


Name Uniquement ex‐ MPI, PROFIBUS, PROFINET
portation
Type Exporter seule‐ Ethernet ou PROFIBUS ou MPI ou ASi
ment
NetworkAddress Obligatoire
SubnetMask Optionnel PROFINET
La valeur par défaut est conservée pour l'importation quand aucune valeur n'est
déterminée.
RouterAddress Optionnel PROFINET
déterminée.
DhcpClientId Optionnel PROFINET
déterminée.
IpProtocolSelection Optionnel PROFINET
déterminée.
Valeurs : Project, Dhcp, UserProgram, OtherPath
Attributs d'un élément "voie"


Type Obligatoire TOR ou analogique
IoType Obligatoire Entrée ou sortie
Number Obligatoire
Length Exporter
seulement

Exemple : sous-réseau exporté

Structure AML
Les figures suivantes montrent la structure du fichier AML exporté.

Voir aussi

8.6.27 Exportation/importation de réseaux IO
Conditions
Structure AML
Les réseaux IO sont représentés comme <InternalElement> dans la structure AML.
Les réseaux IO d'un maître ou d'un contrôleur IO sont ajoutés sous l'élément
<CommunicationInterface> de l'élément d'appareil d'une interface.
Les réseaux IO reliés comme esclave ou comme périphérique IO sont ajoutés comme
éléments <ExternalInterface> sous l'élément <CommunicationInterface> de
l'élément d'appareil d'une interface.

Les partenaires reliés du réseau IO sont représentés comme éléments <InternalLink>.

Les variables <InternalLink> sont ajoutées sous l'élément supérieur commun d'un réseau
IO et de l'élément d'appareil esclave relié, par ex. sous Project, DeviceFolder, DeviceItem.
Le nom de variable <InternalLink> est unique dans l'élément supérieur commun.
Attributs d'un élément "Réseau IO"


Name Obligatoire Nom du réseau IO. Quand une chaîne de caractères vide est importée, le réseau IO est
créé avec le nom par défaut.
Number Optionnel En l'absence d'indication pour l'importation, c'est la valeur par défaut qui est utilisée.
Voir aussi
8.6.28 Exportation/importation de commentaires multilingues
Conditions requises

Utilisation
Commentaires d'exportation et d'importation et commentaires multilingues sur l'échange de
données CAx des objets matériels suivants :
● appareils (appareil)
● modules (éléments d'appareils)
● variables (variable)
L'importation/exportation de commentaires multilingues comprend toutes les langues de TIA
Portal.
Restrictions
● Exportation
– Un attribut "Comment" est exporté vers le fichier AML seulement s'il existe un
commentaire.
● Importation
– L'attribut ""Comment" " est facultatif.
– Pour les éléments d'appareil virtuels, aucun commentaire ne peut être importé.
Exemple : Configuration exportée avec commentaires multilingues

La figure suivante représente la configuration d'un SIMATIC S7 1500 (appareil) avec API_1
(éléments d'appareil). Des commentaires en anglais, français, allemand et chinois sont définis
pour les deux objets.
Structure AML
Après l'exportation de ces configurations, les commentaires multilingues sont générés comme
des attributs imbriqués de l'appareil, de l'élément d'appareil ou des variables.
● L'attribut de niveau supérieur "Comment" doit posséder la valeur utilisée dans la langue par
défaut.
● L'attribut qui suit existe pour chaque commentaire en langue étrangère.

Voir aussi
8.6.29 Prise en charge des attributs avec AML AR APC 1.1
8.6.29.1 Exportation/importation de variables API
Conditions
Utilisation
Les mnémoniques et les variables exportés et importés sont affectés à un élément d'appareil.
L'importation/exportation assistée par ordinateur concerne les mnémoniques et les variables
en rapport avec le matériel. Les mnémoniques et les variables sont exportés seulement avec
l'élément d'appareil de la consigne de commande, par exemple de la CPU, et non avec d'autres
éléments d'appareil auxquels ils se réfèrent, un module d'E/S par exemple. Comme les
appareils, les variables sont souvent subdivisées en tables de variables et dans une structure
hiérarchique en dossiers.

Éléments de structure AML

Les variables API, tables des variables et dossiers utilisateur de variables peuvent être
exportés et importés par la fonction importation/exportation assistée par ordinateur. Les objets
variable sont reproduits dans les éléments de structure AML suivants :
● <InternalElement>
Les tables de variables et les dossiers utilisateur de variables sont reproduits comme
éléments internes de l'API correspondant avec la classification de rôle respective.
● <ExternalInterface>
Représente une variable API appartenant à l'élément interne de la table des variables
correspondante ou au dossier utilisateur de variables.
Une voie d'affectation avec une variable API est exportée au moyen de l'élément <internal
link> en tant que partenaire de communication. La structure XML suivante donne un
exemple :
Dossier utilisateur de variables API

Les objets "TagUserFolder" requièrent seulement l'attribut "Name" dans les fichiers
d'importation et exportation assistés par ordinateur.
Attributs d'une table des variables API


Name Obligatoire, n'est
pas pris en consi‐
dération lorsque
"AssignToDefault"
" = TRUE :
AssignToDefault Importer seulement Utilisé pour identifier la table des variables standard pendant l'importation Lorsque
"AssignToDefault" = TRUE, toutes les variables sont créées dans le cadre de la
table des variables standard de TIA Portal.

Attributs d'une variable API


Name Obligatoire
DataType Obligatoire
LogicalAddress Optionnel Est importé et exporté au format abréviations internationales
IoType Optionnel Entrée ou sortie
Comment Optionnel
Remarque
TIA Portal V16 prend en charge l'exportation et l'importation de l'attribut IoType dans des
fichiers AML avec AR APC V1.1.0.
Exemple : structure AML

La figure ci-dessous montre la structure des objets variable exportés suivants :
● Table de variables standard vide
● Dossier utilisateur de variables "Groupe_1"
● Table de variables incluse "Table de variables_1"
● Quatre variables

Voir aussi
8.6.29.2 Exportation/importation de RH/API
Conditions
Application
TIA Portal vous permet d'importer les fichiers AML dans AR APC V1.1 pour API R/H dans la
même configuration d'adresses IP.
Attribut
TIA Portal ne prend en charge un attribut dans le fichier AML pour API R/H que s'il est
disponible dans l'interface utilisateur de TIA Portal :
Nom d'attribut de l'élément d'appareil Manipulation Commentaire

HNetworkAddress Obligatoire Exportation/importation si cet attribut est pris en
charge par l'API R/H de l'élément d'appareil dans TIA
Portal et n'est pas vide. Sinon, il est ignoré.
Pour l'importation, l'option "Partager l'adresse IP
système pour la connexion activée" est paramétrée
et HNetworkAddress, prise en considération.
Restriction
● Exporter
- Uniquement en cas de sélection de "Partager l'adresse IP système pour la connexion
activée" dans TIA Portal.


La configuration suivante montre un élément d'appareil pour lequel HNetworkAddress est
configuré.


La figure suivante indique la structure du fichier AML exporté pour API R/H.
<InternalElement ID="e1879cf8-8222-4ce3-b171-60c56aed7f18" Name="PROFINET interface_1">

<Value>X1</Value>
</Attribute>
<Value>32768</Value>
</Attribute>
<Value>true</Value>
</Attribute>
<InternalElement ID="a32c67c7-47dc-4362-a9c4-b41b93b58eff" Name="E1">
</Attribute>
<Value>192.168.0.1</Value>
</Attribute>
<Value>255.255.255.0</Value>
</Attribute>
</Attribute>
<Attribute Name="HNetworkAddress" AttributeDataType="xs:string">
<Value>192.168.0.3</Value>
</Attribute>
<ExternalInterface ID="802676fa-212f-4bf5-b112-de94993a0340" Name="LogicalEndPoint_Node"
RefBaseClassPath="CommunicationInterfaceClassLib/LogicalEndPoint" />
</InternalElement>
Voir aussi
8.6.29.3 Exportation/importation de AML avec des variables et éléments d'appareils personnalisés
Conditions

Application
Vous pouvez exporter et importer avec TIA Portal des fichiers AML dans AR APC V1.1 avec un
sous-attribut de type 'Customized' pour variable et DeviceItem.
Attribut
Le tableau ci-dessous montre l'attribut correspondant d'une variable disponible lors de
l'importation et l'exportation CAx de fichiers :
Nom d'attribut Manipulation Commentaire

Customized Optionnel pour exporta‐ Sous-attribut de 'DataType' d'une variable.
tion/importation Seules les valeurs TRUE et FALSE sont autorisées pour 'Cus‐
tomized'.
Pendant l'importation, l'attribut 'Customized' est sans impor‐
tance.
Pendant l'exportation, le sous-attribut 'Customized' est à
"True" pour tous les types de données qui ne sont pas confor‐
mes à CEI 61131. Les sous-attributs 'Customized' des types
de données conformes à CEI 61131 n'est pas exporté.
Le tableau ci-dessous montre l'attribut correspondant d'un élément d'appareil disponible lors
de l'importation et l'exportation CAx de fichiers :
Nom d'attribut Manipulation Commentaire

Customized Optionnel pour l'importa‐ Il s'agit d'un attribut qui suit l'attribut 'DeviceItemType' de ni‐
tion veau supérieur pour un élément d'appareil (DeviceItem).
Seules les valeurs TRUE et FALSE sont autorisées pour Cus‐
tomized.
Pendant l'importation et l'exportation, l'attribut Customized est
sans importance.

Fichier AML exporté

Le fichier AML suivant est généré lors de l'exportation d'un fichier AML avec des éléments
d'appareil avec l'attribut 'Customized'.

<CAEXFile FileName="Project26.aml" SchemaVersion="2.15"
<WriterHeader>
...
</WriterHeader>
<InternalElement ID="03ecf798-3e07-4976-b281-f8b98eb3a590" Name="Project26">
...
<InternalElement ID="c218aea9-93b8-4719-be6f-ccfa9517e2c6" Name="S71500/ET200MP station_1">
</Attribute>
<InternalElement ID="c1ae306f-183f-47b8-91e6-cb331c559278" Name="Rail_0">
...
<InternalElement ID="8d7d5ee1-603a-4897-b47e-8954d4c21a31" Name="PLC_1">
...
<Value>CPU</Value>
</Attribute>
...
...
DeviceItem" />
</InternalElement>
DeviceItem" />
</InternalElement>
Device" />
</InternalElement>
AutomationProject" />
</InternalElement>
</InstanceHierarchy>
</CAEXFile>
Voir aussi

8.6.29.4 Importation/exportation d'API de sécurité
Conditions
Établir une connexion à TIA Portal (Page 79)
Application
Vous pouvez exporter et importer avec TIA Portal un fichier AML dans AR APC V1.1 avec un
API de sécurité avec des attributs de sécurité.
Attributs
Le tableau ci-dessous montre la liste d'attributs de sécurité de fichiers AML pour l'importation
CAx et l'exportation CAx :
Attributs dans Openness Manipulation Commentaire Nom AR APC dans AML

Failsafe_FSourceAddress Obligatoire Exportation/importation unique‐ Failsafe_FSourceAddress
ment si l'élément d'appareil est
un API de sécurité et si cet at‐
tribut est pris en charge dans
TIA Portal et n'est pas vide. Si‐
non, il est ignoré.
Failsafe_LowerBoundForFDes‐ Obligatoire Exportation/importation unique‐ Failsafe_LowerBoundForFDes‐
tinationAddresses ment si l'élément d'appareil est tinationAddresses
Failsafe_UpperBoundForFDes‐ Obligatoire Exportation/importation unique‐ Failsafe_UpperBoundForFDes‐
tinationAddresses ment si l'élément d'appareil est tinationAddresses

Attributs dans Openness Manipulation Commentaire Nom AR APC dans AML

Failsafe_CentralFSourceAd‐ Optionnel Exportation/importation unique‐ Failsafe_FSourceAddress
dress ment si l'élément d'appareil est
Failsafe_FDestinationAddress Optionnel Exportation/importation unique‐ Failsafe_FDestinationAddress
ment si l'élément d'appareil est

La configuration suivante montre un élément d'appareil pour lequel les attributs sont
configurés.


Les figures suivantes montrent la structure du fichier AML exporté.

<InternalElement ID="9c944d2c-e0ae-4f39-b35a-a63faaf35be7" Name="PLC_1">

<Value>CPU 1511TF-1 PN</Value>
</Attribute>
<Value>CPU</Value>
</Attribute>
<Value>1</Value>
</Attribute>
</Attribute>
<Value>OrderNumber:6ES7 511-1UK01-0AB0</Value>
</Attribute>
<Attribute Name="InstallationDate" AttributeDataType="xs:dateTime">
<Value>2019-02-28T08:12:12.987Z</Value>
</Attribute>
<Attribute Name="Failsafe_FSourceAddress" AttributeDataType="xs:string">
<Value>1</Value>
</Attribute>
<Attribute Name="Failsafe_LowerBoundForFDestinationAddresses"
AttributeDataType="xs:string">
<Value>1</Value>
</Attribute>
<Attribute Name="Failsafe_UpperBoundForFDestinationAddresses"
AttributeDataType="xs:string">
<Value>99</Value>
</Attribute>
<Value>V2.8</Value>
</Attribute>
<InternalElement ID="4f718e93-b541-4983-8f13-1f5b21c3e70c" Name="Default tag table">
TagTable"/>
</InternalElement>
<InternalElement ID="20e19f5b-8ace-4e0c-af0b-c710ae4817da" Name="CPU display_1">
<Value>3</Value>
</Attribute>
<Value>true</Value>
</Attribute>
DeviceItem" />
</InternalElement>
<InternalElement ID="5a24516f-17d6-4b2a-a4ac-efc1b577875d" Name="Card reader/writer_1">
<Value>4</Value>
</Attribute>
<Value>true</Value>
</Attribute>

DeviceItem" />
</InternalElement> <InternalElement ID="0f746d71-035e-4e64-b0d7-51d0449cfd88" Name="OPC
UA_1">
<Value>254</Value>
</Attribute>
<Value>true</Value> </Attribute>
DeviceItem" />
</InternalElement>
<InternalElement ID="a0633104-a2ac-4680-bb99-81df50f5ec40" Name="PROFINET interface_1">
<Value>X1</Value>
</Attribute>
</Attribute>
<Value>true</Value>
</Attribute>
<InternalElement ID="e3497176-dbba-4fec-9d3a-772ae13987c4" Name="E1">
<Value>Ethernet</Value> </Attribute>
<Value>192.168.0.1</Value>
</Attribute>
<Value>255.255.255.0</Value>
</Attribute>
</Attribute>
</InternalElement>
<InternalElement ID="3208384f-d5ba-4ccb-b8da-f08ec38ec681" Name="Port_1">
<Value>P1 R</Value>
</Attribute>
</Attribute>
<Value>true</Value>
</Attribute>
</InternalElement>
<InternalElement ID="4a47c05e-9656-4e02-9b51-23b065b6fe47" Name="Port_2">
<Value>P2 R</Value>
</Attribute>
</Attribute>


<Value>true</Value>
</Attribute>
</InternalElement>
</InternalElement>
DeviceItem" />
</InternalElement>
<InternalElement ID="e3fdb611-4b68-4682-b154-ae43c74a24d3" Name="F-DI 16x24V DC_1">
<Value>F-DI 16x24V DC</Value>
</Attribute>
<Value>2</Value>
</Attribute>
<Value>false</Value> </Attribute>
<Value>OrderNumber:6ES7 526-1BH00-0AB0</Value>
</Attribute>
<Value>V1.0</Value>
</Attribute>
<InternalElement ID="77c4fea0-baba-44e6-80f2-72b7b830a88a" Name="F-DI 16x24V DC_1">
<Value>1</Value>
</Attribute> <Attribute Name="BuiltIn" AttributeDataType="xs:boolean">
<Value>true</Value>
</Attribute>
<Attribute Name="Failsafe_FSourceAddress" AttributeDataType="xs:string">
<Value>1</Value>
</Attribute>
<Attribute Name="Failsafe_FDestinationAddress" AttributeDataType="xs:string">
<Value>655</Value>
</Attribute>
</InternalElement>
</InternalElement>
Voir aussi

8.6.29.5 Importation/exportation d'E/S de sécurité
Conditions
Application
Vous pouvez exporter et importer avec TIA Portal un fichier AML dans AR APC V1.1 avec une
entrée/sortie de sécurité avec des attributs de sécurité.
Attributs
Le tableau suivant montre les attributs correspondants qui sont disponibles dans les modules/
sous-modules d'E/S pour les fichiers d'importation CAx et les fichiers d'exportation CAx :
Nom d'attribut de l'élément d'appareil Manipulation Commentaire

FSourceAddress Obligatoire Exportation/importation uniquement si l'élément
d'appareil est une entrée/sortie de sécurité et s'il est
pris en charge dans TIA Portal.
FDestinationAddresses Obligatoire Exportation/importation uniquement si l'élément
d'appareil est une entrée/sortie de sécurité et s'il est
pris en charge dans TIA Portal.
Remarque
● FSourceAddress est protégée en écriture pour la plupart des E/S de sécurité – ne permet
donc pas l'écriture et constitue une réflexion de l'attribut FCentralFSourceAddress de l'API
de sécurité. La même valeur est exportée et ignorée lors de l'importation.
● Si FSourceAddress et FDestinationAddress sont protégées en écriture, la valeur est
exportée. Toutefois, un message d'avertissement doit être affiché pendant l'importation
dans l'onglet Info de TIA Portal.
● FSourceAddress et FDestinationAddress doivent être pris en charge au niveau du module
d'E/S et du sous-module d'E/S.


La configuration suivante montre un élément d'appareil pour lequel les attributs sont configurés.

La figure suivante indique la structure du fichier AML exporté.
<Attribute Name="FSourceAddress" AttributeDataType="xs:string">

<Value>1</Value>
</Attribute>
<Attribute Name="FDestinationAddress" AttributeDataType="xs:string">
</Attribute>
Voir aussi
8.6.29.6 Exporter/importer un attribut spécifique au fabricant
Conditions

Application
Vous pouvez exporter et importer avec TIA Portal un fichier AML pour les appareils et éléments
d'appareils avec l'attribut "Manufacturer", afin de remplacer des informations spécifiques au
fabricant dans différents scénarios Round Trip.
L'attribut "Manufacturer" n'est pas pris en charge par Openness. Il est repris lors de
l'exportation/importation par "Transformation Plugin".
Remarque
Les fichiers AML doivent être générés/exportés de TIA Portal V16 dans AR APC V1.1.
Exporter
Vous pouvez exporter l'attribut "Manufacturer" dans un fichier AML, à condition qu'il soit
présent dans l'AmiModel qui est rempli par les utilisateurs de "Transformation Plugin".
Importer
Vous pouvez importer dans TIA Portal l'attribut "Manufacturer" contenant l'attribut spécifique
au fabricant disponible dans l'AmiModel qui est repris par les utilisateurs de "Transformation
Plugin".
Pour l'instant, cet attribut n'est pris en charge que pour des appareils et éléments d'appareils
du type "Entraînement", car ceux-ci sont les seuls à posséder le "Transformation Plugin" officiel
écrit pour CAx.
Voir aussi
8.6.30 Attributs AML comparés aux attributs TIA Portal Openness
Accéder aux attributs et aux attributs d'exportation/importation

Avec TIA Portal Openness, vous pouvez accéder aux attributs matériels d'objets matériels.
Quelques noms que vous utilisez pour accéder à ces attributs, par ex. celui d'un élément
d'appareil, diffèrent des noms d'attribut dans le fichier AML d'exportation/importation.

Liste des attributs

Le tableau ci-dessous donne une vue d'ensemble des deux types d'attributs :
Tableau 8-6 Noms d'attribut des appareils et des appareils GSD/GSDML
Fichier AML TIA Portal Openness

Name Name
TypeIdentifier TypeIdentifier
Comment Comment
Tableau 8-7 Noms d'attribut des éléments d'appareil

Name Name
TypeIdentifier Affecté au sous-string de <TypeIdentifier>
(c.-à-d. valeur devant premier opérateur "/"), l'élé‐
ment avec la version de firmware n'étant pas pris
en considération.
L'affectation du sous-string est valable seulement
quand l'identifiant de type commence par le préfixe
<OrderNumber:> et comporte un élément avec
la version de firmware, autrement l'affectation s'ef‐
fectue comme complément de
<TypeIdentifier>.
FirmwareVersion <FirmwareVersion> est affecté au sous-string
de <TypeIdentifier> (c.-à-d. valeur derrière
premier opérateur "/"). L'affectation du sous-string
est valable seulement quand
<TypeIdentifier> commence par le
préfixe <OrderNumber:> et comporte un élé‐
ment avec la version de firmware.
TypeName TypeName
DeviceItemType (pour CPU et module de tête) Classification
PositionNumber PositionNumber
BuiltIn IsBuiltIn
PlantDesignation IEC PlantDesignation
LocationIndentifier IEC LocationIdentifier
Comment Comment
Tableau 8-8 Noms d'attribut des éléments d'appareil GSD/GSDML

Name Name
TypeName TypeName
DeviceItemType (pour module de tête) Classification


BuiltIn IsBuiltIn
Comment Comment
Label Label
Tableau 8-9 Noms d'attribut des variables

Name Name
DataType DataTypeName
LogicalAddress LogicalAddress
Comment Comment
Tableau 8-10 Noms d'attribut des tables de variables

Name Name
AssignToDefault IsDefault
Tableau 8-11 Noms d'attribut des adresses

StartAddress StartAddress
Length Length
IoType IoType
Tableau 8-12 Noms d'attribut des ports

Name Name
FirmwareVersion FirmwareVersion
TypeName TypeName
BuiltIn IsBuiltIn
Comment Comment
Label Label

Tableau 8-13 Noms d'attribut des appareils à interface IO

Name Name
FirmwareVersion FirmwareVersion
TypeName TypeName
DeviceItemType (pour CPU et module de tête) Classification
BuiltIn IsBuiltIn
Label Label
Comment Comment
Tableau 8-14 Noms d'attribut des voies

Type Type
IoType IoType
Number Affecté à aucun attribut dans TIA Portal Open‐
ness.
Length ChannelWidth

Principales modifications 9
9.1 Modifications majeures dans TIA Portal Openness V15.1
Modifications
versions et n'avez pas mis à jour votre projet à la version V15.1, vos applications fonctionnent
sans aucune restriction sur tout ordinateur, même si seul TIA Portal V15.1 est installé.
Si vous mettez à jour votre projet à la version V15.1, il est nécessaire de recompiler votre
application avec le fichier SiemensEngineering.dll de version V15.1. Dans certains cas, il peut
être nécessaire d'adapter le code de votre application.
Identifiant de type
L'identifiant de type pour les châssis et les appareils de type "PC avec ports" et "Appareil
Ethernet" a été modifié.
PC avec ports Identifiant de type avant V15.1 Identifiant de type à partir de V15.1
Appareil (device) System:DesktopPC.Device System:Device.DesktopPC
Châssis (rack) System:DesktopPC.Rack System:Rack.DesktopPC
Élément d'appareil System:DesktopPC.Port<X> System:DeviceItem.EthernetDevi‐
<X> denotes the number of ports ce.Port<X>
<X> denotes the number of ports
Appareils Ethernet avec ports

Appareil (device) System:DummyPC.Device System:Device.EthernetDevice
Châssis (rack) System:Rack.DummyPC System:Rack.EthernetDevice
Élément d'appareil System:DummyPC.Port<X>
<X> denotes the number of ports
Défaillances en cas de tentative de connexion à TIA Portal

Si la tentative d'établissement d'une connexion à TIA Portal provoque une défaillance, le
message qui s'affiche ensuite est alors plus spécifique.

Principales modifications
9.1 Modifications majeures dans TIA Portal Openness V15.1
Fonctionnement sur tout le thread

L'accès aux objets Openness n'est pas à thread sécurisé.
Si vous utilisez multithreading pour améliorer la performance de votre application Openness,
alors la création de l'instance de TIA Portal via MTA est recommandée.
Lorsque TIA Portal est créé ou ajouté à l'intérieur d'un thread STA, alors l'accès à tous les
objets Openness en rapport avec cette instance de TIA Portal doit s'effectuer à partir du même
thread STA ; Sinon une exception sera déclenchée.
Les sous-modules n'ont pas les attributs Author et TypeName

Les attributs Author et TypeName ont été supprimés des sous-modules qui ne peuvent pas être
enfichés.
Ouverture d'une bibliothèque globale

À partir de TIA Portal Openness V15.1, il est possible d'ouvrir une bibliothèque globale via
Openness, indépendamment du mode d'aperçu existant de la bibliothèque.
Code en cas d'annulation de l'application

La génération d'un code en cas d'annulation de l'application a les effets suivants :
● Jusqu'à TIA Portal Openness V15, vous recevez une erreur exceptionnelle irréparable.
● À partir de TIA Portal Openness V15.1, vous recevez une EngineeringRuntimeException ou
une EngineeringTargetInvocationException si le code d'erreur est connu ou une erreur
exceptionnelle irréparable si le code d'erreur est inconnu.
Extension des schémas pour des paramètres sans nom

Les blocs SCL peuvent être importés, même si ENO est utilisé pour un appel non formel.
En-tête de paramètres indexés

À partir de TIA Portal Openness V15.1, l'en-tête de paramètres indexés ne peut pas être
modifié via Openness.
Certains paramètres d'entraînement sont structurés en paramètres indexés, car ils fournissent
plusieurs unités de données sur un sujet. La structuration des paramètres d'entraînement
indexés dans Openness suit la définition spécifique à l'entraînement des paramètres, telle que
définie dans la table des paramètres.
Les paramètres indexés sont structurés comme suit :
Élément d'en-tête : le paramètre d'entraînement sans indice. L'élément d'en-tête contient un
texte descriptif qui vous informe sur la sémantique du paramètre indexé référencé. C'est
pourquoi l'élément d'en-tête est protégé en écriture, car il ne contient pas de valeur réelle.
Éléments indexés : les éléments indexés du paramètre d'entraînement sous l'élément d'en-
tête. Ils fournissent un texte descriptif qui définit la sémantique de l'élément indexé (protégé en
écriture). De plus, vous indiquez aussi la valeur qui peut être appelée via l'API Openness. Si le
paramètre indexé permet l'écriture, la valeur peut aussi être définie via l'API Openness.

Attribut TransmissionRateAndDuplex
Certaines valeurs d'énumération pour l'attribut TransmissionRateAndDuplex ont été corrigées,
p. ex., la valeur d'énumération "POFPCF100MbpsFullDuplexLD" a été supprimée et
"POFPCF100MbpsFullDuplex" a été ajoutée. Vous trouverez des informations détaillées
sous Attributs configurables d'une liaison port à port (Page 138).
Attribut AutoNumber pour les blocs avec protection know-how

A partir de la version V15.1, l'attribut AutoNumber ne peut pas être modifié via TIA Portal
Openness lorsqu'un bloc est doté d'une protection know-how.
Nombre de voies référencées par l'interface ChannelInfo

Jusqu'à TIA Portal Openness V15, l'interface ChannelInfo n'affiche pas correctement le
nombre de voies disponibles pour certains modules.
Accès à des attributs d'un bloc fonctionnel ProDiag

Il est possible d'accéder aux attributs suivants d'un bloc fonctionnel ProDiag via TIA Portal
Openness :
● Version
● Acquisition de valeurs initiales
● Utilisation d'horodatages centraux
Importation/exportation de blocs F
L'importation de blocs F de versions antérieures n'est pas possible.
L'exportation de blocs F générés par le système est empêchée à partir de TIA Portal
Openness V15.1.
Systèmes R/H
Le téléchargement et l'accès pour des appareils R/H sont disponibles sur l'appareil.
Les fournisseurs en ligne et de téléchargement ne sont pas disponibles pour les PLC R/H
(DeviceItems).
Le SoftwareContainer n'est pas disponible pour le PLC2 d'un système R/H
Modifications
versions et n'avez pas mis à jour votre projet à la version V15, vos applications fonctionnent
sans aucune restriction sur tout ordinateur, même si seul TIA Portal V15 est installé.

Si vous mettez à jour votre projet à la version V15, il est nécessaire de recompiler votre
application avec la SiemensEngineering.dll de version V15.
Dans certains cas, il est nécessaire d'adapter le code de votre application.
● Modifications du comportement pour les compositions dans DeviceItemComposition
● BitOffset d'adresses Asi
● Classe Exception
● Dossiers système de types de données utilisateur système
● Les sous-modules n'ont pas les attributs Author et TypeName
● Horodatage de la dernière modification
● Fichier XML d'exportation pour blocs GRAPH
● Importer des tables des variables
● Modifier les attributs pertinents non relatifs à la sécurité d'un API
● Modifier les paramètres de sécurité en cas de réglage d'un mot de passe de sécurité
● Accès à des objets dans une CPU S7-1200
Modifications du comportement pour les compositions dans DeviceItemComposition

Les compositions suivantes dans DeviceItemCompositon ont été modifiées afin d'atteindre un
comportement dynamique : la composition est maintenant mise à jour lorsqu'un élément est
ajouté ou supprimé via l'interface utilisateur de TIA Portal.
● IoSystem – ConnectedIoDevices
● Subnet – IoSystems
● Subnet – Nodes
● NetworkInterface – Nodes
● NetworkInterface – Ports
● NetworkPort – ConnectedPorts
● SubnetOwner – Subnets
BitOffset d'adresses Asi

Si un module a une adresse d'entrée et une adresse de sortie pour les deux objets d'adresse,
l'attribut BitOffset correct est fourni.
Si un module est doté de voies, l'attribut BitOffset n'est pas fourni pour la voie.
Classe Exception
ServiceID et MessageID ont été supprimés de la classe exception.

Les sous-modules n'ont pas les attributs Author et TypeName

Les attributs Author et TypeName ont été supprimés des sous-modules qui ne peuvent pas être
enfichés.
Dossiers système de types de données utilisateur système

Pour les dossiers système de types de données utilisateur, le dossier correspondant et la
composition correspondante sont mis à disposition. Cela conduit également à une modification
dans la hiérarchie de résultats de comparaison.
Horodatage de la dernière modification

Si un objet est modifié pendant la mise à niveau d'un objet, l'horodatage de la dernière
modification est également modifié.
Fichier XML d'exportation pour blocs GRAPH

Le fichier XML d'exportation pour des blocs GRAPH contient une action vide supplémentaire :
<Actions />.
Importer des tables des variables

Le réglage des attributs de variable ne dépend plus du type de données.
Modifier les attributs pertinents non relatifs à la sécurité d'un API

Tous les attributs pertinents non relatifs à la sécurité d'un API peuvent être modifiés via TIA
Portal Openness, même si un mot de passe de sécurité est paramétré.
Modifier les paramètres de sécurité en cas de réglage d'un mot de passe de sécurité
Les paramètres de sécurité d'E/S de sécurité ne peuvent être modifiés que si le mot de passe
de sécurité n'est pas paramétré.
Accès à des objets dans une CPU S7-1200

L'accès aux variables de tableau pour les objets technologiques TO_PositioningAxis et
TO_CommandTable a été modifié. Vous trouverez des informations à ce sujet au chapitre
concernant S7-1200 Motion Control.

9.3 Modifications importantes dans V14 SP1
9.3.1 Modifications importantes dans V14 SP1
Introduction
Les modifications suivantes ont été apportées au modèle d'objet TIA Portal Openness API V14
SP1, ce qui peut avoir des effets sur vos applications existantes :
Modification Adaptation nécessaire du code de programme

Maniement amélioré des copies maîtres L'action CreateFrom crée un nouvel objet sur la base d'une copie maître
dans une bibliothèque et le place dans la composition là où l'action a été
appelée. L'action CreateFrom ne prend en charge que les copies maîtres qui
contiennent exclusivement des objets isolés. Le type fourni correspond au
type composé respectif.
Les compositions suivantes prennent en charge CreateFrom :
● Siemens.Engineering.HW.DeviceComposition
● Siemens.Engineering.HW.DeviceItemComposition
● Siemens.Engineering.SW.Blocks.PlcBlockComposition
● Siemens.Engineering.SW.Tags.PlcTagTableComposition
● Siemens.Engineering.SW.Tags.PlcTagComposition
● Siemens.Engineering.SW.Types.PlcTypeComposition
● Siemens.Engineering.SW.TechnologicalObjects.TechnologicalInstan‐
ceDBComposition
● Siemens.Engineering.SW.Tags.PlcUserConstantComposition
● Siemens.Engineering.Hmi.Tag.TagTableComposition
● Siemens.Engineering.Hmi.Tag.TagComposition
● Siemens.Engineering.Hmi.Screen.ScreenComposition
● Siemens.Engineering.Hmi.Screen.ScreenTemplateComposition
● Siemens.Engineering.Hmi.RuntimeScripting.VBScriptComposition
● Siemens.Engineering.HW.SubnetComposition
● Siemens.Engineering.HW.DeviceUserGroupComposition
● Siemens.Engineering.SW.Blocks.PlcBlockUserGroupComposition
● Siemens.Engineering.SW.ExternalSources.PlcExternalSourceUser‐
GroupComposition
● Siemens.Engineering.SW.Tags.PlcTagTableUserGroupComposition
● Siemens.Engineering.SW.Types.PlcTypeUserGroupComposition
Maniement amélioré des bibliothèques globa‐ À présent, les actions existantes avec des bibliothèques globales peuvent
les englober des actions de modification, par ex. supprimer une copie maître
d'une bibliothèque globale.
UpdateProject et UpdateLibrary n'utilisent plus les paramètres Update‐
PathsMode et DeleteUnusedVersionsMode. Les versions non utilisées ne
sont pas effacées après une mise à jour.


Modification de System.String dans Sys‐ Tous les événements pour lesquels il faut spécifier un chemin en chaîne de
tem.IO.FileInfo caractères utilisent le chemin FileInfo ou le chemin DirectoryInfo. Exemple :
Modification de System.String dans Sys‐ ● Ouvrir un projet
tem.IO.DirectoryInfo ● Ouvrir une bibliothèque
● Créer un projet
● Créer une bibliothèque globale
● ...
Nouveaux éléments dans le modèle d'objet
Nom Type Espace nom Commentaire

PlcUserConstant Classe Siemens.Engineer‐ Parties de PlcConstant
ing.SW.Tags
PlcUserConstantComposition Classe Siemens.Engineer‐ Parties de PlcConstantComposition
ing.SW.Tags
PlcSystemConstant Classe Siemens.Engineer‐ Parties de PlcConstant
ing.SW.Tags
PlcSystemConstantComposition Classe Siemens.Engineer‐ Parties de PlcConstantComposition
ing.SW.Tags
MultilingualTextItem Classe Siemens.Engineering Accéder aux textes multilingues
MultilingualTextItemComposition Classe Siemens.Engineering Accéder aux textes multilingues
TiaPortalTrustAuthority.Feature‐ Valeur d'énu‐ Siemens.Engineering Accéder aux paramètres de TIA Portal
Tokens mération
TiaPortalSetting Classe Siemens.Engineering.Set‐ Accéder aux paramètres de TIA Portal
tings
TiaPortalSettingComposition Classe Siemens.Engineering.Set‐ Accéder aux paramètres de TIA Portal
tings
TiaPortalSettingsFolder Classe Siemens.Engineering.Set‐ Accéder aux paramètres de TIA Portal
tings
TiaPortalSettingsFolderComposi‐ Classe Siemens.Engineering.Set‐ Accéder aux paramètres de TIA Portal
tion tings
LanguageAssociation Classe Siemens.Engineering Accéder aux langues actives
LanguageComposition.Find Méthode Siemens.Engineering Accéder aux langues actives
Éléments modifiés dans le modèle d'objet

PlcConstant Classe Siemens.Engineer‐ Classe de base sortie de PlcUserConstant
ing.SW.Tags et de PlcSystemConstant
PlcTag Classe Siemens.Engineer‐ Parties de PlcConstantComposition
ing.SW.Tags
ITargetComparable Interface Siemens.Engineering.Com‐ Attribut string DataTypeName à la place
pare d'un lien ouvert DataType
MultilingualText Classe Siemens.Engineering Accéder aux textes multilingues


ProjectComposition.Create Méthode Siemens.Engineering Paramètre modifié pour utiliser Directo‐
ryInfo et un string
Project.Subnets Attribut Siemens.Engineering Accéder aux sous-réseaux
Project.Languages Attribut Siemens.Engineering Déplacé pour représenter l'attribut de Sie‐
mens.Engineering.LanguageSettings et
mettre à disposition les langues prises en
charge
Éléments supprimés dans le modèle d'objet

PlcConstantComposition Classe Siemens.Engineer‐ Parties dans PlcSystemConstant‐
ing.SW.Tags Composition et PlcUserConstant‐
Composition
CompareResultElement.PathInformation Attribut Siemens.Engineer‐ N'est plus utilisé
ing.SW.Tags
MultilingualText.GetText(CultureInfo cul‐ Méthode Siemens.Engineer‐ Concept modifié pour l'accès aux
tureInfo) ing.Compare éléments de texte de Multilingual‐
Text
TiaPortalTrustAuthority.CustomerIdenti‐ Valeur d'énu‐ Siemens.Engineering N'est plus utilisé
fication mération
TiaPortalTrustAuthority.ElevatedAcces‐ Valeur d'énu‐ Siemens.Engineering N'est plus utilisé
sExtensions mération
Modifications du comportement

PlcTag.Export(FileInfo path, ExportOp‐ Méthode Siemens.Engineer‐ À présent, la valeur de l'attribut Logi‐
tions options) ing.SW.Tags calAddress est toujours exportée en
abréviations internationales. Les
abréviations allemandes sont enco‐
re acceptées pour l'importation.
PlcTag.LogicalAddress Attribut Siemens.Engineer‐ À présent, la valeur de l'attribut Logi‐
ing.SW.Tags calAddress est toujours retournée
en abréviations internationales. Les
abréviations allemandes sont enco‐
re acceptées pour l'écriture.

9.3.2 Principales modifications dans le modèle d'objet
Modèle d'objet de TIA Portal Openness V14

Pour permettre une comparaison entre l'ancien et le nouveau modèle d'objet TIA Portal
Openness, le diagramme ci-dessous décrit le modèle d'objet de TIA Portal V14.
Remarque
Le modèle objet décrit dans le diagramme est déconseillé. Vous trouverez des informations sur
le modèle d'objet de TIA Portal Openness V14 SP1 sous AUTOHOTSPOT
'HYLFHVQ
8QJURXSHG'HYLFHV*URXS 'HYLFH6\VWHP*URXS 'HYLFH,WHPV
'HYLFH*URXS
'HYLFHVQ 'HYLFH 'HYLFH,WHPVQ 'HYLFH,WHP
$EVWUDFW!!
'HYLFH*URXSVQ 'HYLFH8VHU*URXS ,6RIWZDUH&RQWDLQHU

6HUYLFH!!
*UDSKLFVQ 0XOWL/LQJXDO*UDSKLF

6RIWZDUH&RQWDLQHU
7,$3RUWDO 3URMHFWVQ 3URMHFW +Z([WHQVLRQVQ ,([WHQVLRQ

6RIWZDUH
+LVWRU\(QWULHVQ +LVWRU\(QWU\ 6RIWZDUH%DVH

*OREDO/LEUDULHVQ $EVWUDFW!!
/DQJXDJHVQ /DQJXDJH
3URMHFW/LEUDU\

8VHG3URGXFWVQ 8VHG3URGXFW 3OF6RIWZDUH +PL7DUJHW

*OREDO/LEUDU\ 3URMHFW/LEUDU\
Le schéma suivant illustre les objets disponibles sous ProjectLibrary.

3URMHFW/LEUDU\
Le schéma suivant illustre les objets disponibles sous HmiTarget.

&RQQHFWLRQVQ &RQQHFWLRQ
&\FOHVQ &\FOH
*UDSKLF/LVWVQ *UDSKLF/LVW
6FUHHQ)ROGHU )ROGHUVQ 6FUHHQ8VHU)ROGHU

6FUHHQ)ROGHU 6FUHHQ6\VWHP)ROGHU
$EVWUDFW!! 6FUHHQVQ 6FUHHQ
6FUHHQ*OREDO(OHPHQWV 6FUHHQ*OREDO(OHPHQWV
+PL7DUJHW
6FUHHQ2YHUYLHZ 6FUHHQ2YHUYLHZ
6FUHHQ7HPSODWH)ROGHU )ROGHUVQ 6FUHHQ7HPSODWH8VHU)ROGHU
$EVWUDFW!! 6FUHHQ7HPSODWHVQ 6FUHHQ7HPSODWH
6FUHHQ7HPSODWH)ROGHU 6FUHHQ7HPSODWH6\VWHP)ROGHU
7DJ)ROGHU )ROGHUVQ 7DJ8VHU)ROGHU

$EVWUDFW!! 7DJ7DEOHVQ
7DJ)ROGHU 7DJ6\VWHP)ROGHU 7DJ7DEOH 7DJVQ 7DJ
'HIDXOW7DJ7DEOH
7H[W/LVWVQ 7H[W/LVW
9%6FULSW)ROGHU )ROGHUVQ 9%6FULSW8VHU)ROGHU

9%6FULSW)ROGHU 9%6FULSW6\VWHP)ROGHU
$EVWUDFW!! 9%6FULSWVQ 9%6FULSW
Le schéma suivant illustre les objets disponibles sous PlcSoftware.


)%
%ORFNVQ &RGH%ORFN

)&
$EVWUDFW!!
2%
,QVWDQFH'%

*OREDO'%
$EVWUDFW!!
$UUD\'%

3OF([WHUQDO6RXUFH
$EVWUDFW!! *URXSVQ
3OF6RIWZDUH

3OF6WUXFW
7DJ7DEOH*URXS 3OF7DJ7DEOH6\VWHP*URXS 3OF7DJ7DEOH8VHU*URXS 3OF7DJ
7DJVQ
3OF7DJ7DEOH*URXS *URXSVQ
&RQVWDQWVQ
3OF&RQVWDQW
7HFKQRORJLFDO,QVWDQFH'
'DWD%ORFN

Relation entre TIA Portal et le modèle d'objet TIA Portal Openness

La figure suivante présente la relation entre le modèle d'objet et un projet dans TIA Portal :
Project DeviceItem
PlcSoftware
HmiTarget
① L'objet "Project" correspond à un projet ouvert dans TIA Portal.

② L'objet "PlcSoftware" est de type "SoftwareBase"④ et correspond à un API. Le contenu de l'objet correspond à un
API dans la navigation du projet, avec accès à des objets tels que des blocs ou des variables API.
③ L'objet "HmiTarget" est de type "SoftwareBase"④ et correspond à un pupitre opérateur. Le contenu de l'objet
correspond à un appareil IHM dans la navigation du projet, avec accès à des objets tels que des vues ou des
variables IHM.
④ L'objet "DeviceItem" correspond à un objet dans l'éditeur "Appareils & réseaux". Un objet du type "DeviceItem" peut
être aussi bien un châssis qu'un module enfiché.

9.3.3 Modifications apportées à la fonction du pilote
Introduction
Les modifications suivantes ont été apportées au modèle d'objet API V14 SP1 et sont
pertinentes uniquement pour les utilisateurs qui ont utilisé la fonction pilote de HW Config dans
V14 :
Modifications apportées aux types de TIA Portal Openness API
Type de TIA Portal Openness API Nouveau type de TIA Portal Openness API
Siemens.Engineering.HW.IAddress Siemens.Engineering.HW.Address
Siemens.Engineering.HW.IAddressController Siemens.Engineering.HW.Features.AddressController
Siemens.Engineering.HW.IChannel Siemens.Engineering.HW.Channel
Siemens.Engineering.HW.IDevice Siemens.Engineering.HW.Device
Siemens.Engineering.HW.IDeviceItem Siemens.Engineering.HW.DeviceItem
Siemens.Engineering.HW.IExtension Siemens.Engineering.HW.Extensions
Siemens.Engineering.HW.IGsd Siemens.Engineering.HW.Features.GsdObject
Siemens.Engineering.HW.IGsdDevice Siemens.Engineering.HW.Features.GsdDevice
Siemens.Engineering.HW.IGsdDeviceItem Siemens.Engineering.HW.Features.GsdDeviceItem
Siemens.Engineering.HW.IHardwareObject Siemens.Engineering.HW.HardwareObject
Siemens.Engineering.HW.IHwIdentifier Siemens.Engineering.HW.HwIdentifier
Siemens.Engineering.HW.IHwIdentifierController Siemens.Engineering.HW.Features.HwIdentifierController
Siemens.Engineering.HW.IIoConnector Siemens.Engineering.HW.IoConnector
Siemens.Engineering.HW.IIoController Siemens.Engineering.HW.IoController
Siemens.Engineering.HW.IIoSystem Siemens.Engineering.HW.IoSystem
Siemens.Engineering.HW.IInterface Siemens.Engineering.HW.Features.NetworkInterface
Siemens.Engineering.HW.Extensions.ModuleInformation‐ Siemens.Engineering.HW.Utilities.ModuleInformationProvi‐
Provider der
Siemens.Engineering.HW.INode Siemens.Engineering.HW.Node
Siemens.Engineering.HW.OPCUAExportProvider Siemens.Engineering.HW.Utilities.OpcUaExportProvider
Siemens.Engineering.HW.IPort Siemens.Engineering.HW.Features.NetworkPort
Siemens.Engineering.HW.IRole Siemens.Engineering.HW.Features.HardwareFeature
Siemens.Engineering.HW.Features.DeviceFeature
Siemens.Engineering.HW.Utilities.ModuleInformationProvi‐
der
Siemens.Engineering.HW.SoftwareBase Siemens.Engineering.HW.Software
Siemens.Engineering.HW.ISubnet Siemens.Engineering.HW.Subnet
Siemens.Engineering.HW.ISoftwareContainer Siemens.Engineering.HW.Features.SoftwareContainer
Siemens.Engineering.HW.ISubnetOwner Siemens.Engineering.HW.Features.SubnetOwner

Modifications des Enums
Type de TIA Portal Openness API Type Nouveau type de TIA Portal Openness API Type
de don‐ de don‐
nées nées
Siemens.Engineering.HW.Enums.AddressContext Siemens.Engineering.HW.AddressContext
Siemens.Engineering.HW.Enums.AddressIoType Siemens.Engineering.HW.AddressIoType
Siemens.Engineering.HW.Enums.AttachmentTy‐ Siemens.Engineering.HW.MediumAttachmentTy‐
pe pe
Siemens.Engineering.HW.Enums.BaudRate Siemens.Engineering.HW.BaudRate
Siemens.Engineering.HW.Enums.BusLoad Siemens.Engineering.HW.CommunicationLoad
Siemens.Engineering.HW.Enums.BusProfile Siemens.Engineering.HW.BusProfile
Siemens.Engineering.HW.Enums.CableLength Siemens.Engineering.HW.CableLength
Siemens.Engineering.HW.Enums.CableName ULong Siemens.Engineering.HW.CableName Long
Siemens.Engineering.HW.Enums.ChannelIoType Byte Siemens.Engineering.HW.ChannelIoType Int
Siemens.Engineering.HW.Enums.ChannelType Byte Siemens.Engineering.HW.ChannelType Int
Siemens.Engineering.HW.Enums.DeviceItem‐ Siemens.Engineering.HW.DeviceItemClassifica‐
Classifications tions
Siemens.Engineering.HW.Enums.InterfaceOpera‐ Siemens.Engineering.HW.InterfaceOperatingMo‐
tingModes des
Siemens.Engineering.HW.Enums.IpProtocolSe‐ Siemens.Engineering.HW.IpProtocolSelection
lection
Siemens.Engineering.HW.Enums.MediaRedun‐ Siemens.Engineering.HW.MediaRedundancyRole
dancyRole
Siemens.Engineering.HW.Enums.NetType Siemens.Engineering.HW.NetType
Siemens.Engineering.HW.Enums.ProfinetUpdate‐ distant
TimeMode
Siemens.Engineering.HW.Enums.RtClass Byte Siemens.Engineering.HW.RtClass Int
Siemens.Engineering.HW.Enums.SignalDelaySe‐ Byte Siemens.Engineering.HW.SignalDelaySelection Int
lection
Siemens.Engineering.HW.Enums.SyncRole Byte Siemens.Engineering.HW.SyncRole Int
Siemens.Engineering.HW.Enums.Transmission‐ Uint Siemens.Engineering.HW.TransmissionRateAnd‐ Int
RateAndDuplex Duplex
Modifications des valeurs d'attributs de Siemens.Engineering.HW.IoConnector
Attribut Type de données Nouveau nom Type de données

ProfinetUpdateTimeMode ProfinetUpdateTimeMo‐ PnUpdateTimeAutoCalculation Bool
de
ProfinetUpdateTime PnUpdateTime
AdaptUpdateTime PnUpdateTimeAdaption
WatchdogFactor PNWatchdogFactor
DeviceNumber String

Modifications des valeurs d'attributs de Siemens.Engineering.HW.IoController

DeviceNumber String
Modifications des valeurs d'attributs de Siemens.Engineering.HW.Node

HighestAddress distant, disponible sur le sous-réseau uniquement
TransmissionSpeed distant, disponible sur le sous-réseau uniquement
IsoProtocolUsed UseIsoProtocol
IpProtocolUsed UseIpProtocol
RouterAddressUsed UseRouter
PnDeviceNameAutoGenera‐ PnDeviceNameAutoGeneration
ted
DeviceNumber distant, déplacer sur IO-Connector / IO-Controller
Modifications des valeurs d'attributs de Siemens.Engineering.HW.Subnet

HighestAddress Byte HighestAddress Int
CableConfiguration PbCableConfiguration
RepeaterCount PbRepeaterCount
CopperCableLength PbCopperCableLength
OpticalComponentCount PbOpticalComponentCount
OpticalCableLength PbOpticalCableLength
OpticalRingEnabled PbOpticalRing
OlmP12 PbOlmP12
OlmG12 PbOlmP12
OlmG12Eec PbOlmG12Eec
OlmG121300 PbOlmG121300
AdditionalNetworkDevices PbAdditionalNetworkDevices
AdditionalDpMaster Byte PbAdditionalDpMaster Int
TotalDpMaster Byte PbTotalDpMaster Int
AdditionalPassiveDevice Byte PbAdditionalPassiveDevice Int
TotalPassiveDevice Byte PbTotalPassiveDevice Int
AdditionalActiveDevice Byte PbAdditionalActiveDevice Int
TotalActiveDevice Byte PbTotalActiveDevice Int
PbCommunicationLoad BusLoad PbAdditionalCommunicationLoad CommunicationLoad
OptimizeDde PbDirectDateExchange
MinimizeTslot PbMinimizeTslotForSlaveFailure
OptimizeCableConfig PbOptimizeCableConfiguration
CyclicDistribution PbCyclicDistribution
TslotInit PbTslotInit


Tslot PbTslot
MinTsdr PbMinTsdr
MaxTsdr PbMaxTsdr
Tid1 PbTid1
Tid2 PbTid2
Trdy PbTrdy
Tset PbTset
Tqui PbTqui
Ttr PbTtr
TtrMs distant
TtrTypical PbTtrTypical
TtrTypicalMs distant
Watchdog PbWatchdog
WatchdogMs distant
Gap Byte PbGapFactor Int
RetryLimit Byte PbRetryLimit Int
IsochronMode IsochronousMode
AdditionalDevice PbAdditionalPassivDeviceForIsochro‐
nousMode
TotalDevice PbTotalPassivDeviceForIsochronous‐
Mode
DpCycleTimeAutoCalc DpCycleMinTimeAutoCalculation
TiToAutoCalc IsochronousTiToAutoCalculation
Ti IsochronousTi
To IsochronousTo
Modifications des valeurs d'attributs de Siemens.Engineering.Project

.HwExtensions .HwUtilities
Modifications des valeurs d'attributs de Siemens.Engineering.HW.Baudrate

BaudRate.BAUD_9600 BaudRate.BAUD9600


Modifications des valeurs d'attributs de Siemens.Engineering.HW.CableLength

CableLength.Unknown CableLength.None
CableLength.Length_20m CableLength.Length20m
Modifications des valeurs d'attributs de Siemens.Engineering.HW.ChannelIoType

ChannelIoType.Unknown ChannelIoType.Complex
Modifications des valeurs d'attributs de Siemens.Engineering.HW.IpProtocolSelection

IpProtocolSelection.Address‐ IpProtocolSelection.ViaIoController
Tailoring
Modifications des valeurs d'attributs de Siemens.Engineering.HW.TransmissionRateAndDuplex
Attribut Type Nouveau nom Type de

de don‐ données
nées
TransmissionRateAndDuplex.Unknown TransmissionRateAndDuplex.None
TransmissionRateAndDuplex.TP10Mbps_HalfDu‐ TransmissionRateAndDuplex.TP10MbpsHalfDu‐
plex plex
TransmissionRateAndDuplex.TP10Mbps_FullDu‐ TransmissionRateAndDuplex.TP10MbpsFullDu‐
plex plex
TransmissionRateAndDuplex.AsyncFi‐ TransmissionRateAndDuplex.AsyncFi‐
ber10Mbps_HalfDuplex ber10MbpsHalfDuplex
TransmissionRateAndDuplex.AsyncFi‐ TransmissionRateAndDuplex.AsyncFi‐
ber10Mbps_FullDuplex ber10MbpsFullDuplex
TransmissionRateAndDuplex.TP100Mbps_Half‐ TransmissionRateAndDuplex.TP100MbpsHalf‐
Duplex Duplex
TransmissionRateAndDuplex.TP100Mbps_FullDu‐ TransmissionRateAndDuplex.TP100MbpsFullDu‐
plex plex
TransmissionRateAndDuplex.FO100Mbps_Full‐ TransmissionRateAndDuplex.FO100MbpsFull‐
Duplex Duplex

Attribut Type Nouveau nom Type de

de don‐ données
nées
TransmissionRateAndDuplex.X1000Mbps_FullDu‐ TransmissionRateAndDuplex.X1000MbpsFullDu‐
plex plex
Duplex_LD DuplexLD
Duplex Duplex
TransmissionRateAndDuplex.TP1000Mbps_Full‐ TransmissionRateAndDuplex.TP1000MbpsFull‐
Duplex Duplex
Duplex Duplex
Duplex_LD DuplexLD
TransmissionRateAndDu‐ TransmissionRateAndDu‐
plex.POFPCF100Mbps_FullDuplex_LD plex.POFPCF100MbpsFullDuplexLD
9.3.4 Modifications de l'importation et de l'exportation
9.3.4.1 Modifications de l'importation et de l'exportation
Introduction
L'exportation et l'importation au moyen de la TIA Portal Openness API ont été améliorées dans
V14 SP1 afin de pouvoir traiter les commentaires pour les éléments de tableau. Cela a rendu
nécessaire un nouveau schéma. Deux version de schéma sont désormais utilisées pour
l'importation et l'exportation d'interfaces de blocs :
● Pour l'importation : le choix de la version de schéma utilisée s'opère sur la base de la plage
de noms : <Sections xmlns=http://www.siemens.com/automation/Openness/SW/Interface/
v2>
● Pour l'exportation : le choix de la version de schéma utilisée s'opère sur la base de la version
du projet. Les projets V14 SP1 correspondent à la version 2, les projets V14, à la version 1.
9.3.4.2 Modifications dans l'API
Générer une source

Les méthodes suivantes ont été supprimées de ProgramBlocks :
● GenerateSourceFromBlocks
● GenerateSourceFromTypes
Les méthodes suivantes ont été complétées :
● GenerateSource à PlcExternalSourceSystemGroup

Exemple
// generate source for V14

var types = new List<PlcBlock>(){udt1};
var fileInfoBlock = new FileInfo("D:\Export\Block.scl");
var fileInfoType = new FileInfo("D:\Export\Type.udt");
PlcBlocksSystemGroup blocksGroup = ...;

blocksGroup.GenerateSourceFromBlocks(blocks, fileInfo);
PlcTypesSystemGroup plcDataTypesGroup = ...;
plcDataTypesGroup.GenerateSourceFromTypes(types, fileInfo);
//generate source as of V14 SP1

var types = new List<PlcBlock>(){udt1};
var fileInfoBlock = new FileInfo("D:\Export\Blocks.scl");
var fileInfoType = new FileInfo("D:\Export\Type.udt");
PlcExternalSourceSystemGroup externalSourceGroup = plc.ExternalSourceGroup;

externalSourceGroup.GenerateSource(blocks, fileInfoBlock);
externalSourceGroup.GenerateSource(types, fileInfoType);
9.3.4.3 Extension des schémas
Extension des schémas pour les commentaires et les valeurs de démarrage

Les commentaires et les valeurs de démarrage sont enregistrés dans le nouvel élément
"Subelement", qui se rapporte à l'élément de tableau possédant l'attribut "Path".
Subelement contient la valeur de démarrage et le commentaire relatifs à l'élément de tableau
référencé. L'attribut "Path" de StartValue est supprimé du nouveau schéma.
Définition du schéma de "Subelement" :

Extension du type de membre :
Exemples :
Enregistrement de commentaires et valeurs de démarrage dans des tableaux simples :
Enregistrement de commentaires et valeurs de démarrage dans des tableaux de type de

données UDT :

Enregistrement de commentaires et valeurs de démarrage dans des tableaux de type de

données STRUCT :

9.3.4.4 Modifications apportées au schéma
Nœud Access dans SW.PlcBlocks.Access.xsd

L'attribut Type du nœud Access a été déplacé vers les nœuds subordonnés de Access pour
● AbsoluteOffset – obligatoire
● Address – facultatif
L'attribut Type de Constant a été remplacé par le nouveau sous-nœud ConstantType.
La valeur de l'attribut Scope dans Access a été renommée en TypedConstant quand

ConstantValue contient une valeur qualifiée de type (exemple : int#10).
Constant ne possède aucun attribut Type quand ConstantValue contient une valeur qualifiée
de type (exemple : int#10).
Les variables locales ne possèdent aucun nœud Address quand Scope est une LocalVariable.
Lorsqu'un Access est imbriqué dans un autre Access, quel que soit le niveau, seul l'Access
extérieur a besoin d'un UId.
Nœud Address dans SW.PlcBlocks.Access.xsd

L'attribut BitOffset du nœud Address est désormais facultatif.
Le tableau suivant représente les modifications apportées aux déclarations pour exporter
l'accès absolu :
Zone à partir de V14 Type Numéro de bloc Décalage de bit Exemple

SP1
DB Block_DB obligatoire interdit OPN %DB12
DB non trié existant obligatoire %DB100.DBX10.3
DB non trié inexistant obligatoire %DB100.DBX10.3
L non trié interdit obligatoire %LW10.0

Zone à partir de V14 Type Numéro de bloc Décalage de bit Exemple

SP1
I non trié interdit obligatoire %I0.0
Q %Q0.0
M %M0.0
T non trié interdit obligatoire %T0
C %C1
Block_FC Block_FC obligatoire interdit Appel %FB4, %DB5 Input_1 :=
Block_FC Block_FB %FC10
Appel %FB4, %DB5 Input_2 :=
%FB11
Entrée de périphérie non trié interdit obligatoire
Sortie de périphérie non trié interdit obligatoire
Nœud Area dans SW.PlcBlocks.Access.xsd

Le nœud Area possède désormais une liste de valeurs d'énumération simplifiée :
● LocalC et LocalN deviennent Local
● DBc, DBv, DBr ont été supprimés.
Nœud CallInfo dans SW.PlcBlocks.Access.xsd

L'attribut Name du nœud CallInfo est désormais facultatif.
L'attribut BlockType du nœud CallInfo est désormais obligatoire.
+2.2.5 Appels de blocs utilisateurs
Nœud Constant dans SW.PlcBlocks.Access.xsd

Le nœud Constant référence le nœud CostantType avec minOccurs=0.
Le nœud Constant ne référence plus le nœud IntegerAttribute.
Nœud ConstantValue dans SW.PlcBlocks.Access.xsd

Le nœud ConstantValue reçoit un attribut informatif.
Nœud Instruction dans SW.PlcBlocks.Access.xsd

Le nœud Instruction référence le nœud Acces avec minOccurs=0.
Les attributs de paramètre Section, Type et TemplateReference ont été supprimés sur
Instruction.
Nœud Parameter dans SW.PlcBlocks.Access.xsd

L'attribut SectionName du nœud Parameter est désormais facultatif.

Valeurs de Scope dans SW.PlcBlocks.Access.xsd

La liste des valeurs d'énumération de Scope a été complétée par :
● TypedConstant
● AddressConstant
● LiteralConstant
● AlarmConstant
● Address
● Statusword
● Expression
● Call
● CallWithType
Nœud Statusword dans SW.PlcBlocks.Access.xsd

La liste des valeurs d'énumération de Statusword a été complétée par :
● STW
Nœud ConstantType dans SW.PlcBlocks.Access.xsd

Le nouveau nœud ConstantType a été introduit avec l'attribut Informative facultatif.
Nœud CallRef dans SW.PlcBlocks.LADFBD.xsd

Le nœud CallRef a été renommé en Call et ne possède plus de sous-nœud BooleanAttribute.
Nœud InstructionRef dans SW.PlcBlocks.LADFBD.xsd

Le nœud InstructionRef a été remplacé par le nœud Part.
Nœud Part dans SW.PlcBlocks.LADFBD.xsd

Le nouveau nœud ConstantType a été introduit et il remplace le nœud InstructionRef.
● Attributs : nom et version
● Sous-nœud : le sous-nœud Instruction disponible comme nouvelle sélection, en plus de
Equation existant
● Ne possède ni sous-nœud BooleanAttribute ni attribut Gate.
Nœud Wire dans SW.PlcBlocks.LADFBD.xsd

L'attribut Name du nœud Wire a été supprimé.

Nœud TemplateReference dans SW.PlcBlocks.LADFBD.xsd

Le nœud TemplateReference a été supprimé.
Nœud StatementList dans SW.PlcBlocks.STL.xsd

Liste des valeurs d'énumération de StatementList (STL_TE) :
● L_STW a été supprimé
● T_STW a été supprimé
9.3.4.5 Modifications du comportement
Accès absolu
Dans V14, l'importation de l'accès absolu était annulée pour la plupart des combinaisons. A
partir de V14 SP1, l'importation de l'accès absolu fonctionne pour les zones suivantes :
● entrée
● sortie
● mémentos
● temporisation, si pris en charge par l'API
● compteur, si pris en charge par l'API
● DB
● DI
En cas d'utilisation simultanée d'un accès symbolique et d'un accès absolu non rejetés après
vérification du schéma ou du type de nœud, l'importation n'est réussie que quand les
informations d'accès aux boîtes ont été résolues avec succès. Lorsque l'accès symbolique et
l'accès absolu donnent des informations incohérentes, l'importation est refusée.

Accès direct via DB

A partir de V14 SP1, l'accès indirect via DB ne peut être importé que si vous avez défini les
valeurs Offset', 'Type' et 'Symbole'.
Informations symboliques et absolues pour l'accès local

Lors de l'importation d'un "accès symbolique", toutes les "informations pour l'accès absolu"
possibles indiquées sont vérifiées, tant qu'elles ne sont pas marquées comme "informatives".
A partir de V14 SP1, l'importation est annulée en cas d'incohérence des informations absolues.
Restrictions relatives à l'interface de bloc

Différentes restrictions sont à l'étude dans V14 SP1. Ces restrictions sont déjà connues des
utilisateurs de l'éditeur d'interface de bloc. Chaque fois que l'éditeur d'interface de bloc
renomme un paramètre en le complétant ou en augmentant sa valeur de '_1', le processus
d'importation OPNS est annulé.
Par exemple, les restrictions suivantes sont à l'étude :
● Doubles noms de paramètre
● Noms de section erronés, y compris la 'section Return' des blocs FB
● Limitation de caractères
Tri des sections lors de l'importation

Lorsque le bloc appelé n'est pas disponible au moment de l'importation, c'est la définition de
l'interface, côté appel, qui est utilisée pour afficher le bloc utilisateur appelé. Dans V14 SP1, les
sections sont triées dans l'ordre dans lequel elles seraient affichées dans l'interface de bloc du
bloc appelé, si celui-ci avait existé avec les mêmes paramètres.
Ordre d'affichage des sections des paramètres importés :
● entrée
● sortie
L'exemple en LIST xml suivant

entraîne :
CALL "Block_2"
Input_1 :="Tag_1"
Input_2 :="Tag_2"
Output_1 :="Tag_3"
Output_2 :="Tag_4"
Noms d'appelant univoques pour blocs utilisateurs

Les noms doivent être univoques dans TIA Portal. Autrement dit, une variable, par exemple, ne
doit pas posséder le même nom qu'un bloc. Pour l'importation sous XML de la TIA Portal
Openness API, cela signifie que lorsque le XML contient un appel de bloc utilisateur pour lequel
le bloc appelé n'est pas disponible au moment de l'importation, le nom du bloc appelé doit être
univoque par rapport à tous les noms existants dans le projet. Quand le nom du bloc appelé
n'est pas univoque, le processus d'importation est annulé.
Dans l'exemple suivant, le processus d'importation est annulé parce que le nom du bloc appelé
"Tag_1" est déjà utilisé pour une table de variables.

Dans l'exemple suivant, le processus d'importation est annulé parce que deux paramètres
possèdent le même nom "Input1".
Appels de blocs de bibliothèque

Le fichier XML importé peut contenir des appels de blocs utilisateur. Ces blocs utilisateur sont
identifiés par leur nom.
Les blocs utilisateur peuvent également appeler des éléments de bibliothèque. Ces éléments
de bibliothèque peuvent être générés en tant que "Appels de blocs de bibliothèque". Comme
les blocs de bibliothèque utilisent la même plage de nom que les blocs utilisateur, il est possible

que l'importation d'un appel de bloc utilisateur effectuée par le nom appelle l'implémentation
d'un bloc utilisateur.
Avant V14 SP1, le processus d'importation essayait d'attribuer les paramètres entre l'appel du
bloc utilisateur et l'appel du bloc d'instruction. Le processus d'importation était annulé
ponctuellement, tous les paramètres incohérents étaient supprimés occasionnellement.
A partir de V14 SP1, l'appel du bloc utilisateur continue de trouver le bloc de bibliothèque, mais
sans que l'appel ne devienne invalide.
Incohérence du type de bloc

Lorsque le XML contient un appel de bloc utilisateur du 'Block_1' possédant plus de paramètres
que le FC correspondant n'en possède dans le projet, à partir de V14 SP1, l'importation définit
pour le bloc appelé une nouvelle interface qui correspond à l'appel du bloc utilisateur existant
dans le XML. A la prochaine compilation du bloc de programme, le système essaie d'actualiser
l'appel.

Nouvelle étendue des fonctions pour constantes

A partir V14 SP1, différentes fonctions nouvelles ont été définies pour les constantes.
L'importation ne peut réussir que si les valeurs dans le fichier XML correspondent à l'étendue
des fonctions de la constante. Il se peut que le processus d'importation soit annulé quand
toutes les informations spécifiées pour une constante ne correspondent pas à la constante
existante.

Remarques concernant les versions d'instruction

A partir de V14 SP1, vous ne pouvez importer que les versions d'instruction utilisables sur l'API
dans lequel vous souhaitez importer. Si aucune version d'instruction n'est mentionnée dans le
fichier XML, c'est la version sélectionnée dans l'API qui est utilisée. En CONT et en LOG, il
n'existe aucune attribution de versions pour certains éléments représentés comme
instructions. Ces éléments ne peuvent être importés que sans version.
ENO désactivé
Sur les automates S7-1200 et S7-1500, la fonction de désactivation d'ENO sert à désactiver les
calculs de l'état de liaison d'ENO sollicitant le temps d'exécution.
A partir de V14 SP1, le mémento DisabledENO ne peut être importé sur les API qui prennent
en charge cette nouvelle fonction.
Validation du type pour l'accès à la pile des données locales

A partir de V14 SP1, le processus d'importation est annulé lorsque le type n'est pas utilisé ou
ne peut être attribué.
Validation d'Index-Ident
L'accès via l'Index est utilisable quand la fonction "Accès symbolique à la mémoire" est définie,
par exemple accès local, accès global, accès indirect.
En cas d'utilisation d'une constante littérale comme index, les types entier signé ou non sont
convertis en DINT. A partir de V14 SP1, le processus d'importation est annulé quand un type
se situe en dehors de la plage indiquée.
Pour tout accès via l'Index, le système vérifie au préalable si 'accès via l'Index' peut vraiment
être utilisé comme type d'accès. A partir de V14 SP1, le processus d'importation est annulé
lorsque l'accès via l'Index défini ne peut pas être utilisé.

Tri dans l'ordre des éléments

A partir de V14 SP1, les éléments dans CONT et LOG sont triés dans l'ordre de génération des
codes où l'exportation automatique est possible. Dans quelques rares cas, vous ne pouvez
plus réimporter le fichier XML exporté. Dans ces cas, vous devez soit modifier le fichier XML ou
supprimer et programmer de nouveau les réseaux correspondants. Toutefois, l'ordre des
conducteurs et références reste peu fiable.
Constantes d'alarme
Avec V14 SP1, la vérification des compilations a été élargie à la validité des constantes
d'alarme. Il peut arriver qu'en raison d'un XML importé dans V14 avec des constantes d'alarme
défectueuses, un projet soit compilable dans V14 SP1. Dans ce cas, ouvrez le réseau pertinent
dans l'éditeur CONT/LOG et supprimer l'opérande d'alarme réelle. L'éditeur crée
automatiquement une nouvelle constante d'alarme valide.
Restrictions concernant les instances de blocs utilisateur et Motion Control

Dans V14, il était possible d'importer des appels de blocs utilisateur FC dans une instance et
même de compiler ponctuellement ces appels.
A partir de V14 SP1, l'importation d'instances n'est possible que là où les instances sont prise
en charge. Vous ne pourrez éventuellement plus compiler des projets existants avec des
instances d'appels de blocs utilisateur et instructions. Dans ce cas, vous devez supprimer
l'appel et le programmer de nouveau. Toute tentative visant à effectuer une actualisation
d'appel ou tout autre type de réparation automatique est vouée à l'échec.

EnEno visible
Dans V14, c'est le mémento ENENO qui déterminait si les entrées/sorties EN et ENO de
'InstructionRef' étaient utilisables ou pas.
A partir de V14 SP1, OPNS utilise pendant l'importation les entrées/sorties EN ou ENO en
fonction de l'élément et du câblage. En raison de cette identification automatique, il convient de
préciser toute utilisation différente des entrées/sorties EN et ENO. Il est très probable que seuls
les boîtes des temporisations CEI et de compteurs CEI posent quelques problèmes.
Affectation d'UId
Avec V14 SP1, l'affectation de UId aux pièces, accès et conducteurs a changé. Les UId des
expressions, CallInfo et opérandes doivent être univoques dans une unité de compilation.
Dans la perspective TIA Portal, les UId dans la clé XML n'ont pas de signification
supplémentaire si ce n'est l'identification d'un élément.
Contrôle des chaînes de caractères

Des contrôles plus stricts des guillemets, caractères génériques et caractères de contrôle de
l'attribut Name sont effectués lors de l'importation de
● IntegerAttribute
● StringAttribute
● DateAttribute
● AutomaticTyped
● Component
● Invisible
● Label
● NameCon
● Negated
● TemplateValue
● CallInfo
● Instruction
● Parameter
● Part
● Step
Des contrôles plus stricts des caractères génériques et caractères de contrôle sont effectués
lors de l'importation de
● Titres de blocs et réseaux
● Texte LineComment
● Chaînes de caractères de constantes (types STRING, WSTRING, CHAR, WCHAR)

Des contrôles plus stricts des caractères génériques et caractères de contrôle (tabulation et
nouvelle ligne autorisées) sont effectués lors de l'importation de
● Commentaires et réseaux
● Attributs de chaînes de caractères
● Nœuds, définissant des textes multilingues comme Alarmtext, Comments
● Textes Token
Non-respect de la casse dans les modèles d'opération et paramètres

A partir de V14 SP1, les modèles d'opération pour les instructions et les paramètres d'appel ou
d'instruction ne respectant pas la casse sont importés et corrigés automatiquement.
Le code suivant est importé, la valeur erronée "Eq" est corrigée en "EQ" et le paramètre erroné
"iN1" est corrigé en "IN1" :
Multi-instances utilisées dans les appels

A partir de V14 SP1, le processus d'importation est annulé lorsque la multi-instance utilisée
dans un appel est inexistante.
Le code suivant présente un exemple de XML dans lequel la multi-instance est correctement
définie dans la section d'interface :

Modèles de cardinalités dans LIST

Dans LIST, les modèles de cardinalités pour chaque instruction ont une valeur par défaut fixe,
qui est la seule valeur valide. A partir de V14 SP1, le processus d'importation est annulé quand
une valeur différente est utilisée pour la cardinalité.
Importer l'accès direct

A partir de V14 SP1, l'accès indirect ne peut être importé que là où il peut être compilé.

Importer des mots d'état

A partir de V14 SP1, vous ne pouvez importer le mot d'état qu'avec les instructions où il est pris
en charge.
● L - mot d'état pris en charge : STW
● T - mot d'état pris en charge : STW
● A - mot d'état pris en charge : BR, OV, OS, EQ, NE, GT, Lt, GE, LE, U0, NU
● AN - mot d'état pris en charge : BR, OV, OS, EQ, NE, GT, Lt, GE, LE, U0, NU
● O - mot d'état pris en charge : BR, OV, OS, EQ, NE, GT, Lt, GE, LE, U0, NU
● ON - mot d'état pris en charge : BR, OV, OS, EQ, NE, GT, Lt, GE, LE, U0, NU
● X - mot d'état pris en charge : BR, OV, OS, EQ, NE, GT, Lt, GE, LE, U0, NU
● XN - mot d'état pris en charge : BR, OV, OS, EQ, NE, GT, Lt, GE, LE, U0, NU
Remarque
La plupart des mots d'état sont uniquement utiles pour les automates S7-300 et S7-400.
Instructions vides
Le processus d'importation est annulé quand une instruction ne possède aucun nœud
<StlStatement/>. Dans une instruction vide, ajoutez le nœud <StlToken Text="Empty_Line" />.
Le processus d'importation est annulé quand une instruction vide dispose de commentaires.
Pour une instruction possédant uniquement des commentaires, utilisez <StlToken
Text="COMMENT" />.
9.3.4.6 Modifications apportées aux attributs de bloc
Modifications apportées aux attributs généraux

AutoNumber possède une nouvelle valeur par défaut (false) pour les OB classiques.
HeaderVersion possède un nouveau type System.Version (à la place de String).
IsKnowHowProtected s'applique également aux types de données définis par l'utilisateur.

ILibraryTypeInstance.ConnectedVersion, ILibraryTypeInstance.Dependencies,
ILibraryTypeInstance.Dependents ont été supprimés du tableau des attributs généraux, car ils
ne sont ni exportés dans XML ni accessibles via API.
MemoryLayout possède une nouvelle valeur par défaut : Standard pour API classiques et
Optimized pour API Plus.
Number s'applique également aux types de données définis par l'utilisateur, est représenté
dans XML et également accessible via API.
Modifications apportées aux attributs spécifiques

IsOnlyStoredInLoadMemory et IsWriteProtectedInAS sont désormais en lecture seule sur
IDBofUDT, pour autant que l'UDT appartienne à un élément de bibliothèque système.
OfSystemLibElement et OfSystemLibVersion ne font plus partie des attributs généraux, mais
appartiennent aux attributs spécifiques.
OfSystemLibVersion possède un nouveau type System.Version (à la place de String).
ParameterPassing reste accessible en lecture et en écriture pour les FC et les FB uniquement
si
● ProgrammingLanguage est LIST
● MemoryLayout est Standard
● l'interface est vide.
GraphVersion possède un nouveau type System.Version (à la place de String).
Un nouvel attribut appelé ExtensionBlockName est introduit pour les FB écrits dans GRAPH
(à partir de la version V4).
Un nouvel attribut appelé InvalidValuesAcquisition est introduit pour les FB écrits dans
GRAPH (à partir de la version V4).
Un nouvel attribut appelé IsWriteProtected est introduit pour les blocs code.
DownloadWithoutReinit est désormais en lecture seule et valable également pour IDBofFBs.
Supervisions est désormais en lecture seule pour les IDBofFBs.
Modifications dans les énumérations

Les valeurs d'énumération de ProgrammingLanguage ont été modifiées de la manière
suivante :
● Une valeur d'énumération F_CALL a été introduite.
● Une nouvelle valeur d'énumération Motion_DB a été introduite pour l'objet technologique
Motion.
● GRAPH_SEQUENCE, GRAPH_ACTIONS, GRAPH_ADDINFOS ont été supprimés des
énumérations. Ils ont été remplacés par GRAPH.
Les valeurs d'énumération de BlockType ont été modifiées de la manière suivante :
● Les valeurs OB, FC, DB, SFC ont été supprimées, car les énumérations correspondantes
ne sont utilisées qu'avec l'attribut InstanceOfType .

9.4 Modifications importantes dans V14
9.4.1 Principales modifications du modèle d'objet
Modèle d'objet de TIA Portal Openness V13 SP1 et plus ancien

Pour permettre une comparaison entre l'ancien et le nouveau modèle d'objet de TIA Portal
Openness, le diagramme ci-dessous décrit le modèle d'objet de TIA Portal V13 SP1.
Remarque
Le modèle objet décrit dans le diagramme est déconseillé. Vous trouverez des informations sur
le modèle d'objet de TIA Portal Openness V14 SP1 sous AUTOHOTSPOT


9.4.2 Avant la mise à niveau d'une application vers TIA Portal Openness V14
Application
Les paramètres suivants doivent être modifiés avant la mise à niveau d'une application vers
TIA Portal Openness V14 :
1. Les renvois vers l'API V14 doivent être adaptés en complétant les API TIA Portal Openness
suivants :
– Siemens.Engineering
– Siemens.Engfineering.Hmi
2. Mettre à niveau le .Net-Framework de Visual Studio vers la version 4.6.1.
3. Actualisez la méthode AssemblyResolve en modifiant le nouveau chemin d'installation de
TIA Portal.
– Si vous travaillez à partir du fichier d'enregistrement, modifiez la nouvelle clé comme
dans l'exemple suivant :
"HKEY_LOCAL_MACHINE\SOFTWARE\Siemens\Automation\_InstalledSW
\TIAP14\TIA_Opns\..."
– Si vous travaillez avec le fichier de configuration d'application, adaptez les chemins au
nouveau chemin d'installation.

9.4.3 Principales modifications de chaîne de caractères
Introduction
Les modifications suivantes ont été apportées à TIA Portal Openness V14 et il se peut que cela
ait des effets sur vos applications existantes :

Les méthodes de compilation ont été modifiées. Modifiez les méthodes de compilation comme dans l'exemple
suivant :
● TIA Portal Openness V13 SP1(obsolète) :
controllerTarget.Compile(CompilerOptions.
Software, BuildOptions.Rebuild);
● TIA Portal Openness V14:
plcSoftware.GetService<ICompilable>().Com
pile();
De nouveaux espaces de noms ont été ajoutés. 1. Ajoutez les instructions d'espaces de noms suivantes :
Siemens.Engineering.SW.Blocks;
Siemens.Engineering.SW.ExternalSources;
Siemens.Engineering.SW.Tags;
Siemens.Engineering.SW.Types;
2. Supprimez l'instruction d'espace de nom using
ControllerTarget =
Siemens.Engineering.HW.ControllerTarget.
3. Compilez l'application.
ControllerTarget a été remplacé par PlcSoftware et la 1. Vérifiez les exemples de code dans la documentation fai‐
fonctionnalité a été modifiée dans certains cas. sant partie de votre fonctionnalité d'application.
2. Actualisez le code du programme de votre application TIA
Portal Openness d'après l'exemple suivant :
– TIA Portal Openness V13 SP1(obsolète) :
ControllerTarget controllerTarget =
deviceItem as ControllerTarget
– TIA Portal Openness V14:
PlcSoftware plcSoftware =
deviceItem.GetService<SoftwareContainer
>().Software as PlcSoftware


Des objets ont été remplacés. 1. Recherchez et remplacez les objets suivants :
DeviceUserFolderAggregation =
DeviceUserGroupComposition
DeviceFolders = DeviceGroups
DeviceUserFolder = DeviceUserGroup
ProgramblockSystemFolder =
PlcBlockSystemGroup
ProgramblockUserFolder = PlcBlockUserGroup
IBlock = PlcBlock
ControllerDatatypeSystemFolder =
PlcTypeSystemGroup
ControllerDatatypeUserFolder =
PlcTypeUserGroup
ControllerDatatype = PlcType
ControllerTagSystemFolder =
PlcTagTableSystemGroup
ControllerTagUserFolder =
PlcTagTableUserGroup
ControllerTagTable = PlcTagTable
ControllerTag = PlcTag
ControllerConstant = PlcConstant
ExternalSourceSystemFolder =
PlcExternalSourceSystemGroup
ExternalSource = PlcExternalSource
IOnline = OnlineProvider
ILibraryType = LibraryType
Les agrégations ont été remplacées par des compositions. 1. Remplacez chaque Aggregation dans votre code
par Composition comme dans les exemples suivants :
ProjectAggregation = ProjectComposition
IDeviceAggregation = IDeviceComposition
TagTableAggregation = TagTableComposition
CycleAggregation = CycleComposition
GraphicListAggregation =
GraphicListComposition
TextListAggregation = TextListComposition
ConnectionAggregation =
ConnectionComposition
MultiLingualGraphicAggregation =
MultiLingualGraphicComposition
UpdateCheckResultMessageAggregation =
UpdateCheckResultMessageComposition
Les dossiers ont été remplacés par des groupes dans toutes 1. Excepté les sections de code concernant les pupitres
les relations, sauf pour concerne les pupitres opérateurs. opérateurs, remplacez chaque Folder dans votre code
de programme par Group.


La méthode GetAttributeNames a été remplacée par la 1. Pour déterminer les attributs, utilisez
méthode GetAttributeInfos . IList<EngineeringAttributeInfo>
IEngineeringObject.GetAttributeInfos(Attr
ibuteAccessMode attributeAccessMode); .
Pour plus d'informations, référez-vous à Déterminer la
structure et les attributs de l'objet (Page 125).
La méthode Close de fermeture d'un projet a été modifiée. 1. Remplacez
project.Close(CloseMode.PromptIfModified)
; par project.Close();.
Pour plus d'informations, référez-vous à Fermer un projet
(Page 137).
L'accès simultané a été remplacé par l'accès exclusif et des 1. Remplacez l'accès simultané par l'accès exclusif et des
transactions exclusives. transactions exclusives comme dans les exemples sui‐
vants :
tiaProject.StartTransaction("Reseting
project to default");
...
tiaProject.CommitTransaction();
//Use exclusive access to avoid user
changes
ExclusiveAccess exclusiveAccess =
tiaPortal.ExclusiveAccess();
...
exclusiveAccess.Dispose();
//Use transaction to be able to
rollbank changes:
Transaction transaction =
exclusiveAccess.Transaction(tiaProject,
"Compiling device");
transaction.CommitOnDispose();
Pour plus d’informations, voir Accès en exclusivité (Pa‐
ge 94) et Traitement des transactions (Page 103).


L'accès en ligne à la CPU a été modifié 1. Modifiez l'accès en ligne à la CPU comme dans les exem‐
ples suivants :
((IOnline)controllerTarget).GoOffline()
;
((DeviceItem)
plcSoftware.Parent.Parent).GetService<O
nlin
eProvider>().GoOffline();
La configuration matérielle a été modifiée 1. Modifiez la configuration matérielle :
Device.Elements = Device.Items
2. Retirez les attributs de matériel suivants :
– Device.InternalDeviceItem
– Device.SubType
Voir aussi
Traitement des exceptions (Page 765)
9.4.4 Importation de fichiers créés avec TIA Portal Openness V13 SP1 et des versions
antérieures
Application
Si vous essayez d'importer des fichiers qui ont été générés avec TIA Portal Openness V13 SP1
ou une version antérieure, une exception d'incompatibilité est déclenchée. Motif : des
modifications dans les variables IHM et les écrans IHM. Les tableaux suivants montrent les
principales modifications d'attributs. Vous trouverez des informations détaillées dans le
chapitre "Créer les vues > Utilisation des objets et de groupes d'objets > Utilisation des objets
> Configuration de plages" dans l'aide en ligne de TIA Portal :

Modifications de variables IHM

Le tableau suivant montre les principales modifications d'attributs de variables IHM :
Attributs supprimés Attributs ajoutés

RangeMaximumType LimitUpper2Type.
RangeMaximum LimitUpper2.
RangeMinimumType LimitLower2Type.
RangeMinimum LimitLower2.
LimitUpper1Type
LimitUpper1
LimitLower1Type
LimitLower1
Modifications d'éléments graphiques IHM

Le tableau suivant montre les principales modifications d'attributs de curseur :

RangeLower1Color
RangeLower1Enabled
RangeLower2Color
RangeLower2Enabled
RangeNormalColor
RangeNormalEnabled
RangeUpper1Color
RangeUpper1Enabled
RangeUpper2Color
RangeUpper2Enabled
ScalePosition
ShowLimitLines
ShowLimitMarkers
ShowLimitRanges

Le tableau suivant montre les principales modifications d'attributs de plage de mesure :

DangerRangeColor RangeLower1Color
DangerRangeStart RangeLower1Enabled
DangerRangeVisible RangeLower2Color
WarningRangeColor RangeLower2Enabled
WarningRangeStart RangeNormalColor
WarningRangeVisible RangeNormalEnabled
RangeUpper1Color
RangeUpper1Enabled
RangeUpper1Start
RangeUpper2Color
RangeUpper2Enabled
RangeUpper2Start
Le tableau suivant montre les principales modifications d'attributs de bargraphe :

AlarmLowerLimitColor RangeLower1Color
AlarmUpperLimitColor RangeLower1Enabled
RangeLower2Color
RangeLower2Enabled
RangeNormalColor
RangeNormalEnabled
RangeUpper1Color
RangeUpper1Enabled
RangeUpper2Color
RangeUpper2Enabled

Index
Condition d'édition
Votre application Openness et le TIA Portal se
A trouvent sur le même ordinateur, 50
Configuration
Accéder
Votre application Openness et le TIA Portal se
Copie maître dans une bibliothèque de
trouvent sur différents ordinateurs, 49
projet, 168
Connecter
Acquittement d'événements système piloté par le
Axe synchrone avec des valeurs pilote, 581
programme, 87
Came, 578
API
Codeur, 576
Comparaison avec état réel, 494
Codeur à un bloc de données, 562
Comparer, 494
Codeurs pour les entraînements analogiques à
Déterminer statut, 439
l'adresse matérielle, 560
Etablir une liaison en ligne, 498
Codeurs pour les PROFIdrives à l'adresse
Interrompre la liaison en ligne/déconnecter, 498
matérielle, 558
Entraînements, 571
Entraînements analogiques à l'adresse
B matérielle, 559
Bibliothèque Entraînements analogiques avec un bloc de
Accéder à des dossiers, 154 données, 561
Déterminer les versions de types Palpeur de mesure, 579
d'instances, 175 Piste de came, 578
Fonctions, 141 PROFIdrives à l'adresse matérielle, 557
Bibliothèque de projet PROFIdrives avec un bloc de données, 561
Accéder, 142, 146 Télégramme 750, 574
Accéder aux copies maîtres, 168 Connexion
Bibliothèque globale Sortie PTO, 556
Accéder, 142, 146 Connexion au portail TIA
Accès aux paramètres de langue, 144 Fermer, 88
Bloc Copie maître
Créer un groupe, 524 Copie, 175
Exporter, 896 Copier le contenu dans dossier de projet, 172
Générer une source, 531 Copier
Importer, 895 Contenu d'une copie maître dans dossier de
Interroger des informations, 520 projet, 172
Supprimer, 523 Copie maître, 175
Supprimer un groupe, 525 Copies maître
Bloc de programme Supprimer, 181
Supprimer, 523 Coupure de la connexion au portail TIA, 88
Création
Créer des dossiers de vues personnalisés, 270
C Dossier personnalisé pour les tables des variables
API, 590
Compilation
Dossiers personnalisés pour variables IHM, 276
Groupe d'objets technologiques, 549
Groupe pour bloc, 524
Logiciel, 134
Sous-dossiers personnalisés pour scripts, 278
Matériel, 134
Créer
Objet technologique, 548
Came, 563

Index
Palpeur de mesure, 563 Type de données utilisateur, 896

Piste de came, 563 Une seule variable ou constante d'une table de
variables API, 912
D
Démarrer
F
Editeur de bloc, 537 Fichier d'exportation
Editeur de variables, 588 Contenu, 779
Dossier Structure de base, 790, 941, 945
Supprimer, 181 Structure du fichier XML, 790, 945
Fichier XML
Editer, 778
E Exportation, 779
Fonctions, 53
Ecrire
API, 514, 515, 517, 518, 520, 590, 591, 594, 595,
Paramètres d'un objet technologique, 554
596, 598, 911, 912, 913
Éditeur "Appareils et réseaux"
Constantes API, 598
Ouvrir, 184
Créer des dossiers de vues personnalisés, 270
Editeur de bloc
Créer les sous-dossiers personnalisés pour
Démarrer, 537
scripts, 278
Editeur de variables
Créer un dossier personnalisé pour tables des
Démarrer, 588
variables API, 590
Enregistrer le projet, 136
Définir un dossier système, 515
Enumérer
Enregistrer le projet, 136
Blocs, 518
Énumérer des appareils, 236, 239
Dossiers Blocs personnalisés, 517
Enumérer des blocs, 518
Dossiers personnalisés pour variables API, 589
Énumérer des éléments d'appareil, 252
Enumérer des tables de variables API dans des
dossiers, 592
Sous-dossier système, 515
Énumérer des textes multilingues, 123, 128
Tables de variables API, 592
Enumérer des variables API, 595
Toutes les variables d'une table de variables, 276
Enumérer le dossier Blocs personnalisé, 517
Variables API, 595
Enumérer le sous-dossier système, 515
Énumérer
Enumérer les dossiers personnalisés pour
Appareils, 236, 239
variables API, 589
Éléments d'appareil, 252
Enumérer les variables d'une table de variables
Textes multilingues, 123, 128
IHM, 276
Énumérer des appareils, 236, 239
Exemple d'application Public API, 72
Énumérer des éléments d'appareil, 252
Exporter une variable ou une constante d'une
Énumérer des textes multilingues, 123, 128
table de variables API, 912
Établir une liaison à TIA Portal, 79
Fermer un projet, 137
Exceptions
Généralités, 79, 87, 88
En cas d'accès au portail TIA avec des API
Générer des dossiers personnalisés pour
publics, 765
variables IHM, 276
Exemple d'application Public API, 72
IHM, 270, 271, 272, 273, 274, 275, 276, 277, 278,
Exemple de programme, 53
279
Importer une table de variables API, 911
Utilisation, 39
Importer une variable dans une table des variables
Exporter
API, 913
Bloc, 896
Interroger la famille du bloc, 520
Objets technologiques, 918
Interroger la version du bloc, 520
Interroger l'attribut "Consistency" d'un bloc, 520

Index
Interroger l'auteur du bloc, 520

Interroger le dossier "Blocs de programme", 514
Interroger le nom de bloc, 520 I
Interroger le numéro de bloc, 520
Importation/exportation
Interroger le titre du bloc, 520
Editer un fichier XML, 778
Interroger le type de bloc, 520
Importer
Interroger les informations d'une table de
Bloc, 895
variables API, 593
Objets technologiques, 921
Interroger l'horodatage d'un bloc, 520
Tables de variables API, 911
Interroger PLC Target et HMI Target, 185
Type de données utilisateur, 937
Interroger un dossier système pour variables
Une seule variable dans une table des variables
API, 588
API, 913
Lecture de l'heure des dernières modifications
Importer/exporter
dans une table des variables API, 594
Exporter des commentaires multilingues, 1024,
Limitation aux projets de TIA Portal V13, 109
1032
Ouvrir un projet, 109
Exporter des variables, 1035
Paramètres généraux de TIA Portal, 114
Importer des commentaires multilingues, 1024,
Projets, 109, 114, 123, 128, 133, 136, 137, 185,
1032
236, 239, 252, 588, 589, 592, 593, 595
Importer des variables, 1035
Suppression de cycle, 273
Importer/Exporter
Suppression de la bibliothèque de
AML-GUID stables, 983
graphiques, 133
API, 854, 892, 896
Suppression de la liaison, 275
Appareils et modules Round-Trip, 983
Suppression de la liste de textes, 274
Définir le comportement d'importation à l'aide de
Suppression de la table des variables, 278
codes de programme, 780
Suppression de la table des variables API, 595
Domaine d'application, 776
Suppression de toutes les vues, 272
Données du projet, 783, 784
Suppression d'un modèle de vue, 272
Exportation de commentaires multilingues, 1015,
Suppression d'une liste de graphiques, 275
1033
Suppression d'une variable d'une table des
Exportation de cycles, 793
variables API, 596
Exportation de données de configuration, 778
Suppression d'une vue, 271
Exportation de vues contextuelles, 828
Supprimer les scripts VB d'un dossier, 279
Exportation d'une vue Slide-in, 830
Supprimer un dossier personnalisé pour tables de
Exporter aussi les valeurs standard, 779
variables API, 591
Exporter des blocs avec protection know-
Supprimer une variable d'une table des
how, 854
variables, 277
Exporter des blocs sans protection know-
how, 896
Exporter des blocs système, 892
G Exporter des connexions, 810
Générer Exporter des listes de textes, 805
Source à partir d'un bloc, 531 Exporter des modèles de vue, 824
Source à partir d'un type de données Exporter des scripts VB, 802, 803
utilisateur, 531 Exporter des tables de variables API, 910
Groupe d'objets technologiques Exporter des tables de variables IHM, 795
Compilation, 549 Exporter la variable sélectionnée, 799
Exporter les listes de graphiques, 809
Exporter les valeurs modifiées uniquement, 779
H Exporter les vues d'un appareil IHM, 816
Exporter l'image avec une instance de bloc
Hiérarchie des objets matériels du modèle
d'affichage, 833
d'objet, 69
Exporter tous les graphiques d'un projet, 783

Index
exporter tous les modèles de vue, 823 TIA Openness V13 complément, 30
Exporter une fenêtre permanente, 821 Vérifier l'authentification d'accès, 31
Exporter une variable d'une table de Installation du complément, 30
variables, 799 Instances
Exporter une vue à partir d'un dossier de Définir une version de type, 175
vues, 817 Interrogation
Format d'exportation, 776 Objet technologique, 546
Formats XML avancés pour l'exportation/ Interroger
importation de listes de textes, 807 Informations du bloc, 520
Graphiques, 782 Informations du type de données utilisateur, 520
IHM, 793, 794, 795, 798, 799, 800, 801, 802, 803,
804, 805, 806, 807, 809, 811, 812, 816, 817, 819,
821, 822, 823, 824, 826, 828, 829, 830, 832, 833, L
835, 910
Liaison à TIA Portal
Importation de commentaires multilingues, 1015,
Configuration, 79
1033
Lire
Importation de connexions, 811
Heure des dernières modifications dans une table
Importation de données de configuration, 780
des variables API, 594
Importation de vues contextuelles, 829
Importation d'une vue Slide-in, 832
Logiciel
Importer des cycles, 794
Compilation, 134
Importer des graphiques dans un projet, 784
Importer des listes de textes, 806
Importer des modèles de vue, 826
Importer des scripts VB, 804
M
Importer des vues dans un appareil IHM, 819 Matériel
Importer les listes de graphiques, 809 Compilation, 134
Importer l'image avec une instance de bloc Modèle d'objet, 54
d'affichage, 835
Importer une fenêtre permanente, 822
Importer une table de variables dans un dossier de O
variables, 798
Objet technologique, 543, 915
Importer une variable HMI dans une table de
Compilation, 548
variables, 800
Créer, 547
Limiter les exportations aux valeurs
Enumérer, 550
modifiées, 779
Interrogation, 546
Marche à suivre pour l'importation, 781
Rechercher, 550
notions de base, 773
Supprimer, 548
Objets d'AML, 941
Types de données, 545
Objets exportables, 773
Objets
Objets graphiques exportables, 812
Objets exportables, 773
Objets importables, 773
Objets importables, 773
Objets technologiques, 918, 920
Objets graphiques exportables, 812
Paramétrage de l'exportation, 778
Particularités des variables IHM intégrées, 801
Exporter, 918
Restrictions, 776
Importer, 921
Structure des données, 790, 945
Ouverture d'un projet, 109
Volume d'exportation, 778
Ouvrir
Installation
Éditeur "Appareils et réseaux", 184
Ajouter un utilisateur au groupe d'utilisateurs, 31
Etapes standard pour l'accès au portail TIA, 37

Index
Siemens.Engineering.Hmi.RuntimeScripting, 45
Siemens.Engineering.Hmi.Screen, 45
P Siemens.Engineering.Hmi.Tag, 45
Siemens.Engineering.Hmi.TextGraphicList, 45
Paramètres
Siemens.Engineering.HW, 45
Comptage, 586
Siemens.Engineering.SW, 45
Easy Motion Control, 587
Statut (API)
Régulation PID, 585
Déterminer, 439
S7-1500 Motion Control, 565
Structure de base d'un fichier d'exportation, 790,
Paramètres d'un objet technologique
945
Ecrire, 554
Enumérer, 551
AML, 941
Lire, 553
Structure des données d'exportation, 790, 941, 945
Rechercher, 552
Suppression
Paramètres généraux de TIA Portal, 114
Bibliothèque de graphiques, 133
Particularités des variables IHM du type de données
Certaines variables d'une table des
"UDT", 802
variables, 277
Projet
Connexion, 275
Enregistrer, 136
Cycle, 273
Fermer, 137
Liste de graphiques, 275
Interroger HMI Targets, 185
Liste de textes, 274
Interroger PLC Targets, 185
Modèle de vue, 272
Interroger un type d'appareil, 185
Script VB d'un dossier, 279
Ouvrir, 109
Table des variables, 278
Toutes les vues, 272
Une seule variable d'une table des variables
R API, 596
Rechercher Vue, 271
Objet technologique, 550 Supprimer
Paramètres d'un objet technologique, 552 Bloc, 523
Requêtes Bloc de programme, 523
Attribut "Consistency" d'un bloc, 520 Constantes API, 598
Auteur du bloc, 520 Dossier personnalisé pour les tables des variables
Dossier "Blocs de programme", 514 API, 591
Dossier système pour variables API, 588 Groupe pour bloc, 525
Famille de bloc, 520 Objet technologique, 548
Horodatage d'un bloc, 520 Supprimer une table de variables API d'un
Informations d'une table de variables API, 593 dossier, 595
Nom de bloc, 520 Type de données utilisateur, 536
Numéro de bloc, 520
Titre du bloc, 520
Trouver, 515 T
Type de bloc, 520
TIA Portal Openness, 47
Version du bloc, 520
Accès, 38
Ajouter un utilisateur au groupe d'utilisateurs, 31
API publique, 53
S Concepts sous-jacents à la vérification de l'identité
Siemens.Engineering, 45 d'objet, 100
Siemens.Engineering.Hmi, 45 Concepts sous-jacents d'affectations, 99
Siemens.Engineering.Hmi.Communication, 45 Concepts sous-jacents pour la manipulation
Siemens.Engineering.Hmi.Cycle, 45 d'exceptions, 765
Siemens.Engineering.Hmi.Globalization, 45 Conditions, 29

Index
Configuration, 49
Droits d'accès, 31
Etapes standard pour l'accès au portail TIA, 37
Etendue des fonctions, 47
Exportation/importation, 39
Fonctions, 53
Introduction, 47
Notions de base sur la composition, 99
Savoir-faire nécessaire de l'utilisateur, 29
Tâches typiques, 38
Vue d'ensemble de la programmation, 53
Trouver
Came, 563
Palpeur de mesure, 563
Piste de came, 563
Type de données utilisateur
Exporter, 896
Générer une source, 531
Importer, 937
Interroger des informations, 520
Supprimer, 536
Types
Supprimer, 181
Types de données
V
Variables IHM du type de données "UDT", 802
Variables IHM intégrées, 801
Vue d'ensemble de la programmation, 53

TIAPortalOpenness FR FR

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TIAPortalOpenness FR FR

Transféré par

Droits d'auteur :

Formats disponibles

Consignes de sécurité 1

TIA Portal Openness API 7

Impression de l'aide en ligne

1 Consignes de sécurité ................................................................................................................................17

Openness : Automatisation de la création de projet

7.9.2 Etablissement d'une connexion au portail TIA .......................................................................79

Openness : Automatisation de la création de projet

7.12.17 Copier des copies maîtresse................................................................................................174

Openness : Automatisation de la création de projet

7.15.9 Supprimer un appareil..........................................................................................................241

Openness : Automatisation de la création de projet

7.18.5 Logs .....................................................................................................................................296

Openness : Automatisation de la création de projet

7.19.8.5 Protection de l'API par mot de passe ...................................................................................479

Openness : Automatisation de la création de projet

7.19.23.9 Rechercher un objet technologique .....................................................................................550

Openness : Automatisation de la création de projet

7.21.2 Définir la stratégie de sécurité pour OPC UA.......................................................................638

Openness : Automatisation de la création de projet

7.27.6.8 Activation de Safety Integrated ............................................................................................699

Openness : Automatisation de la création de projet

7.29 Fonctions pour DCC.............................................................................................................751

Openness : Automatisation de la création de projet

8.3 Importation/exportation de données d'un appareil IHM........................................................788

Openness : Automatisation de la création de projet

8.5.1.7 Exportation/importation de blocs d'appel SCL .....................................................................874

Openness : Automatisation de la création de projet

8.6.24 Exportation/importation d'appareils et éléments d'appareils basés sur GSD/GSDML.......1015

Openness : Automatisation de la création de projet

Openness : Automatisation de la création de projet

Openness : Automatisation de la création de projet

Openness : Automatisation de la création de projet

Mesures de sécurité pour applications TIA Portal Openness

Copie d'une application TIA Portal Openness

Prise en charge de certaines fonctions dans un projet TIA Portal

Openness : Automatisation de la création de projet

Sécurité en cas de défaut

Amélioration des performances de TIA Portal Openness

Code du programme à thread sécurisé

Comportement d'exportation d'éléments d'écran avec style activé

Openness : Automatisation de la création de projet

Copie des objets technologiques de S7-1500 pour la commande des mouvements

Importation des esclaves ASi via AML

Importation et exportation de touches de fonction

Accès à un appareil en ligne

Openness : Automatisation de la création de projet

Informations sur des fonctions spécifiques

2.2 Modifications majeures dans TIA Portal Openness V16

Exportation de blocs de données avec l'option "Aucun"

Attributs d'adresse de I&M et PROFIsafe pour panneaux de touches et boutons-poussoirs

Exportation d'attributs de bloc de données de la propriété "Structure de la mémoire"

Attributs non pris en charge dans les unités

Openness : Automatisation de la création de projet

Définition du schéma du fichier XML de SimaticML

Amélioration de la méthode d'importation XML pour les blocs et les types

Des GUID AML sont enregistrés dans des ID d'application

Nom de classes d'objets IHM

Nom de la classe Nouveau nom de la classe

Nom de propriété pour l'archive de données/archive d'alarmes ajouté/supprimé

HmiDataLog dataLog = hmiSoftware.DataLogs.Find("DataLog1");

Openness : Automatisation de la création de projet

Nom de propriété supprimé de HMI Tag

2.3 Notification des modifications majeures dans les prochaines versions