Aller au contenu

Forge : bibliothèque de types de blocs

Sur cette page

Forge est votre Bibliothèque de types de blocs réutilisable : vous capturez des blocs existants d'un projet d'automate, vous les rassemblez et les organisez en un seul endroit, puis vous déployez plus tard toute la bibliothèque dans n'importe quel automate connecté : la structure de dossiers de la bibliothèque est recréée comme structure de groupes dans l'automate. Au passage, Forge redessine les projets existants sous forme de graphes de projet que vous pouvez parcourir, valider, modifier et redéployer dans un automate.

Ouvrez le conteneur de vues Forge depuis la barre d'activité. La Bibliothèque de types de blocs apparaît dans la barre latérale sous forme d'arborescence de dossiers et de types, disposée comme l'Explorateur de projet : un projet capturé affiche son dossier de projet, Source et les dossiers Blocs, Types de données et Variables avec les mêmes icônes, et chaque type de bloc porte l'icône de son genre (FB, FC, OB, DB, type de données, table de variables).

Prérequis : Forge fait partie des éditions payantes. Sans licence, les commandes Forge restent désactivées. Consultez Licences.

Se connecter à Forge

  1. Ouvrez la palette de commandes (Ctrl+Shift+P) et lancez "Se connecter à Forge", ou cliquez sur Connecter dans le conteneur de vues Forge.
  2. Une fois la connexion établie, la barre d'état affiche Forge : Connecté et la bibliothèque se charge.

Pour vous déconnecter, lancez "Se déconnecter de Forge".

Capturer des blocs dans la bibliothèque

Vous alimentez la bibliothèque directement depuis un projet TIA ouvert (voir Explorateur de projet). Forge et le projet TIA doivent tous deux être connectés.

  1. Cliquez avec le bouton droit sur un PLC, un groupe ou un seul bloc dans l'Explorateur de projet.
  2. Sélectionnez "Capturer dans la bibliothèque Forge".
  3. Confirmez le nombre d'éléments à capturer.
  4. Forge crée un type réutilisable pour chaque élément et reproduit la structure de groupes du projet sous forme de dossiers dans la bibliothèque.

Les types capturés se trouvent sous un dossier portant le nom du projet (par exemple MixingPlant). Les types de différents projets restent ainsi bien séparés : vous voyez d'un coup d'œil ce qui vient d'où, et la capture d'un second projet ne mélange plus ses blocs avec ceux du premier.

La capture couvre les blocs, les types de données et les tables de variables, y compris ceux des Software Units.

Chaque bloc est enregistré avec son XML à côté de sa source, la même paire que celle écrite par un Export All, de sorte que la bibliothèque contient ce que contient le projet. Les types de données sont enregistrés dans la bibliothèque au format XML. Pour les enregistrer plutôt comme source .udt modifiable, activez Capturer les types de données en source .udt (voir Types de données en source .udt ou XML).

À la fin, une notification indique combien de types ont été créés et combien ont été mis à jour. Les éléments qui ne peuvent pas être capturés sont listés avec leur nom et motif ; les doublons identiques sont ignorés automatiquement et ne sont pas comptés comme des échecs.

Organiser la bibliothèque

Toutes les opérations sont accessibles par un clic droit dans la Bibliothèque de types de blocs :

  • Nouveau type de bloc : ajoute un nouveau type que vous gérez vous-même.
  • Modifier / Dupliquer / Supprimer le type de bloc : sur un type.
  • Dossier / Sous-dossier : structurez la bibliothèque sur autant de niveaux que vous le souhaitez.
  • Renommer : sur un type ou un dossier.
  • Déplacer vers … : affecte un type à un autre dossier ; un sélecteur liste tous les dossiers existants.
  • Créer un graphe de projet à partir de la bibliothèque (barre d'outils) : crée un nouveau graphe de projet à partir de toute la bibliothèque.
  • Créer un graphe de projet à partir du dossier : crée un nouveau graphe de projet à partir de tous les types de blocs du dossier.
  • Créer un graphe de projet à partir de la sélection : crée un nouveau graphe de projet à partir des types de blocs sélectionnés.

Chaque entrée de la liste affiche une courte étiquette de type neutre après le nom du bloc (SCL, DB, UDT ou XML), pour que vous voyiez d'un coup d'œil de quel genre de type il s'agit. La liste Plugins affiche le générateur de code sous le nom TIA SCL.

Vous pouvez réordonner les entrées par glisser-déposer. La structure de dossiers que vous créez ici détermine plus tard la structure de groupes dans l'automate.

Le chat IA vous aide à écrire vos propres modèles de types : adressez-vous à l'agent Forge Engineer. Il connaît le langage de modèles et vous aide à créer, relire et corriger vos modèles.

Installer l'exemple prêt à l'emploi

Pour vous éviter de partir de zéro, Forge fournit un exemple prêt à l'emploi : une bibliothèque complète de types de blocs accompagnée d'un exemple de graphe de projet correspondant, que vous pouvez étudier à votre rythme.

  1. Cliquez sur Installer l'exemple (MixingPlant) dans la barre de titre de la Bibliothèque de types de blocs, ou lancez la même commande depuis la palette de commandes (Ctrl+Shift+P).
  2. Une courte notification indique combien de types ont été ajoutés (et combien étaient déjà présents), et si le graphe d'exemple a été ajouté.

Vous pouvez relancer la commande à tout moment : elle n'écrase jamais vos propres types ou graphes. Les éléments déjà présents sont ignorés, et seul ce qui manque encore est ajouté.

Après l'installation, la bibliothèque affiche un seul dossier Mixing Plant Demo qui contient l'exemple complet : les blocs fidèles de l'installation à côté des types d'exemple réutilisables ; le graphe d'exemple apparaît dans la liste Graphes de projet.

Ouvrez n'importe quel type pour voir comment il est construit : les modèles sont abondamment commentés et expliquent, étape par étape, comment fonctionne la génération et quand chaque élément est utilisé. Vous pouvez ensuite générer du code à partir d'eux et le déployer dans TIA de la même manière que vos propres types.

Stockage et versionnage Git

La Bibliothèque de types de blocs et vos Graphes de projet peuvent se trouver dans des dossiers que vous maîtrisez, pour que vous puissiez les placer sous contrôle de version avec le reste de votre travail. Vous configurez cela dans Paramètres AnyAutomation → Forge.

Choisir l'emplacement de la bibliothèque

Vos types de blocs réutilisables sont conservés dans un Dossier de la bibliothèque. Par défaut, Forge utilise son propre emplacement, mais vous pouvez faire pointer la bibliothèque vers n'importe quel dossier, par exemple un dossier que vous gérez déjà dans un dépôt Git, pour que toute la bibliothèque suive votre historique de versions.

  • Dans Paramètres AnyAutomation → Forge, réglez le Dossier de la bibliothèque sur le dossier que vous voulez utiliser. Utilisez Parcourir… pour en choisir un, ou laissez le champ vide pour conserver l'emplacement par défaut.
  • L'icône de dossier du champ ouvre ce dossier sur le disque (l'emplacement par défaut lorsque le champ est vide), pour que vous puissiez examiner et versionner son contenu avec le contrôle de version intégré de Studio.

Enregistrer les graphes de projet dans le projet

Les graphes de projet sont enregistrés sous forme de fichiers texte. Comme il s'agit de texte brut, vous pouvez les versionner avec Git, et les modifications apparaissent dans vos diffs comme pour tout autre fichier. L'Arborescence de projet fait partie du graphe, elle est donc versionnée avec lui. Vos graphes sont toujours enregistrés et se rechargent au prochain démarrage.

Sur le disque, chaque graphe de projet est un dossier contenant un fichier forge.yaml : un dossier de graphes contient un tel sous-dossier par graphe. Les paramètres décrivent eux aussi cette structure, pour que vous sachiez quoi chercher lorsque vous choisissez un dossier.

Dans Paramètres AnyAutomation → Forge, la section Graphes de projet détermine l'emplacement des graphes :

  • Dossier des Project Graphs : utilisez Parcourir… pour choisir un dossier fixe pour vos graphes. Faites-le pointer, par exemple, vers un dossier que vous gérez déjà dans un dépôt Git. L'icône de dossier du champ ouvre ce dossier sur le disque.
  • Laissez le champ vide pour enregistrer les graphes dans le projet ouvert : dans un sous-dossier (.forge par défaut) juste à côté du projet, que vous pouvez modifier sous Sous-dossier du projet. Si aucun projet n'est ouvert, Forge utilise un emplacement par défaut pour que vos graphes soient tout de même conservés.

La modification de l'un ou l'autre paramètre prend effet immédiatement : la liste Graphes de projet passe au dossier nouvellement choisi et affiche ses graphes sans rouvrir la vue.

Charger un graphe depuis un fichier et recharger la liste

