manuel de programmation - etsmtl.ca · 2013-09-17 · lorsqu’une instruction complémentaire est...

Manuel de programmation

Automates Logix5000 – Instructions complémentairesRéférences ControlLogix 1756, GuardLogix 1756, CompactLogix 1768, Compact GuardLogix 1768, CompactLogix 1769, SoftLogix 1789, PowerFlex avec DriveLogix

Informations importantes destinées à l’utilisateurLes équipements électroniques possèdent des caractéristiques de fonctionnement différentes de celles des équipements électromécaniques. La publication SGI-1.1, Safety Guidelines for the Application, Installation and Maintenance of Solid State Controls (disponible auprès de votre agence commerciale Rockwell Automation ou en ligne sur le site http://www.rockwellautomation.com/literature/) décrit certaines de ces différences. En raison de ces différences et de la diversité des utilisations des produits décrits dans le présent manuel, les personnes qui en sont responsables doivent s’assurer de l’acceptabilité de chaque application.

La société Rockwell Automation, Inc. ne saurait en aucun cas être tenue pour responsable ni être redevable des dommages indirects ou consécutifs à l’utilisation ou à l’application de cet équipement.

Les exemples et schémas contenus dans ce manuel sont présentés à titre indicatif seulement. En raison du nombre important de variables et d’impératifs associés à chaque installation, la société Rockwell Automation, Inc. ne saurait être tenue pour responsable ni être redevable des suites d’utilisation réelle basée sur les exemples et schémas présentés dans ce manuel.

La société Rockwell Automation, Inc. décline également toute responsabilité en matière de propriété intellectuelle et industrielle concernant l’utilisation des informations, circuits, équipements ou logiciels décrits dans ce manuel.

Toute reproduction totale ou partielle du présent manuel sans autorisation écrite de la société Rockwell Automation, Inc. est interdite.

Des remarques sont utilisées tout au long de manuel pour attirer votre attention sur les mesures de sécurité à prendre en compte :

Allen-Bradley, Rockwell Software, Rockwell Automation et TechConnect sont des marques commerciales de Rockwell Automation, Inc.

Les marques commerciales n’appartenant pas à Rockwell Automation sont la propriété de leurs sociétés respectives.

AVERTISSEMENT : actions ou situations susceptibles de provoquer une explosion en environnement dangereux et risquant d’entraîner des blessures pouvant être mortelles, des dégâts matériels ou des pertes financières.

ATTENTION : actions ou situations risquant d’entraîner des blessures pouvant être mortelles, des dégâts matériels ou des pertes financières. Ces mises en garde vous aident à identifier un danger, à éviter ce danger et en discerner les conséquences.

DANGER D’ÉLECTROCUTION : les étiquettes ci-contre, placées sur l’équipement ou à l’intérieur (un variateur ou un moteur, par ex.), signalent la présence éventuelle de tensions électriques dangereuses.

RISQUE DE BRÛLURE : les étiquettes ci-contre, placées sur l’équipement ou à l’intérieur (un variateur ou un moteur, par ex.) indiquent que certaines surfaces peuvent atteindre des températures particulièrement élevées.

IMPORTANT Informations particulièrement importantes dans le cadre de l’utilisation du produit.

http://literature.rockwellautomation.com/idc/groups/literature/documents/in/sgi-in001_-en-p.pdf

http://www.rockwellautomation.com/literature/

Sommaire des modifications

La synthèse ci-dessous regroupe les modifications apportées à ce manuel depuis sa dernière publication.

Afin de vous permettre d’identifier les informations nouvelles et celles qui ont été mises à jour dans cette version du manuel, des barres de modification, telles que celle figurant à droite de ce paragraphe, sont utilisées.

Les modifications apportées par ce manuel sont détaillées dans le tableau suivant.Sujet Page

Actualisation des informations relatives aux types de données et aux automates de sécurité 37

Suppression des informations relatives à la protection des sources redondantes et ajout d’une référence 55

Publication Rockwell Automation 1756-PM010D-FR-P – Novembre 2011 3

Sommaire des modifications

Notes :

4 Publication Rockwell Automation 1756-PM010D-FR-P – Novembre 2011

Table des matières

Préface Objet de ce manuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Informations supplémentaires sur les applications de sécurité . . . . . . . . . . 9Comprendre la terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

Chapitre 1Conception d’instructions complémentaires

Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11A propos des instructions complémentaires. . . . . . . . . . . . . . . . . . . . . . . . . 11Composants d’une instruction complémentaire. . . . . . . . . . . . . . . . . . . . . 13

Informations générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Points locaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Type de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Sous-programme logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Sous-programmes optionnels en mode de scrutation . . . . . . . . . . . . . 16Signature d’instruction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Historique de signature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Historique des modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

Aspects d’une instruction complémentaire . . . . . . . . . . . . . . . . . . . . . . . . . 18Fonctionnalité de l’instruction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Instructions complémentaires de sécurité . . . . . . . . . . . . . . . . . . . . . . . 19Signature d’instruction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Signature d’instruction de sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21Langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21Instructions de transition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21Taille de l’instruction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Modification de l’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Imbrication d’instructions complémentaires . . . . . . . . . . . . . . . . . . . . 22Comparaison entre sous-programmes et instructions complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23Accès aux données par programmation . . . . . . . . . . . . . . . . . . . . . . . . . 24Instructions indisponibles dans les instructions complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Utilisation des instructions GSV et SSV . . . . . . . . . . . . . . . . . . . . . . . . 26

Éléments à prendre en compte pour la création de paramètres . . . . . . . . 27Passage d’arguments aux paramètres par référence ou par valeur. . . 27Choix d’un type de données pour un paramètre . . . . . . . . . . . . . . . . . 27Création d’un alias de paramètre pour un point local . . . . . . . . . . . . 28Utilisation d’un tableau unidimensionnel comme paramètre d’entrée-sortie (InOut) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Définir quels paramètres rendre visibles ou obligatoires . . . . . . . . . . 29Utilisation des points standard et de sécurité . . . . . . . . . . . . . . . . . . . . 30Contrôle de l’accès aux données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Planification de la conception d’une instruction complémentaire . . . . . 32Comportement attendu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32Conventions de dénomination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32


Table des matières

Protection de la source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Imbrication – réutilisation d’Instructions . . . . . . . . . . . . . . . . . . . . . . . 33Points locaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Sous-programmes en mode de scrutation. . . . . . . . . . . . . . . . . . . . . . . . 34Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34Documentation d’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Chapitre 2Définition des instructions complémentaires

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35Création d’une instruction complémentaire . . . . . . . . . . . . . . . . . . . . . . . . 35Création des paramètres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Création de points locaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Modification des paramètres et des points locaux . . . . . . . . . . . . . . . . . . . . 41Mises à jour des arguments suite à des modifications de paramètre . . . . 41Copie des valeurs par défaut d’un paramètres ou d’un point local . . . . . 43Création d’un programme pour une instruction complémentaire . . . . . 44

Remarques concernant l’exécution des instructions complémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44Optimisation des performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Définition du fonctionnement dans les différents modes de scrutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45Activation des modes de scrutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

Sous-programme de pré-scrutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46Sous-programme de post-scrutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48Sous-programme EnableInFalse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Utilisation des paramètres EnableIn et EnableOut. . . . . . . . . . . . . . . . . . . 51Paramètre EnableIn et diagramme de logique à relais . . . . . . . . . . . . . 52Paramètre EnableIn et blocs fonctionnels . . . . . . . . . . . . . . . . . . . . . . . 52Paramètre EnableIn et texte structuré. . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Modification de la classe d’une instruction complémentaire . . . . . . . . . . 53Test d’une instruction complémentaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Avant le démarrage du test. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Test du déroulement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Contrôle du programme avec visualisation contextuelle des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Validation des différents modes de scrutation . . . . . . . . . . . . . . . . . . . 55

Définition de la protection de la source d’une instruction complémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

Fonction d’activation de la protection de la source . . . . . . . . . . . . . . . 56Génération d’une signature d’instruction complémentaire . . . . . . . . . . . 56

Création, suppression ou copie d’une signature d’instruction . . . . . 56Création d’une entrée d’historique de signature . . . . . . . . . . . . . . . . . 57Génération d’une signature d’instruction de sécurité . . . . . . . . . . . . . 58Visualisation et impression de la signature d’instruction . . . . . . . . . . 58

Création de l’aide pour l’instruction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Rédaction de descriptions claires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Création de la documentation d’une instruction complémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61


Table des matières

Changement de langue d’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63Exemple d’instruction de démarrage de moteur . . . . . . . . . . . . . . . . . . . . . 64Exemple d’instruction de simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Configuration en diagramme de logique à relais (LD). . . . . . . . . . . . 68Configuration en diagramme de blocs fonctionnels (FBD) . . . . . . . 69Configuration en texte structuré (ST) . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Chapitre 3Utilisation des instructions complémentaires

Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71Accès aux instructions complémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . 71Utilisation de la boîte de dialogue Add Element. . . . . . . . . . . . . . . . . . . . . 72Inclusion d’une instruction complémentaire dans un sous-programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Conseils d’utilisation d’une instruction complémentaire . . . . . . . . . . . . . 75Accès à un paramètre par programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

Utilisation de la commande Jog (avance par à-coups) dans un diagramme de logique à relais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76Utilisation de la commande Jog (avance par à-coups) dans un diagramme de blocs fonctionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . 76Utilisation de la commande Jog (avance par à-coups) dans un texte structuré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Surveillance de la valeur d’un paramètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78Visualisation du programme et surveillance dans le contexte de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79Déterminer si la source d’une instruction complémentaire est protégée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81Copie d’une instruction complémentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 82Sauvegarde de vos instructions complémentaires . . . . . . . . . . . . . . . . . . . . 83

Chapitre 4Importation et exportation d’instructions complémentaires

Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85Création d’un fichier d’exportation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Exportation dans des fichiers séparés . . . . . . . . . . . . . . . . . . . . . . . . . . . 86Exportation dans un seul fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

Importation d’une instruction complémentaire . . . . . . . . . . . . . . . . . . . . . 88Règles d’importation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88Configuration d’importation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Mise à jour par importation d’une instruction complémentaire avec une nouvelle révision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

Index


Table des matières


Préface

Objet de ce manuel Ce manuel décrit la conception, la configuration et la programmation des instructions complémentaires. Il fait partie d’un ensemble de manuels relatifs aux procédures communes de programmation et d’exploitation des automates Logix5000. Pour la liste complète des manuels décrivant ces procédures communes, se reporter à la publication 1756-PM001, « Logix5000 Controllers Common Procedures Programming Manual ».

Le terme « automate Logix5000 » s’applique à tous les automates basés sur le système d’exploitation Logix5000, tels que les automates :

· CompactLogix et Compact GuardLogix ;· ControlLogix et GuardLogix ;· DriveLogix ;· FlexLogix ;· SoftLogix5800.

Informations supplémentaires sur les applications de sécurité

Avec l’introduction des instructions complémentaires de sécurité dans la version 18 du logiciel RSLogix 5000, vous pouvez maintenant utiliser des instructions complémentaires pour les fonctions de sécurité des automates GuardLogix et Compact GuardLogix. Ce manuel fournit des informations sur ces instructions complémentaires de sécurité.

Pour plus d’informations sur la conception des applications de sécurité, la signature de tâche de sécurité, ainsi que la configuration et l’utilisation des automates de sécurité, se reporter aux publications suivantes :

· « GuardLogix Systems Safety Reference Manual », publication 1756-RM093 ;

· « Compact GuardLogix Controllers User Manual », publication 1768-UM002 ;

· « GuardLogix Controllers User Manual », publication 1756-UM020 ;· « GuardLogix Safety Application Instruction Set Reference Manual »,

publication 1756-RM095.


http://literature.rockwellautomation.com/idc/groups/literature/documents/pm/1756-pm001_-en-e.pdf

http://literature.rockwellautomation.com/idc/groups/literature/documents/rm/1756-rm093_-en-p.pdf

http://literature.rockwellautomation.com/idc/groups/literature/documents/um/1768-um002_-en-p.pdf

http://literature.rockwellautomation.com/idc/groups/literature/documents/um/1756-um020_-en-p.pdf


Préface

Comprendre la terminologie Ce tableau définit certains des termes apparaissant dans ce manuel pour décrire les paramètres et les arguments utilisés dans les instructions complémentaires.

Terme Définition

Argument Un argument est attribué à un paramètre dans une instance d’instruction complémentaire. Un argument contient les spécifications des données utilisées par une instruction dans un programme utilisateur. Un argument peut contenir les éléments suivants :

· un point simple (par exemple : L101) ;· une valeur littérale (par exemple : 5) ;· une référence de structure de point (par exemple : Recipe.Temperature) ;· une référence directe à un tableau de données (par exemple : Buffer[1]) ;· une référence indirecte à un tableau de données (par exemple : Buffer[Index+1]) ;· une combinaison de références (par exemple : Buffer[Index+1].Delay).

Paramètre Les paramètres sont créés au niveau de la définition de l’instruction complémentaire. Lorsqu’une instruction complémentaire est utilisée dans le programme d’une application, des arguments doivent être affectés à chaque paramètre nécessaire à l’instruction complémentaire.

Paramètre InOut (entrée-sortie)

Un paramètre InOut définit des données pouvant être utilisées aussi bien comme données d’entrée ou de sortie lors de l’exécution de l’instruction. Du fait que les paramètres InOut sont toujours passés par référence, leurs valeurs peuvent changer en fonction de la source externe pendant l’exécution de l’instruction complémentaire.

Paramètre d’entrée Dans une instruction complémentaire, un paramètre d’entrée définit des données qui sont passés par valeur dans l’instruction en cours d’exécution. Du fait que ces paramètres d’entrée sont toujours passés par valeur, leurs valeurs ne peuvent pas changer en fonction de la source externe pendant l’exécution de l’instruction complémentaire.

Paramètre de sortie Dans une instruction complémentaire, un paramètre de sortie définit des données dont la production est la conséquence directe de l’exécution de l’instruction. Du fait que ces paramètres de sortie sont toujours passés par valeur, leurs valeurs ne peuvent pas changer en fonction la source externe pendant l’exécution de l’instruction complémentaire.

Passage par référence Lorsqu’un argument est passé à un paramètre par référence, le programme logique lit ou écrit directement la valeur que le point utilise dans la mémoire de l’automate. Étant donné que l’instruction complémentaire agit sur la même mémoire de point que l’argument, une interaction externe du programme ou d’une IHM modifiant la valeur de l’argument peut changer cette valeur lors de l’exécution de l’instruction complémentaire.

Passage par valeur Lorsqu’un argument est passé à un paramètre par valeur, cette valeur est copiée dans le paramètre ou à partir du paramètre lors de l’exécution de l’instruction complémentaire. La valeur de l’argument n’est pas modifiée par l’interaction externe du programme ou d’une IHM indépendamment de l’instruction complémentaire elle-même.


Chapitre 1

Conception d’instructions complémentaires

Introduction Les instructions complémentaires sont disponibles à partir de la version 16 du logiciel RSLogix 5000. Ce sont des instructions personnalisées qui peuvent être conçues et crées par l’utilisateur. À partir de la version 18 du logiciel RSLogix 5000, des instructions complémentaires à haute intégrité et de sécurité sont utilisables.

A propos des instructions complémentaires

Grâce aux instructions complémentaires, vous pouvez créer de nouvelles instructions pour les jeux de programmes que vous utilisez habituellement. Vous pouvez créer une interface commune pour ces programmes ainsi que la documentation relative aux instructions.

Les instructions complémentaires sont destinées à permettre l’encapsulation de fonctions ou de commandes de dispositifs couramment utilisées. Elles n’ont pas pour objectif d’être un outil de conception de haut niveau hiérarchique. Les programmes utilisant des sous-programmes sont les mieux adaptés à l’intégration d’un code destiné à une zone ou à des niveaux unitaires de votre application.

Les avantages liés à l’utilisation d’instructions complémentaires sont les suivants :· Réutilisation de code.

– Vous pouvez vous servir des instructions complémentaires pour favoriser la continuité entre vos projets grâce au recyclage des algorithmes de commande que vous utilisez de façon courante.

– Si un algorithme doit être employé plusieurs fois dans un même projet ou dans plusieurs projets, il peut être judicieux d’incorporer ce code dans une instruction complémentaire de façon à le rendre modulaire et à faciliter sa réutilisation.

· Réalisation d’interfaces simplifiant la compréhension.– Vous pouvez placer des algorithmes complexes à l’intérieur d’une

instruction complémentaire, puis réaliser une interface simplifiant la compréhension en ne rendant visibles ou obligatoires que les paramètres essentiels.

– Vous pouvez réduire les temps de développement de la documentation grâce à la génération automatique de l’aide pour l’instruction.

· Protection de votre propriété intellectuelle.

Rubrique Page

A propos des instructions complémentaires 11

Composants d’une instruction complémentaire 13

Aspects d’une instruction complémentaire 18

Éléments à prendre en compte pour la création de paramètres 27

Planification de la conception d’une instruction complémentaire 32


Chapitre 1

– Vous pouvez placer votre programme propriétaire dans une instruction complémentaire, puis utiliser la protection de source pour empêcher des tiers de visualiser ou de modifier ce code.

· Simplification de la maintenance.– Vous pouvez simplifier la maintenance de votre code grâce au fait que le

programme d’une l’instruction complémentaire, supervisé par le logiciel RSLogix 5000, est nourri par des valeurs de points relatives à une instance spécifique de cette instruction complémentaire.

· Suivi des révisions et confirmation facilitée de la fonctionnalité de l’instruction grâce aux instructions complémentaires à haute intégrité.– Vous pouvez ajouter une signature d’instruction à votre instruction

complémentaire. Elle générera un identifiant unique qui empêchera que l’instruction soit modifiée sans que sa signature ne se trouve également modifiée.

Une instruction complémentaire peut être utilisée dans plusieurs projets. Vous pouvez définir vos instructions. Elles peuvent vous être fournies par une source extérieure ou être recopiées dans un autre projet.

Une fois définies dans un projet, elles se comportent de la même façon que les instructions intégrées déjà disponibles dans le logiciel RSLogix 5000. Pour faciliter leur accès, elles apparaissent dans la barre d’outils des instructions ainsi que dans l’arborescence des instructions, au même titre que les instructions intégrées au logiciel RSLogix 5000.

Tout comme les instructions complémentaires standard, les instructions complémentaires de sécurité vous permettent d’encapsuler un programme de sécurité à usage courant dans une seule instruction, ce qui le rend modulaire et plus facile à réutiliser. En plus de la signature d’instruction utilisée pour les instructions complémentaires à haute intégrité, les instructions complémentaires de sécurité sont dotées d’une signature d’instruction de sécurité SIL 3 leur permettant d’être utilisées dans des fonctions de sécurité classées jusqu’au niveau SIL 3 inclus.

Reportez-vous à la publication 1756-RM093, « GuardLogix Controller Systems Safety Reference Manual », pour plus de précisions sur la certification des instructions complémentaires de sécurité et leur utilisation dans les applications de sécurité de type SIL 3.



Chapitre 1

Composants d’une instruction complémentaire

Les instructions complémentaires sont constituées des éléments suivants.

Informations générales

L’onglet General regroupe les informations que vous avez saisies lors de la création initiale de l’instruction. Vous pouvez utiliser cet onglet pour mettre à jour ces informations. La description, la version, les notes de révision, ainsi que les informations relatives au fournisseur sont recopiées dans le fichier d’aide personnalisé de l’instruction. La gestion des révisions n’est pas effectuée automatiquement par le logiciel. C’est à vous de définir comment elles doivent être utilisées et quand elles doivent être actualisées.

Les informations relatives à la classe apparaissent également dans l’onglet General pour les projets impliquant un automate de sécurité. Cette classe peut être standard ou de sécurité. Les instructions complémentaires de sécurité doivent être conformes aux règles spécifiques aux applications de sécurité. Voir Instructions complémentaires de sécurité, page 19 pour plus d’informations.


Chapitre 1

Paramètres

Les paramètres définissent l’interface de l’instruction ; c’est-à-dire, comment se présente l’instruction lorsqu’elle est utilisée. L’ordre de ces paramètres correspond à celui dans lequel ils apparaissent lors de l’appel de l’instruction.

Points locaux

L’onglet Local Tags définit les points qui sont utilisés par le programme de l’instruction complémentaire mais qui ne sont pas visibles à l’extérieur de cette instruction. D’autres instructions complémentaires ou programmes du projet ne peuvent pas accéder à ces points.

La seule façon de rendre un point local ou un de ses éléments accessible à l’extérieur de l’instruction consiste à définir un alias de paramètre.

Voir Création d’un alias de paramètre pour un point local, page 28.


Chapitre 1

Type de données

Les paramètres et les points locaux sont utilisés pour définir le type de données utilisé pour l’exécution de l’instruction. Le logiciel crée le type de données associé. Le logiciel organise les éléments du type de données correspondant aux paramètres selon l’ordre dans lequel ces paramètres sont définis. Les points locaux sont inclus en tant qu’éléments masqués.

Sous-programme logique

Le sous-programme logique d’une l’instruction complémentaire définit la fonctionnalité principale de l’instruction. Il s’agit du code qui est exécuté lorsque l’instruction est appelée. Le schéma ci-dessous montre l’interface d’une instruction complémentaire et son sous-programme logique principal définissant ce que fait l’instruction.


Chapitre 1

Sous-programmes optionnels en mode de scrutation

Vous pouvez définir des sous-programmes additionnels pour un comportement en mode de scrutation (Scan Mode).

Signature d’instruction

La signature d’instruction est constituée d’un numéro d’identification (ID) qui définit le contenu de l’instruction complémentaire et d’un horodatage qui enregistre la date et l’heure auxquelles la signature d’instruction a été générée ou auxquelles une entrée a été faite dans l’historique de signature (selon la plus récente occurrence de ces deux évènements).

Une fois générée, la signature d’instruction scelle l’instruction complémentaire, ce qui empêche toute modification tant que cette signature est active.

De plus, lorsqu’une instruction complémentaire de sécurité scellée est chargée pour la première fois, une signature d’instruction de sécurité SIL 3 est générée automatiquement. Cette signature d’instruction de sécurité est un numéro d’identification définissant les caractéristiques d’exécution de l’instruction complémentaire de sécurité.


Chapitre 1

Historique de signature

L’historique de signature assure un enregistrement des signatures pour permettre une consultation ultérieure. Une entrée d’historique de signature est constituée du nom de l’utilisateur, de la signature d’instruction, de la valeur d’horodatage et d’une description saisie par l’utilisateur. Jusqu’à six entrées d’historique peuvent être stockées. Si une septième entrée est réalisée, la plus ancienne des entrées existantes sera effacée automatiquement.

Historique des modifications

L’onglet Change History d’historique des modifications affiche les dernières informations de création et de modification enregistrées par le logiciel. Les champs By (par) indiquent l’auteur de la modification sur la base du nom d’utilisateur Windows actif au moment de la modification.


Chapitre 1

Aide

Le nom, la révision, la description et les définitions de paramètre sont utilisés pour établir automatiquement l’aide (Help) relative à l’instruction. Utilisez le champ Extended Description Text (texte de description étendue) pour fournir des informations d’aide supplémentaires sur l’instruction complémentaire. Le champ Instruction Help Preview (prévisualisation de l’aide de l’instruction) montre comment votre instruction apparaîtra dans les différentes langues, en fonction des paramètres qui ont été définis comme obligatoires ou visibles.

Aspects d’une instruction complémentaire

Lorsque vous envisagez de créer une instruction complémentaire, les aspects suivants sont à prendre en considération.

Fonctionnalité de l’instruction

Les instructions complexes sont généralement très spécifiques à une application donnée. Elles ne sont donc pas réutilisables ou nécessitent un programme d’adaptation de configuration supplémentaire. Comme pour les instructions intégrées, les instructions complémentaires doivent réaliser une action de façon pertinente et prendre en charge le codage modulaire. Considérez la façon dont l’instruction sera utilisée et appréciez la complexité à donner à l’interface en fonction des utilisateurs finaux ou de l’application.

Les instructions complémentaires sont les mieux adaptées pour fournir un type spécifique de fonctionnalité ou de commande de dispositif.


Chapitre 1

Encapsulation

Les instructions complémentaires sont conçues pour encapsuler entièrement le code et les données associées à l’instruction. Le programme logique interne d’une instruction complémentaire utilise uniquement les paramètres et les points locaux répertoriés dans sa définition. Un accès direct par programme aux points d’automate ou de programme n’est pas possible. Cela permet à l’instruction complémentaire de fonctionner comme un composant autonome. Elle peut être exécutée dans n’importe quelle application faisant appel à elle par l’intermédiaire de l’interface des paramètres. Elle peut être validée une fois pour toutes, puis verrouillée pour empêcher les modifications.

Instructions complémentaires de sécurité

Les instructions complémentaires de sécurité sont utilisées pour la tâche de sécurité des automates de sécurité GuardLogix. Créez une instruction complémentaire de sécurité lorsque cette instruction doit être utilisée dans une application de sécurité. Les instructions complémentaires de sécurité sont sujettes à un certain nombre de restrictions. Ces restrictions sont opérées par le logiciel RSLogix 5000 et les automates GuardLogix. Elles sont mentionnées à la suite pour information.

· Seuls peuvent être utilisés des instructions et des types de données homologués de sécurité.

· Tous les paramètres et points locaux utilisés dans une instruction complémentaire de sécurité doivent également être de classe sécurité.

· Les instructions complémentaires de sécurité utilisent uniquement des programmes en logique à relais. Elles ne peuvent en effet être appelées que par des routines de sécurité qui sont, pour l’instant, limitées à ce langage.

· Des références à des instructions complémentaires de sécurité peuvent être faites par d’autres instructions complémentaires de sécurité, mais pas par des instructions complémentaires standard.

· Des instructions complémentaires de sécurité ne peuvent pas être créées, modifiées ou importées dans un projet de sécurité lorsqu’il existe un verrouillage de sécurité ou une signature de tâche de sécurité.

Se reporter à la publication 1756-RM093, « GuardLogix Controller Systems Safety Reference Manual », pour plus d’informations sur la certification d’une instruction complémentaire de sécurité ainsi que sur les règles relatives aux applications de sécurité et à la signature de tâche de sécurité. Cette publication fournit également une liste d’instructions et de types de données homologués.



Chapitre 1

Signature d’instruction

La signature d’instruction, utilisable avec les automates standard aussi bien que ceux de sécurité, vous permet de déterminer rapidement si l’instruction complémentaire a été modifiée. Chaque instruction complémentaire possède une signature d’instruction spécifique au niveau de sa définition. Cette signature d’instruction est nécessaire lorsque l’instruction complémentaire est utilisée dans ses fonctions de sécurité de niveau SIL 3. Elle peut par ailleurs être requise dans certaines industries réglementées. Utilisez-la lorsque votre application nécessite un niveau d’intégrité élevé.

Une fois générée, la signature d’instruction scelle l’instruction complémentaire. Ceci empêche toute modification tant que cette signature est active. Sont ainsi protégés les commentaires de ligne, les descriptions de points et toute documentation qui a pu être créée pour l’instruction. Lorsqu’une instruction est scellée, vous ne pouvez exécuter que les actions suivantes :

· copier la signature de l’instruction ;· créer ou copier une entrée de l’historique de signature ;· créer des instances de l’instruction complémentaire ;· télécharger l’instruction ;· supprimer la signature de l’instruction ;· imprimer des rapports.

La signature d’instruction n’empêche pas la modification des instructions complémentaires référencées ou des types de données utilisateur. La modification des paramètres d’une instruction complémentaire référencée ou des éléments d’un type de données utilisateur en référence peut entraîner l’invalidation de la signature d’instruction. Les types de modification concernés sont :

· l’ajout, l’effacement ou le déplacement de paramètres, de points locaux ou d’éléments des types de données utilisateur en référence ;

· la modification du nom, du type de données ou du style d’affichage de paramètres, de points locaux ou d’éléments des types de données utilisateur en référence.

Si vous souhaitez activer le changement de langue ou la protection de la source sur une instruction complémentaire qui doit être scellée par une signature d’instruction, vous devrez importer les éléments traduits ou appliquer la protection de source avant de générer cette signature. Vous devez disposer de la clé d’accès à la source pour générer une signature ou créer une entrée d’historique de signature dans le cas d’une instruction complémentaire avec une signature d’instruction et dotée d’une protection de source.

Se reporter à Définition de la protection de la source d’une instruction complémentaire, page 55 our plus d’informations sur la protection de la source d’une instruction complémentaire.


Chapitre 1

Signature d’instruction de sécurité

Lorsqu’une instruction complémentaire de sécurité scellée est téléchargée pour la première fois, une signature d’instruction de sécurité SIL 3 est générée automatiquement.

Pour plus d’informations sur la certification d’une instruction complémentaire de sécurité, reportez-vous à la publication 1756-RM093, « GuardLogix Controller Systems Safety Reference Manual ».

Langages de programmation

Sélectionnez le langage de programmation en fonction du type d’application que vous voulez développer. Les langages en diagramme de logique à relais (LD), diagramme de blocs fonctionnels (FBD) et texte structuré (ST) peuvent être utilisés pour la programmation d’une instruction complémentaire.

Chacun des langages de programmation pris en charge par le logiciel RSLogix 5000 est adapté à des types d’applications et des styles de programmation différents. En général, la logique à relais est la plus rapide pour exécuter une logique booléenne simple, des temporisations et des comptages. Les diagrammes de blocs fonctionnels et le texte structuré seront plus adaptés si vous souhaitez profiter des instructions de commande de procédés et de variateurs plus évoluées offertes par ces langages.

Vous ne pouvez pas comparer les temps d’exécution d’une même instruction complémentaire écrite dans différents langages de programmation. En effet, il existe des différences fondamentales dans le mode d’exécution et de compilation de chaque langage.

Instructions de transition

Certaines instructions sont exécutées (ou redéclenchées) uniquement lorsque l’état d’entrée de la ligne passe de Faux à Vrai. Il s’agit d’instructions de transition en logique à relais. Lorsqu’elles sont employées dans une instruction complémentaire, ces instructions ne détectent pas le passage de l’entrée de ligne à l’état Faux. Lorsque le bit EnableIn est sur Faux, le sous-programme logique de l’instruction complémentaire n’est plus exécuté. L’instruction de transition ne détecte donc plus le passage à l’état Faux. Une logique conditionnelle supplémentaire est alors nécessaire pour gérer le déclenchement des instructions de transition contenues dans une instruction complémentaire.

Voici quelques exemples d’instructions de transition : ONS, MSG, PXRQ, SRT, certaines instructions ASCII et certaines instructions de commande de mouvement.

CONSEIL Après avoir créé une instruction complémentaire, vous pouvez changer de langage de programmation en cliquant sur Change Type (changer de type) dans l’onglet General (général) de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor). Cependant, tout programme existant sera perdu.