La liste Graphes de projet dispose de deux autres boutons dans sa barre de titre (affichés une fois que vous êtes connecté à Forge) :

  • Charger un graphe de projet depuis un fichier (icône de dossier) : ouvre un sélecteur de fichiers pour charger un graphe qui n'a pas été détecté automatiquement ou qui se trouve en dehors du dossier configuré. Sélectionnez le fichier forge.yaml du graphe ; le graphe apparaît alors dans la liste et s'ouvre immédiatement, et une copie est enregistrée dans votre dossier de graphes actuel.
  • Recharger les graphes de projet (icône d'actualisation) : relit le dossier de graphes depuis le disque, par exemple après une modification des fichiers de graphes en dehors de Studio.

Placer un dossier sous contrôle de version

Pour commencer à versionner un dossier, utilisez le bouton Initialiser le dépôt Git dans la barre de titre de la vue Forge elle-même, de la vue Bibliothèque de types de blocs pour vos types de blocs et de la vue Graphes de projet pour vos graphes (toutes deux affichées une fois que vous êtes connecté à Forge) :

  • Cliquez sur Initialiser le dépôt Git : Studio crée un dépôt Git directement dans ce dossier, puis le confirme par un court message.
  • Vous pouvez ensuite examiner, indexer et committer vos types de blocs ou vos graphes de projet avec le contrôle de version intégré de Studio, comme pour tout autre dossier. Pour accéder au dossier sur le disque, utilisez l'icône de dossier de son champ de chemin dans les paramètres ci-dessus.

Types de données en source .udt ou XML

Deux options dans Paramètres AnyAutomation → Forge, section Types de données, déterminent la façon dont Forge traite les types de données d'automate. Toutes deux sont désactivées par défaut.

  • Capturer les types de données en source .udt : lorsque vous capturez des éléments du projet dans la Bibliothèque de types de blocs, les types de données sont enregistrés comme source .udt modifiable. Si l'option est désactivée, ils sont enregistrés au format XML.
  • Préférer .udt à .xml lors du déploiement : lorsqu'un déploiement ou une importation dans TIA Portal contient un type de données à la fois en .udt et en XML, le .udt est importé et le XML est ignoré. Si l'option est désactivée, le XML est importé et le .udt est ignoré. Si un seul des deux est présent, c'est celui-ci qui est importé dans tous les cas. Cela s'applique au déploiement de la bibliothèque, au déploiement d'un graphe de projet et à l'importation de fichiers générés avec Importer la sélection dans TIA Portal ou Tout importer dans TIA Portal.

Remarque : une source .udt ne porte pas l'attribut de sécurité (fail-safe) d'un type de données. Un type de données de sécurité est donc toujours capturé au format XML et toujours importé depuis son XML, quelle que soit la position de ces options.

Ces deux options sont indépendantes des options de types de données des paramètres Import / Export de TIA Portal, de sorte que Forge et vos propres exportations peuvent être réglés différemment.

Modifier un type de bloc

Double-cliquez sur un type dans la Bibliothèque de types de blocs et il s'ouvre dans un onglet : les champs du type à gauche, un onglet de modèle par cible de sortie à droite. Un bloc capturé affiche son onglet source et un onglet XML en lecture seule ; dès que vous enregistrez une modification de la source, l'onglet XML disparaît et le type est construit à partir de sa seule source. Le bouton Enregistrer de la barre d'outils enregistre l'ensemble du type : les champs et tous les modèles ensemble.

Les modifications non enregistrées sont en sécurité : l'onglet les signale par le point habituel, passer à un autre onglet puis revenir conserve tout (les champs comme le texte des modèles) et la fermeture de l'onglet demande d'abord s'il faut enregistrer ou abandonner, comme pour tout autre fichier.

Ouvrir un modèle dans un éditeur de texte

Un modèle peut aussi être modifié dans un onglet d'éditeur classique, pratique pour le placer côte à côte avec d'autres fichiers :

  • cliquez sur "Ouvrir le modèle dans l'éditeur de texte" dans la barre d'outils de l'onglet du type de bloc, ou
  • cliquez avec le bouton droit sur le type dans la Bibliothèque de types de blocs et choisissez "Ouvrir le modèle dans l'éditeur de texte". Si le type comporte plusieurs modèles, une liste vous demande d'abord lequel ouvrir.

L'onglet texte et l'onglet du type de bloc affichent toujours le même contenu : ce que vous tapez dans l'un apparaît immédiatement dans l'autre. Ctrl+S dans l'onglet texte enregistre uniquement ce modèle ; le bouton Enregistrer de l'onglet du type de bloc enregistre toujours l'ensemble.

Un tout nouveau type de bloc doit être enregistré une fois avant que ses modèles puissent être ouverts de cette façon. Il en va de même pour une cible de sortie tout juste ajoutée, jusqu'au prochain enregistrement.

Le chat voit votre modèle

Tant que l'onglet du type de bloc (ou l'un de ses onglets texte de modèle) est actif, l'assistant de chat dispose automatiquement de ce modèle comme contexte : il apparaît au-dessus de la zone de saisie du chat. Posez directement vos questions sur le modèle : l'assistant connaît son contenu et les fonctions d'aide disponibles pour les modèles, sans que vous ayez à coller quoi que ce soit.

Intégrer un projet

Forge peut redessiner un programme d'automate existant sous forme de graphe de projet en une seule étape, tout en capturant l'ensemble de son contenu sous forme de types de bibliothèque couplés : la base pour redéployer plus tard le programme à partir du graphe.

  1. Connectez d'abord Forge et le projet TIA : ce n'est qu'ensuite que l'entrée correspondante apparaît dans le menu contextuel. Cliquez ensuite avec le bouton droit sur un PLC dans l'Explorateur de projet.
  2. Sélectionnez "Intégrer le projet dans une bibliothèque couplée" et confirmez : les types de bibliothèque portant le même nom sont écrasés.
  3. Un affichage de progression dans la section Import / Export et dans la barre d'état nomme chaque étape avec son compteur : l'exportation depuis TIA Portal, la lecture des fichiers exportés, l'analyse des appels et des dépendances, la construction du graphe de projet, la capture des types de bibliothèque, le couplage du graphe, son importation dans Forge et son ouverture. Annuler arrête l'exécution. À la fin, le nouveau graphe s'ouvre dans un onglet, et une notification résume combien de types ont été capturés et combien d'objets et de connexions ont été dessinés. Le graphe et son arborescence de projet portent le nom du projet, et les types de bibliothèque capturés se trouvent sous un dossier portant le nom du projet, ce qui les sépare des types d'autres projets.

Les éléments qui ne peuvent pas être capturés sont cités dans la notification avec leur nom et motif : ils apparaissent quand même sur le graphe, mais restent sans type de bibliothèque couplé. Lorsqu'un objet référence plusieurs fois le même autre objet, le graphe affiche une seule connexion au lieu d'un faisceau de lignes parallèles.

Créer un graphe de projet à partir de la bibliothèque

Transformez les types de blocs de votre bibliothèque en un graphe de projet prêt à l'emploi, sans ouvrir de projet TIA.

  1. Dans la Bibliothèque de types de blocs, cliquez sur Créer un graphe de projet à partir de la bibliothèque dans la barre d'outils de la vue pour utiliser toute la bibliothèque. Pour utiliser un seul dossier, cliquez dessus avec le bouton droit et choisissez Créer un graphe de projet à partir du dossier. Pour utiliser des types de blocs individuels, sélectionnez-les, cliquez avec le bouton droit et choisissez Créer un graphe de projet à partir de la sélection. La même commande se trouve aussi dans le menu de débordement de la vue Graphes de projet.
  2. Saisissez un nom pour le graphe, ou conservez celui qui est proposé.
  3. Le nouveau graphe s'ouvre. Son arborescence de projet affiche les mêmes dossiers que votre bibliothèque, avec les tables de variables comme nœuds à part entière, et les blocs sont reliés selon la façon dont ils s'appellent et s'utilisent : un bloc qui appelle un autre bloc, un bloc qui lit un bloc de données, un bloc qui écrit une variable ou lit une constante utilisateur avec la table de variables qui la contient, un bloc, un bloc de données ou une table de variables qui utilise un type de données d'automate, et chaque bloc de données d'instance avec son bloc fonctionnel.

Les types de blocs dont dépend la sélection sont ajoutés automatiquement, même lorsqu'ils se trouvent dans un autre dossier, pour que le graphe se génère et se déploie comme un tout. Les tables de variables font partie du graphe comme les blocs : un déploiement les amène dans l'automate avec les types de données qu'utilisent leurs variables, et lorsque vous retirez un bloc du graphe, les tables de variables et les types de données que seul ce bloc utilise vous sont proposés à la suppression avec lui. Les types de blocs situés dans une Software Unit sont laissés de côté. Le message affiché après la création du graphe nomme tout ce qui a été laissé de côté ou ajouté, les noms introuvables dans la bibliothèque et les noms qui correspondent à plusieurs types de blocs. Chaque exécution crée un nouveau graphe et ne modifie jamais un graphe existant. Vous pouvez générer et déployer le graphe comme n'importe quel autre graphe de projet. Lorsque deux blocs d'un graphe portent le même nom, le déploiement s'arrête avant de modifier quoi que ce soit dans l'automate et les nomme.

Modules : transformer un bloc en module avec des instances

Un bloc fonctionnel que votre projet utilise plusieurs fois avec la même empreinte, comme un module de process appelé depuis le bloc principal avec son propre bloc de données d'instance, ses blocs de données, une constante de journal et un paramètre dans le bloc de cellule, peut devenir un module. Le graphe de projet contient alors un nœud par instance de module, l'ajout d'un nœud génère une seconde fois toute l'empreinte, et la suppression d'un nœud emporte toute l'empreinte avec lui.

  1. Dans la Bibliothèque de types de blocs, cliquez avec le bouton droit sur le bloc fonctionnel et choisissez Paramétrer comme module, ou ouvrez le type de bloc et cliquez sur Paramétrer comme module dans sa barre d'outils. La même entrée se trouve dans le menu contextuel d'un bloc dans un graphe de projet ouvert.
  2. L'aperçu Module s'ouvre. Il affiche la clé de module (MIX pour fbMixer), que vous pouvez modifier avant de relancer l'analyse, les instances trouvées dans le projet (MIX01, MIX02, ...), les membres qui appartiennent à chaque instance (bloc de données d'instance, blocs de données, autres objets nommés d'après l'instance) regroupés selon leur modèle de nom avec une case à cocher par groupe (les groupes dont l'analyse n'est pas sûre sont décochés au départ), ainsi que chaque bloc, table de variables, bloc de données et type de données d'automate qui mentionne une instance ou déclare un membre nommé d'après elle, avec son genre et le nombre d'occurrences.
  3. Sous Décisions, vous voyez chaque endroit où une instruction touche plusieurs modules à la fois, par exemple une ligne qui transmet une valeur d'un module à un autre. Choisissez pour chaque ligne si elle reste telle quelle dans le bloc généré (par défaut), si elle est répétée pour chaque instance ou si elle est répétée avec l'instance de même numéro de l'autre module. Les lignes qui utilisent un nom qui n'est pas créé pour chaque instance sont listées sans choix et restent toujours telles quelles ; l'indication à côté de la ligne en donne la raison, par exemple quel groupe de membres vous devez cocher pour que la ligne puisse être répétée, ou que le nom est écrit avec des majuscules et des minuscules différentes.
  4. Cliquez sur Exécution à blanc pour voir le résultat sans rien modifier : pour chaque bloc, l'aperçu indique s'il a passé la vérification (le bloc généré est identique au bloc capturé) et affiche le modèle généré.
  5. Cliquez sur Appliquer. La bibliothèque génère désormais les blocs hôtes à partir de la liste des instances. Lorsque l'aperçu a été ouvert depuis un graphe de projet, ce graphe est converti en même temps : les blocs de données d'instance et les blocs de données de chaque instance deviennent un nœud d'instance de module par instance, relié au bloc qui l'appelle et aux blocs qui l'hébergent.