Chapitre 1

Taille de l’instruction

Les instructions complémentaires possèdent un sous-programme logique principal qui définit le comportement de l’instruction lors de son exécution. Ce sous-programme logique est semblable à tout autre sous-programme du projet et ne présente aucune restriction supplémentaire en matière de longueur. Le total paramètres d’entrée + paramètres de sortie + points locaux peut atteindre 512. Il n’existe pas de limite pour le nombre des paramètres d’entrée-sortie (InOut). La valeur maximum admissible d’une instance de données (incluant les entrées, les sorties et les points locaux) est de deux mégaoctets. La taille des données est affichée en bas de l’onglet des paramètres et des points locaux (Parameters and Local Tags) dans l’écran de définition de l’instruction complémentaire.

Modification de l’exécution

Les instructions complémentaires ne peuvent être modifiées qu’hors ligne. Si la fonctionnalité prévue doit être modifiée sur un automate en service, posez-vous la question de savoir si une instruction complémentaire est toujours adaptée.

Imbrication d’instructions complémentaires

Les instructions complémentaires peuvent appeler d’autres instructions complémentaires par l’intermédiaire de leurs sous-programmes. Ceci permet de concevoir une programmation plus modulaire en créant des instructions plus simples qui pourront être utilisées pour élaborer des fonctionnalités plus complexes par imbrication de ces instructions. Les instructions peuvent être imbriquées sur sept niveaux de profondeur.

Les instructions complémentaires ne peuvent pas appeler d’autres sous-programmes par l’intermédiaire d’une instruction JSR. Si vous avez besoin d’une fonctionnalité complexe faisant appel à plusieurs sous-programmes, vous devez utiliser des instructions imbriquées.

CONSEIL Le sous-programme EnableInFalse peut être utilisé pour fournir les conditions nécessaires au redéclenchement des instructions de transition contenues dans une instruction complémentaire. Cependant, cette méthode ne fonctionne pas pour les appels d’une instruction complémentaire contenus dans un sous-programme en texte structuré parce que EnableIn est toujours sur Vrai dans le cas d’appels en texte structuré.

CONSEIL Pour imbriquer des instructions complémentaires, l’instruction imbriquée et l’instruction qui l’appelle doivent être du même type, sinon cette instruction d’appel ne sera pas validée. En d’autres termes, des instructions complémentaires standard ne peuvent appeler que des instructions complémentaires standard et des instructions complémentaires de sécurité que des instructions complémentaires de sécurité.


Chapitre 1

Comparaison entre sous-programmes et instructions complémentaires

Vous pouvez écrire votre programme de trois façons différentes : pour une exécution en ligne en tant que sous-programme principal, pour l’utilisation d’appels de sous-programmes ou sous forme d’instructions complémentaires. Le tableau suivant présente les avantages et inconvénients de chacune de ces méthodes.

Tableau 1 – Avantages et inconvénients des sous-programmes et des instructions complémentaires

Critère Sous-programme principal

Sous-programme Instruction complémentaire

Accessibilité – Dans le programme (plusieurs exemplaires, un pour chaque programme)

N’importe où dans l’automate (exemplaire unique pour tout le projet)

Paramètres – Passage par valeur Passage par valeur par l’intermédiaire des paramètres d’entrée et de sortie ou par référence par l’intermédiaire des paramètres d’entrée-sortie (InOut)

Paramètres numériques – Aucune conversion, gestion par l’utilisateur Conversion de type de données automatique pour les paramètres d’entrée et de sortie

Types de données des paramètres

– Atomique, tableaux, structures Atomique pour tous paramètres ;tableaux et structures doivent correspondre à des paramètres d’entrée-sortie (InOut)

Vérification des paramètres – Aucune, gestion par l’utilisateur La vérification s’assure que le type d’argument correct a été fourni pour un paramètre donné

Encapsulation de données – Toutes les données en accès programme ou automate (accessibles sans restriction)

Les données locales sont isolées (uniquement accessibles dans l’instruction)

Surveillance/débogage Programme en ligne avec ses données

Données combinées à partir d’appels multiples, ce qui complique le débogage

Données à appel unique, ce qui simplifie le débogage

Langages de programmation pris en charge

FBD, LD, SFC, ST FBD, LD, SFC, ST FBD, LD, ST

Appel possible en – FBD, LD, SFC, ST FBD, LD, SFC (via ST), ST

Protection Verrouillage et visualisation seule

Verrouillage et visualisation seule Verrouillage et visualisation seule

Documentation Sous-programme, ligne de programme, boîte de texte, ligne de texte

Sous-programme, ligne de programme, boîte de texte, ligne de texte

Instruction, informations de révision, fournisseur, ligne de programme, boîte de texte, ligne de texte, aide étendue

Performance d’exécution La plus rapide Les instructions JSR/SBR/RTN ajoutent une opération supplémentaire.Toutes les données sont copiées.Impact de la référence indexée.

Appel plus efficaceLes paramètres d’entrée-sortie (InOut) sont passés par référence, ce qui est plus rapide que la copie des données à partir de plusieurs types.Les références des paramètres sont automatiquement déplacées à partir de l’emplacement du point de l’instruction qui a été passé.

Utilisation de la mémoire Utilisation maximum Très condensée Un appel condensé requiert plus de mémoire qu’un appel de sous-programme.Toutes les références ont besoin d’un mot supplémentaire

Modification En ligne/hors ligne En ligne/hors ligne Hors ligne uniquement

Importation/exportation Tout le sous-programme, y compris les points et les définitions d’instruction vers L5X

Tout le sous-programme, y compris les points et les définitions d’instruction vers L5X

La définition complète de l’instruction, y compris les sous-programmes et les points vers L5X

Signature d’instruction – – Signature en 32 bits scellant l’instruction pour empêcher sa modification et lui conférer une haute intégrité


Chapitre 1

Accès aux données par programmation

Les paramètres d’entrée et de sortie, ainsi que les points locaux sont utilisés pour déterminer le type de données défini par l’instruction. Chaque paramètre ou point local possède un élément du type de données, cependant les éléments de point local sont occultés pour l’utilisation externe. Chaque appel d’une instruction complémentaire utilise un point de ce type de données pour fournir l’instance de donnée destinée à l’exécution de l’instruction.

Les paramètres d’une instruction complémentaire sont directement accessibles par le programme de l’automate par l’intermédiaire du point défini par l’instruction dans les règles normales d’accès aux points.

Les points locaux ne sont pas accessibles par programme par l’intermédiaire de ce point. Ceci a un impact sur l’utilisation de l’instruction complémentaire. Si une instruction complémentaire de type structurée (notamment de type UDT), tableau ou imbriquée est utilisée comme point local (et non des paramètres d’entrée-sortie InOut), elle ne sera pas accessible par programmation en dehors de la définition de cette instruction complémentaire.

CONSEIL Vous pouvez accéder à un point local par l’intermédiaire d’un alias de paramètre.

Voir Création d’un alias de paramètre pour un point local, page 28.


Chapitre 1

Instructions indisponibles dans les instructions complémentaires

La plupart des instructions intégrées peuvent être utilisées dans des instructions complémentaires. Les instructions suivantes ne peuvent cependant pas être utilisées :

Les instructions spécifiques aux applications de sécurité, comme les commandes de tapis de sécurité (SMAT), peuvent être utilisées uniquement dans des instructions complémentaires de sécurité. Pour plus d’informations sur les instructions destinées aux applications de sécurité, voir la publication 1756-RM095, « GuardLogix Safety Application Instruction Set Safety Reference Manual ».

De plus, les instructions suivantes peuvent être utilisées dans une instruction complémentaire, mais les instances de données doivent être passées comme des paramètres d’entrée-sortie (InOut).

· ALMA (Analog Alarm – alarme analogique)· ALMD (Digital Alarm – alarme TOR)· Toutes les instructions de commande de mouvement· MSG (Message)

Instruction indisponible Description

BRK Break (coupure)

EOT End of Transition (fin de transition)

EVENT Event Task Trigger (déclenchement de tâche événementielle)

FOR For (For/Next Loop) (pour – boucle pour/suivante)

IOT Immediate Output (sortie immédiate)

JSR Jump to Subroutine (saut vers sous-programme)

JXR Jump to External Routine (saut vers sous-programme externe)

MAOC Motion Arm Output Cam (armement mouvement de came de sortie)

PATT Attach to Equipment Phase (raccordement à la phase d’équipement)

PCLF Equipment Phase Clear Failure (suppression de défaut de la phase d’équipement)

PCMD Equipment Phase Command (commande de phase d’équipement)

PDET Detach from Equipment Phase (déconnexion de phase d’équipement)

POVR Equipment Phase Override Command (commande de contournement de la phase d’équipement)

RET Return (retour)

SBR Subroutine (sous-programme)

SFP SFC Pause (pause du graphe de fonctionnement séquentiel)

SFR SFC Reset (réinitialisation du graphe de fonctionnement séquentiel)



Chapitre 1

Utilisation des instructions GSV et SSV

Lors de l’utilisation d’instructions GSV et SSV à l’intérieur une instruction complémentaire, les classes suivantes sont prises en charge :

Lorsque vous saisissez une instruction GSV ou SSV, le logiciel RSLogix 5000 affiche les classes d’objet, les noms d’objet et les noms d’attribut pour chaque type d’instruction. Le tableau suivant présente les attributs pour la classe AddOnInstructionDefinition (définition d’instruction complémentaire).

Pour plus d’informations sur l’utilisation des instructions GSV et SSV, voir la publication 1756-RM003, « Logix5000 Controllers General Instructions Reference Manual ».

· AddOnInstructionDefinition (définition d’instruction complémentaire)(1)(2)

(1) GSV uniquement. Les instructions SSV ne seront pas validées.

· MotionGroup (groupe de commande de mouvement)

· Axis (axe) · Program (programme)(2)

(2) Les classes représentant des composants de programmation, comme Task (tâche), Program (programme), Routine (sous-programme) et AddOnInstructionDefinition (définition d’instruction complémentaire), acceptent uniquement « this » (cela) comme nom d’instance.

· Controller (automate) · Routine (sous-programme)(2)

· Controller Device (dispositif automate) · Redundancy (redondance)

· CoordinateSystem (système coordonné) · Safety (sécurité)

· CST · Serial Port (port série)

· DF1 · Task (tâche)(2)

· Fault Log (enregistrement de défaut) · Wall Clock Time (temps réel)

· Message

Nom d’attribut Type de données

Description de l’attribut

MajorRevision DINT Numéro de révision majeure de l’instruction complémentaire

MinorRevision DINT Numéro de révision mineure de l’instruction complémentaire

Name Chaîne de caractères

Nom de l’instruction complémentaire

RevisionExtendedText Chaîne de caractères

Texte décrivant la révision de l’instruction complémentaire

Vendor Chaîne de caractères

Fournisseur auteur de l’instruction complémentaire

LastEditDate LINT Horodatage de la dernière modification de l’instruction complémentaire

SignatureID DINT Valeur de la signature d’instruction (en 32 bits)

SafetySignatureID DINT Valeur de la signature d’instruction de sécurité (en 32 bits)



Chapitre 1

Éléments à prendre en compte pour la création de paramètres

Les informations qui suivent sont à considérer avec attention lorsque vous créez des paramètres.

Passage d’arguments aux paramètres par référence ou par valeur

Les éléments suivants permettent de comprendre la différence existant entre passer des points d’argument aux paramètres par référence ou par valeur.

Choix d’un type de données pour un paramètre

Les automates Logix5000 effectuent des opérations mathématiques de type DINT (en 32 bits) et REAL (en 32 bits). Ceci se traduit une exécution plus rapide des données de type DINT que de celles des autres types à base de nombres entiers. Les règles de conversion des données SINT en INT, puis en DINT, sont automatiquement appliquées. Ceci peut rajouter une opération supplémentaire. Chaque fois que possible, utilisez le type de données DINT pour les paramètres d’entrée et de sortie d’une instruction complémentaire.

Critère Par valeur (entrée ou sortie) Par référence (entrée-sortie)

Valeur Synchrone – la valeur de l’argument ne change pas pendant l’exécution de l’instruction complémentaire.

Asynchrone – la valeur de l’argument peut changer pendant l’exécution de l’instruction complémentaire. Tout accès par le programme de l’instruction lit ou écrit directement la valeur du point qui vient d’être passé.

Performance Les valeurs d’argument sont copiées dans et à partir des paramètres de l’instruction complémentaire. Il faut plus de temps pour exécuter un appel de l’instruction.

Les paramètres accèdent aux points de l’argument directement par référence. Ceci accélère l’exécution des appels de l’instruction.

Utilisation de la mémoire

Quantité maximum. Quantité minimum.

Types de données de paramètre pris en charge

Atomique (SINT, DINT, INT, REAL, BOOL). Atomique, tableaux et structures.


Chapitre 1

Création d’un alias de paramètre pour un point local

Les alias de paramètres simplifient la connexion des points locaux à un point d’entrée ou de sortie habituellement utilisé dans l’application d’une instruction complémentaire, sans qu’il soit nécessaire de créer manuellement un programme pour réaliser l’association. Les alias peuvent être utilisés pour définir un paramètre d’entrée ou de sortie avec accès direct à un point local ou à son élément. La modification de la valeur d’un alias de paramètre change les données du point local ou de l’élément qu’il représente et vice-versa.

Les alias de paramètres sont soumis aux restrictions suivantes :· les alias de paramètres doivent être soit des paramètres d’entrée ou de

sortie ;· vous ne pouvez créer un alias de paramètre que pour un point local ou son

élément ;· un seul paramètre d’entrée et un seul paramètre de sortie peuvent être

référencés à un même point local ou son élément ;· seuls des données de type BOOL, SINT, INT, DINT et REAL peuvent

être utilisées ;· les alias de paramètres peuvent ne pas être des constantes ;· le type d’accès externe à un alias de paramètre correspond au type d’accès

externe au point local auquel il est référencé.Pour plus d’informations sur les constantes et l’accès externe, voir Contrôle de l’accès aux données, page 30.

Utilisation d’un tableau unidimensionnel comme paramètre d’entrée-sortie (InOut)

Un paramètre d’entrée-sortie (InOut) peut être défini comme un tableau unidimensionnel . Lorsque vous définissez la taille de votre tableau, tenez compte du fait que son utilisateur sera susceptible de :

· passer un point de ce tableau de la même taille que celle que vous avez définie ;

· passer un point de ce tableau d’une taille supérieure celle que vous avez définie.

Lorsque vous développez votre programme, utilisez l’instruction Size (dimensionner) pour définir la taille effective du tableau référencé, de façon à permettre cette souplesse.

CONSEIL Lorsque vous contrôlez un paramètre d’entrée-sortie de tableau au niveau du sous-programme logique, la définition de ce paramètre est utilisée pour déterminer la taille du tableau. Supposons, par exemple, que vous ayez défini un paramètre d’entrée-sortie (InOut) sous forme d’un tableau de 10 éléments DINT et que l’utilisateur final fasse passer un tableau de 100 éléments DINT. Dans ce cas, si le programme de l’instruction complémentaire est ouvert, que le contexte approprié pour cet appel est sélectionné et que le paramètre du tableau est sous contrôle, seuls 10 éléments seront affichés.


Chapitre 1

Définir quels paramètres rendre visibles ou obligatoires

Pour s’assurer que des données spécifiques sont bien passées dans l’instruction complémentaire, vous pouvez utiliser des paramètres obligatoires. Un paramètre obligatoire doit avoir passé un argument pour que l’appel de l’instruction soit validé. En diagramme à relais et en texte structuré, ceci est réalisé en spécifiant un point d’argument pour ces paramètres. Dans un diagramme de blocs fonctionnels, les paramètres d’entrée et de sortie obligatoires doivent être reliés et les paramètres d’entrée-sortie (InOut) doivent utiliser un point d’argument. Si un paramètre obligatoire n’a pas d’argument associé, comme décrit précédemment, le sous-programme contenant l’appel de l’instruction complémentaire ne sera pas validé.

Pour les paramètres de sortie, rendre un paramètres visible est utile si vous n’avez pas habituellement besoin de passer la valeur de ce paramètre à un argument, mais que vous souhaitez afficher sa valeur à des fins de dépannage.

Les paramètres obligatoires sont toujours visibles et les paramètres d’entrée-sortie (InOut) sont toujours obligatoires et visibles. Il est possible d’accéder par programmation à tous les paramètres d’entrée et de sortie, qu’ils soient marqués ou non comme obligatoires ou visibles, en les considérant comme éléments du point de l’instruction.

Figure 1– Instruction de simulation en langage à blocs fonctionnels

Figure 2– Instruction de simulation en logique à relais

Ce tableau décrit les effets du réglage des paramètres sur obligatoire (Required) et Visible sur l’affichage de l’instruction.

Paramètre d’entrée obligatoire

Paramètre d’entrée visible (non obligatoire)

Paramètre de sortie booléen visible (non obligatoire)

Paramètre d’entrée-sortie (InOut)

Paramètre de sortie visible (non obligatoire)

Si vous voulez qu’un branchement soit affiché dans le bloc fonctionnel bien que sa liaison soit facultative, réglez-le sur Visible.

Paramètre d’entrée visible (non obligatoire)

Paramètre de sortie visible (non obligatoire)

Paramètre d’entrée obligatoire

Paramètre de sortie booléen visible (non obligatoire)

Paramètre d’entrée-sortie (InOut)

· Si vous voulez que la valeur du paramètre soit affichée dans la représentation de l’instruction en logique à relais, réglez ce paramètre sur visible.

· Un paramètre de sortie non obligatoire mais visible, utilisant un point de type BOOL, sera affiché sous forme d’indicateur d’état à droite du bloc en logique à relais. Ceci peut être utilisé pour les indicateurs d’état de type DN ou ER.


Chapitre 1

Tableau 2 – Réglages des paramètres d’entrée, de sortie et d’entrée-sortie (InOut) sur obligatoire (Required) et Visible

Si vous utilisez un paramètre pour lequel l’utilisateur doit spécifier un point comme source en entrée ou comme destination en sortie, et que vous ne voulez pas que cette action soit occultée, réglez ce paramètre sur obligatoire. Tout paramètre obligatoire est automatiquement défini comme visible.

Ce réglage (Visible) est systématiquement activé pour les paramètres d’entrée-sortie (InOut). Tous les paramètres d’entrée-sortie (InOut) sont définis comme obligatoires.

Utilisation des points standard et de sécurité

Lorsque vous créez une instruction complémentaire de sécurité, respectez les consignes suivantes concernant les points standard et de sécurité :

· les points standard ne peuvent pas être utilisés comme paramètres d’entrée, de sortie ou d’entrée-sortie (InOut) dans une instruction complémentaire de sécurité ;

· les points de sécurité peuvent être utilisés comme paramètres d’entrée dans les instructions complémentaires standard.

Contrôle de l’accès aux données

Dans le logiciel RSLogix 5000 à partir de la version 18, vous pouvez empêcher la modification des paramètres d’entrée-sortie par le programme en définissant ces paramètres comme des constantes. Vous pouvez également configurer le type d’accès autorisé aux dispositifs externes tels que les IHM pour les données de vos points et paramètres. Vous pouvez contrôler l’accès à la modification des données de point avec le logiciel RSLogix 5000 en définissant des règles de sécurité dans FactoryTalk.

Type du paramètre

Le paramètre est-il obligatoire ?

Le paramètre est-il visible ?

Diagramme à relais Diagramme de blocs fonctionnels Texte structuré

La valeur est-elle affichée ?

L’argument est-il affiché ?

Avez-vous besoin de connecter le paramètre ?


Pouvez-vous modifier le réglage de visibilité dans le bloc fonctionnel ?


Entrée Oui Oui Oui Oui Oui – Non Oui

Entrée Non Oui Oui Non Non – Oui Non

Entrée Non Non Non Non Non – Oui Non

Sortie Oui Oui Oui Oui Oui – Non Oui

Sortie Non Oui Oui Non Non – Oui Non

Sortie Non Non Non Non Non – Oui Non

Entrée-sortie (InOut)

Oui Oui Non Oui – Oui Non Oui

CONSEIL Lors de l’utilisation de vos instructions complémentaires, le réglage de visibilité pourra être ignoré dans des sous-programmes en diagramme de blocs fonctionnels si ce paramètre n’est pas obligatoire ou qu’il est déjà relié. Cette annulation de la visibilité lors de l’appel de l’instruction n’affecte pas la configuration de la définition.


Chapitre 1

Valeurs constantes

Les paramètres d’entrée-sortie peuvent être définis comme points à valeur constante afin d’empêcher la modification de leurs données par le programme de l’automate. Si le programme d’une instruction complémentaire contient une opération d’écriture sur un paramètre à valeur constante, cette instruction complémentaire ne sera pas validée par son contexte de définition.

Accès externe

L’accès externe défini le niveau d’accès accordé aux dispositifs externes tels que les IHM pour la visualisation ou la modification des valeurs de point.

Paramètres et points d’une instruction complémentaire Options d’accès externePoint local Read/Write (lecture/écriture)

Read Only (lecture seule)None (aucune action)

Paramètre d’entréeParamètre de sortieParamètre EnableIn (entrée activée)

Lecture seulementParamètre EnableOut (sortie activée)Paramètre d’entrée-sortie (InOut) –


Chapitre 1

Planification de la conception d’une instruction complémentaire

Prenez le temps de planifier la conception de votre instruction. Une planification en amont peut vous permettre d’identifier les problèmes à traiter. Lorsque vous définissez les règles d’une instruction, vous déterminez également son interface. Considérez les aspects suivants lorsque vous définissez les règles de votre instruction complémentaire et que vous la créez.

Comportement attendu· Dans quel but souhaitez-vous créer une instruction complémentaire ?· Quel problème est-elle censée résoudre ?· Comment devra-t-elle fonctionner ?· Avez-vous besoin d’un niveau d’intégrité supérieur pour cette instruction

complémentaire ?

Si tel est le cas, vous pourrez générer une signature d’instruction qui permettra de vérifier que votre instruction complémentaire n’a pas été modifiée.

· Avez-vous besoin d’utiliser des instructions dans des applications de sécurité et de certifier votre instruction complémentaire au niveau d’intégrité SIL-3 ?

Pour plus d’informations sur la certification d’une instruction complémentaire de sécurité, voir la publication 1756-RM093, « GuardLogix Controller Systems Safety Reference Manual ».

Paramètres· Quelles données doivent être passées à l’instruction ? · Quelles informations doivent être accessibles à l’extérieur de l’instruction ?· Des alias de paramètre doivent-ils être définis pour les données de points

locaux devant être accessibles à l’extérieur de l’instruction complémentaire ?

· Comment les paramètres seront-ils affichés ? L’ordre des paramètres définit l’apparence de l’instruction.

· Quels paramètres doivent être rendus obligatoires ou visibles ?

Conventions de dénomination

Le nom défini pour l’instruction sera utilisé comme mnémonique pour cette instruction. Bien que ce nom puisse utiliser jusqu’à 40 caractères, il est préférable d’avoir recours à des noms les plus courts possibles car ils sont plus faciles à gérer.



Chapitre 1

Protection de la source· Quel type de protection de source doit être défini, le cas échéant ?· Qui aura accès à la clé de protection de la source ?· Allez-vous avoir besoin de gérer une protection de la source et une

signature d’instruction ?

La protection de source peut être utilisée pour définir un accès en lecture seule à l’instruction complémentaire ou pour verrouiller ou cacher complètement cette instruction complémentaire ainsi que les points locaux.

La protection de source doit être appliquée avant de générer une signature d’instruction.

Imbrication – réutilisation d’Instructions· Existe-t-il d’autres instructions complémentaires que vous puissiez

réutiliser ?· Avez-vous besoin de concevoir vos instructions de telle façon qu’elles

utilisent le même programme ?

Points locaux· Quelles sont les données nécessaires à l’exécution de votre programme mais

qui ne doivent pas être publiées ?· Identifiez les points locaux que vous êtes susceptible d’utiliser dans votre

instruction. Les points locaux sont utiles pour enregistrer des éléments tels que des valeurs de calcul intermédiaires, que vous ne souhaitez pas rendre visibles aux utilisateurs de votre instruction.

· Souhaitez-vous créer un alias de paramètre de façon à permettre un accès externe à un point local ?

Langages de programmation· Quel langage souhaitez-vous utiliser pour programmer votre instruction ?

Le programme principal de votre instruction doit être composé d’un seul sous-programme en code. Déterminez quel langage de programmation proposé par le logiciel RSLogix 5000 doit être utilisé en fonction du mode d’utilisation et du type de votre application. Les instructions complémentaires de sécurité sont limitées à la programmation en logique à relais.

· Si le temps d’exécution et l’utilisation de la mémoire ont un caractère critique, reportez-vous à la publication 1756-RM087, « Logix5000 Controllers Execution Time and Memory Use Reference Manual ».



Chapitre 1

Sous-programmes en mode de scrutation· Devez-vous réaliser des sous-programmes utilisant un mode de scrutation ?