Un graphe de bibliothèque créé ensuite avec Créer un graphe de projet à partir de la bibliothèque affiche lui aussi les instances de module sous forme de nœuds. Pour ajouter une instance, cliquez avec le bouton droit sur un nœud d'instance et choisissez Ajouter une instance de module : le prochain nom libre est proposé (MIX03 lorsque MIX01 et MIX02 existent, en sautant les noms que le projet utilise déjà ailleurs) et vous pouvez le modifier. Le nouveau nœud reçoit les mêmes connexions que son voisin. Supprimer le nœud sur un nœud d'instance liste les blocs dans lesquels du code est généré pour cette instance, pour que vous voyiez ce qui en disparaît. Un déploiement du graphe génère chaque bloc hôte à partir de ses instances et apporte les blocs de données de chaque instance sous leurs noms d'instance et avec leurs propres numéros de bloc, de sorte que les blocs des instances existantes conservent leurs numéros. Les blocs de données et les types de données d'automate qui contiennent un membre par instance reçoivent ce membre pour chaque instance, avec ses valeurs initiales. Un type de bloc que vous avez modifié à la main après l'avoir paramétré conserve votre modification et n'est pas changé par un module ultérieur ; une copie d'un tel type de bloc redevient le simple bloc capturé.

Si un nouveau nom d'instance est déjà pris par un bloc qui reste dans le graphe de projet, Appliquer est bloqué et l'aperçu nomme le bloc et le groupe de membres à vérifier. L'analyse signale ce qu'elle n'a pas pu décider : un bloc qui appelle le module depuis un réseau graphique, un membre qui sert deux instances, un nom du modèle que le projet utilise déjà pour autre chose (un tel nom n'est jamais proposé pour une nouvelle instance) et un compteur dans une table de variables qui ne peut pas suivre les nouvelles instances. La clé de module est figée une fois appliquée.

Paramétrer comme module est proposé pour les blocs fonctionnels, pas pour les blocs fonctionnels de sécurité. Un module ne peut pas se trouver à l'intérieur d'un autre module : un bloc fonctionnel qui contient déjà du code généré pour un module n'est pas proposé et ne peut pas devenir lui-même un module, et un bloc qui est déjà un module reste inchangé lorsque vous analysez un autre module, l'aperçu le liste et laisse ses occurrences telles quelles. Chaque clé de module doit être unique dans la bibliothèque, y compris lorsque seules les majuscules et les minuscules diffèrent : lorsqu'un autre module utilise déjà la clé, l'aperçu le signale, et vous saisissez une autre clé et relancez l'analyse.

L'assistant du chat IA peut faire la même chose pour vous. Demandez-lui par exemple d'analyser fbMixer comme module : il indique la clé, les instances, les membres, les blocs concernés et les lignes qui nécessitent une décision, et vous pouvez lui dire comment les trancher. Lorsque vous lui demandez d'appliquer le module, il montre d'abord ce qui va changer, la clé, les instances et chaque bloc régénéré, laissé tel quel ou bloqué, et il n'applique qu'après votre confirmation. Lorsque vous nommez un graphe de projet ouvert, ce graphe est converti comme avec Appliquer dans l'aperçu.

Un graphe de projet créé avant l'application d'un module contient encore les anciens blocs de données d'instance et blocs de données de ce module sous forme de nœuds simples. Lorsque vous déployez un tel graphe, le déploiement s'arrête avant de modifier quoi que ce soit dans l'automate et vous demande de convertir d'abord le graphe. Cliquez avec le bouton droit sur le graphe de projet et choisissez Convertir en instances de module, ou cliquez sur le bouton du même nom dans cet avis. Une confirmation liste, pour chaque module, les nœuds supprimés et les nœuds d'instance de module ajoutés ; une fois que vous avez confirmé, tous les modules sont convertis en une seule étape et un avis indique le résultat. Un module dont les blocs ne peuvent pas être associés à exactement une de ses instances reste inchangé et est nommé dans la confirmation ; pour le convertir, recréez le graphe avec Créer un graphe de projet à partir de la bibliothèque. L'assistant du chat IA peut aussi le faire : il affiche la même liste et ne convertit qu'après votre confirmation. Convertir en instances de module nécessite le forfait Pro+ ; l'essai gratuit le débloque aussi.

Certains blocs contiennent du code pour chaque instance d'un module, par exemple une table de variables avec les constantes de chaque instance. Lorsque le graphe de projet contient les nœuds d'instance de module mais aucun nœud pour un tel bloc, le déploiement s'arrête aussi et propose Convertir en instances de module. La conversion ajoute alors ces blocs de la bibliothèque au graphe et y relie les instances de module ; la confirmation les nomme. Lorsqu'un bloc ne peut pas être ajouté, parce que la bibliothèque ne le contient plus, qu'il se trouve dans une Software Unit ou qu'un autre nœud du graphe porte déjà son nom, la confirmation et le résultat indiquent que la conversion est incomplète et nomment le bloc avec la raison. Un déploiement ne génère alors pas le code des instances de module dans ce bloc : restaurez le bloc dans la Bibliothèque de types de blocs, ou renommez ou supprimez l'autre nœud, puis convertissez à nouveau ; un bloc dans une Software Unit, vous le tenez vous-même à jour dans TIA. Un nœud d'instance de module que vous avez ajouté vous-même avec Ajouter une instance de module est relié comme l'instance à partir de laquelle vous l'avez ajouté. Lorsque cela ne peut pas être déterminé, la confirmation le nomme, et vous le supprimez puis l'ajoutez à nouveau après la conversion.

Paramétrer tous les blocs fonctionnels qu'appelle un bloc d'organisation

Lorsque votre bloc d'organisation principal appelle plusieurs modules de process, vous pouvez les transformer en modules en une seule passe au lieu de l'un après l'autre.

  1. Cliquez avec le bouton droit sur un bloc d'organisation SCL, par exemple Main, dans la Bibliothèque de types de blocs ou dans un graphe de projet ouvert et choisissez Paramétrer les blocs fonctionnels appelés comme modules.
  2. L'aperçu du lot s'ouvre. Il liste chaque bloc fonctionnel qu'appelle le bloc d'organisation, dans l'ordre de leur premier appel, chacun avec la ligne de cet appel, sa clé de module proposée, ses instances et les blocs qui les hébergent (les dix premiers, la liste complète lorsque vous la survolez). Les blocs fonctionnels qui peuvent devenir des modules sont cochés ; Tout cocher et Tout décocher modifient toutes les lignes à la fois. Saisissez une autre clé dans le champ Clé d'une ligne lorsque vous en souhaitez une ; une clé marquée à vérifier n'est pas confirmée par les noms des instances, vérifiez-la donc avant de continuer. Afficher les détails ouvre les membres, les hôtes et les décisions d'un bloc fonctionnel, comme dans l'aperçu Module d'un bloc unique.
  3. Sélectionnez Inclure les appels indirects (via des fonctions) pour lister aussi les blocs fonctionnels que le bloc d'organisation atteint par les fonctions qu'il appelle. La liste s'arrête aux blocs fonctionnels : ce qu'un bloc fonctionnel appelle lui-même n'est pas ajouté. Vos coches et vos clés sont conservées.
  4. Une ligne qui ne peut pas être cochée en indique la raison : un bloc de sécurité, un bloc sans source SCL (bloc graphique, de bibliothèque ou système), un bloc qui est déjà un module ou en contient déjà un, ou un bloc fonctionnel sans instances. Lorsque vous cochez deux blocs fonctionnels dont l'un appelle l'autre, les deux lignes indiquent Imbriqué avec ... : les modules dans des modules ne sont pas pris en charge, laissez donc l'un d'eux décoché. Lorsque deux lignes cochées reçoivent la même clé, même lorsque seules les majuscules et les minuscules diffèrent, les deux indiquent Même clé que ... : saisissez une autre clé pour l'une d'elles. Une ligne laissée décochée à cause d'un tel partenaire affiche la raison sous la forme Non coché : .... Certaines remarques n'arrêtent pas la passe : le bloc fonctionnel est aussi appelé depuis un autre bloc d'organisation, il est aussi utilisé comme multi-instance dans un autre bloc (cette utilisation reste telle quelle), ou l'un de ses hôtes est lui-même un module (les appels dans cet hôte restent tels quels).
  5. Après avoir modifié des coches ou des clés, cliquez sur Analyser. Cliquez ensuite sur Exécution à blanc pour voir le résultat sans rien modifier : pour chaque bloc fonctionnel, s'il sera appliqué et quels blocs il réécrit, ou pourquoi il est écarté.
  6. Sous Conflits entre modules, l'exécution à blanc liste chaque instruction que deux modules cochés répéteraient tous deux pour leurs instances, par exemple une ligne d'un bloc partagé qui transmet une valeur de fbMixer à FB_Motor. Par défaut, une telle instruction reste telle quelle pour les deux modules (Les deux restent littéraux). Vous pouvez à la place choisir le module qui la répète, par exemple Boucle dans le module MIX, et relancer l'exécution à blanc.
  7. Cliquez sur Appliquer et confirmez. La confirmation nomme les modules appliqués, les blocs fonctionnels écartés et les blocs de la bibliothèque réécrits, et compte comment les instructions partagées sont traitées. Lorsque l'aperçu a été ouvert depuis un graphe de projet, Appliquer lance d'abord une nouvelle exécution à blanc et le graphe est converti en même temps en nœuds d'instance de module.