Vous pouvez éventuellement définir un comportement de scrutation pour l’instruction, et ce dans différents modes de scrutation. Ceci vous permet de définir des comportements d’initialisation spécifiques lors du démarrage de l’automate (Program -> Run) : post-scrutation d’une étape d’un graphe de fonctionnement séquentiel (SFC) ou condition EnableIn False (activation d’entrée = Faux).

· Dans quel langage les sous-programmes en mode de scrutation doivent-ils être écrits ?

Test· Comment allez-vous tester le fonctionnement de votre instruction

complémentaire avant sa mise en service ?· Quelles entrées inattendues l’instruction risque-t-elle de recevoir et

comment va-t-elle gérer ces cas ?

Documentation d’aide· Quelles informations doivent être fournies par l’aide ?

Lorsque vous créez une instruction, vous avez la possibilité de saisir des informations dans divers champs de description. Vous devrez également élaborer une documentation sur la façon d’utiliser l’instruction et sur son fonctionnement.


Chapitre 2

Définition des instructions complémentaires

Introduction

Création d’une instruction complémentaire

Suivez la procédure ci-dessous pour créer une nouvelle instruction complémentaire.

1. Ouvrez un nouveau projet ou un projet existant.

2. Cliquez avec le bouton droit de la souris sur le dossier des instructions complémentaires (Add-On Instructions) dans l’arborescence de l’automate et choisissez New Add-On Instruction (nouvelle instruction complémentaire).

Rubrique Page

Création d’une instruction complémentaire 35

Création des paramètres 37

Création de points locaux 39

Modification des paramètres et des points locaux 41

Mises à jour des arguments suite à des modifications de paramètre 41

Copie des valeurs par défaut d’un paramètres ou d’un point local 43

Création d’un programme pour une instruction complémentaire 44

Définition du fonctionnement dans les différents modes de scrutation 45

Activation des modes de scrutation 46

Utilisation des paramètres EnableIn et EnableOut 51

Modification de la classe d’une instruction complémentaire 53

Test d’une instruction complémentaire 53

Définition de la protection de la source d’une instruction complémentaire 55

Génération d’une signature d’instruction complémentaire 56

Création de l’aide pour l’instruction 59

Exemple d’instruction de démarrage de moteur 64

Exemple d’instruction de simulation 66


Chapitre 2

3. Entrez un nom original pour la nouvelle instruction.

Ce nom peut comporter jusqu’à 40 caractères. Il doit commencer par une lettre ou un caractère de soulignement et doit contenir uniquement des lettres, des chiffres ou des caractères de soulignement. Il ne doit pas correspondre au nom d’une instruction intégrée ou d’une instruction complémentaire déjà existante.

4. Tapez une description de 512 caractères au maximum pour cette nouvelle instruction.

5. Pour les projets de sécurité, choisissez la classe Standard ou Safety (sécurité).

Le champ Class (classe) est accessible dans la boîte de dialogue New Add-On Instruction (nouvelle instruction complémentaire) pour les projets d’automate de sécurité.

6. Choisissez un langage de programmation pour le programme de l’instruction complémentaire.

Le type de langage par défaut pour les instructions complémentaires de sécurité est le diagramme de logique à relais (LD).

7. Attribuez un niveau de révision à l’instruction.

8. Rédigez une note de révision (Revision Note) si nécessaire.

9. Ajoutez les informations concernant le fournisseur (Vendor) si nécessaire.

10. Cliquez sur OK pour créer l’instruction.


Chapitre 2

Création des paramètres Utilisez l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) pour créer les paramètres de vos instructions. Suivez les étapes ci-dessous pour définir les paramètres de votre instruction.

1. Dans l’arborescence de l’automate, cliquez avec le bouton droit de la souris sur une instruction complémentaire et choisissez Open Definition (ouvrir la définition).

2. Cliquez sur l’onglet Parameters et saisissez un nom de paramètre.

3. Définissez le mode d’utilisation (Usage) en fonction du type de paramètre : Input (entrée), Output (sortie), InOut (entrée-sortie).

4. Sélectionnez le type de données selon l’une des options suivantes en fonction du mode d’utilisation du paramètre :– Un paramètre d’entrée (Input) est passé par valeur à l’intérieur de

l’instruction complémentaire. Son type de données doit être SINT, INT, DINT, REAL ou BOOL.

– Un paramètre de sortie (Output) est passé par valeur à l’extérieur de l’instruction complémentaire. Son type de données doit être SINT, INT, DINT, REAL ou BOOL.

– Un paramètre d’entrée-sortie (InOut) est passé par référence à l’intérieur de l’instruction complémentaire. Il peut utiliser n’importe quel type de données, y compris les structures et les tableaux.

CONSEIL Une instruction utilisant uniquement des paramètres d’entrée, à l’exception d’EnableOut (activation de la sortie), est traitée comme une instruction d’entrée dans un diagramme de logique à relais. Elle est affichée alignée à gauche. Le paramètre EnableOut (activation de la sortie) est utilisé pour définir l’état de la ligne en sortie.

CONSEIL Les données de type REAL ne sont pas autorisées dans les instructions complémentaires destinées aux automates 1756-L6xS et 1768-L4xS. Les données de type REAL sont autorisées pour les automates ICE (1756-L7xS).


Chapitre 2

5. Si ce paramètre est conçu comme alias d’un point local existant, cliquez sur le menu déroulant Alias For (alias de) pour sélectionner ce point local ou son élément.

6. Configurez les valeurs par défaut.

Les valeurs par défaut sont chargées à partir de la définition de l’instruction complémentaire dans le point du type de données de cette instruction à sa création et chaque fois qu’un nouveau paramètre d’entrée ou de sortie est ajouté à l’instruction complémentaire.

7. Configurez le style d’affichage.

8. Cochez la case pour rendre le paramètre obligatoire (Required) ou visible, selon le cas.

Voir Définir quels paramètres rendre visibles ou obligatoires on page 29.

Si vous décidez de rendre le paramètre obligatoire, il sera également visible.

9. Saisissez une description de 512 caractères au maximum.

Cette description apparaîtra dans l’aide de l’instruction.

10. Choisissez un type d’accès externe (External Access) pour les paramètres d’entrée ou de sortie.

11. Cochez la case Constant pour les paramètres d’entrée-sortie (InOut) que vous souhaitez définir comme valeurs constantes.

12. Répétez ces opérations pour les autres paramètres.

L’ordre dans lequel vous créez les paramètres correspond à celui dans lequel ils apparaîtront dans le type de données et le synoptique de l’instruction. Vous pouvez modifier cet ordre dans l’onglet Parameters (paramètres) de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) en sélectionnant la ligne correspondant au paramètre et en cliquant sur Move Up (déplacer vers le haut) ou Move Down (déplacer vers le bas).

CONSEIL Vous pouvez également définir un paramètre comme alias d’un point local en utilisant l’éditeur de point.

Voir Modification des paramètres et des points locaux, page 41.

CONSEIL Cochez la case en bas de la fenêtre de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) pour copier toutes les valeurs par défaut des paramètres et des points locaux dont les valeurs ont été modifiées dans l’ensemble des points de ce type d’instruction. Ceci permet la mise à jour des appels existants de l’instruction suivant les nouvelles valeurs par défaut.

Pour plus de détails sur la copie des valeurs par défaut, voir Copie des valeurs par défaut d’un paramètres ou d’un point local, page 43.

CONSEIL Vous pouvez également créer des paramètres en utilisant les boîtes de dialogue Tag Editor, New Parameter (éditeur de point, nouveau paramètre) ou Local Tag (point local) ; ou encore en cliquant avec le bouton droit de la souris sur un nom de point dans votre sous-programme.


Chapitre 2

Figure 3 – Éditeur de définition d’instruction complémentaire – Onglet des paramètres

Création de points locaux Utilisez l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) pour créer des points locaux pour vos instructions. Les points locaux contiennent les données utilisées par votre instruction complémentaire que vous ne voulez pas rendre visibles aux utilisateurs de votre instruction. Les points locaux n’apparaissent pas dans la structure de données de l’instruction complémentaire car ce sont des éléments cachés.

Suivez la procédure ci-dessous pour définir des points locaux pour votre instruction.

1. Dans l’arborescence de l’automate, cliquez avec le bouton droit de la souris sur une instruction et choisissez Open Definition (ouvrir la définition).

CONSEIL Vous pouvez accéder aux valeurs d’un point local par l’intermédiaire d’une IHM en spécifiant le nom de ce point local comme élément d’un point de type instruction complémentaire. Par exemple, l’instruction Motor_Starter v1.0, illustrée à l’étape 2, utilise un point appelé CheckAuxContact. Ce point peut être référencé par une IHM au moyen de la ligne instancetag. CheckAuxContact, dans lequel « instancetag » correspondra au point utilisé pour appeler l’instruction.


Chapitre 2

2. Cliquez sur l’onglet Local Tags (points locaux) et tapez un nom pour le nouveau point, puis sélectionnez un type de données (Data Type).

Vous ne pouvez pas utiliser les types de données suivants pour les points locaux : ALARM_ANALOG, ALARM_DIGITAL, MESSAGE, ni les types de données correspondant aux commandes de mouvement comme Axis ou MOTION_GROUP. Pour utiliser ces types de points dans votre instruction complémentaire, vous devez définir un paramètre d’entrée-sortie (InOut). Les points locaux sont également limités à des tableaux unidimensionnels, tout comme les types de données utilisateur.

3. Définition des valeurs par défaut.

Les valeurs par défaut sont chargées à partir de la définition de l’instruction complémentaire dans le point du type de données de cette instruction à sa création, ou chaque fois qu’un nouveau paramètre d’entrée ou de sortie est ajouté à l’instruction complémentaire.

4. Configurez le style d’affichage (Style).

5. Saisissez une description de 512 caractères au maximum.

6. Répétez ces opérations pour les autres points locaux.

CONSEIL Se reporter à la publication 1756-RM093, « GuardLogix Controller Systems Safety Reference Manual », pour la liste des types de données pris en charge par les instructions de sécurité.

CONSEIL Cochez la case en bas de la fenêtre de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) pour copier toutes les valeurs par défaut des paramètres et des points locaux dont les valeurs ont été modifiées dans l’ensemble des points de ce type d’instruction. Ceci permet la mise à jour des appels existants de l’instruction suivant les nouvelles valeurs par défaut.

Pour plus de détails sur la copie des valeurs par défaut, voir Copie des valeurs par défaut d’un paramètres ou d’un point local, page 43.

CONSEIL Lorsque vous créez un point local dans l’onglet Local Tags (points locaux), le réglage External Access (accès externe) est configuré sur None (aucun) par défaut. Vous pouvez modifier ce réglage d’accès externe dans l’éditeur de point (Tag Editor).

Voir Modification des paramètres et des points locaux, page 41.



Chapitre 2

Modification des paramètres et des points locaux

Vous pouvez également ajouter et modifier des paramètres et des points locaux dans l’onglet Edit Tags (modifier les points) représenté ci-dessous.

Mises à jour des arguments suite à des modifications de paramètre

Si vous modifiez une instruction complémentaire par ajout, suppression, changement de nom, réorganisation ou modification de l’état ou du type d’utilisation d’un ou de plusieurs de ses paramètres, le logiciel RSLogix 5000, à partir de la version 18, mettra à jour automatiquement les arguments lors des appels de cette instruction.

Les sous-programmes et les autres instructions complémentaires à protection de source utilisant l’instruction complémentaire modifiée ne seront pas mis à jour automatiquement si la clé de la source n’est pas disponible. Cette instruction complémentaire ou ce sous-programme pourront tout de même être validés, mais le fonctionnement qui en résultera peut ne pas correspondre à ce qui est attendu.

Lorsque vous effectuez des modifications sur des instructions complémentaires existantes, vous devez savoir à quel endroit du programme ces instructions complémentaires sont utilisées.


Chapitre 2

Une boîte de dialogue de confirmation vous alertera sur les conséquences de ces modifications et vous permettra de revoir les modifications en instance avant de les confirmer définitivement ou de les abandonner.

· Un astérisque identifie les paramètres ayant des modifications en instance.· Les arguments existants sont réinitialisés en même temps que les

paramètres auxquels ils étaient initialement associés.· Les paramètres nouvellement ajoutés sont incorporés avec un « ? » dans le

champ Argument, sauf dans le cas d’une instruction en texte structuré pour laquelle ce champ reste vide.

· Des paramètres inconnus sont créés pour les arguments dont les paramètres associés ont été supprimés.

Pour effectuer cette mise à jour, le logiciel RSLogix 5000 remonte l’historique des modifications apportées aux paramètres de l’instruction complémentaire depuis la version initiale jusqu’à la version finale. A l’inverse, les processus d’importation et de collage se contentent de comparer les noms des paramètres pour leur associer des arguments. En conséquence, si deux paramètres différents ont le même nom mais des définitions d’utilisation différentes, l’importation ou le collage peut avoir un impact sur le comportement de l’instruction.


Chapitre 2

Copie des valeurs par défaut d’un paramètres ou d’un point local

Dans le logiciel RSLogix 5000 à partir de la version 18, vous avez la possibilité de copier les valeurs par défaut d’un paramètre ou d’un point local dans tous les points du type de données de l’instruction complémentaire ou uniquement dans des points spécifiques. Cette opération ne peut se réaliser que lorsque vous vous trouvez hors ligne.

Si vous modifiez les valeurs par défaut d’un paramètre ou d’un point local par l’intermédiaire de la boîte de dialogue Add-On Instruction Definition Editor (éditeur de définition d’instruction complémentaire), vous pouvez choisir de copier les valeurs modifiées dans tous les points du type de données de l’instruction complémentaire en cochant « Copy all default values of parameters and local tags… » (copier toutes les valeurs par défaut des paramètres ou des points locaux).

Vous pouvez également cliquer sur l’icône de recopie des valeurs par défaut pour copier ces valeurs dans tous les points du type de données de l’instruction complémentaire. Cette icône apparaît dans le panneau de contrôle (sous forme d’un menu contextuel), dans l’écran de surveillance des données et dans l’éditeur de programme lorsque le contexte de données (Data Context) correspond à la définition de l’instruction complémentaire.

Si vous voulez sélectionner des points et des valeurs spécifiques pour la copie, cliquez sur la flèche de déroulement du menu de l’icône de copie des valeurs par défaut et choisissez Copy Specified Values (copier les valeurs spécifiées).

La boîte de dialogue Copy Default Values (copier les valeurs par défaut) indique les valeurs par défaut actuelles des paramètres et des points locaux, ainsi que les points d’instance avec lesquels l’instruction complémentaire est utilisée ou auxquels elle est référencée.

ATTENTION : les valeurs ne peuvent pas être modifiées lorsque leurs points d’instance font partie d’une instruction complémentaire avec protection de source ou lorsque vous ne disposez pas d’un niveau d’autorisation suffisant pour effectuer ces modifications.


Chapitre 2

Cochez les cases pour sélectionner les valeurs à recopier et les points de destination, puis cliquez sur OK.

Création d’un programme pour une instruction complémentaire

Suivez la procédure ci-dessous pour entrer un programme dans votre projet.

1. Dans l’arborescence de l’automate (Controller Organizer), développez le niveau Add-On Instructions (instructions complémentaires).

2. Développez le contenu du dossier de l’instruction concernée et cliquez deux fois sur le sous-programme logique pour l’ouvrir.

3. Modifiez le programme à l’aide des éditeurs de langages disponibles.

Remarques concernant l’exécution des instructions complémentaires

Une instruction complémentaire s’exécute comme tout autre sous-programme appartenant à un programme donné. Du fait qu’une autre tâche peut avoir la priorité sur un programme contenant une instruction complémentaire en cours d’exécution, celle-ci peut être interrompue avant la fin de son exécution.


Chapitre 2

Dans les programmes standard, vous pouvez utiliser des instructions UID/UIE (User Interrupt Disable/Enable – désactivation/activation de l’interruption par l’utilisateur) pour bloquer un basculement entre tâches. Ceci vous garantira que l’exécution d’une instruction complémentaire ne sera pas interrompue par le basculement sur une autre tâche.

Optimisation des performances

La performance d’une l’instruction complémentaire dépend de sa structure, de sa configuration et du volume de code qu’elle utilise. Vous pouvez passer une grande quantité de données par une structure en utilisant un paramètre d’entrée-sortie (InOut). La taille des données référencées par un paramètre d’entrée-sortie (InOut) n’a pas d’incidence sur le temps de scrutation. Il n’y a par ailleurs pas de différence entre passer un point de type défini par l’utilisateur ou un point de type atomique parce que ce passage se fait par référence.

Lorsqu’une ligne est à l’état Faux, tous les appels d’instruction complémentaire sont traités, même si le sous-programme logique n’est pas exécuté. Le temps de scrutation peut cependant être affecté lorsqu’un certain nombre d’instances d’une instruction complémentaire sont exécutées à l’état Faux. Assurez-vous de fournir dans votre documentation des informations sur la possibilité de passer outre une instruction complémentaire lorsque l’état de la ligne est sur Faux.

Définition du fonctionnement dans les différents modes de scrutation

De façon à conférer aux instructions complémentaires la même souplesse que les instructions intégrées, des sous-programmes optionnels en mode de scrutation peuvent être configurés de telle sorte que le comportement de l’instruction soit complètement défini. Les instructions complémentaires ne comportent pas à l’origine de sous-programmes en mode de scrutation. Mais vous pouvez en créer selon les besoins de votre instruction.

Comme toutes les instructions intégrées d’un automate, les instructions complémentaires prennent en charge les quatre modes de scrutation suivants des automates.

CONSEIL Les instructions UID et UIE ne sont pas prises en charge dans la tâche de sécurité des projets GuardLogix.

Mode de scrutation

Description

Vrai L’instruction est scrutée lorsque la ligne est à l’état vrai ou lorsque le paramètre EnableIn (activation de l’entrée) est configuré sur Vrai.

Faux L’instruction est scrutée lorsque la ligne est à l’état faux ou lorsque le paramètre EnableIn (activation de l’entrée) est configuré sur Faux. Les instructions de l’automate peuvent éventuellement utiliser un programme qui ne s’exécutera que lorsque l’instruction est scrutée à l’état Faux.

Pré-scrutation Est réalisée lorsque l’automate démarre en mode d’exécution (Run) ou passe du mode de programmation (Program) au mode d’exécution. Les instructions de l’automate peuvent éventuellement utiliser un programme qui ne s’exécutera que si l’instruction est elle-même exécutée en mode de pré-scrutation.

Post-scrutation(1)

(1) Des sous-programmes en mode de post-scrutation ne peuvent pas être créés pour les instructions complémentaires de sécurité. Ces instructions de sécurité ne prennent pas en charge en effet le langage SFC.

Est réalisée lorsque une action d’un sous-programme en graphe de fonctionnement séquentiel (SFC) est terminée et que ce type de graphe est configuré pour une réinitialisation automatique. Les instructions de l’automate peuvent éventuellement utiliser un programme qui ne s’exécutera que si l’instruction est elle-même exécutée en mode de post-scrutation.


Chapitre 2

Le fonctionnement par défaut, c’est à dire l’exécution de l’instruction complémentaire sans utilisation d’un sous-programme de scrutation optionnel, s’avère généralement suffisant pour obtenir le résultat souhaité. Si vous ne définissez pas de mode de scrutation optionnel, l’instruction complémentaire présentera les comportements par défaut suivants :

Pour chacun de ces modes de scrutation, vous pouvez définir un sous-programme spécialement élaboré pour ce mode particulier et qui sera configuré pour y être exécuté spécifiquement.

Activation des modes de scrutation

L’onglet Scan Modes (modes de scrutation) de l’éditeur de définition d’instruction (Instruction Definition Editor) vous permet de créer et d’activer l’exécution des sous-programmes dans les trois modes de scrutation : pré-scrutation (Prescan), post-scrutation (Postscan) et Activation de l’entrée = Faux (EnableInFalse).

Sous-programme de pré-scrutation

Lorsque l’automate passe du mode programmation (Program) au mode d’exécution (Run) ou lorsqu’il démarre en mode d’exécution, tous ses programme internes sont exécutés en mode de pré-scrutation. Au cours de cette opération, chaque instruction peut se réinitialiser et certaines instructions réinitialisent également tous les points auxquels elles peuvent faire référence. Pour la plupart des instructions, le mode de pré-scrutation est synonyme de scrutation à l’état Faux. Par exemple, une instruction OTE effacera simplement son bit de sortie lorsqu’elle est exécutée en mode de pré-scrutation. Pour d’autres instructions, une réinitialisation particulière peut être effectuée comme dans le cas d’une instruction ONS qui utilisera le mode de pré-scrutation pour configurer son bit de mémoire. En mode de pré-scrutation, toutes les instructions sont considérées comme étant à l’état Faux. Leur logique conditionnelle ne peut donc pas s’exécuter.

Mode de scrutation

Résultat

Vrai Exécute le sous-programme logique principal de l’instruction complémentaire.

Faux N’exécute aucun programme de l’instruction complémentaire et n’écrit aucune sortie. Les paramètres d’entrée sont des valeurs passées.

Pré-scrutation Exécute le sous-programme logique principal de l’instruction complémentaire en mode de pré-scrutation. Toutes les valeurs des paramètres d’entrée et de sortie obligatoires sont passées.

Post-scrutation Exécute le sous-programme logique principal de l’instruction complémentaire en mode de post-scrutation.

Mode de scrutation

Résultat

Vrai Le sous-programme logique principal (non facultatif) de l’instruction complémentaire est exécuté.

Faux Le sous-programme EnableIn False (activation d’entrée = Faux) s’exécute normalement à la place du programme principal lorsque l’instruction est scrutée à l’état Faux. Toutes les valeurs des paramètres d’entrée et de sortie obligatoires (ou reliés en diagramme de blocs fonctionnels) sont passées.

Pré-scrutation Le sous-programme de pré-scrutation est exécuté normalement en mode de pré-scrutation après l’exécution du sous-programme logique principal. Toutes les valeurs obligatoires des paramètres d’entrée et de sortie sont passées.

Post-scrutation Le sous-programme de post-scrutation est exécuté normalement après l’exécution du sous-programme logique principal en mode de post-scrutation.


Chapitre 2

Le sous-programme optionnel de pré-scrutation d’une instruction complémentaire offre un moyen de définir un comportement supplémentaire pour cette instruction en mode de pré-scrutation. Lorsqu’un sous-programme de pré-scrutation est défini et activé, ce sous-programme s’exécute normalement en mode de pré-scrutation après l’exécution du sous-programme logique principal. Cela est très utile lorsque vous voulez réinitialiser les valeurs des points selon un état connu ou prédéfini préalablement à l’exécution. Par exemple, si vous souhaitez définir une instruction PID en mode manuel avec une sortie à 0 % avant sa première exécution, ou pour réinitialiser certaines valeurs de coefficients dans votre instruction complémentaire.

Lorsqu’une instruction complémentaire est exécutée en mode de pré-scrutation, les données de tous les paramètres obligatoires sont passées.

· Ces valeurs sont passées aux paramètres d’entrée à partir de leurs arguments lors de l’appel de l’instruction.

· Elles sont passées hors des paramètres de sortie vers les arguments qui leur ont été définis lors de l’appel de l’instruction.

Ces valeurs sont passées même lorsque la ligne est à l’état Faux dans un diagramme en logique à relais, ou lorsque l’appel de l’instruction se trouve dans une instruction conditionnelle à l’état Faux dans le cas d’un programme en texte structuré. Lorsqu’un diagramme de blocs fonctionnels est exécuté, les valeurs des données sont copiées vers toutes les entrées reliées et depuis toutes les sorties reliées, que les paramètres soient obligatoires ou non.

Suivez la procédure ci-dessous pour créer un sous-programme de pré-scrutation.


2. Cliquez sur l’onglet Scan Modes (modes de scrutation).

3. Cliquez sur New (nouveau) sous Prescan Routine (sous-programme de pré-scrutation).


Chapitre 2

4. Dans le menu déroulant Type de la boîte de dialogue New Scan Mode Routine (nouveau sous-programme en mode de scrutation), choisissez le type de langage de programmation, diagramme de logique à relais (Ladder Diagram), blocs fonctionnels (Function Block) ou texte structuré (Structured Text).

5. Tapez une description pour le comportement de pré-scrutation.

6. Cliquez sur OK pour créer le sous-programme et revenir à l’onglet Scan Modes (modes de scrutation).

7. Définissez si ce sous-programme de pré-scrutation doit être exécuté ou non en cochant ou en décochant la case Execute Prescan routine after the logic routine is prescanned (exécuter le sous-programme de pré-scrutation après pré-scrutation du sous-programme logique).

Le sous-programme de pré-scrutation peut désormais être modifié comme tout autre sous-programme.

Sous-programme de post-scrutation

Le mode de post-scrutation est utilisé uniquement dans les programmes en SFC, lorsqu’une action est terminée et que les graphes en SFC sont configurés pour une réinitialisation automatique (ce qui ne constitue pas une option par défaut du langage SFC). Lorsqu’une action en graphe de fonctionnement séquentiel est terminée, le programme de cette action est exécuté une fois encore en mode de post-scrutation. Ce mode est similaire au mode de pré-scrutation dans la mesure où la plupart des instructions sont simplement exécutées comme si elles étaient à l’état Faux. Il est possible pour une instruction d’avoir un comportement différent en mode de post-scrutation et en mode de pré-scrutation.

Lorsqu’une instruction complémentaire est appelée par le programme dans le cadre d’une action en SFC, ou si l’appel se trouve dans un sous-programme lui-même appelé par une instruction JSR depuis une action en SFC, et que l’option de réinitialisation automatique est activée, l’instruction complémentaire sera exécutée en mode de post-scrutation. Le sous-programme logique principal de l’instruction complémentaire sera exécuté en mode de post-scrutation. Ensuite, s’il est défini et activé, le sous-programme de post-scrutation de l’instruction complémentaire sera exécuté. Cela peut être utile pour réinitialiser les états internes et leurs valeurs, ou pour désactiver automatiquement les sorties de l’instruction lorsque l’action est terminée.


Chapitre 2

Suivez la procédure ci-dessous pour créer un sous-programme de post-scrutation.



3. Cliquez sur New (nouveau) sous Postscan Routine (sous-programme de post-scrutation).

4. Dans le menu déroulant Type de la boîte de dialogue New Scan Mode Routine (nouveau sous-programme en mode de scrutation), choisissez le type de langage de programmation : diagramme de logique à relais (Ladder Diagram), blocs fonctionnels (Function Block) ou texte structuré (Structured Text).

5. Tapez une description pour le comportement de post-scrutation.

6. Cliquez sur OK pour créer le sous-programme et revenir à l’onglet Scan Modes (modes de scrutation).

7. Définissez si ce sous-programme de pré-scrutation doit être exécuté ou non en cochant ou en décochant la case Execute Prescan routine after the logic routine is prescanned (exécuter le sous-programme de pré-scrutation après pré-scrutation du sous-programme logique).

Le sous-programme de post-scrutation peut désormais être modifié comme tout autre sous-programme.

CONSEIL Étant donné que les instructions complémentaires de sécurité ne peuvent pas être appelées depuis une action en SFC, cette option est désactivée pour ces instructions complémentaires de sécurité.


Chapitre 2

Sous-programme EnableInFalse

Lorsqu’il est défini et activé pour une instruction complémentaire, le sous-programme EnableInFalse (activation de l’entrée = Faux) est exécuté lorsque la ligne est à l’état Faux ou lorsque le paramètre EnableIn (activation de l’entrée) de l’instruction complémentaire est sur Faux (0). Cela est principalement utile pour les programmes scrutés à l’état Faux, lorsqu’ils sont utilisés comme instruction de sortie dans un sous-programme en logique à relais. Une utilisation classique de la scrutation à l’état Faux est le passage des instructions OTE à l’état désactivé lorsque les conditions de ligne précédentes sont sur Faux. Une instruction complémentaire peut utiliser l’option EnableInFalse (activation de l’entrée = Faux) pour vous permettre de définir un comportement lorsque l’état est sur Faux.

Lorsqu’une instruction complémentaire est exécutée à l’état Faux et que le sous-programme EnableInFalse (activation de l’entrée = Faux) est défini et activé, les données de tous les paramètres obligatoires sont passées.

· Ces valeurs sont passées aux paramètres d’entrée à partir de leurs arguments lors de l’appel de l’instruction.

· Elles sont passées hors des paramètres de sortie à partir de leurs arguments lors de l’appel de l’instruction.

Si le sous-programme EnableInFalse (activation de l’entrée = Faux) n’est pas activé, la seule action effectuée par une instruction complémentaire à l’état Faux sera le passage des valeurs à tous les paramètres d’entrée obligatoires (en logique à relais).

Suivez la procédure ci-dessous pour créer un sous-programme EnableInFalse (activation de l’entrée = Faux).

1. Cliquez avec le bouton droit de la souris sur l’instruction et choisissez Open Definition (ouvrir la définition).


3. Cliquez sur New (nouveau) dans le sous-programme EnableInFalse (activation de l’entrée = Faux).


Chapitre 2

4. Dans le menu déroulant Type de la boîte de dialogue New Scan Mode Routine (nouveau sous-programme en mode de scrutation), choisissez le type de langage de programmation : diagramme de logique à relais (Ladder Diagram), blocs fonctionnels (Function Block) ou texte structuré (Structured Text).

5. Tapez une description pour le comportement en mode EnableInFalse (activation de l’entrée = Faux).

6. Cliquez sur OK pour ajouter le sous-programme EnableInFalse (activation de l’entrée = Faux) à la définition de l’instruction complémentaire.

7. Définissez si ce sous-programme EnableInFalse (activation de l’entrée = Faux) doit être exécuté ou non en cochant ou décochant la case Execute EnableInFalse routine (exécuter le sous-programme Activation de l’entrée = Faux).

Le sous-programme EnableInFalse (activation de l’entrée = Faux) peut désormais être modifié comme tout autre sous-programme.

Utilisation des paramètres EnableIn et EnableOut

Les paramètres EnableIn (activation de l’entrée) et EnableOut (activation de la sortie) qui apparaissent par défaut dans chaque instruction complémentaire ont des comportements adaptés aux environnements des trois langage de programmation : diagramme de logique à relais (Ladder Diagram), blocs fonctionnels (Function Block) ou texte structuré (Structured Text).

Pour exécuter un sous-programme logique principal réalisé dans l’un de ces environnements de programmation, le paramètre EnableIn (activation de l’entrée) doit être sur Vrai (1). En général, le paramètre EnableIn (activation de l’entrée) ne doit pas être référencé par le sous-programme logique principal dans la définition de l’instruction. Le paramètre EnableOut (activation de la sortie) est aligné par défaut sur l’état du paramètre EnableIn (activation de l’entrée). Mais l’état de ce paramètre peut être forcé par le programme utilisateur.

Si le paramètre EnableIn (activation de l’entrée) de l’instruction est sur Faux (0), le sous-programme logique ne sera pas exécuté et le paramètre EnableOut (activation de la sortie) sera défini sur Faux (0). Si un sous-programme EnableInFalse (activation de l’entrée = Faux) est inclus dans la définition de l’instruction et s’il est activé, ce sous-programme EnableInFalse sera exécuté.

CONSEIL Si EnableIn (activation de l’entrée) est sur Faux, EnableOut (activation de la sortie) ne peut pas être rendu Vrai dans le sous-programme EnableIn False (activation de l’entrée = Faux).


Chapitre 2

Paramètre EnableIn et diagramme de logique à relais

Dans un environnement de programmation en diagramme de logique à relais, le paramètre EnableIn (activation de l’entrée) reflète l’état de la ligne au lancement de l’instruction. Si la ligne est à l’état Vrai (1) précédemment à l’instruction, le paramètre EnableIn (activation de l’entrée) est sur Vrai et le sous-programme logique principal de l’instruction est exécuté. De même, si la ligne est à l’état Faux (0) précédemment à l’instruction, le paramètre EnableIn (activation de l’entrée) est sur Faux et le sous-programme logique principal n’est pas exécuté.

Paramètre EnableIn et blocs fonctionnels

Dans l’environnement de programmation en blocs fonctionnels, le paramètre EnableIn (activation de l’entrée) peut être manipulé par l’utilisateur par ses connexions. Si aucune connexion filaire n’est réalisée, le paramètre EnableIn (activation de l’entrée) est défini sur Vrai (1) lorsque l’instruction commence à s’exécuter et que son sous-programme logique principal est exécuté. Si une connexion filaire à ce paramètre est sur Faux (0), le sous-programme logique principal de l’instruction n’est pas exécuté. Toute autre écriture de référence au paramètre EnableIn (activation de l’entrée), comme une ligne de diagramme de logique à relais ou une affectation en texte structuré, n’aura pas d’incidence sur l’état de ce paramètre. Seule une connexion filaire au branchement d’entrée de ce paramètre peut le forcer à l’état Faux (0).

Paramètre EnableIn et texte structuré

Dans l’environnement de programmation en texte structuré, le paramètre EnableIn (activation de l’entrée) est toujours défini sur Vrai (1) par défaut. L’utilisateur ne peut pas agir sur cet état du paramètre EnableIn (activation de l’entrée) dans un appel d’instruction en texte structuré. Étant donné qu’EnableIn (activation de l’entrée) est toujours sur Vrai (1) en texte structuré, le sous-programme EnableInFalse (activation de l’entrée = Faux) n’est jamais exécuté lors d’un appel d’instruction dans ce langage.

CONSEIL Une instruction comportant uniquement des paramètres d’entrée, à l’exception d’EnableOut (activation de la sortie), est traitée comme une instruction d’entrée (alignée à gauche) dans un diagramme de logique à relais. Le paramètre EnableOut (activation de la sortie) est utilisé pour définir l’état de sortie de la ligne.


Chapitre 2

Modification de la classe d’une instruction complémentaire

Vous pouvez modifier la classe d’une instruction complémentaire de sécurité de façon à ce qu’elle puisse être utilisée dans une tâche standard ou dans un automate standard. Vous pouvez modifier cette classe dans le projet de sécurité lorsque l’instruction n’a pas de signature d’instruction, que vous êtes hors ligne, que l’application n’a pas de signature de tâche de sécurité et qu’elle n’a pas de verrouillage de sécurité.

Vous pouvez également faire passer la classe d’une instruction complémentaire de « standard » à « sécurité », de façon à ce qu’elle puisse être utilisée dans la tâche de sécurité.

La modification de la classe d’une instruction complémentaire entraîne le même changement de classe pour les sous-programmes, paramètres et points locaux de cette instruction complémentaire. Ce changement n’affecte pas les instructions complémentaires imbriquées ou les instances existantes de l’instruction complémentaire.

Si des paramètres ou des points ne peuvent plus être validés en raison de cette modification de classe, ils sont identifiés dans les onglets Parameters (paramètres) et Local Tags (points locaux) de l’éditeur d’instruction complémentaire (Add-On Instruction Editor).

Si l’une des restrictions spécifiques aux instructions complémentaires se trouve transgressée par le changement de classe de « standard » à « sécurité », une des erreurs suivantes s’affiche et la modification échoue :

· « Routines must be of Ladder Diagram type » (les sous-programmes doivent être de type diagramme de logique à relais) ;

· « Safety Add-On Instructions do not support the Postscan routine » (les instructions complémentaires de sécurité ne prennent pas en charge les sous-programmes de post-scrutation) ;

· « One or more parameters or local tags have an invalid data type for a safety Add-On Instruction » (un ou plusieurs paramètres ou points locaux utilisent un type de données non autorisé pour une instruction complémentaire de sécurité).

Vous devrez alors modifier le type de vos paramètres, points ou sous-programmes avant que la modification de la classe puisse être entérinée.

Test d’une instruction complémentaire

Vous devez tester et éventuellement déboguer le programme d’une instruction avant de la mettre en service.

CONSEIL Si le projet d’un automate de sécurité contient des instructions complémentaires de sécurité, vous devrez les supprimer de ce projet ou les passer en classe standard avant de transformer l’automate en type standard.

CONSEIL Lorsqu’un défaut se produit dans un sous-programme d’instruction complémentaire, un journal d’erreurs est créé, contenant des informations détaillées permettant le dépannage.


Chapitre 2

Avant le démarrage du test

Avant de démarrer le test d’une instruction complémentaire, effectuez les opération suivantes :

1. Ouvrez le projet à déboguer hors ligne.

2. Ajoutez l’instruction complémentaire au projet, si ce n’est pas déjà fait.

Test du déroulement

1. Ajoutez un appel de l’instruction dans un sous-programme du projet actif.

2. Affectez des arguments aux paramètres obligatoires pour cet appel.

3. Chargez le projet.

Contrôle du programme avec visualisation contextuelle des données

Vous pouvez simplifier le contrôle et le dépannage en ligne de votre instruction complémentaire au moyen de la visualisation contextuelle des données. Le sélecteur Data Context (contexte de données) vous permet de sélectionner un appel spécifique de l’instruction complémentaire. Celui-ci définit une instance et des arguments d’appel dont les valeurs seront utilisées pour visualiser le programme de l’instruction complémentaire.

CONSEIL Les instructions complémentaires peuvent être créées ou modifiées hors ligne uniquement. Vous pouvez ajouter, supprimer ou modifier des arguments de point dans vos appels d’instructions complémentaire dans le cadre de modifications en ligne, mais vous ne pouvez pas modifier des arguments à l’intérieur d’une instruction complémentaire lorsque vous êtes en ligne.