La bibliothèque se présente alors comme si vous aviez lancé Paramétrer comme module une fois pour chaque bloc fonctionnel appliqué, dans l'ordre des appels. Un bloc fonctionnel dont le bloc d'organisation ne peut pas répéter les appels pour chaque instance est écarté, et les autres sont appliqués malgré tout : un avis liste les blocs fonctionnels écartés, et l'aperçu affiche la raison sur chaque ligne et sous Constats du lot. Cliquez sur Actualiser pour lister à nouveau les blocs fonctionnels après une application. Ajoutez des instances et déployez comme décrit plus haut. L'exécution à blanc compare chaque bloc généré au bloc capturé ; après avoir ajouté des instances, compilez donc le projet dans TIA pour vérifier aussi les nouvelles.

L'assistant du chat IA peut faire de même. Demandez-lui par exemple de lister les blocs fonctionnels qu'appelle Main, de les analyser comme modules avec une exécution à blanc, de laisser un module répéter une instruction partagée, puis de les appliquer. Avant d'appliquer quoi que ce soit, il affiche une confirmation qui liste chaque module avec ses instances, chaque bloc fonctionnel écarté avec sa raison, chaque bloc réécrit et la façon dont chaque instruction partagée est traitée, et il n'applique qu'après votre confirmation.

Paramétrer les blocs fonctionnels appelés comme modules nécessite le forfait Pro+ ; l'essai gratuit le débloque aussi.

Afficher le graphe de projet

Lorsque Forge lit un projet existant, vous pouvez le parcourir comme un navigateur de dépendances. Ouvrez un graphe depuis la liste Graphes de projet du conteneur de vues Forge : double-cliquez sur un graphe et il s'ouvre dans un onglet. Même les très grands projets comportant des milliers de blocs s'ouvrent instantanément.

L'onglet est divisé en deux zones : une arborescence de tous les blocs à gauche, et les dépendances du bloc sélectionné à droite.

Choisir un bloc dans l'arborescence

L'arborescence de gauche liste tous les blocs du projet sous la même forme que l'Explorateur de projet : le projet, son dossier Source, l'automate (lorsque le graphe a été lu depuis un projet), puis les dossiers Blocs, Types de données et Variables et les groupes qu'ils contiennent, avec les mêmes icônes. Chaque ligne porte l'icône de son genre de bloc (FB, FC, OB, DB, type de données, table de variables) et un petit indicateur de couplage qui montre d'un coup d'œil à quel point le bloc est connecté. Cliquez sur un bloc pour voir ses dépendances à droite.

Une zone de recherche vous permet de taper un nom de bloc : l'arborescence ouvre les dossiers sur le chemin de la correspondance et y saute directement, pour que vous trouviez n'importe quel bloc sans faire défiler.

Voir ce qui utilise un bloc, et ce qu'il utilise

Pour le bloc sélectionné, deux listes apparaissent à droite :

  • Utilisé par : chaque bloc qui utilise celui-ci (par exemple un bloc d'organisation qui l'appelle).
  • Utilise : chaque bloc que celui-ci utilise lui-même (blocs appelés, types de données référencés, etc.).

Chaque entrée affiche le nom du bloc et le type de relation sous forme d'étiquette colorée. Les boutons de filtre en haut masquent un type de relation ou les réaffichent tous. Un indicateur de couplage dans l'en-tête résume à quel point le bloc est connecté. Si le bloc n'utilise rien, ou n'est utilisé nulle part, cela est indiqué explicitement.

Cliquez sur une entrée pour sauter directement à ce bloc : il est sélectionné dans l'arborescence et ses dépendances apparaissent à droite. Vous parcourez ainsi le projet pas à pas.

Basculer entre liste et voisinage

Un sélecteur fait basculer la partie droite entre deux vues :

  • Liste : les deux colonnes Utilisé par / Utilise (décrites ci-dessus).
  • Voisinage : une petite image qui montre le bloc sélectionné au centre avec ses voisins directs autour de lui. Cliquez sur un voisin pour centrer la vue sur lui et continuer. Faites défiler pour zoomer autour du curseur, faites glisser avec le bouton central de la souris pour vous déplacer, et double-cliquez sur un emplacement vide pour réajuster le graphe dans la vue. Utilisez le sélecteur Profondeur dans le coin supérieur gauche pour afficher plus ou moins de niveaux autour du bloc, afin de suivre ce qu'il utilise (et ce qui l'utilise) sur plusieurs niveaux à la fois au lieu de cliquer bloc par bloc. Si un niveau n'affiche qu'une partie des blocs, un repère +N autres révèle le lot suivant de blocs à chaque clic, et Afficher moins les replie ; le tableau liste toujours tous les blocs. Cliquez avec le bouton droit sur n'importe quel bloc (celui du centre ou un voisin) pour Ouvrir les objets de projet, Connecter, Supprimer l'arête, Supprimer le nœud et Générer la sélection.

La dernière vue que vous avez choisie est mémorisée pour ce graphe.

Supprimer plusieurs graphes de la liste

Dans la liste Graphes de projet, vous pouvez aussi sélectionner plusieurs graphes à la fois : Ctrl+clic ajoute ou retire une entrée individuelle, Shift+clic sélectionne une plage, et Ctrl+A sélectionne tout. Appuyez ensuite sur Delete (lorsque la liste a le focus), ou cliquez avec le bouton droit sur la sélection et choisissez "Supprimer N graphes de projet" : une seule confirmation couvre toute la sélection. Pour supprimer un seul graphe, utilisez le bouton corbeille qui apparaît lorsque vous survolez sa ligne.

Renommer un graphe