CONSEIL Pour le débogage d’une instruction complémentaire, utilisez un point d’instance hors tableau pour l’appel de l’instruction. Ceci vous permet de contrôler et d’intervenir sur le sous-programme logique de l’instruction en utilisant le contexte de données. Les tableaux à indexation variable ne peuvent pas être utilisés pour contrôler le programme d’une instruction complémentaire.


Chapitre 2

Suivez la procédure ci-dessous pour contrôler le programme.

1. Passez en mode d’exécution (Run).

2. Cliquez avec le bouton droit de la souris sur l’appel de l’instruction et choisissez Open Instruction Logic (ouvrir le programme de l’instruction).

Le sous-programme logique s’ouvre avec un programme activé pour l’instance d’appel spécifique.

Validation des différents modes de scrutation

La méthode la plus directe pour valider le fonctionnement du mode de scrutation consiste à exécuter d’abord l’instruction avec le sous-programme de scrutation désactivé, puis, de nouveau, avec ce sous-programme activé. Vous pouvez alors déterminer si le sous-programme de scrutation s’est déroulé comme attendu.

Définition de la protection de la source d’une instruction complémentaire

Vous pouvez appliquer la protection de source à votre instruction complémentaire afin de protéger votre propriété intellectuelle ou d’empêcher des modifications inopportunes d’une source validée.

Instruction Description

Vrai Il s’agit simplement de l’exécution du sous-programme logique principal.

Faux Dans un sous-programme cible en logique à relais, cela implique de placer une instruction XIC avant une instance de l’instruction et d’évaluer les résultats de l’instruction lorsque XIC est sur Faux.Dans un sous-programme cible en blocs fonctionnels, cela implique d’exécuter une instance de l’instruction avec le paramètre EnableIn (activation de l’entrée) réglé sur zéro (0).

Pré-scrutation Placez l’automate en mode de programmation (Program), puis passez-le en mode d’exécution (Run).

Post-scrutation Avec l’automate configuré pour la réinitialisation automatique des programmes en SFC, placez une instance de l’instruction dans l’action d’un graphe de fonctionnement séquentiel. Lancez ce graphe de fonctionnement séquentiel de façon à ce que l’action soit exécutée et que le programme se poursuivre au-delà de l’étape associée à cette action.


Chapitre 2

Avec la protection de source, vous pouvez limiter l’accès de l’utilisateur à votre instruction complémentaire à la lecture seule ou empêcher cet accès au programme interne ou aux points locaux utilisés par l’instruction. Vous pouvez protéger l’utilisation et les modifications de vos instructions avec un fichier de clé de source lors de leur distribution.

Vous disposez de deux options d’application de la protection de la source.· Protection de la source

Les utilisateurs ne disposant pas de clé de source ne peuvent pas visualiser les sous-programmes ni les points locaux, ni apporter aucune modification à l’instruction complémentaire. Choisissez cette option si vous voulez protéger la définition de la source d’une instruction complémentaire de la vue des utilisateurs. Ceci pourra être justifié par la nature propriétaire des algorithmes ou par une volonté de contrôle strict des révisions.

· Protection de la source avec option de visualisation

Les utilisateurs ne disposant pas de clé de source peuvent visualiser tous les composants de l’instruction complémentaire, y compris son programme et ses points locaux, mais ils ne peuvent pas modifier cette instruction.

Fonction d’activation de la protection de la source

Si la protection de source n’est pas disponible et n’apparaît pas dans vos menus, vous pouvez l’activer à l’aide de l’outil RS5KSrcPtc.exe figurant sur votre CD d’installation.

Pour plus d’informations sur l’utilisation de la protection de la source, voir publication 1756-PM016, « Logix5000 Controllers Security Programming Manual ».

Génération d’une signature d’instruction complémentaire

L’onglet Signature de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) vous permet de gérer la signature d’instruction, de créer des entrées d’historique de signature et de visualiser la signature d’instruction de sécurité lorsqu’elle est présente. Les signatures d’instruction sont appliquées à la définition de l’instruction complémentaire. Toutes les instances de l’instruction complémentaire sont scellées une fois la signature appliquée.

Création, suppression ou copie d’une signature d’instruction

Dans l’onglet Signature de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor), cliquez sur Generate (générer) pour créer une signature d’instruction ou sur Remove (supprimer) pour supprimer une signature existante.

CONSEIL Appliquez la protection de source avant de générer une signature d’instruction pour la définition de votre instruction complémentaire. Vous aurez besoin de la clé de source pour créer une entrée dans l’historique de signature.

Lorsque la protection de source est activée, vous pouvez toujours copier la signature d’instruction ou l’historique de signature, s’ils existent.


http://literature.rockwellautomation.com/idc/groups/literature/documents/rm/1756-rpm016E.pdf

Chapitre 2

Vous devez vous trouver hors ligne pour pouvoir générer ou supprimer une signature d’instruction. Ces deux actions changent la dernière date de modification (Last Edited Date).

Vous pouvez cliquer sur Copy (copier) pour copier la signature d’instruction et, le cas échéant, la signature d’instruction de sécurité dans le presse-papiers afin faciliter leur archivage.

Création d’une entrée d’historique de signature

L’historique de signature (Signature History) assure un enregistrement des signatures pour permettre une consultation ultérieure. Une entrée d’historique de signature est constituée du nom de l’utilisateur, de la signature d’instruction, de la valeur d’horodatage et d’une description saisie par l’utilisateur. Vous ne pouvez créer un historique de signature que s’il existe une signature d’instruction et que vous êtes hors ligne. La création d’un historique de signature affecte la dernière date de modification (Last Edited Date), qui est remplacée par l’horodatage apparaissant dans l’entrée de l’historique. Jusqu’à six entrées d’historique peuvent être stockées.

Suivez la procédure ci-dessous pour créer une entrée d’historique de signature.

1. Dans l’onglet Signature de la fenêtre Add-On Instruction Definition Editor (éditeur de définition d’instruction complémentaire), cliquez sur Add to History (ajouter à l’historique).

2. Tapez une description (de 512 caractères au maximum) pour cette entrée.

3. Cliquez sur OK.

Pour supprimer l’historique de signature, cliquez sur Clear Signature History (effacer l’historique de signature) une fois que l’instruction n’a plus de signature d’instruction. Vous devez vous trouver hors ligne pour pouvoir supprimer cet historique de signature.

IMPORTANT Si vous supprimez une signature d’instruction alors que l’instruction complémentaire concernée possède également une signature d’instruction de sécurité, cette signature d’instruction de sécurité sera également supprimée.

IMPORTANT Si une signature d’instruction non valide est détectée au cours de la vérification, un message d’erreur indique que cette signature n’est pas valable. Vous devez alors supprimer la signature d’instruction, contrôler l’instruction complémentaire et générer une nouvelle signature d’instruction.

CONSEIL Pour faciliter l’archivage, vous pouvez recopier tout l’historique de signature dans le presse-papiers en sélectionnant toutes les lignes de cet historique et en choisissant Copy (copier) dans le menu Edit (modifier). Les données seront copiées au format TSV (valeurs séparées par tabulations).


Chapitre 2

Génération d’une signature d’instruction de sécurité

Lorsqu’une instruction complémentaire de sécurité scellée est téléchargée pour la première fois, une signature d’instruction de sécurité SIL 3 est générée automatiquement. Une fois créée, cette signature d’instruction de sécurité est vérifiée à chaque chargement.

Si le logiciel RSLogix 5000 détecte une valeur de signature d’instruction de sécurité non valide, il génère une nouvelle valeur de signature d’instruction de sécurité dans le projet hors ligne et affiche un avertissement indiquant cette modification. La signature d’instruction de sécurité se trouve supprimée automatiquement lorsque la signature d’instruction est supprimée.

Visualisation et impression de la signature d’instruction

Lorsqu’une signature d’instruction a été générée, le logiciel RSLogix 5000 affiche l’instruction avec une icône de sceau bleue dans l’arborescence de l’automate, sur la barre de titre de l’instruction complémentaire et dans l’éditeur de programme.

Vous pouvez également voir la signature d’instruction et la signature d’instruction de sécurité dans le panneau Quick View (vue rapide) de l’arborescence de l’automate, ainsi que dans l’onglet Signature de la boîte de dialogue Instruction Definition Editor (éditeur de définition d’instruction).

IMPORTANT Après avoir testé votre instruction complémentaire de sécurité et vérifié ses fonctionnalités, vous devez enregistrer la signature d’instruction, la signature d’instruction de sécurité et la valeur d’horodatage. L’enregistrement de ces valeurs permettra de déterminer si les fonctionnalités de l’instruction ont été modifiées.

Pour plus d’informations sur les règles propres aux applications de sécurité, voir publication 1756-RM093, « GuardLogix Controller Systems Safety Reference Manual ».

CONSEIL Lorsqu’une instruction est scellée, la signature d’instruction est affichée sur le synoptique de l’instruction dans l’éditeur de diagramme de logique à relais et celui de diagramme de blocs fonctionnels.

Vous pouvez désactiver cet affichage de la signature d’instruction dans la boîte de dialogue Workstation Options (options du poste de travail) du logiciel RSLogix 5000.

Logique à relais Diagramme de blocs fonctionnels



Chapitre 2

Le nom de l’instruction complémentaire, sa révision, sa signature d’instruction, sa signature d’instruction de sécurité et l’horodatage sont imprimés sur le rapport des signatures d’instruction complémentaire. Vous pouvez également choisir d’inclure la signature d’instruction, la signature d’instruction de sécurité et l’historique des signatures dans le rapport de l’instruction complémentaire en cliquant sur Print Options (options d’impression) dans la boîte de dialogue Generate Report (création de rapport).

Création de l’aide pour l’instruction

Une aide pour l’instruction personnalisée est générée automatiquement lorsque vous créez des instructions complémentaires. Le logiciel RSLogix 5000 élabore automatiquement une aide pour vos instructions complémentaires à partir de la description de l’instruction, de la note de révision et des descriptions des paramètres. En rédigeant des descriptions claires pour ces éléments, vous contribuez à aider les utilisateurs de votre instruction.

De plus, vous pouvez rajouter un texte personnalisé à l’aide en utilisant le champ de description étendue (Extended Description). Vous pouvez également fournir une documentation d’aide complémentaire en l’entrant dans l’onglet Help (aide) de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor). L’aide de l’instruction est accessible en appuyant sur F1 dans l’arborescence des instructions et depuis n’importe quel appel de l’instruction dans un éditeur de langage.

Rédaction de descriptions claires

Ayez les principes suivants à l’esprit lorsque vous rédigez vos descriptions :· utilisez des phrases courtes et un langage simple ;· soyez brefs et directs dans votre formulation ;· incluez des exemples simples ;· relisez ce que vous avez écrit.


Chapitre 2

Un exemple de remplissage du champ Extended Description Text (texte de description étendue) de l’onglet Help (aide) de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) est fourni à la suite. Ce champ vous permet de fournir des recommandations pour l’utilisation et le dépannage de votre instruction. La fenêtre Instruction Help Preview (prévisualisation de l’aide de l’instruction) vous permet de visualiser votre texte d’aide pour l’instruction sous sa forme finale.

CONSEIL Lorsque vous saisissez votre texte dans le champ Extended Description Text (texte de description étendue), vous pouvez utiliser des retours chariot et des tabulations pour formater ce texte à l’intérieur du champ. Si vous copiez et collez un texte dans ce champ, ses tabulations seront préservées.


Chapitre 2

Création de la documentation d’une instruction complémentaire

Suivez la procédure ci-dessous pour créer une aide personnalisée pour une instruction.

1. Cliquez avec le bouton droit de la souris sur une instruction complémentaire et choisissez Open Definition (ouvrir la définition).

2. Dans l’onglet General, saisissez une description et une note de révision pour cette instruction complémentaire afin d’expliquer sa finalité.

3. Cliquez sur l’onglet Parameters et saisissez une description claire pour chaque paramètre.

4. Dans l’arborescence de l’automate, cliquez avec le bouton droit de la souris sur chacun des sous-programmes appartenant à l’instruction complémentaire et choisissez Properties (propriétés).

5. Saisissez une description pour l’exécution de chacun de ces sous-programmes.a. Pour le sous-programme logique, décrivez la façon dont l’instruction

s’exécute lorsque le paramètre EnableIn (activation de l’entrée) est sur Vrai.

b. S’il existe un sous-programme EnableInFalse (activation de l’entrée = Faux), décrivez ce qui va se produire si EnableIn (activation de l’entrée) est sur Faux, comme par exemple l’effacement de toutes les sorties.

c. S’il existe un sous-programme de pré-scrutation, décrivez brièvement ce qui va se produire lors de l’exécution de ce sous-programme, comme par exemple la réinitialisation de tous les paramètres.

d. S’il existe un sous-programme de post-scrutation, décrivez brièvement ce qui va se produire lors de l’exécution de ce sous-programme, comme par exemple la réinitialisation de tous les paramètres réarmant l’instruction en interne.

6. Cliquez sur l’onglet Help (aide) de la fenêtre de l’éditeur de définition d’instruction complémentaire (Add-On Instruction Definition Editor) et saisissez vos informations complémentaires dans le champ Extended Description (description étendue).

Cette description étendue peut inclure les informations suivantes :

· informations complémentaires sur les paramètres ;· description du mode d’exécution de l’instruction ;· historique des modifications.


Chapitre 2

7. Vérifiez la présentation de votre aide dans la fenêtre de prévisualisation.

Un exemple d’aide pour une instruction, générée par le logiciel RSLogix 5000, est présenté à la suite. Les informations fournies constituent la synthèse des descriptions que vous avez saisies lors de votre définition de l’instruction.


Chapitre 2

Changement de langue d’interface

Avec le logiciel RSLogix 5000 à partir de la version 17, vous avez la possibilité d’afficher la documentation de votre projet, telle que les descriptions des points et les commentaires de ligne traduits dans toutes les langues prises en charge par ce projet. Vous pouvez mémoriser une documentation de projet plurilingue dans un fichier de projet commun plutôt que dans des fichiers de projet spécifiques à chaque langue. Vous définissez toutes les langues localisées que le projet prendra en charge et choisissez la langue localisée actuelle, par défaut et personnalisée en option. Le logiciel utilise la langue par défaut si le contenu de langue actuelle est vide pour un composant particulier du projet. Toutefois, vous pouvez utiliser une langue personnalisée pour adapter exactement la documentation à un utilisateur particulier du fichier de projet.

Entrez les descriptions localisées dans votre projet RSLogix 5000 soit en programmant dans cette langue, soit en utilisant l’option d’importation/exportation afin de traduire la documentation hors ligne et de la réimporter dans le projet. Dès que vous avez validé la commutation de langue dans le logiciel RSLogix 5000, vous pouvez passer d’une langue à l’autre pendant l’utilisation du logiciel.

Une documentation de projet qui prend en charge plusieurs traductions au sein d’un projet comprend :

· les descriptions de composant dans les points, les sous-programmes, les programmes, les types de données utilisateur et les instructions complémentaires ;

· les phases d’équipement ;· les tendances ;· les automates ;· les messages d’alarme (pour les configurations ALARM_ANALOG et

ALARM_DIGITAL) ;· les tâches ;· la description des caractéristiques des modules présents dans l’arborescence

de l’automate ;· les commentaires de ligne, les zones de texte des programmes en SFC et en

FBD.

Si vous souhaitez autoriser le changement de langue pour une instruction complémentaire scellée par une signature d’instruction, vous devez intégrer les traductions de la documentation dans cette instruction complémentaire avant de générer la signature. Étant donné que l’historique de signature est généré après la création de la signature d’instruction, cet historique de signature n’est pas traduisible. Si les informations traduites sont déjà présentes lorsque vous générez la signature d’instruction complémentaire, vous pourrez changer de langue sans incidence sur la signature car cette commutation ne modifie pas la définition de l’instruction. Elle ne modifie que la langue d’affichage.

Reportez-vous à l’aide en ligne pour obtenir des informations supplémentaires sur la validation d’un projet devant prendre en charge plusieurs traductions de la documentation.


Chapitre 2

Exemple d’instruction de démarrage de moteur

L’instruction complémentaire Motor_Starter permet de démarrer et d’arrêter un moteur.

Si le bouton-poussoir d’arrêt est en position fermée et que l’utilisateur appuie sur le bouton-poussoir de démarrage :

· le moteur reçoit une commande de marche ;· l’instruction verrouille la commande, le moteur continue donc de

fonctionner même lorsque le bouton-poussoir de démarrage est relâché.

Si on appuie sur le bouton-poussoir d’arrêt (qu’on l’ouvre), le moteur s’arrête.

Figure 4 – Exemple d’onglet General de l’éditeur de définition (Definition Editor) de l’instruction de démarrage de moteur

Figure 5 – Exemple d’onglet Parameter de l’éditeur de définition (Definition Editor) de l’instruction de démarrage de moteur


Chapitre 2

Figure 6 – Exemple de programme de démarrage de moteur en logique à relais

Les diagrammes suivants présentent l’appel de l’instruction Motor_ Starter dans trois langages de programmation différents.

Figure 7 – Démarrage du moteur en logique à relais (LD)


Chapitre 2

Figure 8 – Démarrage du moteur en diagramme de blocs fonctionnels (FBD)

Figure 9 – Démarrage du moteur en texte structuré (ST)

Motor_Starter(Motor_Starter_ST, Stop_PB, Start_PB, Motor_Out_ST);

Exemple d’instruction de simulation

L’instruction complémentaire Simulation_DT_1st rajoute un temps mort et un décalage du premier ordre à une variable d’entrée.

Figure 10 – Exemple d’onglet General de l’éditeur de définition (Definition Editor) pour une instruction de simulation


Chapitre 2

Figure 11 – Exemple d’onglet Parameter de l’éditeur de définition (Definition Editor) pour une instruction de simulation

Figure 12 – Exemple de programme de simulation


Chapitre 2

Configuration en diagramme de logique à relais (LD)

Dans cet exemple, l’instruction simule un temps mort et un processus de décalage (du premier ordre).

L’instruction Simulation_DT_1st lit la variable de contrôle à partir de l’instruction PID. L’instruction PID lit le paramètre SimOutput de l’instruction Simulation_DT_1st.

L’instruction Simulation_DT_1st lit la variable de contrôle à partir de l’instruction PID.

L’instruction PID lit le paramètre SimOutput de l’instruction Simulation_DT_1st.

Sim_DT_LD.SimOutput

point Simulation_DT_1st Paramètre SimOutput


Chapitre 2

Configuration en diagramme de blocs fonctionnels (FBD)

L’instruction PIDE envoie la variable de contrôle à l’instruction Simulation_DT_1st. L’instruction Simulation_DT_1st calcule une valeur de sortie et la renvoie à l’instruction PIDE comme variable de procédé.

Configuration en texte structuré (ST)

L’instruction PIDE envoie la variable de contrôle à l’instruction Simulation_DT_1st.

L’instruction Simulation_DT_1st calcule une valeur de sortie et la renvoie à l’instruction PIDE comme variable de procédé.

Simulation_DT_1st(Sim_DT_ST, My_PIDE_ST.CVEU, DT_Array_ST);My_PIDE_ST.PV := Sim_DT_ST.SimOutput;PIDE(My_PIDE_ST);

L’instruction Simulation_DT_1st lit la variablede contrôle à partir de l’instruction PIDE et

calcule une valeur de sortie.

La sortie passe sur la variable de procédé del’instruction PIDE.

Sim_DT_ST . SimOutput

Point Simulation_DT_1st

point

Paramètre SimOutput


Chapitre 2

Notes :


Chapitre 3

Utilisation des instructions complémentaires

Introduction Les instructions complémentaires s’utilisent dans vos sous-programmes comme n’importe quelle instruction intégrée. Vous ajoutez des appels de votre instruction, puis vous définissez les arguments pour tous ses paramètres.

Accès aux instructions complémentaires

Une instruction complémentaire peut être programmée dans n’importe lequel de ces langages : logique à relais, blocs fonctionnels ou texte structuré (y compris texte structuré à l’intérieur d’actions en graphe de fonctionnement séquentiel). L’apparence de l’instruction sera conforme au mode d’expression du langage utilisé.

Il est possible d’accéder aux instructions complémentaires d’un projet à partir de n’importe lequel des outils de sélection d’instructions habituels.

La barre d’outils d’instruction possède un onglet Add-On (complémentaire) qui affiche toutes les instructions complémentaires présentes dans le projet.

Rubrique Page

Accès aux instructions complémentaires 71

Utilisation de la boîte de dialogue Add Element 72

Inclusion d’une instruction complémentaire dans un sous-programme 73

Conseils d’utilisation d’une instruction complémentaire 75

Accès à un paramètre par programme 75

Surveillance de la valeur d’un paramètre 78

Visualisation du programme et surveillance dans le contexte de données 79

Déterminer si la source d’une instruction complémentaire est protégée 81

Copie d’une instruction complémentaire 82

Sauvegarde de vos instructions complémentaires 83

IMPORTANT Les instructions complémentaires de sécurité peuvent être utilisées uniquement dans des sous-programmes de sécurité. Ceux-ci sont actuellement limités à la logique à relais. Les instructions complémentaires de sécurité sont affichées dans la barre d’outils Language Element (élément de langage) uniquement lorsque le sous-programme est un sous-programme de sécurité.


Chapitre 3

Utilisation de la boîte de dialogue Add Element

Suivez la procédure ci-dessous pour accéder à la boîte de dialogue Add (language) Element (ajouter un élément [dans un des langages]).

1. Appuyez sur Alt + Insert n’importe où dans l’éditeur ou cliquez avec le bouton droit de la souris sur le programme dans cet éditeur.

2. Repérez l’instruction complémentaire que vous souhaitez ajouter à votre sous-programme.


Chapitre 3

3. Sélectionnez cette instruction complémentaire et cliquez sur OK.

Utilisez pour afficher l’aide de chaque instruction figurant dans l’arborescence.

Inclusion d’une instruction complémentaire dans un sous-programme

Suivez la procédure ci-dessous lorsque vous voulez utiliser une instruction complémentaire dans l’un de vos sous-programmes.

1. Ouvrez le dossier Add-On Instruction (instruction complémentaire) dans l’arborescence de l’automate (Controller Organizer) et parcourrez la liste des instructions.

Si l’instruction que vous voulez utiliser ne figure pas dans cette liste, vous pouvez alternativement :

· créer cette instruction dans votre projet ;· copier-coller une instruction existante dans votre projet ;· récupérer le fichier de définition d’une instruction précédemment

exportée, puis importer cette instruction dans votre projet actif.

2. Ouvrez le sous-programme qui va utiliser l’instruction.

3. Cliquez sur l’onglet Add-On (complémentaire) dans la barre d’outils d’instruction.

4. Cliquez sur l’instruction complémentaire désirée, par exemple Simulation, et faites glisser cette instruction dans le sous-programme depuis la barre d’outils.

5. Définissez les arguments pour chaque paramètre d’appel de l’instruction.


Chapitre 3

L’instruction apparaît dans chacun des langages telle que représentée ci-dessous.

L’instruction attend des arguments pour les paramètres obligatoires listés dans l’info-bulle de l’instruction.

Paramètre avec Description

Un seul point d’interrogation Paramètre d’entrée-sortie (InOut) obligatoire. Entrer un point.

Un ou deux points d’interrogation Paramètre d’entrée ou de sortie obligatoire. Entrer un point.

Deux points d’interrogation Paramètre non obligatoire. Vous pouvez, soit :· le laisser tel quel et utiliser sa valeur par défaut ;· saisir une valeur différente s’il s’agit d’un paramètre d’entrée.

Élément Description

Mamelon à l’extrémité du branchement Paramètre d’entrée ou de sortie obligatoire.Vous devez relier le branchement à une IREF, une OREF, un connecteur ou à un autre bloc pour validation.

Un seul point d’interrogation Paramètre d’entrée-sortie (InOut) obligatoire. Entrer un point.

Pas de mamelon à l’extrémité du branchement Paramètre non obligatoire.Vous pouvez, soit :

· le laisser tel quel et utiliser sa valeur par défaut ;· saisir une valeur différente s’il s’agit d’un paramètre d’entrée.

CONSEIL Pour obtenir de l’aide sur une instruction, sélectionnez cette instruction et appuyez sur F1. En texte structuré, assurez-vous que le curseur se trouve sur le nom de l’instruction en bleu.

Logique à relais

Diagramme de blocs fonctionnels

Mamelon

Texte structuré


Chapitre 3

Conseils d’utilisation d’une instruction complémentaire

Ce tableau regroupe des recommandations de programmation à connaître pour l’utilisation d’instructions complémentaires.

Accès à un paramètre par programme

Suivez ces procédures dans les différents langages lorsque vous voulez accéder à un paramètre d’instruction complémentaire qui n’est pas disponible sur le synoptique d’instruction par défaut.

Les procédures suivantes montre comment utiliser le paramètre Jog (avance par à-coups) d’une instruction complémentaire Motor Starter (démarrage de moteur).

Rubrique Description

Aide de l’instruction Utilisez l’aide de l’instruction pour savoir comment utiliser celle-ci dans votre programme.

Lignes de logique à relais Pour une ligne de logique à relais, vérifiez si l’instruction peut être exécutée ou non lorsque la ligne se trouve à l’état Faux. Ne pas l’exécuter peut améliorer le temps de scrutation.

Types de données Le type de données défini avec l’instruction complémentaire est utilisé pour le point qui fournit le contexte de son exécution depuis votre programme. Un point doit être défini dans ce type pour l’appel de l’instruction.

Point indexé Vous pouvez utiliser un point de tableau indexé indirectement pour l’instance de l’instruction. L’inconvénient est que vous ne pourrez pas contrôler l’instruction complémentaire en utilisant cette configuration comme contexte de données.

Passage des données · Les paramètres d’entrée et de sortie sont passés par valeur.· Les paramètres d’entrée-sortie (InOut) sont passés par référence.


Chapitre 3

Utilisation de la commande Jog (avance par à-coups) dans un diagramme de logique à relais

La première ligne définit le bit Jog de Motor_Starter_LD = Jog_PB.

Utilisation de la commande Jog (avance par à-coups) dans un diagramme de blocs fonctionnels

Tout paramètre peut être rendu visible ou invisible, sauf ceux définis comme obligatoires. Les paramètres obligatoires sont toujours visibles. Si le paramètre est obligatoire, il est coché dans la boîte de dialogue Properties (propriétés).

1. Cliquez sur Properties (propriétés) pour l’instruction.

2. Cochez la case Vis (visible) du paramètre Jog à utiliser dans votre diagramme.

3. Cliquez sur OK.

Motor_Starter_LD . Jog

Point Motor_Starter

point

Paramètre Jog

Utilisez une autre instruction, une affectation ou une expression pour lire ou écrire sur le nom de point du paramètre. Utilisez ce format pour le nom de point du paramètre.Add_On_Tag.Parameter

Dans lequel Est

Add_On_Tag Un point d’instance défini par le type de données Add On (complémentaire).

Parameter Le nom du paramètre.


Chapitre 3

4. Reliez le branchement du paramètre.

Utilisation de la commande Jog (avance par à-coups) dans un texte structuré

Motor_Starter_ST.Jog := Jog_PB;Motor_Starter(Motor_Starter_ST, Stop_PB, Start_PB, Motor_Out_ST);

L’affectation définit le bit Jog deMotor_Starter_ST = Jog_PB.

Motor_Starter_ST . Jog

Point Motor_Starter

point

Paramètre Jog


Chapitre 3

Surveillance de la valeur d’un paramètre

Suivez cette procédure lorsque vous voulez visualiser ou modifier une valeur de paramètre pour une instruction complémentaire.

1. Ouvrez les propriétés de l’instruction pour le langage que vous utilisez.a. En diagramme de blocs fonctionnels ou en logique à relais, cliquez sur

Properties (propriétés) correspondant à l’instruction.

b. En texte structuré, cliquez avec le bouton droit de la souris sur le nom de l’instruction et choisissez Properties (propriétés).

2. Contrôlez les valeurs des paramètres et modifiez-les si nécessaire.

3. Saisissez une nouvelle valeur pour chaque paramètre en fonction des besoins.

4. Cliquez sur Apply (appliquer), puis sur OK lorsque vous avez terminé.

Motor_Starter(Motor_Starter_ST, Stop_PB,Start_PB,Motor_Out_ST);


Chapitre 3

Visualisation du programme et surveillance dans le contexte de données

Suivez cette procédure lorsque vous voulez visualiser le programme d’une instruction complémentaire et superviser les valeurs des données en même temps que ce programme.

1. Cliquez avec le bouton droit de la souris sur l’appel de l’instruction dans n’importe quel sous-programme.

2. Choisissez Open Instruction Logic (ouvrir le programme de l’instruction).

La fenêtre Language Editor (éditeur de langage) s’ouvre avec le sous-programme logique de l’instruction complémentaire et les valeurs des données à partir de l’appel de l’instruction.

Lorsque vous visualisez le programme, vous pouvez :

· identifier l’appel d’instruction dont les points sont utilisés pour les données ;

· voir le programme en cours d’exécution (lorsque vous êtes en ligne) ;· voir les valeurs de paramètre et de point local ;· modifier ces valeurs de point local et de paramètre pour l’instance de

données sélectionnée.

Motor_Starter(Motor_Starter_ST,Stop_PB,Start_PB,Motor_Out_ST);


Chapitre 3

Le contexte de données identifie (par son point d’instance) l’appel de l’instruction utilisé pour les données.

Voir les valeurs de paramètres et de points locaux.

Modifier les valeurs des paramètres et des points locaux pour ce contexte de données.


Chapitre 3

Pour modifier le programme d’une l’instruction complémentaire, vous devez sélectionner la définition (<definition>) de cette instruction dans le champ Data Context (contexte de données).

Vous ne pouvez pas modifier le programme d’une l’instruction lorsque :· vous êtes en ligne ;· le programme est dans un contexte d’appel de l’instruction ;· la source de l’instruction est protégée ;· l’instruction est scellée avec une signature d’instruction.

Déterminer si la source d’une instruction complémentaire est protégée

La source d’une instruction complémentaire peut être protégée de sorte que vous ne puissiez pas visualiser son programme. Suivez les étapes ci-dessous pour vérifier si la source d’une instruction complémentaire est protégée.

1. Sélectionnez l’instruction complémentaire dans l’arborescence de l’automate.

Cette instruction complémentaire ne peut pas être affichée lorsqu’elle est totalement protégée.

2. Recherchez Source Protection (protection de la source) dans le panneau de visualisation rapide (Quick View).

Si cet attribut Source Protection (protection de la source) n’est pas listé, l’instruction n’est pas protégée.


Chapitre 3

Copie d’une instruction complémentaire

Vous pouvez copier une instruction complémentaire appartenant à un autre projet Logix 5000 dans votre projet. Après avoir copié cette instruction complémentaire, vous pouvez l’utiliser sans modifications ou vous pouvez la renommer et la modifier pour pouvoir l’utiliser dans vos programmes.

Suivez la procédure ci-dessous pour copier une instruction complémentaire.

1. Ouvrez le projet RSLogix 5000 contenant l’instruction complémentaire.

2. Localisez l’instruction dans le dossier des instructions complémentaires (Add-On Instructions).

3. Cliquez avec le bouton droit de la souris sur l’instruction et choisissez Copy (copier).

4. Ouvrez l’autre projet dans lequel vous voulez copier l’instruction.

5. Cliquez avec le bouton droit sur le dossier Add-On Instructions (instructions complémentaires) et choisissez Paste (coller).

IMPORTANT Soyez prudent(e) lorsque vous copiez et collez des composants entre différentes versions du logiciel de programmation RSLogix 5000. RSLogix 5000 n’accepte la copie que dans une version identique ou plus récente du logiciel. La copie dans une version antérieure du logiciel RSLogix 5000 n’est a-priori pas possible. Lorsque vous faites une copie dans une version antérieure, cette action peut réussir mais le résultat peut être imprévu.

CONSEIL Lorsque vous copiez-collez des instructions complémentaires, tenez compte des règles suivantes :

· Vous ne pouvez pas coller une instruction complémentaire de sécurité dans un sous-programme standard.

· Vous ne pouvez pas coller une instruction complémentaire de sécurité dans un projet de sécurité ayant un verrouillage de sécurité ou une signature de tâche de sécurité.

· Vous ne pouvez pas copier et coller une instruction complémentaire de sécurité lorsque vous êtes en ligne.


Chapitre 3

Sauvegarde de vos instructions complémentaires

Un groupe d’instructions complémentaires peut être sauvegardé de deux façons. L’une consiste à sauvegarder vos instructions complémentaires dans un fichier projet. L’autre consiste à créer un fichier d’exportation L5X, comme décrit au Chapitre 4.

Suivez la procédure ci-dessous pour sauvegarder vos instructions dans un fichier projet.

1. Identifiez les instructions que vous souhaitez sauvegarder.

2. Placez-les dans un fichier projet doté d’un nom du genre « MesInstructions.ACD ».

3. Ouvrez d’autres projets dans des instances complémentaires du logiciel RSLogix 5000 et utilisez un copier-coller ou un glisser-déposer pour déplacer une copie de l’instruction depuis « MesInstructions.ACD » vers un autre projet.

Si l’une de ces instructions fait référence à la même instruction complémentaire ou au même type de données utilisateur, il n’y aura qu’une seule copie partagée dans le fichier projet. Lorsqu’une instruction complémentaire est recopiée dans un autre projet, toute instruction à laquelle elle fait référence se trouve également recopiée dans le projet cible.


Chapitre 3

Notes :


Chapitre 4

Importation et exportation d’instructions complémentaires

Introduction

Création d’un fichier d’exportation

Une instruction complémentaire exportée inclut tous les paramètres, points locaux et sous-programmes. Ces derniers sont automatiquement importés avec l’instruction complémentaire.

Vous pouvez également inclure toutes les instructions complémentaires imbriquée ou tous les types de données utilisateur qui sont référencés par l’instruction complémentaire exportée. Ces instructions complémentaires et ces types de données de référence seront exportés dans le fichier L5X si vous cochez « Include all referenced Add-On Instructions and User-Defined Types » (inclure toutes les instructions complémentaires et les types de données utilisateur référencés) pour l’exportation.

Les références de définition de l’instruction complémentaire peuvent aussi être exportées lorsqu’un programme, un sous-programme, un ensemble de lignes, ou un type de données utilisateur est exporté.

Lorsque vous décidez de la façon dont vos définitions d’instruction complémentaire vont être gérées dans les fichiers d’exportation, vous devez tenir compte des objectifs recherchés par cette sauvegarde.

Rubrique Page

Création d’un fichier d’exportation 85

Importation d’une instruction complémentaire 88

Mise à jour par importation d’une instruction complémentaire avec une nouvelle révision 90

CONSEIL Lorsqu’une instruction complémentaire utilise une instruction MSG (message) et des paramètres d’entrée-sortie (InOut) de type MESSAGE, vous pouvez, si vous le désirez, exporter une ligne contenant l’instruction complémentaire afin d’inclure les points MESSAGE. Cela permet de récupérer les données de configuration du message, comme son type et son chemin d’accès.

Si Alors

Vous voulez sauvegarder dans un emplacement unique un certain nombre d’instructions complémentaires utilisant le même jeu d’instructions complémentaires ou de types de données utilisateur référencés.

Exportez-les dans des fichiers séparés, comme décrit page 86.

Vous voulez distribuer une instruction complémentaire sous forme d’un fichier unique.Exportez-la dans un seul fichier, comme décrit page 87.

Vous voulez gérer chaque instruction complémentaire de façon autonome.

Vous voulez préserver la signature d’instruction de votre instruction complémentaire.

CONSEIL Les instructions complémentaires possédant une signature d’instruction sont codées lors de leur exportation de façon à empêcher toute modification dans le fichier d’exportation.


Chapitre 4

Exportation dans des fichiers séparés

Si vous voulez sauvegarder dans un même emplacement plusieurs instructions complémentaires partageant un jeu commun d’instructions complémentaires ou de types de données utilisateur, vous pouvez choisir d’exporter chaque instruction complémentaire et type de données utilisateur dans des fichiers séparés sans inclure de références.

Suivez la procédure ci-dessous pour effectuer une exportation dans des fichiers séparés.

1. Cliquez avec le bouton droit de la souris sur l’instruction complémentaire dans l’arborescence de l’automate (Controller Organizer) et choisissez Export Add-On Instruction (exporter l’instruction complémentaire).

2. Sélectionnez l’emplacement commun où seront sauvegardés les fichiers L5X.

3. Tapez un nom pour le fichier.

4. Décochez la case « Include referenced Add-On Instructions and User-Defined Types » (inclure les instructions complémentaires et les types définis par l’utilisateur de référence).

5. Cliquez sur Export (exporter).

6. Renouvelez les étapes précédentes pour exporter individuellement toutes les autres instructions complémentaires et types de données utilisateur partagés.