Cliquez avec le bouton droit sur un graphe dans la liste Graphes de projet et choisissez "Renommer le graphe de projet", ou cliquez sur le crayon dans la barre de titre de l'Arborescence de projet. Saisissez le nouveau nom et il apparaît partout : dans la liste, dans l'arborescence de projet et dans un onglet déjà ouvert. (Le graphe de projet et l'arborescence de projet sont le même graphe, le renommage prend donc effet dans les deux.)

Modifier le graphe

Vous modifiez les nœuds et les connexions avec les boutons de la barre d'outils : Ajouter un nœud, Connecter, Supprimer le nœud, Supprimer l'arête et Actualiser. Connecter et Supprimer le nœud deviennent actifs dès que vous avez sélectionné un bloc ; Supprimer l'arête propose les connexions du bloc sélectionné. Avant qu'un bloc ne disparaisse, la confirmation liste ses DB d'instance et les objets que plus rien n'utilise une fois le bloc supprimé, avec une case à cocher pour les supprimer avec lui ; les blocs qui appellent le bloc supprimé restent. Après chaque modification, la vue s'actualise ; si une modification ne peut pas être appliquée, un message en explique la raison et rien ne change.

Lorsque vous supprimez un nœud qui est le seul utilisateur d'autres objets, par exemple un bloc dont les types de données ne sont référencés par rien d'autre, la boîte de dialogue de confirmation liste ces objets par leur nom et propose une case à cocher précochée "Supprimer aussi les N objets référencés uniquement par ce nœud". Laissez-la cochée pour les nettoyer en même temps que le nœud, ou décochez-la pour ne supprimer que le nœud. Les objets qu'un autre nœud utilise encore ne sont jamais listés ni supprimés.

Générer du code uniquement pour les objets sélectionnés

Vous n'êtes pas obligé de générer tout le projet d'un coup : vous pouvez générer du code uniquement pour les objets que vous choisissez.

  1. Dans l'arborescence, sélectionnez les blocs souhaités : maintenez Ctrl/Cmd et cliquez sur plusieurs d'entre eux, ou maintenez Shift et sélectionnez une plage contiguë.
  2. Choisissez Générer les nœuds sélectionnés : depuis le bouton Générer la sélection de la barre d'outils, ou depuis la palette de commandes.

Seuls les objets sélectionnés sont (re)générés ; tout ce que vous avez généré auparavant reste en l'état. Le reste du projet est tout de même vérifié en arrière-plan pour que les références croisées soient résolues correctement, et la génération ne s'arrête que si l'un des objets sélectionnés présente un problème.

Lorsque vous avez fini de choisir des objets, générez à tout moment le projet entier avec Générer le graphe de projet (palette de commandes).

Générateurs de code et cibles de sortie

Forge transforme chaque objet en source grâce à un générateur de code. Les générateurs dont vous disposez sont listés dans la vue Plugins du conteneur de vues Forge ; le générateur intégré pour Siemens SCL apparaît sous le nom TIA SCL. Chaque ligne nomme le générateur avec sa version. La liste est informative : vous ne choisissez pas de cible ici. Recharger les plug-ins actualise la liste après l'ajout ou la modification de générateurs. Si aucun générateur n'est disponible, la vue l'indique en rouge et Build affiche le même message : mettez Studio à jour vers la dernière version, puis choisissez Recharger les plug-ins.

Choisir ce qui est généré

Vous choisissez la cible de sortie à chaque génération, ni dans les paramètres ni dans la liste Plugins. Dès que vous lancez "Générer le graphe de projet" ou "Générer les nœuds sélectionnés", un sélecteur vous demande pour quelles cibles générer ; toutes les cibles disponibles sont présélectionnées. Confirmez la sélection et la source est produite par cible. TIA SCL est la cible intégrée pour Siemens SCL.

Le générateur qui traite un objet donné dépend de son Type de bibliothèque ou, s'il n'est pas défini, de son Sous-type. Vous définissez les deux dans la section Inspecter et modifier un objet.

Choisir les fichiers générés à importer

Après une génération, les fichiers générés apparaissent dans la vue Sortie de génération, chacun avec une case à cocher (et une case par groupe qui coche ou décoche tous ses fichiers d'un coup).

  • Cochez les fichiers souhaités et choisissez Importer la sélection dans TIA Portal pour importer uniquement ceux-ci dans l'automate connecté. Cette action reste désactivée tant qu'aucun fichier importable n'est coché.
  • Choisissez Tout importer dans TIA Portal pour importer tous les blocs générés, quelles que soient les cases cochées.

Les deux suivent les règles habituelles : Forge et le projet TIA doivent être connectés, vous choisissez l'automate cible lorsque le projet en comporte plusieurs, les blocs de même nom ne sont écrasés qu'après votre confirmation, et une notification indique combien de blocs ont été importés. Les éléments marqués comme protégés par le cadenas rouge dans l'arborescence de projet ne sont pas écrasés et sont listés comme protégés dans la notification (voir Éléments protégés).

Parcourir les objets dans l'arborescence de projet

La vue Arborescence de projet de la barre latérale Forge affiche les objets d'un graphe de projet sous forme d'arborescence de dossiers : la même structure de dossiers que dans le projet. Lorsqu'un niveau de dossier contient plusieurs genres d'objets, l'arborescence les regroupe en plus par catégorie (blocs fonctionnels, blocs de données, types de données, etc.).

  • Lorsque plusieurs graphes existent, une liste déroulante en haut de la vue choisit le graphe affiché : chaque entrée porte le nom du graphe et sa date de création.
  • Le bouton corbeille de la barre de titre de la vue supprime le graphe affiché (après confirmation).
  • Cliquez sur un objet pour examiner ses détails ; un double-clic (ou Enter) ouvre le graphe dans un onglet et saute directement à l'objet.
  • Cliquez avec le bouton droit sur un objet pour "Afficher dans le graphe", "Ouvrir les objets de projet" (ouvre le tableau préfiltré sur le dossier de l'objet) et "Supprimer le nœud" (avec confirmation). Cliquez avec le bouton droit sur un dossier pour "Ouvrir les objets de projet du dossier".

L'arborescence se met à jour en direct à mesure que le graphe change.

Modifier les objets dans le tableau

"Ouvrir les objets de projet" (palette de commandes, ou menu contextuel de l'arborescence de projet) ouvre les objets d'un graphe sous forme de tableau dans un onglet d'éditeur : l'endroit où examiner les propriétés et les modifier sur de nombreux objets à la fois.

  • Filtre : des bascules par genre d'objet, une liste déroulante de sous-type, une zone de préfixe de dossier, une recherche dans le symbole et la description, et une bascule "Sans arêtes" pour les objets sans connexion. Une liste déroulante de tri avec une bascule croissant/décroissant ordonne les lignes.
  • Colonnes : Symbole, Genre, Sous-type, Dossier, Description et Arêtes. Lorsque le tableau n'affiche que des objets d'un seul sous-type, il ajoute une colonne par propriété.
  • Valeurs en direct : lorsque vous êtes en ligne avec un automate, activez Surveillance en haut à droite : la colonne En direct affiche alors la valeur actuelle de chaque variable et la tient à jour tant que la surveillance est active. Les objets structurés et les tableaux affichent un tiret, car ils n'ont pas de valeur unique. Pour suivre une seule variable sans tout surveiller, cliquez sur l'œil de sa ligne pour observer cette seule valeur ; cliquez à nouveau pour arrêter.
  • Modification directe : cliquez sur une cellule (symbole, description ou propriété) et modifiez la valeur sur place : elle est enregistrée immédiatement. Si l'objet a été modifié ailleurs entre-temps, le tableau recharge les dernières valeurs au lieu de les écraser.
  • "Définir la colonne…" : sélectionnez plusieurs lignes et attribuez la même valeur à une propriété pour toutes ces lignes. L'opération s'exécute avec un indicateur de progression et peut être annulée ; en cas de conflit, elle s'arrête et indique combien d'objets ont été définis. Les autres restent inchangés.

Si le graphe de projet est supprimé alors que son tableau est ouvert, l'onglet affiche une note qui le signale et peut simplement être fermé. Aucun message d'erreur n'apparaît.

Inspecter et modifier un objet

Sélectionnez un objet (dans l'arborescence de projet, le tableau ou sur la carte) et l'Inspecteur du conteneur de vues Forge affiche tous ses champs, regroupés en Profils, Nœud, Propriétés et Points de données. La plupart des champs sont modifiables directement ici, et chaque modification est enregistrée immédiatement. Si le même objet a été modifié ailleurs entre-temps, l'Inspecteur demande s'il faut recharger les dernières valeurs au lieu d'écraser votre modification à l'aveugle.

Profils : profil et variante du graphe

Le réglage tout en haut s'applique à l'ensemble du graphe, pas à l'objet seul : un Profil choisi dans la liste (l'entrée Aucun supprime l'affectation) et une Variante facultative. Cela transmet les valeurs par défaut du profil à chaque objet (décrit en détail sous Profils : superposer des valeurs par défaut).

Nœud : symbole, genre, description, sous-type et type de bibliothèque

  • Symbole : le nom de l'objet tel qu'il apparaît dans l'arborescence, sur la carte et dans les références. Librement modifiable.
  • Genre : la catégorie de base de l'objet. Valeurs possibles : Équipement, Cellule / Station, Ressource, Pièce, Point d'E/S, Matériel et Composite. Ce champ est en lecture seule. Les blocs intégrés sont toujours Composite, de sorte qu'un bloc capturé depuis un projet affiche toujours la même valeur ; les autres genres ne sont attribués que lorsque vous modélisez vous-même une installation.
  • Description : un commentaire libre. Librement modifiable.
  • Sous-type : la catégorie de bloc concrète que représente l'objet. Saisissez-la directement, ou cliquez sur le symbole du sélecteur et choisissez parmi les Genres de blocs (OB, FB, InstanceDB, FC, DB, UDT, TO, Tag), les genres Failsafe (FOB, FFB, FFC, FDB), ou saisissez votre propre identifiant via Personnalisé….
  • Type de bibliothèque : relie l'objet à un type réutilisable de la Bibliothèque de types de blocs ; la source est générée à partir de ce type. Saisissez-le, ou choisissez-le dans votre bibliothèque ou parmi les types intégrés via le symbole du sélecteur ; "Aucun" supprime le lien. Lorsqu'un type de bibliothèque est défini, il prime sur le sous-type lors de la génération ; s'il n'y en a pas, le sous-type s'applique. Lorsque le type choisi repose sur un type de données partagé, Forge ajoute ce type de données au graphe pour vous : il apparaît comme un nœud à part entière avec une ligne de liaison, de sorte que la dépendance est visible et accompagne le graphe lors du déploiement. Définir à nouveau le même type ne crée pas de doublons.
  • Version : un numéro de révision en lecture seule qui augmente à chaque modification. Il empêche qu'une modification faite ailleurs soit écrasée par accident.

Propriétés

La section Propriétés affiche les propriétés de l'objet, une par ligne :

  • Les propriétés déclarées du sous-type ou du type de bibliothèque apparaissent sous forme de champs adaptés (nombre, interrupteur, liste déroulante ou texte), certaines marquées comme obligatoires (*) ou avec une unité. Vous pouvez effacer leur valeur, mais pas supprimer la ligne.
  • Les propriétés libres peuvent être modifiées librement et supprimées avec l'icône corbeille. Les objets intégrés apportent de telles entrées libres, par exemple le numéro de bloc, le chemin du dossier de projet, un indicateur pour les blocs de sécurité et le nom TIA d'origine.

Points de données

La section Points de données liste les points de données nommés d'un objet avec leur type de données (et, le cas échéant, leur unité et leur valeur). La liste est en lecture seule. Pour les objets intégrés ou tout juste ajoutés, elle est généralement vide : les points de données n'apparaissent que lorsqu'un objet a été chargé ou créé avec eux.

Profils : superposer des valeurs par défaut

Un profil est un ensemble nommé de valeurs par défaut qui s'applique à tout un graphe de projet. Au lieu de définir la même valeur sur de nombreux objets un par un, vous la définissez une seule fois dans le profil : elle se reporte alors dans la colonne Valeur effective des objets du projet et dans le code généré. Les valeurs peuvent être superposées par Type, Rôle et Variante : une valeur plus spécifique l'emporte sur une valeur plus générale.

Gérer les profils

La vue Profils du conteneur de vues Forge liste tous les profils. Faites un clic droit sur une entrée ou utilisez les boutons de la vue :

  • Nouveau profil : vous lui donnez un identifiant et un nom d'affichage. Les identifiants ne peuvent contenir que des lettres, des chiffres et des traits de soulignement.
  • Renommer le profil / Dupliquer le profil / Supprimer le profil : sur un profil (la suppression demande d'abord confirmation).

Un double-clic ouvre le profil dans un onglet.

Modifier un profil

L'éditeur de profil est centré sur la résolution : vous choisissez une cible en haut et, en dessous, vous voyez pour chaque propriété la valeur qui en résulte et sa provenance.

  1. Choisir la cible : réglez Type sur le type de bloc dont vous voulez définir les valeurs par défaut, ou saisissez un Rôle, et éventuellement une Variante. Type et Rôle s'excluent mutuellement ; l'éditeur vous le signale (par exemple "Clear Role to target a Type").
  2. Le tableau comporte trois colonnes : Propriété, Valeur effective et Couche source.
    • Les lignes héritées sont grisées ; la couche source indique d'où vient la valeur : la valeur par défaut intégrée du type, la Base du profil ou une couche plus générale.
    • Les lignes que vous définissez vous-même affichent Propre dans la couche source.
  3. Définir une valeur : double-cliquez sur une cellule de Valeur effective et saisissez : la ligne devient Propre (votre propre valeur pour exactement cette cible) et affiche aussitôt la valeur saisie.
  4. Réinitialiser : l'icône de rétablissement au bout d'une ligne Propre supprime votre substitution ; la ligne revient à la valeur héritée.
  5. Enregistrer : Enregistrer (ou Ctrl+S) enregistre le profil ; les modifications non enregistrées sont signalées par le point habituel sur l'onglet. Si vous enregistrez un profil qui n'a encore aucune valeur propre, Studio confirme l'enregistrement et vous rappelle que rien n'est stocké tant que vous n'avez pas choisi un Type et modifié une Valeur effective : choisir un Type seul ne stocke rien.

Lorsque Type est réglé sur l'entrée vide, le tableau affiche les valeurs de base du profil (vides au départ pour un nouveau profil). Choisissez un Type pour voir et définir ses propriétés. L'éditeur mémorise le dernier Type, Rôle et Variante choisis pour chaque profil et les rétablit à la prochaine ouverture du profil, si bien que vos propres valeurs sont visibles immédiatement.

Un profil couvre de nombreuses cibles. Vous n'êtes pas limité à un seul Type : changez le Type (ou le Rôle / la Variante) en haut et définissez à nouveau des valeurs : chaque cible que vous modifiez est conservée dans le même profil. Un profil peut ainsi contenir, par exemple, des valeurs par défaut de base ainsi que des valeurs distinctes pour mixerT et agitator côte à côte. Lorsque le profil est appliqué, un objet reprend les valeurs des couches qui lui correspondent, et une couche plus spécifique l'emporte sur une couche plus générale : Type sur Base, et une combinaison Type+Variant sur Type seul. Un objet d'un Type que vous n'avez jamais défini reçoit simplement les valeurs de base (ou intégrées).

Valeurs sous forme d'expressions

Une valeur n'a pas besoin d'être une constante fixe : vous pouvez saisir à la place une expression, évaluée pour chaque objet au moment de la génération. Écrivez-la en la faisant précéder de =, par exemple ={{ node.symbol }} fault ou ={{ node.props.openTime + 2 }}. Une expression peut lire le nom de l'objet (node.symbol), son rôle (node.role), son type (node.type) et les propriétés déjà définies de l'objet qui ont une valeur constante (node.props.<name>).

  • Pour qu'une valeur commence par un = littéral, faites-la précéder de = (=Start produit le texte =Start).
  • Dans l'éditeur, l'expression apparaît exactement telle que vous l'avez saisie ; elle n'est évaluée qu'au moment de la génération, pour chaque objet.
  • Si une expression ne peut pas être évaluée, la génération signale une erreur pour cet objet et ne génère rien : une valeur erronée n'est jamais utilisée en silence.

Appliquer un profil à un graphe

Le profil et la variante qui s'appliquent à un graphe de projet se choisissent dans l'Inspecteur de ce graphe, section Profils : choisissez un Profil dans la liste (l'entrée Aucun supprime l'affectation) et éventuellement une Variante. Les valeurs par défaut du profil choisi apparaissent alors dans la colonne Valeur effective des objets du projet et se reportent dans le code généré.

Prévisualiser en direct le code source généré

Lorsqu'un objet du projet est sélectionné (dans l'arborescence du projet, le tableau ou sur la carte), "Aperçu du code source généré" (palette de commandes) ouvre le code source généré de cet objet, en lecture seule, juste à côté de votre travail. La première fois, Forge demande quelles cibles de génération de code prévisualiser ; le choix est mémorisé pour chaque graphe. Si l'objet n'a pas de code source généré, une brève remarque apparaît dans la barre d'état.

Pour que l'aperçu suive automatiquement votre sélection, activez l'option Preview : Auto Open dans la section Forge des paramètres : l'aperçu se met alors à jour de lui-même lorsque vous parcourez les objets.

Valider le graphe de projet

"Valider le graphe de projet" (palette de commandes) analyse un graphe à la recherche d'anomalies : par exemple une connexion que des objets comparables possèdent mais qui manque à celui-ci, une propriété obligatoire vide ou une valeur numérique inhabituelle. Une notification résume les avertissements et les remarques, et les résultats apparaissent dans la vue Diagnostic sous Vérifications d'anomalies. Un clic sur un résultat mène directement à l'objet concerné sur la carte. La vérification est en lecture seule : elle ne modifie jamais le graphe.

Assistance IA

L'assistant de chat connaît vos graphes de projet : il peut lire les objets et leurs propriétés, valider le graphe et, sur votre instruction, ajouter, modifier ou supprimer des objets et des connexions. Chaque modification du graphe demande d'abord votre confirmation, et vous pouvez autoriser une modification une seule fois, pour la session ou définitivement si vous préférez ne plus être sollicité.

L'assistant prend aussi en charge le catalogue de machines et la boucle CMS : demandez-lui de déclarer un graphe comme modèle de machine, d'exporter le catalogue de machines dans un fichier ou de l'envoyer vers votre CMS du catalogue de machines, de lister les configurations qui y sont publiées, de matérialiser une configuration (depuis un fichier ou directement depuis le CMS, y compris le renvoi du manifeste tel que construit), ou de renvoyer le manifeste tel que construit d'une machine après un déploiement. Chaque étape qui modifie quelque chose ou communique avec le CMS demande d'abord votre confirmation, sauf si vous avez autorisé cette étape pour la session ou définitivement, et la validation stricte est la même qu'avec les commandes : une configuration non valide ne matérialise rien.

Déployer la bibliothèque sur un automate

Une seule commande matérialise toute la bibliothèque sous forme de blocs dans un automate connecté.

  1. Assurez-vous que Forge est connecté et que le projet TIA comporte un automate (connectez le projet via "Se connecter à TIA Portal").
  2. Cliquez sur Déployer (icône de nuage) dans la barre de titre de la Bibliothèque de types de blocs, ou lancez "Déployer la bibliothèque dans TIA Portal" depuis la palette de commandes.
  3. Si le projet comporte plusieurs automates, choisissez l'automate cible dans la liste.
  4. Si des blocs portant les mêmes noms existent déjà, une confirmation s'affiche avec le nombre de blocs qui seront écrasés : confirmez avec "Deploy and Overwrite" ou annulez.
  5. Une notification de progression suit le déploiement ; à la fin, une notification indique combien de blocs ont été importés dans l'automate. Le projet est ensuite compilé et enregistré.

Les blocs sont placés dans la même structure de groupes que dans la bibliothèque : les dossiers imbriqués sont créés comme groupes imbriqués dans l'automate. Un nouveau déploiement réutilise les groupes existants et écrase les blocs.

Contenu pris en charge : blocs de programme (FB/FC/OB, DB globaux et DB d'instance), types de données automate (UDT) et tables de variables automate. Les types de catégories non prises en charge sont ignorés avant le déploiement et comptés dans la notification finale ; les blocs en liste d'instructions (STL) sont eux aussi ignorés d'emblée et nommés dans la notification finale avec leur motif. Le contenu des Software Units est également ignoré d'emblée et nommé dans la notification finale avec son nom et son motif : le déploiement dans des Software Units n'est pas encore pris en charge. Les éléments marqués comme protégés par le cadenas rouge dans l'arborescence du projet ne sont pas écrasés par un déploiement et sont listés comme protégés dans la notification finale.

Déployer un graphe de projet

Un graphe de projet peut lui aussi être déployé directement dans un automate connecté, avec tout ce qu'il contient : blocs, types de données et tables de variables. Le déploiement d'un graphe entier ou de la bibliothèque remplace le contenu de l'automate : les blocs, types de données et tables de variables que le graphe ou la bibliothèque ne contient pas sont supprimés. Avant le démarrage, un avertissement vous demande de confirmer. Les blocs protégés par know-how et tout ce que vous avez marqué comme protégé dans l'Explorateur de projet restent inchangés, de même que les éléments que le graphe nomme sans générer de fichier pour eux, comme les blocs de données d'instance. Si le déploiement échoue, le message indique si l'automate est inchangé ou ce qui manque, et si le projet a été enregistré. Vous pouvez annuler un déploiement en cours ; le message vous indique alors si l'automate est inchangé. Les tables de variables passent en premier, y compris celles qui ne contiennent que des constantes utilisateur, afin que les types de données et les blocs qui utilisent une constante dans une limite de tableau ou une longueur de chaîne puissent s'importer. Les types de données dont dépend l'interface d'un bloc sont déployés avec le bloc, si bien que son interface est résolue dans TIA Portal au lieu d'afficher un type de données manquant.

  1. Ouvrez le graphe dans un onglet et cliquez sur Déployer (icône de fusée) dans sa barre de titre (visible tant que le projet TIA est connecté), ou cliquez sur la fusée dans la barre de titre de la liste Graphes de projet : le graphe ouvert est déployé ; si aucun n'est ouvert, le seul graphe enregistré est utilisé, et s'il y en a plusieurs, vous en choisissez un dans une liste. Vous pouvez aussi lancer "Déployer le graphe dans TIA Portal" depuis la palette de commandes.
  2. Si le projet comporte plusieurs automates, choisissez l'automate cible dans la liste.
  3. Si des blocs portant les mêmes noms existent déjà, confirmez l'écrasement avec "Deploy and Overwrite".
  4. À la fin, une notification indique combien de blocs ont été importés dans l'automate et, lorsque la compilation s'est terminée avec des erreurs ou des avertissements, combien ; les erreurs apparaissent aussi dans la vue Problèmes, sur le bloc auquel elles appartiennent ; un double-clic ouvre le bloc à l'instruction concernée, et lorsque TIA Portal ne peut pas fournir un bloc dont la compilation a échoué, c'est la source déployée pour ce bloc qui s'ouvre. Lorsqu'une génération échoue à cause d'un modèle, le message et la vue Sortie de génération nomment le type de bloc, le modèle et la ligne, et Ouvrir le modèle vous y mène. Si un bloc échoue, le message le désigne avec son nom et son motif. Tout le reste est tout de même importé. Les éléments ignorés d'emblée (comme les blocs STL ou les tables de variables provenant d'une Software Unit) sont aussi listés dans le message avec leur nom et leur motif, de même que les éléments marqués comme protégés, qui restent inchangés.

Configurateur de machines : du modèle à la machine finie

Le configurateur de machines transforme un graphe de projet en modèle de machine réutilisable doté d'options sélectionnables, et en produit autant de variantes de machine concrètes que vous le souhaitez, entièrement câblées, adressées et prêtes à être déployées sur un automate.

Le déroulement en bref : vous définissez un modèle une fois (quels appareils, quelles options), recevez un fichier de configuration avec les options choisies pour chaque commande, le matérialisez en un graphe de projet concret et déployez celui-ci sur l'automate. Un manifeste tel que construit documente ensuite, sous une forme lisible par machine, ce qui a été construit.

Définir un modèle de machine

  1. Ouvrez le graphe de projet qui doit servir de modèle, en général un projet de référence intégré.
  2. Liez les nœuds d'appareil à leurs types d'appareil : sélectionnez un nœud et renseignez la section Liaison d'appareil dans l'Inspecteur. Vous y définissez quel type d'appareil capturé sous-tend le nœud et combien d'instances il doit produire : un nombre fixe ou piloté par une option. Les noms se définissent aussi ici : un motif pour les noms d'instance et un motif pour les noms de blocs de chaque instance (ainsi dbPress devient dbPress_Press_1, dbPress_Press_2, … pour chaque presse).
  3. Dans le menu de titre (…) de l'onglet du graphe, choisissez "Modifier les options du modèle de machine" (également disponible depuis la palette de commandes). Un éditeur JSON s'ouvre avec les options du modèle.
  4. Décrivez l'identifiant et le nom d'affichage du modèle ainsi que ses options (options oui/non, quantités avec minimum et maximum, ou listes de choix) et éventuellement des règles entre options ("requires" / "excludes").
  5. Enregistrez via "Enregistrer les options du modèle de machine" dans le menu de titre de l'onglet JSON. Une saisie non valide est refusée et rien n'est enregistré.

Dès qu'un graphe est un modèle de machine, il ne peut plus être généré ni déployé directement : c'est un plan abstrait. Un avis vous invite plutôt à matérialiser d'abord une configuration.

Exporter le catalogue de machines

"Exporter le catalogue de machines" (via l'icône de nuage dans la barre de titre de la liste Graphes de projet, ou la palette de commandes) écrit un fichier de catalogue contenant tous les modèles de machine du projet : options, règles et un résumé des appareils, mais rien des détails internes de vos modèles. Un système de sélection externe (par exemple un CMS ou votre outil commercial) peut en tirer une interface de sélection et produire des fichiers de configuration prêts à l'emploi.

Matérialiser une configuration

  1. Lancez "Matérialiser la configuration de machine" (via l'icône de nuage dans la barre de titre de la liste Graphes de projet, ou la palette de commandes) et choisissez le fichier de configuration.
  2. Forge valide le fichier de manière stricte : des options inconnues, des limites dépassées ou des règles non respectées interrompent l'opération, et rien n'est créé. Si le modèle a changé depuis la création de la configuration, une invite vous demande s'il faut tout de même matérialiser.
  3. Si une machine matérialisée à partir de la même configuration existe déjà, Studio demande s'il faut la remplacer. Les unités qui n'apparaissent plus dans la nouvelle configuration sont nommées.
  4. À la fin, un nouveau graphe de projet concret apparaît dans la liste Graphes de projet : les blocs de type partagés (par exemple le bloc fonctionnel de la presse) exactement une fois sous leur nom d'origine, plus des blocs de données par instance nommés selon votre motif, entièrement câblés, avec des adresses S7 sans chevauchement. Le manifeste tel que construit est écrit automatiquement à côté du fichier de configuration, et une notification indique combien d'instances ont été créées.

Déployer la machine matérialisée

Déployez la machine matérialisée comme n'importe quel graphe de projet (voir plus haut). L'automate se présente alors comme si vous l'aviez construit à la main : un bloc de type par type d'appareil sous son nom d'origine dans la structure de groupes normale, à côté des blocs de données d'instance de chaque instance configurée avec leurs noms uniques : trois presses configurées donnent un fbPress et trois DB d'instance.

Le manifeste tel que construit

Le manifeste décrit sous une forme lisible par machine ce qui a été construit : toutes les instances avec leurs noms de blocs, leurs adresses et leurs points de données, connexions comprises : la base pour les systèmes en aval, par exemple un SCADA qui se lie lui-même à l'automate. Il est écrit automatiquement lors de la matérialisation ; "Exporter le manifeste as-built" (menu de titre de l'onglet du graphe, visible uniquement sur les machines matérialisées, ou palette de commandes) le régénère à tout moment, par exemple après un déploiement.

Travailler avec un CMS du catalogue de machines (facultatif)

Au lieu de faire circuler à la main les fichiers de catalogue, de configuration et de manifeste, Studio peut exécuter toute la boucle directement avec un CMS du catalogue de machines : le référentiel central de catalogue de votre entreprise, où le service commercial ou le traitement des commandes configure les machines. Votre administrateur fournit l'adresse et un jeton d'accès. Les commandes de catalogue et de CMS sont regroupées derrière l'icône de nuage dans la barre de titre de la liste Graphes de projet : un clic ouvre le menu.

Configuration : saisissez l'adresse de base dans les paramètres sous CMS du catalogue de machines Forge et enregistrez le jeton avec la commande "Définir le jeton du CMS du catalogue de machines" : il est conservé de manière sécurisée et n'est plus jamais affiché. "Effacer le jeton du CMS du catalogue de machines" le supprime. Tant que l'adresse ou le jeton manque, chaque commande CMS vous indique clairement ce qui est encore nécessaire.

Envoyer le catalogue : "Envoyer le catalogue de machines vers le CMS" (icône de nuage de la liste Graphes de projet, ou palette de commandes) envoie tous les modèles de machine du projet avec les résumés de leurs types d'appareil ; la notification finale indique les nombres. Un nouvel envoi met à jour les entrées sans créer de doublons.

Matérialiser directement depuis le CMS : "Matérialiser la configuration depuis le CMS" (également derrière l'icône de nuage) liste les configurations de machine publiées dans le CMS (nom, modèle et dernière mise à jour) pour que vous en choisissiez une. Après le choix, la même validation stricte et le même déroulement s'appliquent qu'avec la méthode par fichier, y compris chaque invite. Le manifeste as-built est écrit dans le dossier forge-manifests de votre espace de travail et renvoyé automatiquement au CMS, ce qui documente la commande telle que construite. Si une configuration du CMS contient des données qui ne correspondent pas au format attendu, Studio interrompt l'opération sans rien créer.

Renvoyer le manifeste : "Envoyer le manifeste as-built vers le CMS" (icône de nuage de la liste Graphes de projet, menu de titre de l'onglet du graphe sur les machines matérialisées, ou palette de commandes) envoie le manifeste à tout moment, par exemple après un déploiement. Studio trouve la configuration CMS correspondante par son nom ; s'il y a plusieurs candidates, vous choisissez dans une liste. Avec le paramètre "Renvoyer automatiquement le manifeste as-built vers le CMS du catalogue de machines après le déploiement réussi d'un graphe matérialisé", cela se fait tout seul après chaque déploiement réussi.

Exporter une configuration SCADA à partir d'une sélection

Pour les systèmes en aval (par exemple un SCADA), Forge transforme une sélection du canevas en configuration SCADA lisible par machine : les points de données de vos blocs d'interface SCADA avec type de données, valeur initiale et commentaire, ainsi que les variables des tables de variables sélectionnées avec adresse et commentaire.

  1. Marquer les interfaces : faites un clic droit sur un nœud de bloc de données dans le graphe, puis choisissez "Marquer comme interface SCADA". Marquez-en autant que nécessaire ; l'Inspecteur affiche la marque, et exécuter à nouveau la commande la supprime. La marque est enregistrée avec le graphe.
  2. Faire une sélection : sélectionnez les nœuds voulus dans le graphe (la même sélection multiple que pour la génération sélective) : les blocs de données marqués et les variables qui vont avec.
  3. "Exporter la configuration SCADA" (clic droit sur la sélection, ou palette de commandes) : donnez-lui un nom, choisissez un emplacement, et c'est fait : le fichier est <name>.scada.json. Les structures imbriquées apparaissent sous forme de chemins pointés (Drive.Setpoint).
  4. "Envoyer la configuration SCADA vers le CMS" enregistre plutôt la même configuration dans le CMS du catalogue de machines (adresse et jeton configurés comme ci-dessus). Un nouvel envoi met à jour l'entrée sans doublons ; votre chaîne d'outils SCADA peut y récupérer les configurations.

Si quelque chose ne peut pas être lu (par exemple, une source de bloc manque et aucun projet TIA correspondant n'est connecté), l'export s'interrompt avec un message clair et aucun fichier à moitié terminé n'est écrit. Les adresses et commentaires des variables proviennent du projet TIA connecté ; sans connexion, le message nomme la table concernée.

Exporter directement depuis l'arborescence du projet

Vous n'avez pas besoin d'un graphe Forge pour une configuration SCADA. Dans l'arborescence du projet, faites un clic droit sur un bloc de données, un type de données automate (UDT), une table de variables ou un dossier et choisissez "Exporter en JSON" : vous obtenez le même <name>.scada.json. Les blocs de données globaux et d'instance sont exportés de la même manière. Lorsque vous exportez un seul élément, le fichier prend automatiquement son nom ; Studio ne demande un nom que lorsque vous exportez plusieurs éléments. Les éléments cochés sont inclus, un dossier prend tous les blocs correspondants qu'il contient. Les tables de variables apportent désormais aussi leurs constantes et les commentaires des variables ; les types de données automate arrivent dans le fichier avec leur structure complète de membres, leurs valeurs par défaut, leurs commentaires et leur accessibilité externe. Pendant la collecte des données, la section Import / Export affiche la progression et le temps écoulé, et Annuler arrête l'export. Pour exporter en une fois tous les blocs de données, types de données automate et tables de variables, un fichier par objet dans le dossier d'exportation, utilisez la puce JSON de la vue Import / Export, voir Import / Export.

Générer à partir des nœuds OPC UA d'une CPU

La configuration la plus riche provient de l'Espace d'adressage OPC UA de la CPU elle-même. Exportez-le depuis le menu contextuel de la CPU ("Exporter les nœuds OPC UA"), puis faites un clic droit sur le fichier obtenu et choisissez "Générer SCADA à partir des nœuds OPC UA". Le résultat contient les adresses réelles auxquelles votre SCADA se connecte, l'arborescence, le type de données de chaque signal et s'il est en lecture seule ou modifiable : exactement ce que le serveur expose réellement.

Générer un tableau de bord web

À partir d'une configuration SCADA, Studio peut créer un tableau de bord web exécutable. Définissez l'adresse de votre serveur de tableau de bord dans les paramètres (section Forge), puis lancez "Générer le projet FUXA" sur un .scada.json (ou directement depuis l'étape des nœuds OPC UA) : Studio crée des affichages et des commandes pour chaque signal et les envoie au serveur, ou les écrit dans un fichier pour une importation manuelle. Les signaux modifiables apparaissent comme champs de saisie, ceux en lecture seule comme affichages. L'envoi ajoute le tableau de bord au projet déjà présent sur le serveur et conserve ce que vous y avez construit à la main ; une confirmation s'affiche d'abord, et vous pouvez choisir de remplacer plutôt le projet entier. Pour un tableau de bord structuré avec plusieurs écrans et une barre latérale de navigation, planifiez d'abord les écrans sur la page SCADA (voir ci-dessous).

Une courte vidéo présente tout le déroulement, d'un projet TIA Portal à un tableau de bord FUXA en marche avec des valeurs en direct via OPC UA : Generate a FUXA Web SCADA from a Siemens TIA Portal Project.

Le tableau de bord généré exploite davantage ce que vos signaux décrivent déjà. Une valeur porte son unité et le nombre de décimales que vous avez noté dans le commentaire du signal, un champ de saisie maintient les consignes saisies dans les limites du signal, et une courbe de tendance conserve son historique et s'ouvre déjà remplie au lieu d'être vide. Avant qu'un envoi ne remplace le projet entier, la confirmation vous indique combien d'appareils, de vues et de signaux se trouvent actuellement sur le serveur, pour que vous voyiez ce qui sera écrasé, et après un envoi réussi vous pouvez ouvrir le tableau de bord dans votre navigateur en un clic. Le bouton Ouvrir FUXA de la section Connexion fait de même à tout moment.

Déclencher des alarmes

Le tableau de bord peut déclencher des alarmes. Pour marquer un signal comme alarme, ajoutez une balise à son commentaire : {alarm=high} (ou low, highhigh, info) transforme le signal en alarme, {group=Faults} le range dans un groupe, {alarmtext=Motor overload} définit le message affiché, et {alarmmin=95} avec {alarmmax=120} définissent la plage d'un signal analogique. Un signal tout ou rien déclenche une alarme lorsqu'il passe à l'état actif ; un signal analogique déclenche une alarme tant que sa valeur se trouve dans la plage, il lui en faut donc une. L'assistant de chat peut aussi marquer un signal comme alarme pour vous, avec la même gravité, le même groupe, le même texte et la même plage.

Dès que le tableau de bord a une alarme, son en-tête affiche une bannière d'alarme, si bien qu'une alarme active est visible depuis chaque écran. Vous pouvez aussi placer un tableau d'alarmes sur un écran : il liste les alarmes actives avec leur heure, leur message, leur type, leur groupe, leur état et s'il y a eu acquittement. Demandez un tableau d'alarmes à l'assistant lorsqu'il propose vos écrans, ou ajoutez-en un vous-même au plan.

Conserver vos modifications manuelles lors de l'envoi

Les écrans, appareils et alarmes que vous avez ajoutés à la main dans FUXA sont conservés lorsque vous envoyez à nouveau. Par défaut, un envoi fusionne le tableau de bord généré dans le projet du serveur : les écrans, appareils et alarmes générés sont ajoutés ou mis à jour, les écrans supprimés par Studio sont aussi supprimés sur le serveur, et les modifications manuelles d'un écran généré sont écrasées par l'envoi suivant. Chaque envoi sauvegarde d'abord le projet du serveur dans le dossier de sauvegardes de votre projet SCADA. Un envoi que vous lancez ouvre la boîte de dialogue d'envoi avec la cible, les pages à envoyer, la sauvegarde et chaque vérification, et rien n'est écrit avant que vous confirmiez. Dans cette boîte de dialogue, vous choisissez le mode de chaque envoi : choisissez Remplacer le projet entier si vous préférez repartir de zéro, ce qui supprime tout sur le serveur et n'écrit que le tableau de bord généré. Un envoi vers un serveur vide donne le même résultat dans les deux cas.

Se connecter à un serveur OPC UA sécurisé

De nombreux automates exigent une connexion sécurisée à leur serveur OPC UA, avec des messages signés et chiffrés et une connexion utilisateur. Dans Paramètres, section SCADA, choisissez le mode de sécurité OPC UA dont le serveur a besoin (None, Sign ou Sign and Encrypt), choisissez la stratégie de sécurité (Basic256Sha256 est le choix habituel pour une CPU Siemens moderne) et saisissez le nom d'utilisateur si le serveur en demande un. Enregistrez le mot de passe correspondant avec la commande "Définir le mot de passe OPC UA" ("Effacer le mot de passe OPC UA" le supprime) ; le mot de passe est conservé de manière sécurisée et n'est jamais écrit dans un fichier. Vous pouvez aussi définir le mode, la stratégie et le nom d'utilisateur, ainsi que le mot de passe, directement depuis la ligne Sécurité OPC UA de la page SCADA.

Le tableau de bord généré se connecte alors à l'automate avec ces paramètres. Pour une connexion signée ou chiffrée, l'automate doit faire confiance au certificat client du tableau de bord : dans TIA Portal, ajoutez-le aux clients de confiance du serveur OPC UA, ou autorisez l'acceptation des clients à l'exécution, puis approuvez le tableau de bord lors de sa première connexion. Laissez le mode sur None et le nom d'utilisateur vide pour un serveur qui autorise un accès anonyme non sécurisé.

La barre latérale SCADA

Au lieu d'exécuter les étapes une commande à la fois, travaillez dans la barre latérale SCADA (l'icône de tableau de bord dans la barre d'activité) : un projet SCADA conserve les signaux, pages, règles, symboles et cibles d'un tableau de bord sous forme de fichiers dans un seul dossier, si bien que chaque étape dispose de sa propre vue. La vue Projet contient le projet et Envoyer à FUXA, la vue Signaux charge les nœuds d'une CPU depuis un fichier de jeu de nœuds, depuis le projet TIA connecté ou directement depuis une CPU en marche et vous permet de cocher les signaux voulus, la vue Pages liste les pages et applique les règles qui placent un widget pour chaque signal, la vue Symboles affiche vos propres symboles SVG, et la vue Règles active et désactive les règles. Chaque page s'ouvre dans un éditeur de page où vous déplacez et redimensionnez les widgets, déposez des signaux et des symboles, testez la page dans un aperçu et l'affichez dans FUXA. La page Tableaux de bord SCADA décrit tout le déroulement : comment ouvrir la barre latérale, charger les signaux, organiser les pages, l'éditeur de page, les symboles avec états, vos symboles dans l'éditeur FUXA, l'envoi et ce que l'assistant fait pour vous.

Les deux commandes de fichier ci-dessus restent disponibles pour un tableau de bord ponctuel à partir d'un fichier .scada.json ou d'un fichier de jeu de nœuds ; la barre latérale regroupe tout le reste en un seul endroit.

Voir ce que fait Forge

La vue Activité de la barre latérale Forge affiche l'opération Forge en cours : création d'un graphe de projet, génération, déploiement d'un graphe ou de la bibliothèque, capture de blocs ou intégration d'un projet. Vous voyez son nom, son avancement (par exemple Create Project Graph: B: 1250/4319), sa durée d'exécution, l'élément en cours de traitement et un bouton Annuler qui l'arrête. Lorsqu'un déploiement atteint TIA Portal, les étapes d'importation y apparaissent aussi, avec les mêmes nombres que dans la vue Import / Export.

En dessous, Terminé liste les opérations déjà exécutées dans cette fenêtre, les plus récentes en premier, chacune avec sa durée et son résultat, par exemple Build Project Graph: B · 02:10: 4319 artifacts, 0 errors, 11 warnings. Une exécution annulée l'indique. La liste conserve les 25 dernières exécutions et redevient vide lorsque vous fermez la fenêtre.

Le panneau Sortie possède son propre canal Forge : il montre en direct ce que font le générateur et la connexion Forge, utile lorsqu'une capture ou un déploiement ne produit pas le résultat attendu.

Remarques et limites

  • Forge et le projet TIA doivent tous deux être connectés. S'il manque l'une des connexions, ou si le projet ne comporte aucun automate, une notification l'indique et rien n'est modifié.
  • L'écrasement nécessite une confirmation : les blocs de même nom ne sont remplacés qu'après votre confirmation.
  • Les blocs graphiques (LAD/FBD) peuvent être refusés par TIA Portal selon la CPU cible ; les blocs SCL, les DB d'instance et globaux, les UDT et les tables de variables se déploient de manière fiable. La notification finale signale les blocs qui n'ont pas été importés, avec le motif.
  • Les blocs en liste d'instructions (STL) sont ignorés d'emblée lors d'un déploiement et nommés dans la notification finale avec leur nom et leur motif, au lieu de provoquer une erreur TIA Portal.
  • Mêmes noms à plusieurs endroits : lorsque deux éléments portent le même nom (par exemple un type de données sous les types de données automate et un homonyme dans une Software Unit), les deux sont capturés ; l'élément de la Software Unit reçoit dans la bibliothèque un libellé unique qui indique à quelle Software Unit il appartient. Seuls les doublons identiques au même endroit sont ignorés sans avertissement.
  • Les tables de variables d'une Software Unit sont actuellement ignorées d'emblée lors du déploiement et nommées dans la notification finale avec leur nom et leur motif : le déploiement dans une Software Unit n'est pas encore pris en charge.
  • Le déploiement de groupes imbriqués nécessite TIA Portal V17 ou une version plus récente.