Effectuer ainsi votre exportation vous permettra de gérer votre instruction complémentaire et les types de données utilisateur partagés indépendamment des autres instructions complémentaires qui y font référence. Un avantage de cette procédure est la possibilité de mettre à jour un composant partagé sans avoir à générer de nouveau l’ensemble des fichiers d’exportation pour les instructions qui y font référence. Cela est dû au fait qu’il est sauvegardé dans un fichier unique et non dans chacun des fichiers auquel l’instruction fait référence. Ceci contribue à faciliter la maintenance des instructions car vous n’avez besoin de mettre à jour qu’un seul fichier d’exportation.


Chapitre 4

Pour utiliser une instruction complémentaire qui a été exportée dans un fichier séparé sans ses références, vous devez d’abord importer tous les types de données utilisateur des instructions complémentaires auxquelles cette instruction exportée fait référence avant de pouvoir mener à bien son importation. Pour cela, procédez du bas vers le haut. Importez les types de données utilisateur du niveau le plus bas et tous les types de données utilisateur qui y font référence.

Puis, importez les instructions complémentaires du niveau le plus bas et ensuite toutes les instructions complémentaires qui y font référence. Une fois que l’ensemble des éléments auxquels l’instruction complémentaire fait référence est en place, son importation peut être réalisée avec succès.

Exportation dans un seul fichier

Si vous gérez individuellement vos instructions complémentaires de façon autonome, vous pouvez choisir de les exporter avec toutes les autres instructions complémentaires ou les types de données utilisateur auxquels elle font référence dans un fichier unique. En incluant les instructions complémentaires ou les types de données utilisateur référencés, vous pourrez également faciliter la préservation de la signature de l’instruction complémentaire exportée.

Suivez la procédure ci-dessous pour effectuer l’exportation dans un seul fichier incluant les éléments référencés.

1. Cliquez avec le bouton droit de la souris sur l’instruction complémentaire dans l’arborescence de l’automate (Controller Organizer) et choisissez Export Add-On Instruction (exporter l’instruction complémentaire).

2. Sélectionnez l’emplacement où sauvegarder le fichier L5X.

3. Tapez un nom pour ce fichier.

4. Cochez la case « Include referenced Add-On Instructions and User-Defined Types » (inclure les instructions complémentaires et les types définis par l’utilisateur de référence).

5. Cliquez sur Export (exporter).


Chapitre 4

Vous exporterez ainsi l’instruction complémentaire sélectionnée et toutes les autres instructions auxquelles elle fait référence dans un même fichier. Ce fichier pourra être utilisé pour distribuer cette instruction complémentaire. Lorsqu’une instruction complémentaire qui a été exportée est importée dans un projet, les instructions référencées sont également importées simultanément.

Importation d’une instruction complémentaire

Vous pouvez importer une instruction complémentaire qui a été exportée depuis un autre projet RSLogix 5000. Lorsque vous importez une instruction complémentaire, ses paramètres, points locaux et sous-programmes sont importés simultanément. Quand le projet a récupéré l’instruction complémentaire, vous pouvez utiliser celle-ci dans vos programmes.

Règles d’importation

Lorsque vous importez des instructions complémentaires autonomes ou de référence, tenez compte des règles suivantes :

ATTENTION : modification d’un fichier L5K ou L5XATTENTION : l’attribut EditedDate (date de modification) d’une instruction complémentaire doit être mis à jour lorsque cette instruction complémentaire est modifiée dans un fichier L5K ou L5X. Si le logiciel RSLogix 5000 détecte des modifications de l’instruction complémentaire, mais que l’attribut Edited Date (date de modification) n’a pas été changé, cette instruction complémentaire ne pourra pas être importée.

Caractéristique Règles

Données de point Les points importés faisant référence à une instruction complémentaire dans le fichier d’importation peuvent se trouver affectés si cette instruction complémentaire n’est pas importée également. Dans un tel cas, les données d’un point importé pourront être converties si la structure de données de l’instruction complémentaire existante est différente. Certaines de ces données de point pourront cependant être perdues.Si une instruction complémentaire existante est écrasée, les données de point du projet peuvent être converties si la structure de données de l’instruction complémentaire est différente. Certaines de ces données de point pourront cependant être perdues.Voir Configuration d’importation, page 89 pour plus d’informations.

Programme Un programme importé faisant référence à une instruction complémentaire située dans le fichier d’importation peut se trouver affecté si cette instruction complémentaire n’est pas importée. Si une instruction complémentaire existante est utilisée comme référence d’un programme importé et que la liste des paramètres de cette instruction complémentaire est différente au niveau du projet, celui-ci ne sera peut être pas validé. Il est possible également qu’il soit validé mais qu’il ne fonctionne pas comme prévu.Si une instruction complémentaire existante est écrasée, le programme qui fait référence à cette instruction complémentaire dans le projet peut se trouver affecté. Ce projet ne sera peut être pas validé. Il est possible également qu’il soit validé mais qu’il ne fonctionne pas comme prévu.Voir Configuration d’importation, page 89 pour plus d’informations.

Manipulation d’instructions complémentaires en ligne

Une instruction complémentaire ne peut pas être écrasée lors de son importation alors que l’automate est en ligne. Une nouvelle instruction complémentaire peut cependant être créée en ligne.

Modification du nom final Si le nom final d’une instruction complémentaire est modifié au niveau de la configuration de l’importation, la dernière date de modification de cette instruction complémentaire importée sera mise à jour. De plus, tous les programmes, points, types de données utilisateur et autres instructions complémentaires présents dans le fichier d’importation et faisant référence à cette instruction complémentaire seront mis à jour de façon à ce que cette référence soit faite au nouveau nom. En conséquence, la dernière date de modification de toutes les autres instructions complémentaires faisant référence à l’instruction complémentaire sera mise à jour.Les instructions complémentaires qui ont été scellées par une signature d’instruction ne peuvent pas être renommées pendant l’importation.

Types de données utilisateur Les instructions complémentaires ne peuvent pas écraser les types de données utilisateur. Les instructions complémentaires et les types de données utilisateur doivent avoir des noms spécifiques.

Signature d’instruction Si vous importez une instruction complémentaire possédant une signature d’instruction dans un projet dans lequel les instructions complémentaires ou les types de données utilisateur de référence ne sont pas utilisés, vous devrez peut-être supprimer la signature.Vous pouvez écraser une instruction complémentaire possédant une signature d’instruction en important une instruction complémentaire différente mais du même nom dans un sous-programme existant. Les instructions complémentaires qui ont été scellées par une signature d’instruction ne peuvent pas être renommées pendant l’importation.

Instructions complémentaires de sécurité

Vous ne pouvez pas importer une instruction complémentaire de sécurité dans une tâche standard.Vous ne pouvez pas importer une instruction complémentaire de sécurité dans un projet de sécurité ayant un verrouillage de sécurité ou une signature de tâche de sécurité.Vous ne pouvez pas importer une instruction complémentaire de sécurité lorsque vous êtes en ligne. La classe, la signature d’instruction, l’historique de signature et la signature d’instruction de sécurité (si présente), sont conservés lors de l’importation d’une instruction complémentaire comportant une signature d’instruction.


Chapitre 4

Configuration d’importation

Lorsque vous sélectionnez un fichier à importer, la boîte de dialogue Import Configuration (configuration de l’importation) vous permet de choisir comment l’instruction complémentaire et ses composants référencés vont être importés.

S’il n’y a pas de problème particulier, vous pouvez cliquer simplement sur OK pour effectuer l’importation.

Si votre instruction complémentaire entre en conflit avec une autre déjà présente dans le projet, vous pouvez :

· la renommer, en saisissant un nouveau nom particulier dans le champ Final Name (nom final) ;

· choisir Overwrite (écraser) dans le menu déroulant Operation (action) ;· choisir Use Existing (utiliser le nom existant) dans le menu déroulant

Operation (action).

Le bouton Collision Details (détails du conflit) vous permet d’accéder à l’onglet Property Compare (comparaison des propriétés), qui indique les différences entre les deux instructions, ainsi qu’à l’onglet Project References (références du projet) qui indique où l’instruction complémentaire existante est utilisée.

IMPORTANT L’importation d’une instruction complémentaire créée dans la version 18 ou supérieure du logiciel RSLogix 5000 dans un ancien projet ne gérant pas les signatures d’instruction complémentaire entraîne la perte des données d’attribut. Cette instruction ne peut ne plus alors être validée.

Le composant est en conflit avec une définition déjà présente dans le projet.Cliquez sur Add-On Instructions

(instructions complémentaires) pour afficher la vue Configure Add-On Instruction References (configuration des références d’instruction complémentaire). Si des définitions d’instructions référencées sont en conflit, le dossier References est marqué d’un repère.

CONSEIL Vous ne pouvez renommer une instruction complémentaire que si elle n’a pas été scellée par une signature d’instruction.

Pour renommer une instruction complémentaire dont la source est protégée, vous avez besoin de la clé de source.


Chapitre 4

Mise à jour par importation d’une instruction complémentaire avec une nouvelle révision

Lorsque vous avez besoin de mettre à jour une instruction avec une nouvelle révision, vous pouvez importer celle-ci depuis un fichier L5X ou la copier à partir d’un projet existant. Vous devez vous trouver hors ligne pour effectuer cette opération.

Suivez la procédure ci-dessous pour mettre à jour une instruction complémentaire par importation d’une nouvelle révision.

1. Cliquez avec le bouton droit de la souris sur le dossier Add-On Instruction (instruction complémentaire) et choisissez Import Add-On Instruction (importer une instruction complémentaire).

2. Sélectionnez le fichier contenant l’instruction complémentaire, puis cliquez sur Import (importer).


Chapitre 4

3. Dans la boîte de dialogue Import Configuration (configuration de l’importation) allez dans le menu déroulant Operation (action) et choisissez Overwrite (écraser).

4. Cliquez sur Collision Details (détails du conflit) pour voir les différences entre les deux versions de l’instruction complémentaire et l’endroit auquel elle est utilisée.

L’onglet Property Compare (comparaison des propriétés) indique les différences entre les deux instructions. Dans le cas présent, il s’agira de la révision (Revision), de la date de modification (Edited Date) et de la version du logiciel (Software Revision).

Choisissez Overwrite (écraser).


Chapitre 4

L’onglet Project References (références du projet) indique à quels niveaux du programme est utilisée l’instruction complémentaire actuelle.

Pour plus d’informations sur la mise à jour des arguments, voir Mises à jour des arguments suite à des modifications de paramètre, page 41.

5. Cliquez sur Close (fermer), puis sur OK pour terminer l’opération.

CONSEIL La boîte de dialogue Compare (comparaison) ne compare que les métadonnées de chaque définition d’instruction, comme la description, la révision ou la date de modification. Pour permettre d’appréhender efficacement une nouvelle révision, saisissez une note de révision détaillée.

IMPORTANT Vérifiez chaque sous-programme dans lequel votre instruction complémentaire est utilisée pour vous assurer que votre programme actuel fonctionne correctement avec la nouvelle révision de l’instruction.


Index

Aaccès

instructions complémentaires 71accès aux données 24accès externe 31action en SFC 48, 49aide

création 61exemple 62

aliasparamètre 28, 38

Bboîte de dialogue Add Element 72boîte de dialogue Copy Default Values

(copier les valeurs par défaut) 43boîte de dialogue Import Configuration 91

Cchangement de langue

signature d’instruction 20changement de langue d’interface 63classe 13

modification 53classes d’objet 26comparaison d’instructions 91conflit

importation 89, 91contrôle de l’accès aux données 30conventions de dénomination 32, 36copie

historique de signature 57instruction complémentaire 82instruction complémentaire de sécurité 82signature d’instruction de sécurité 57valeurs par défaut 43

copiersignature d’instruction 56

créationaide pour instruction 61historique de signature 57instruction complémentaire 35paramètre d’alias 38paramètres 37points locaux 39programme 44sous-programme de pré-scrutation 47sous-programme EnableInFalse 50

créersignature d’instruction 56sous-programme de post-scrutation 49

Ddéplacer

paramètre 38dernière date de modification 57diagramme de blocs fonctionnels

exemple d’instruction 74

Eéditeur de définition d’instruction

complémentaire 37exportation 85-88

Ggénérer

signature d’instruction 56GSV 26

Hhistorique de signature 17, 57

Iimbrication 22

accès aux données 24planification 33

importation 88-92instruction

barre d’outils 71taille 22

instruction complémentaire de sécuritécopie 82importation 88

instructions de transition 21instructions indisponibles 25instructions pour application de sécurité

restrictions 25

Llangage de programmation

choix 21planification 33

logique à relaisexemple d’instruction 74

Mmise à jour de la révision d’une instruction

complémentaire 90modes de scrutation 45-51

planification 34validation 55

modification de classe 53


Index

Oonglet Change History 17onglet Edit Tags 41onglet General 13onglet Help 18onglet Local Tags 14

création de points 40onglet Parameters 14

créer un paramètre 37onglet Project References 92onglet Property Compare 91onglet Scan Mode 16onglet Scan Modes 46onglet Signature 16

Pparamètre

alignement 41-42paramètre EnableIn 51

diagramme de blocs fonctionnels 52diagramme de logique à relais 52texte structuré 52

paramètre EnableOut 51paramètres

alias 28création 37déplacer 38EnableIn 51EnableOut 51obligatoires 29planification 32réorganiser 38surveillance 78visible 30visibles 29

paramètres obligatoires 29passage d’arguments 27performance 45planification 32points

création de points locaux 39de sécurité 30standard 30standard et de sécurité 30

points à valeur constante 31points locaux

accès externe 40création 39planification 33

programme 44

exécution 44protection de la source

activation 56appliquer 56options 56panneau de visualisation rapide (Quick View) 81planification 33signature d’instruction 20

Rrecommandations de programmation 75réorganiser les paramètres 38

Ssauvegarde de vos instructions 83sécurité

classe 13restrictions 19

signature d’instructionactions restreintes 16, 20changement de langue 20changement de langue d’interface 63copier 56définition 16générer 56modification 20protection de la source 20supprimer 56

signature d’instruction de sécurité 16, 21copie 57création 58non valide 58supprimer 58visualiser 58

signature de la tâche de sécurité 53signature de tâche de sécurité 19, 82, 88

documentations complémentaires 9SIL 3 21sous-programme

EnableInFalse 50post-scrutation 48pré-scrutation 46

sous-programme de post-scrutation 48créer 49

sous-programme de pré-scrutation 46création 47

sous-programme EnableInFalse 50créer 50

SSV 26standard


Index

supprimersignature d’instruction 56signature d’instruction de sécurité 58

surveillancevaleurs de paramètre 78valeurs des données 79

Ttableau 28test 53

planification 34texte structuré

exemple d’instruction 74traduction

Voir Changement de langue d’interface

types de donnéesalias 28paramètres 27, 37points 40taille 22

Vvaleurs par défaut 38, 40

copie 43visible

paramètres 30visibles

paramètres 29visualisation contextuelle des données 54


Index


Siège des activités « Power, Control and Information Solutions »Amériques : Rockwell Automation, 1201 South Second Street, Milwaukee, WI 53204-2496 Etats-Unis, Tél. : +1 414.382.2000, Fax : +1 414.382.4444Europe / Moyen-Orient / Afrique : Rockwell Automation NV, Pegasus Park, De Kleetlaan 12a, 1831 Diegem, Belgique, Tél. : +32 2 663 0600, Fax : +32 2 663 0640Asie Pacifique : Rockwell Automation, Level 14, Core F, Cyberport 3, 100 Cyberport Road, Hong Kong, Tél. : +852 2887 4788, Fax : +852 2508 1846

Canada : Rockwell Automation, 3043 rue Joseph A. Bombardier, Laval, Québec, H7P 6C5, Tél: +1 (450) 781-5100, Fax: +1 (450) 781-5101, www.rockwellautomation.caFrance : Rockwell Automation SAS – 2, rue René Caudron, Bât. A, F-78960 Voisins-le-Bretonneux, Tél. : +33 1 61 08 77 00, Fax : +33 1 30 44 03 09Suisse : Rockwell Automation AG, Buchserstrasse 7, CH-5001 Aarau, Tél. : +41 62 889 77 77, Fax : +41 62 889 77 11

www.rockwel lautomation.com

100Publication 1756-PM010D-FR-P – Novembre 2011 Copyright © 2011 Rockwell Automation, Inc. Tous droits réservés. Imprimé aux États-Unis.

Assistance Rockwell Automation

Rockwell Automation fournit des informations techniques sur Internet pour vous aider à utiliser ses produits. Sur le site http://www.rockwellautomation.com/support/, vous trouverez des manuels techniques, une foire aux questions, des notes techniques et des profils d’application, des exemples de code et des liens vers des mises à jour de logiciels (service pack). Vous y trouverez également la rubrique « My Support », que vous pouvez personnaliser pour utiliser au mieux ces outils.

Si vous souhaitez une assistance technique supplémentaire par téléphone pour l’installation, la configuration et le dépannage de vos produits, nous proposons les programmes d’assistance TechConnect. Pour de plus amples informations, contactez votre distributeur ou votre représentant Rockwell Automation, ou allez sur le site http://www.rockwellautomation.com/support/.

Aide à l’installation

En cas de problème dans les 24 heures suivant l’installation, consultez les informations données dans le présent manuel. Vous pouvez également contacter l’Assistance Rockwell Automation afin d’obtenir de l’aide pour la mise en service de votre produit :

Procédure de retour d’un nouveau produit

Rockwell Automation teste tous ses produits pour en garantir le parfait fonctionnement à leur sortie d’usine. Cependant, si votre produit ne fonctionne pas et doit faire l’objet d’un retour :

Commentaires

Vos commentaires nous aident à mieux vous servir. Si vous avez des suggestions sur la façon d’améliorer ce document, remplissez le formulaire de la publication RA-DU002, disponible sur le site http://www.rockwellautomation.com/literature/.

Pour les États-Unis ou le Canada 1.440.646.3434

Pour les autres pays Utilisez la rubrique Worldwide Locator sur le site http://www.rockwellautomation.com/support/americas/phone_en.html, ou contactez votre représentant Rockwell Automation.

Pour les États-Unis Contactez votre distributeur. Vous devrez lui fournir le numéro de dossier que le Centre d’assistance vous aura communiqué (voir le numéro de téléphone ci-dessus), afin de procéder au retour.

Pour les autres pays Contactez votre représentant Rockwell Automation pour savoir comment procéder.

http://www.rockwellautomation.com/locations/

http://www.rockwellautomation.com/support/americas/phone_en.html

http://www.rockwellautomation.com/support/

http://www.rockwellautomation.com/support/

http://literature.rockwellautomation.com/idc/groups/literature/documents/du/ra-du002_-en-e.pdf

http://www.rockwellautomation.com/literature/

manuel de programmation - etsmtl.ca · 2013-09-17 · lorsqu’une instruction complémentaire est...

Documents